libervia-web: src/browser/sat_browser/panels.py comparison

comparison src/browser/sat_browser/panels.py @ 586:3eb3a2c0c011

browser and server side: uses RSM (XEP-0059)

author	souliane <souliane@mailoo.org>
date	Fri, 28 Nov 2014 00:31:27 +0100
parents	bade589dbd5a
children

comparison

equal deleted inserted replaced

-:bade589dbd5a
+:3eb3a2c0c011
 from sat.core.log import getLogger
 log = getLogger(__name__)
 from sat_frontends.tools.strings import addURLToText
 from sat_frontends.tools.games import SYMBOLS
-from sat.core.i18n import _
+from sat.core.i18n import _, D_
 from pyjamas.ui.SimplePanel import SimplePanel
 from pyjamas.ui.AbsolutePanel import AbsolutePanel
 from pyjamas.ui.VerticalPanel import VerticalPanel
 from pyjamas.ui.HorizontalPanel import HorizontalPanel
 self._blog_panel = blog_panel
 self.panel = FlowPanel()
 self.panel.setStyleName('mb_entry')
-self.header = HTMLPanel('')
+self.header = HorizontalPanel(StyleName='mb_entry_header')
 self.panel.add(self.header)
 self.entry_actions = VerticalPanel()
 self.entry_actions.setStyleName('mb_entry_actions')
 self.panel.add(self.entry_actions)
 self.__setHeader()
 self.__setBubble()
 self.__setIcons()
 def __setHeader(self):
-"""Set the entry header"""
+"""Set the entry header."""
 if self.empty:
 return
 update_text = u" — ✍ " + "<span class='mb_entry_timestamp'>%s</span>" % datetime.fromtimestamp(self.updated)
-self.header.setHTML("""<div class='mb_entry_header'>
+self.header.add(HTML("""<span class='mb_entry_header_info'>
 <span class='mb_entry_author'>%(author)s</span> on
 <span class='mb_entry_timestamp'>%(published)s</span>%(updated)s
-</div>""" % {'author': html_tools.html_sanitize(self.author),
+</span>""" % {'author': html_tools.html_sanitize(self.author),
 'published': datetime.fromtimestamp(self.published),
 'updated': update_text if self.published != self.updated else ''
-}
+}))
-)
+if self.comments:
+self.comments_count = self.hidden_count = 0
+self.show_comments_link = HTML('')
+self.header.add(self.show_comments_link)
+def updateHeader(self, comments_count=None, hidden_count=None, inc=None):
+"""Update the header.
+@param comments_count (int): total number of comments.
+@param hidden_count (int): number of hidden comments.
+@param inc (int): number to increment the total number of comments with.
+"""
+if comments_count is not None:
+self.comments_count = comments_count
+if hidden_count is not None:
+self.hidden_count = hidden_count
+if inc is not None:
+self.comments_count += inc
+if self.hidden_count > 0:
+comments = D_('comments') if self.hidden_count > 1 else D_('comment')
+text = D_("<a>show %(count)d previous %(comments)s</a>") % {'count': self.hidden_count,
+'comments': comments}
+if self not in self.show_comments_link._clickListeners:
+self.show_comments_link.addClickListener(self)
+else:
+if self.comments_count > 1:
+text = "%(count)d %(comments)s" % {'count': self.comments_count,
+'comments': D_('comments')}
+elif self.comments_count == 1:
+text = D_('1 comment')
+else:
+text = ''
+try:
+self.show_comments_link.removeClickListener(self)
+except ValueError:
+pass
+self.show_comments_link.setHTML("""<span class='mb_entry_comments'>%(text)s</span></div>""" % {'text': text})
 def __setIcons(self):
 """Set the entry icons (delete, update, comment)"""
 if self.empty:
 return
 self._delete()
 elif sender == self.update_label:
 self.edit(True)
 elif sender == self.comment_label:
 self._comment()
+elif sender == self.show_comments_link:
+self._blog_panel.loadAllCommentsForEntry(self)
 def __modifiedCb(self, content):
 """Send the new content to the backend
 @return: False to restore the original content if a deletion has been cancelled
 """
 def __afterEditCb(self, content):
 """Remove the entry if it was an empty one (used for creating a new blog post).
 Data for the actual new blog post will be received from the bridge"""
 if self.empty:
-self._blog_panel.removeEntry(self.type, self.id)
+self._blog_panel.removeEntry(self.type, self.id, update_header=False)
 if self.type == 'main_item':  # restore the "New message" button
 self._blog_panel.refresh()
 else:  # allow to create a new comment
 self._parent_entry._current_comment = None
 self.entry_dialog.setWidth('auto')
 'type': 'comment',
 'author': self._blog_panel.host.whoami.bare,
 'service': self.comments_service,
 'node': self.comments_node
 }
-entry = self._blog_panel.addEntry(data)
+entry = self._blog_panel.addEntry(data, update_header=False)
 if entry is None:
 log.info("The entry of id %s can not be commented" % self.id)
 return
 entry._parent_entry = self
 self._current_comment = entry
 dialog.ConfirmDialog(confirm_cb, text=_("Do you really want to lose the title and text formatting?")).show()
 else:
 self._blog_panel.host.bridge.call('syntaxConvert', setBubble, text, C.SYNTAX_TEXT, C.SYNTAX_XHTML)
-class MicroblogPanel(base_widget.LiberviaWidget):
+class MicroblogPanel(base_widget.LiberviaWidget, MouseHandler):
 warning_msg_public = "This message will be <b>PUBLIC</b> and everybody will be able to see it, even people you don't know"
 warning_msg_group = "This message will be published for all the people of the group <span class='warningTarget'>%s</span>"
 def __init__(self, host, accepted_groups):
 """Panel used to show microblog
 @param accepted_groups: groups displayed in this panel, if empty, show all microblogs from all contacts
 """
 base_widget.LiberviaWidget.__init__(self, host, ", ".join(accepted_groups), selectable=True)
+MouseHandler.__init__(self)
 self.setAcceptedGroup(accepted_groups)
 self.host = host
 self.entries = {}
 self.comments = {}
 self.selected_entry = None
 self.vpanel = VerticalPanel()
 self.vpanel.setStyleName('microblogPanel')
 self.setWidget(self.vpanel)
+self.footer = HTML('', StyleName='microblogPanel_footer')
+self.footer.waiting = False
+self.footer.addClickListener(self)
+self.footer.addMouseListener(self)
+self.vpanel.add(self.footer)
+self.next_rsm_index = 0
 def refresh(self):
 """Refresh the display of this widget. If the unibox is disabled,
 display the 'New message' button or an empty bubble on top of the panel"""
 if hasattr(self, 'new_button'):
 self.new_button.setVisible(False)
 data = {'id': str(time()),
 'new': True,
 'author': self.host.whoami.bare,
 }
-entry = self.addEntry(data)
+entry = self.addEntry(data, update_header=False)
 entry.edit(True)
 if NEW_MESSAGE_USE_BUTTON:
 self.new_button = Button("New message", listener=addBox)
 self.new_button.setStyleName("microblogNewButton")
 self.vpanel.insert(self.new_button, 0)
 def getNewMainEntry(self):
 """Get the new entry being edited, or None if it doesn't exists.
 @return (MicroblogEntry): the new entry being edited.
 """
-try:
+if len(self.vpanel.children) < 2:
-first = self.vpanel.children[0]
+return None  # there's only the footer
-except IndexError:
+first = self.vpanel.children[0]
-return None
 assert(first.type == 'main_item')
 return first if first.empty else None
 @classmethod
 def registerClass(cls):
 @param item: single group as a string, list of groups
 (as an array) or None (for the meta group = "all groups")
 @return: the created MicroblogPanel
 """
 _items = item if isinstance(item, list) else ([] if item is None else [item])
-_type = 'ALL' if _items == [] else 'GROUP'
 # XXX: pyjamas doesn't support use of cls directly
 _new_panel = MicroblogPanel(host, _items)
-host.FillMicroblogPanel(_new_panel)
+_new_panel.loadMoreMainEntries()
-host.bridge.call('getMassiveLastMblogs', _new_panel.massiveInsert, _type, _items, 10)
 host.setSelected(_new_panel)
 _new_panel.refresh()
 return _new_panel
 @classmethod
 return MicroblogPanel.createPanel(host, None)
 @property
 def accepted_groups(self):
 return self._accepted_groups
+def loadAllCommentsForEntry(self, main_entry):
+"""Load all the comments for the given main entry.
+@param main_entry (MicroblogEntry): main entry having comments.
+"""
+index = str(main_entry.comments_count - main_entry.hidden_count)
+rsm = {'max': str(main_entry.hidden_count), 'index': index}
+self.host.bridge.call('getMblogComments', self.mblogsInsert, main_entry.comments_service, main_entry.comments_node, rsm)
+def loadMoreMainEntries(self):
+if self.footer.waiting:
+return
+self.footer.waiting = True
+self.footer.setHTML("loading...")
+self.host.loadOurMainEntries(self.next_rsm_index, self)
+type_ = 'ALL' if self.accepted_groups == [] else 'GROUP'
+rsm = {'max': str(C.RSM_MAX_ITEMS), 'index': str(self.next_rsm_index)}
+self.host.bridge.call('getMassiveMblogs', self.massiveInsert, type_, self.accepted_groups, rsm)
 def matchEntity(self, item):
 """
 @param item: single group as a string, list of groups
 (as an array) or None (for the meta group = "all groups")
 """Ask all the entries for the currenly accepted groups,
 and fill the panel"""
 def massiveInsert(self, mblogs):
 """Insert several microblogs at once
-@param mblogs: dictionary of microblogs, as the result of getMassiveLastGroupBlogs
+@param mblogs (dict): dictionary mapping a publisher to microblogs data:
-"""
+- key: publisher (str)
-count = sum([len(value) for value in mblogs.values()])
+- value: couple (list[dict], dict) with:
-log.debug("Massive insertion of %d microblogs" % count)
+- list of microblogs data
+- RSM response data
+"""
+count_pub = len(mblogs)
+count_msg = sum([len(value) for value in mblogs.values()])
+log.debug("massive insertion of {count_msg} blogs for {count_pub} contacts".format(count_msg=count_msg, count_pub=count_pub))
 for publisher in mblogs:
-log.debug("adding blogs for [%s]" % publisher)
+log.debug("adding {count} blogs for [{publisher}]".format(count=len(mblogs[publisher]), publisher=publisher))
-for mblog in mblogs[publisher]:
+self.mblogsInsert(mblogs[publisher])
-if not "content" in mblog:
+self.next_rsm_index += C.RSM_MAX_ITEMS
-log.warning("No content found in microblog [%s]" % mblog)
+self.footer.waiting = False
-continue
+self.footer.setHTML('show older messages')
-self.addEntry(mblog)
 def mblogsInsert(self, mblogs):
-""" Insert several microblogs at once
+""" Insert several microblogs from the same node at once.
-@param mblogs: list of microblogs
-"""
+@param mblogs (list): couple (list[dict], dict) with:
+- list of microblogs data
+- RSM response data
+"""
+mblogs, rsm = mblogs
 for mblog in mblogs:
-if not "content" in mblog:
+if "content" not in mblog:
 log.warning("No content found in microblog [%s]" % mblog)
 continue
-self.addEntry(mblog)
+self.addEntry(mblog, update_header=False)
+hashes = set([(entry['service'], entry['node']) for entry in mblogs if entry['type'] == 'comment'])
+assert(len(hashes) < 2)  # ensure the blogs come from the same node
+if len(hashes) == 1:
+main_entry = self.comments[hashes.pop()]
+count = int(rsm['count'])
+hidden = count - (int(rsm['index']) + len(mblogs))
+main_entry.updateHeader(count, hidden)
 def _chronoInsert(self, vpanel, entry, reverse=True):
 """ Insert an entry in chronological order
 @param vpanel: VerticalPanel instance
 @param entry: MicroblogEntry
 @param reverse: more recent entry on top if True, chronological order else"""
+# XXX: for now we can't use "published" timestamp because the entries
+# are retrieved using the "updated" field. We don't want new items
+# inserted with RSM to be inserted "randomly" in the panel, they
+# should be added at the bottom of the list.
 assert(isinstance(reverse, bool))
 if entry.empty:
-entry.published = time()
+entry.updated = time()
 # we look for the right index to insert our entry:
 # if reversed, we insert the entry above the first entry
 # in the past
 idx = 0
-for child in vpanel.children:
+for child in vpanel.children[0:-1]:  # ignore the footer
 if not isinstance(child, MicroblogEntry):
 idx += 1
 continue
-condition_to_stop = child.empty or (child.published > entry.published)
+condition_to_stop = child.empty or (child.updated > entry.updated)
 if condition_to_stop != reverse:  # != is XOR
 break
 idx += 1
 vpanel.insert(entry, idx)
-def addEntry(self, data):
+def addEntry(self, data, update_header=True):
 """Add an entry to the panel
-@param data: dict containing the item data
-@return: the added entry, or None
+@param data (dict): dict containing the item data
+@param update_header (bool): update or not the main comment header
+@return: the added MicroblogEntry instance, or None
 """
 _entry = MicroblogEntry(self, data)
 if _entry.type == "comment":
 comments_hash = (_entry.service, _entry.node)
-if not comments_hash in self.comments:
+if comments_hash not in self.comments:
 # The comments node is not known in this panel
 return None
 parent = self.comments[comments_hash]
 parent_idx = self.vpanel.getWidgetIndex(parent)
 # we find or create the panel where the comment must be inserted
 if not sub_panel or not isinstance(sub_panel, VerticalPanel):
 sub_panel = VerticalPanel()
 sub_panel.setStyleName('microblogPanel')
 sub_panel.addStyleName('subPanel')
 self.vpanel.insert(sub_panel, parent_idx + 1)
 for idx in xrange(0, len(sub_panel.getChildren())):
 comment = sub_panel.getIndexedChild(idx)
 if comment.id == _entry.id:
 # update an existing comment
 sub_panel.remove(comment)
 sub_panel.insert(_entry, idx)
 return _entry
 # we want comments to be inserted in chronological order
 self._chronoInsert(sub_panel, _entry, reverse=False)
+if update_header:
+parent.updateHeader(inc=+1)
 return _entry
-if _entry.id in self.entries:  # update
-idx = self.vpanel.getWidgetIndex(self.entries[_entry.id])
-self.vpanel.remove(self.entries[_entry.id])
-self.vpanel.insert(_entry, idx)
-else:  # new entry
-self._chronoInsert(self.vpanel, _entry)
-self.entries[_entry.id] = _entry
 if _entry.comments:
 # entry has comments, we keep the comments service/node as a reference
 comments_hash = (_entry.comments_service, _entry.comments_node)
 self.comments[comments_hash] = _entry
-self.host.bridge.call('getMblogComments', self.mblogsInsert, _entry.comments_service, _entry.comments_node)
+if _entry.id in self.entries:  # update
+old_entry = self.entries[_entry.id]
+idx = self.vpanel.getWidgetIndex(old_entry)
+counts = (old_entry.comments_count, old_entry.hidden_count)
+self.vpanel.remove(old_entry)
+self.vpanel.insert(_entry, idx)
+_entry.updateHeader(*counts)
+else:  # new entry
+self._chronoInsert(self.vpanel, _entry)
+if _entry.comments:
+self.host.bridge.call('getMblogComments', self.mblogsInsert, _entry.comments_service, _entry.comments_node)
+self.entries[_entry.id] = _entry
 return _entry
-def removeEntry(self, type_, id_):
+def removeEntry(self, type_, id_, update_header=True):
 """Remove an entry from the panel
-@param type_: entry type ('main_item' or 'comment')
-@param id_: entry id
+@param type_ (str): entry type ('main_item' or 'comment')
+@param id_ (str): entry id
+@param update_header (bool): update or not the main comment header
 """
 for child in self.vpanel.getChildren():
 if isinstance(child, MicroblogEntry) and type_ == 'main_item':
 if child.id == id_:
 main_idx = self.vpanel.getWidgetIndex(child)
 self.selected_entry = None
 break
 elif isinstance(child, VerticalPanel) and type_ == 'comment':
 for comment in child.getChildren():
 if comment.id == id_:
+if update_header:
+hash_ = (comment.service, comment.node)
+self.comments[hash_].updateHeader(inc=-1)
 comment.removeFromParent()
 self.selected_entry = None
 break
 def ensureVisible(self, entry):
 return True
 for group in self._accepted_groups:
 if self.host.contact_panel.isContactInGroup(group, jid_s):
 return True
 return False
+def onClick(self, sender):
+if sender == self.footer:
+self.loadMoreMainEntries()
+def onMouseEnter(self, sender):
+if sender == self.footer:
+self.loadMoreMainEntries()
 class StatusPanel(base_panels.HTMLTextEditor):
 EMPTY_STATUS = '&lt;click to set a status&gt;'

Mercurial > libervia-web

comparison src/browser/sat_browser/panels.py @ 586:3eb3a2c0c011