GitLab

at 2018-07-01T22:35:56+02:00

Refactor Pubsub/Bookmarks/UserAvatar into own modules

 from gajim.common.modules.http_auth import HTTPAuth

 from gajim.common.modules.vcard_temp import VCardTemp

 from gajim.common.modules.vcard_avatars import VCardAvatars

+from gajim.common.modules.pubsub import PubSub

+from gajim.common.modules.bookmarks import Bookmarks

+from gajim.common.modules.user_avatar import UserAvatar

 from gajim.common.connection_handlers import *

 from gajim.common.contacts import GC_Contact

 from gajim.gtkgui_helpers import get_action

         self.old_show = ''

         self.priority = app.get_priority(name, 'offline')

         self.time_to_reconnect = None

-        self.bookmarks = []

         self.blocked_list = []

         self.blocked_contacts = []

     def account_changed(self, new_name):

         self.name = new_name

-    def get_bookmarks(self):

-        """

-        To be implemented by derived classes

-        """

-        raise NotImplementedError

-

-    def store_bookmarks(self):

-        """

-        To be implemented by derived classes

-        """

-        raise NotImplementedError

-

     def get_metacontacts(self):

         """

         To be implemented by derived classes

         self.register_module('HTTPAuth', HTTPAuth, self)

         self.register_module('VCardTemp', VCardTemp, self)

         self.register_module('VCardAvatars', VCardAvatars, self)

+        self.register_module('PubSub', PubSub, self)

+        self.register_module('Bookmarks', Bookmarks, self)

+        self.register_module('UserAvatar', UserAvatar, self)

         app.ged.register_event_handler('privacy-list-received', ged.CORE,

             self._nec_privacy_list_received)

             # ask our VCard

             self.get_module('VCardTemp').request_vcard()

-            # Get bookmarks from private namespace

-            self.get_bookmarks()

+            # Get bookmarks

+            self.get_module('Bookmarks').get_bookmarks()

             # Get annotations

             self.get_module('Annotations').get_annotations()

                     self.pubsub_publish_options_supported = True

                 else:

                     # Remove stored bookmarks accessible to everyone.

-                    self.send_pb_purge(our_jid, 'storage:bookmarks')

-                    self.send_pb_delete(our_jid, 'storage:bookmarks')

+                    self.get_module('Bookmarks').purge_pubsub_bookmarks()

             if obj.fjid == hostname:

                 if nbxmpp.NS_SECLABEL in obj.features:

             return True

         return False

-    def _request_bookmarks_xml(self):

-        if not app.account_is_connected(self.name):

-            return

-        iq = nbxmpp.Iq(typ='get')

-        iq2 = iq.addChild(name='query', namespace=nbxmpp.NS_PRIVATE)

-        iq2.addChild(name='storage', namespace='storage:bookmarks')

-        self.connection.send(iq)

-        app.log('bookmarks').info('Request Bookmarks (PrivateStorage)')

-

-    def _check_bookmarks_received(self):

-        if not self.bookmarks:

-            self._request_bookmarks_xml()

-

-    def get_bookmarks(self, storage_type=None):

-        """

-        Get Bookmarks from storage or PubSub if supported as described in XEP

-        0048

-

-        storage_type can be set to xml to force request to xml storage

-        """

-        if not app.account_is_connected(self.name):

-            return

-

-        if storage_type != 'xml':

-            if self.pep_supported and self.pubsub_publish_options_supported:

-                self.send_pb_retrieve('', 'storage:bookmarks')

-                app.log('bookmarks').info('Request Bookmarks (PubSub)')

-                # some server (ejabberd) are so slow to answer that we

-                # request via XML if we don't get answer in the next 30 seconds

-                app.idlequeue.set_alarm(self._check_bookmarks_received, 30)

-                return

-

-        self._request_bookmarks_xml()

-

-    def get_bookmarks_storage_node(self):

-        NS_GAJIM_BM = 'xmpp:gajim.org/bookmarks'

-        storage_node = nbxmpp.Node(

-            tag='storage', attrs={'xmlns': 'storage:bookmarks'})

-        for bm in self.bookmarks:

-            conf_node = storage_node.addChild(name="conference")

-            conf_node.setAttr('jid', bm['jid'])

-            conf_node.setAttr('autojoin', bm['autojoin'])

-            conf_node.setAttr('name', bm['name'])

-            conf_node.setTag(

-                'minimize', namespace=NS_GAJIM_BM).setData(bm['minimize'])

-            # Only add optional elements if not empty

-            # Note: need to handle both None and '' as empty

-            #   thus shouldn't use "is not None"

-            if bm.get('nick', None):

-                conf_node.setTagData('nick', bm['nick'])

-            if bm.get('password', None):

-                conf_node.setTagData('password', bm['password'])

-            if bm.get('print_status', None):

-                conf_node.setTag(

-                    'print_status',

-                    namespace=NS_GAJIM_BM).setData(bm['print_status'])

-        return storage_node

-

-    @staticmethod

-    def get_bookmark_publish_options():

-        options = nbxmpp.Node(nbxmpp.NS_DATA + ' x',

-                              attrs={'type': 'submit'})

-        f = options.addChild('field',

-                             attrs={'var': 'FORM_TYPE', 'type': 'hidden'})

-        f.setTagData('value', nbxmpp.NS_PUBSUB_PUBLISH_OPTIONS)

-        f = options.addChild('field', attrs={'var': 'pubsub#access_model'})

-        f.setTagData('value', 'whitelist')

-        return options

-

-    def store_bookmarks(self, storage_type=None):

-        """

-        Send bookmarks to the storage namespace or PubSub if supported

-

-        storage_type can be set to 'pubsub' or 'xml' so store in only one method

-        else it will be stored on both

-        """

-        if not app.account_is_connected(self.name):

-            return

-

-        storage_node = self.get_bookmarks_storage_node()

-

-        if storage_type != 'xml':

-            if self.pep_supported and self.pubsub_publish_options_supported:

-                self.send_pb_publish(

-                    '', 'storage:bookmarks', storage_node, 'current',

-                    options=self.get_bookmark_publish_options())

-                app.log('bookmarks').info('Bookmarks published (PubSub)')

-

-        if storage_type != 'pubsub':

-            iq = nbxmpp.Iq('set', nbxmpp.NS_PRIVATE, payload=storage_node)

-            self.connection.send(iq)

-            app.log('bookmarks').info('Bookmarks published (PrivateStorage)')

-

     def get_roster_delimiter(self):

         """

         Get roster group delimiter from storage as described in XEP 0083

             destroy.setAttr('jid', jid)

         self.connection.send(iq)

         i = 0

-        for bm in self.bookmarks:

-            if bm['jid'] == room_jid:

-                del self.bookmarks[i]

-                break

-            i += 1

+        self.get_module('Bookmarks').bookmarks.pop(jid, None)

         self.store_bookmarks()

     def send_gc_status(self, nick, jid, show, status, auto=False):

 from gajim.common import configpaths

 from gajim.common.caps_cache import muc_caps_cache

 from gajim.common.commands import ConnectionCommands

-from gajim.common.pubsub import ConnectionPubSub

 from gajim.common.protocol.caps import ConnectionCaps

 from gajim.common.protocol.bytestream import ConnectionSocks5Bytestream

 from gajim.common.protocol.bytestream import ConnectionIBBytestream

         if message:

             i = item.addChild('text')

             i.addData(message)

-        self._pubsub_connection.send_pb_publish('', nbxmpp.NS_ACTIVITY, item,

-            '0')

+        self.get_module('PubSub').send_pb_publish(

+            '', nbxmpp.NS_ACTIVITY, item, '0')

     def retract_activity(self):

         if not self.pep_supported:

             return

         self.send_activity(None)

         # not all client support new XEP, so we still retract

-        self._pubsub_connection.send_pb_retract('', nbxmpp.NS_ACTIVITY, '0')

+        self.get_module('PubSub').send_pb_retract('', nbxmpp.NS_ACTIVITY, '0')

     def send_mood(self, mood, message=None):

         if self.connected == 1:

         if message:

             i = item.addChild('text')

             i.addData(message)

-        self._pubsub_connection.send_pb_publish('', nbxmpp.NS_MOOD, item, '0')

+        self.get_module('PubSub').send_pb_publish('', nbxmpp.NS_MOOD, item, '0')

     def retract_mood(self):

         if not self.pep_supported:

             return

         self.send_mood(None)

         # not all client support new XEP, so we still retract

-        self._pubsub_connection.send_pb_retract('', nbxmpp.NS_MOOD, '0')

+        self.get_module('PubSub').send_pb_retract('', nbxmpp.NS_MOOD, '0')

     def send_tune(self, artist='', title='', source='', track=0, length=0,

     items=None):

             i.addData(length)

         if items:

             item.addChild(payload=items)

-        self._pubsub_connection.send_pb_publish('', nbxmpp.NS_TUNE, item, '0')

+        self.get_module('PubSub').send_pb_publish('', nbxmpp.NS_TUNE, item, '0')

     def retract_tune(self):

         if not self.pep_supported:

             return

         self.send_tune(None)

         # not all client support new XEP, so we still retract

-        self._pubsub_connection.send_pb_retract('', nbxmpp.NS_TUNE, '0')

+        self.get_module('PubSub').send_pb_retract('', nbxmpp.NS_TUNE, '0')

     def send_nickname(self, nick):

         if self.connected == 1:

             return

         item = nbxmpp.Node('nick', {'xmlns': nbxmpp.NS_NICK})

         item.addData(nick)

-        self._pubsub_connection.send_pb_publish('', nbxmpp.NS_NICK, item, '0')

+        self.get_module('PubSub').send_pb_publish('', nbxmpp.NS_NICK, item, '0')

     def retract_nickname(self):

         if not self.pep_supported:

             return

-        self._pubsub_connection.send_pb_retract('', nbxmpp.NS_NICK, '0')

+        self.get_module('PubSub').send_pb_retract('', nbxmpp.NS_NICK, '0')

     def send_location(self, info):

         if self.connected == 1:

             if info.get(field, None):

                 i = item.addChild(field)

                 i.addData(info[field])

-        self._pubsub_connection.send_pb_publish('', nbxmpp.NS_LOCATION, item, '0')

+        self.get_module('PubSub').send_pb_publish('', nbxmpp.NS_LOCATION, item, '0')

     def retract_location(self):

         if not self.pep_supported:

             return

         self.send_location({})

         # not all client support new XEP, so we still retract

-        self._pubsub_connection.send_pb_retract('', nbxmpp.NS_LOCATION, '0')

+        self.get_module('PubSub').send_pb_retract('', nbxmpp.NS_LOCATION, '0')

 # basic connection handlers used here and in zeroconf

 class ConnectionHandlersBase:

 class ConnectionHandlers(ConnectionArchive313,

 ConnectionSocks5Bytestream, ConnectionDisco,

-ConnectionCommands, ConnectionPubSub, ConnectionPEP, ConnectionCaps,

+ConnectionCommands, ConnectionPEP, ConnectionCaps,

 ConnectionHandlersBase, ConnectionJingle, ConnectionIBBytestream,

 ConnectionHTTPUpload):

     def __init__(self):

         ConnectionSocks5Bytestream.__init__(self)

         ConnectionIBBytestream.__init__(self)

         ConnectionCommands.__init__(self)

-        ConnectionPubSub.__init__(self)

         ConnectionPEP.__init__(self, account=self.name, dispatcher=self,

             pubsub_connection=self)

         ConnectionHTTPUpload.__init__(self)

         self.privacy_default_list = None

-        app.nec.register_incoming_event(PrivateStorageBookmarksReceivedEvent)

-        app.nec.register_incoming_event(BookmarksReceivedEvent)

         app.nec.register_incoming_event(StreamConflictReceivedEvent)

         app.nec.register_incoming_event(StreamOtherHostReceivedEvent)

         app.nec.register_incoming_event(MessageReceivedEvent)

         app.ged.register_event_handler('roster-set-received',

             ged.CORE, self._nec_roster_set_received)

-        app.ged.register_event_handler('private-storage-bookmarks-received',

-            ged.CORE, self._nec_private_storate_bookmarks_received)

         app.ged.register_event_handler('roster-received', ged.CORE,

             self._nec_roster_received)

         app.ged.register_event_handler('iq-error-received', ged.CORE,

         ConnectionHandlersBase.cleanup(self)

         ConnectionCaps.cleanup(self)

         ConnectionArchive313.cleanup(self)

-        ConnectionPubSub.cleanup(self)

         ConnectionHTTPUpload.cleanup(self)

         app.ged.remove_event_handler('roster-set-received',

             ged.CORE, self._nec_roster_set_received)

-        app.ged.remove_event_handler('private-storage-bookmarks-received',

-            ged.CORE, self._nec_private_storate_bookmarks_received)

         app.ged.remove_event_handler('roster-received', ged.CORE,

             self._nec_roster_received)

         app.ged.remove_event_handler('iq-error-received', ged.CORE,

                 conn=self, stanza=obj.stanza))

             return True

-    def _nec_private_storate_bookmarks_received(self, obj):

-        if obj.conn.name != self.name:

-            return

-        app.log('bookmarks').info('Received Bookmarks (PrivateStorage)')

-        resend_to_pubsub = False

-        bm_jids = [b['jid'] for b in self.bookmarks]

-        for bm in obj.bookmarks:

-            if bm['jid'] not in bm_jids:

-                self.bookmarks.append(bm)

-                # We got a bookmark that was not in pubsub

-                resend_to_pubsub = True

-        if resend_to_pubsub:

-            self.store_bookmarks('pubsub')

-

-    def _PrivateCB(self, con, iq_obj):

-        """

-        Private Data (XEP 048 and 049)

-        """

-        log.debug('PrivateCB')

-        app.nec.push_incoming_event(PrivateStorageReceivedEvent(None,

-            conn=self, stanza=iq_obj))

-

     def _SecLabelCB(self, con, iq_obj):

         """

         Security Label callback, used for catalogues.

             # ask our VCard

             self.get_module('VCardTemp').request_vcard()

-        # Get bookmarks from private namespace

-        self.get_bookmarks()

+        # Get bookmarks

+        self.get_module('Bookmarks').get_bookmarks()

         # Get annotations from private namespace

         self.get_module('Annotations').get_annotations()

             nbxmpp.NS_MUC_OWNER)

         con.RegisterHandler('iq', self._MucAdminCB, 'result',

             nbxmpp.NS_MUC_ADMIN)

-        con.RegisterHandler('iq', self._PrivateCB, 'result', nbxmpp.NS_PRIVATE)

         con.RegisterHandler('iq', self._SecLabelCB, 'result',

             nbxmpp.NS_SECLABEL_CATALOG)

         con.RegisterHandler('iq', self._CommandExecuteCB, 'set',

         con.RegisterHandler('iq', self._PrivacySetCB, 'set', nbxmpp.NS_PRIVACY)

         con.RegisterHandler('iq', self._ArchiveCB, ns=nbxmpp.NS_MAM_1)

         con.RegisterHandler('iq', self._ArchiveCB, ns=nbxmpp.NS_MAM_2)

-        con.RegisterHandler('iq', self._PubSubCB, 'result')

-        con.RegisterHandler('iq', self._PubSubErrorCB, 'error')

         con.RegisterHandler('iq', self._JingleCB, 'result')

         con.RegisterHandler('iq', self._JingleCB, 'error')

         con.RegisterHandler('iq', self._JingleCB, 'set', nbxmpp.NS_JINGLE)

                     self.users_dict[jid]['reason'] = reason

         return True

-class PrivateStorageReceivedEvent(nec.NetworkIncomingEvent):

-    name = 'private-storage-received'

-    base_network_events = []

-

-    def generate(self):

-        query = self.stanza.getTag('query')

-        self.storage_node = query.getTag('storage')

-        if self.storage_node:

-            self.namespace = self.storage_node.getNamespace()

-            return True

-

-

-class BookmarksHelper:

-    def parse_bookmarks(self):

-        self.bookmarks = []

-        NS_GAJIM_BM = 'xmpp:gajim.org/bookmarks'

-        confs = self.storage_node.getTags('conference')

-        for conf in confs:

-            autojoin_val = conf.getAttr('autojoin')

-            if not autojoin_val:  # not there (it's optional)

-                autojoin_val = False

-            minimize_val = conf.getTag('minimize', namespace=NS_GAJIM_BM)

-            if not minimize_val:  # not there, try old Gajim behaviour

-                minimize_val = conf.getAttr('minimize')

-                if not minimize_val:  # not there (it's optional)

-                    minimize_val = False

-            else:

-                minimize_val = minimize_val.getData()

-

-            print_status = conf.getTag('print_status', namespace=NS_GAJIM_BM)

-            if not print_status:  # not there, try old Gajim behaviour

-                print_status = conf.getTagData('print_status')

-                if not print_status:  # not there, try old Gajim behaviour

-                    print_status = conf.getTagData('show_status')

-            else:

-                print_status = print_status.getData()

-

-            try:

-                jid = helpers.parse_jid(conf.getAttr('jid'))

-            except helpers.InvalidFormat:

-                log.warning('Invalid JID: %s, ignoring it'

-                            % conf.getAttr('jid'))

-                continue

-

-            bm = {'name': conf.getAttr('name'),

-                  'jid': jid,

-                  'autojoin': autojoin_val,

-                  'minimize': minimize_val,

-                  'password': conf.getTagData('password'),

-                  'nick': conf.getTagData('nick'),

-                  'print_status': print_status}

-

-            bm_jids = [b['jid'] for b in self.bookmarks]

-            if bm['jid'] not in bm_jids:

-                self.bookmarks.append(bm)

-

-class PrivateStorageBookmarksReceivedEvent(nec.NetworkIncomingEvent,

-BookmarksHelper):

-    name = 'private-storage-bookmarks-received'

-    base_network_events = ['private-storage-received']

-

-    def generate(self):

-        self.conn = self.base_event.conn

-        self.storage_node = self.base_event.storage_node

-        if self.base_event.namespace != nbxmpp.NS_BOOKMARKS:

-            return

-        self.parse_bookmarks()

-        return True

-

-class BookmarksReceivedEvent(nec.NetworkIncomingEvent):

-    name = 'bookmarks-received'

-    base_network_events = ['private-storage-bookmarks-received',

-        'pubsub-bookmarks-received']

-

-    def generate(self):

-        self.conn = self.base_event.conn

-        self.bookmarks = self.base_event.bookmarks

-        return True

-

-class PubsubReceivedEvent(nec.NetworkIncomingEvent):

-    name = 'pubsub-received'

-    base_network_events = []

-

-    def generate(self):

-        self.jid = self.stanza.getFrom()

-        self.pubsub_node = self.stanza.getTag('pubsub')

-        if not self.pubsub_node:

-            return

-        self.items_node = self.pubsub_node.getTag('items')

-        if not self.items_node:

-            return

-        return True

-

-class PubsubBookmarksReceivedEvent(nec.NetworkIncomingEvent, BookmarksHelper):

-    name = 'pubsub-bookmarks-received'

-    base_network_events = ['pubsub-received']

-

-    def generate(self):

-        self.conn = self.base_event.conn

-        self.item_node = self.base_event.items_node.getTag('item')

-        if not self.item_node:

-            return

-        children = self.item_node.getChildren()

-        if not children:

-            return

-        self.storage_node = children[0]

-        ns = self.storage_node.getNamespace()

-        if ns != nbxmpp.NS_BOOKMARKS:

-            return

-        self.parse_bookmarks()

-        return True

-

 class IqErrorReceivedEvent(nec.NetworkIncomingEvent, HelperEvent):

     name = 'iq-error-received'

     base_network_events = []

     ROOM = 1

     USER = 2

+@unique

+class BookmarkStorageType(IntEnum):

+    PRIVATE = 0

+    PUBSUB = 1

+

 SSLError = {

     2: _("Unable to get issuer certificate"),

     3: _("Unable to get certificate CRL"),

+# This file is part of Gajim.

+#

+# Gajim is free software; you can redistribute it and/or modify

+# it under the terms of the GNU General Public License as published

+# by the Free Software Foundation; version 3 only.

+#

+# Gajim is distributed in the hope that it will be useful,

+# but WITHOUT ANY WARRANTY; without even the implied warranty of

+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

+# GNU General Public License for more details.

+#

+# You should have received a copy of the GNU General Public License

+# along with Gajim.  If not, see <http://www.gnu.org/licenses/>.

+

+# XEP-0048: Bookmarks

+

+import logging

+

+import nbxmpp

+

+from gajim.common import app

+from gajim.common import helpers

+from gajim.common.const import BookmarkStorageType

+from gajim.common.nec import NetworkIncomingEvent

+

+log = logging.getLogger('gajim.c.m.bookmarks')

+

+

+class Bookmarks:

+    def __init__(self, con):

+        self._con = con

+        self._account = con.name

+        self.bookmarks = {}

+

+        self.handlers = []

+

+    def _pubsub_support(self):

+        return (self._con.pep_supported and

+                self._con.pubsub_publish_options_supported)

+

+    def get_bookmarks(self, storage_type=None):

+        if not app.account_is_connected(self._account):

+            return

+

+        if storage_type in (None, BookmarkStorageType.PUBSUB):

+            if self._pubsub_support():

+                self._request_pubsub_bookmarks()

+            else:

+                # Fallback, request private storage

+                self._request_private_bookmarks()

+        else:

+            log.info('Request Bookmarks (PrivateStorage)')

+            self._request_private_bookmarks()

+

+    def _request_pubsub_bookmarks(self):

+        log.info('Request Bookmarks (PubSub)')

+        self._con.get_module('PubSub').send_pb_retrieve(

+            '', 'storage:bookmarks',

+            cb=self._pubsub_bookmarks_received)

+

+    def _pubsub_bookmarks_received(self, conn, stanza):

+        if not nbxmpp.isResultNode(stanza):

+            log.info('No pubsub bookmarks: %s', stanza.getError())

+            # Fallback, request private storage

+            self._request_private_bookmarks()

+            return

+

+        log.info('Received Bookmarks (PubSub)')

+        self._parse_bookmarks(stanza)

+        self._request_private_bookmarks()

+

+    def _request_private_bookmarks(self):

+        if not app.account_is_connected(self._account):

+            return

+

+        iq = nbxmpp.Iq(typ='get')

+        query = iq.addChild(name='query', namespace=nbxmpp.NS_PRIVATE)

+        query.addChild(name='storage', namespace='storage:bookmarks')

+        log.info('Request Bookmarks (PrivateStorage)')

+        self._con.connection.SendAndCallForResponse(

+            iq, self._private_bookmarks_received)

+

+    def _private_bookmarks_received(self, stanza):

+        if not nbxmpp.isResultNode(stanza):

+            log.info('No private bookmarks: %s', stanza.getError())

+        else:

+            log.info('Received Bookmarks (PrivateStorage)')

+            merged = self._parse_bookmarks(stanza, check_merge=True)

+            if merged:

+                log.info('Merge PrivateStorage with PubSub')

+                self.store_bookmarks(BookmarkStorageType.PUBSUB)

+        self.auto_join_bookmarks()

+        app.nec.push_incoming_event(BookmarksReceivedEvent(

+            None, account=self._account))

+

+    @staticmethod

+    def _get_storage_node(stanza):

+        node = stanza.getTag('pubsub', namespace=nbxmpp.NS_PUBSUB)

+        if node is None:

+            node = stanza.getTag('event', namespace=nbxmpp.NS_PUBSUB_EVENT)

+            if node is None:

+                # Private Storage

+                query = stanza.getQuery()

+                if query is None:

+                    return

+                storage = query.getTag('storage',

+                                       namespace=nbxmpp.NS_BOOKMARKS)

+                if storage is None:

+                    return

+                return storage

+

+        items_node = node.getTag('items')

+        if items_node is None:

+            return

+        if items_node.getAttr('node') != nbxmpp.NS_BOOKMARKS:

+            return

+

+        item_node = items_node.getTag('item')

+        if item_node is None:

+            return

+

+        storage = item_node.getTag('storage', namespace=nbxmpp.NS_BOOKMARKS)

+        if storage is None:

+            return

+        return storage

+

+    def _parse_bookmarks(self, stanza, check_merge=False):

+        merged = False

+        storage = self._get_storage_node(stanza)

+        if storage is None:

+            return

+

+        NS_GAJIM_BM = 'xmpp:gajim.org/bookmarks'

+        confs = storage.getTags('conference')

+        for conf in confs:

+            autojoin_val = conf.getAttr('autojoin')

+            if not autojoin_val:  # not there (it's optional)

+                autojoin_val = False

+            minimize_val = conf.getTag('minimize', namespace=NS_GAJIM_BM)

+            if not minimize_val:  # not there, try old Gajim behaviour

+                minimize_val = conf.getAttr('minimize')

+                if not minimize_val:  # not there (it's optional)

+                    minimize_val = False

+            else:

+                minimize_val = minimize_val.getData()

+

+            print_status = conf.getTag('print_status', namespace=NS_GAJIM_BM)

+            if not print_status:  # not there, try old Gajim behaviour

+                print_status = conf.getTagData('print_status')

+                if not print_status:  # not there, try old Gajim behaviour

+                    print_status = conf.getTagData('show_status')

+            else:

+                print_status = print_status.getData()

+

+            try:

+                jid = helpers.parse_jid(conf.getAttr('jid'))

+            except helpers.InvalidFormat:

+                log.warning('Invalid JID: %s, ignoring it'

+                            % conf.getAttr('jid'))

+                continue

+

+            if check_merge:

+                if jid not in self.bookmarks:

+                    merged = True

+

+            log.debug('Found Bookmark: %s', jid)

+            self.bookmarks[jid] = {

+                'name': conf.getAttr('name'),

+                'autojoin': autojoin_val,

+                'minimize': minimize_val,

+                'password': conf.getTagData('password'),

+                'nick': conf.getTagData('nick'),

+                'print_status': print_status}

+

+        return merged

+

+    def _build_storage_node(self):

+        NS_GAJIM_BM = 'xmpp:gajim.org/bookmarks'

+        storage_node = nbxmpp.Node(

+            tag='storage', attrs={'xmlns': 'storage:bookmarks'})

+        for jid, bm in self.bookmarks.items():

+            conf_node = storage_node.addChild(name="conference")

+            conf_node.setAttr('jid', jid)

+            conf_node.setAttr('autojoin', bm['autojoin'])

+            conf_node.setAttr('name', bm['name'])

+            conf_node.setTag(

+                'minimize', namespace=NS_GAJIM_BM).setData(bm['minimize'])

+            # Only add optional elements if not empty

+            # Note: need to handle both None and '' as empty

+            #   thus shouldn't use "is not None"

+            if bm.get('nick', None):

+                conf_node.setTagData('nick', bm['nick'])

+            if bm.get('password', None):

+                conf_node.setTagData('password', bm['password'])

+            if bm.get('print_status', None):

+                conf_node.setTag(

+                    'print_status',

+                    namespace=NS_GAJIM_BM).setData(bm['print_status'])

+        return storage_node

+

+    @staticmethod

+    def get_bookmark_publish_options():

+        options = nbxmpp.Node(nbxmpp.NS_DATA + ' x',

+                              attrs={'type': 'submit'})

+        f = options.addChild('field',

+                             attrs={'var': 'FORM_TYPE', 'type': 'hidden'})

+        f.setTagData('value', nbxmpp.NS_PUBSUB_PUBLISH_OPTIONS)

+        f = options.addChild('field', attrs={'var': 'pubsub#access_model'})

+        f.setTagData('value', 'whitelist')

+        return options

+

+    def store_bookmarks(self, storage_type=None):

+        if not app.account_is_connected(self._account):

+            return

+

+        storage_node = self._build_storage_node()

+

+        if storage_type is None:

+            if self._pubsub_support():

+                self._pubsub_store(storage_node)

+            else:

+                self._private_store(storage_node)

+        elif storage_type == BookmarkStorageType.PUBSUB:

+            if self._pubsub_support():

+                self._pubsub_store(storage_node)

+        elif storage_type == BookmarkStorageType.PRIVATE:

+            self._private_store(storage_node)

+

+    def _pubsub_store(self, storage_node):

+        self._con.get_module('PubSub').send_pb_publish(

+            '', 'storage:bookmarks', storage_node, 'current',

+            options=self.get_bookmark_publish_options(),

+            cb=self._pubsub_store_result)

+        log.info('Publish Bookmarks (PubSub)')

+

+    def _private_store(self, storage_node):

+        iq = nbxmpp.Iq('set', nbxmpp.NS_PRIVATE, payload=storage_node)

+        log.info('Publish Bookmarks (PrivateStorage)')

+        self._con.connection.SendAndCallForResponse(

+            iq, self._private_store_result)

+

+    def _pubsub_store_result(self, conn, stanza):

+        if not nbxmpp.isResultNode(stanza):

+            log.error('Error: %s', stanza.getError())

+            return

+

+    def _private_store_result(self, stanza):

+        if not nbxmpp.isResultNode(stanza):

+            log.error('Error: %s', stanza.getError())

+            return

+

+    def auto_join_bookmarks(self):

+        if app.is_invisible(self._account):

+            return

+        for jid, bm in self.bookmarks.items():

+            if bm['autojoin'] in ('1', 'true'):

+                # Only join non-opened groupchats. Opened one are already

+                # auto-joined on re-connection

+                if jid not in app.gc_connected[self._account]:

+                    # we are not already connected

+                    minimize = bm['minimize'] in ('1', 'true')

+                    app.interface.join_gc_room(

+                        self._account, jid, bm['nick'],

+                        bm['password'], minimize=minimize)

+

+    def add_bookmark(self, name, jid, autojoin,

+                     minimize, password, nick):

+        self.bookmarks[jid] = {

+            'name': name,

+            'autojoin': autojoin,

+            'minimize': minimize,

+            'password': password,

+            'nick': nick}

+

+        self.store_bookmarks()

+        app.nec.push_incoming_event(BookmarksReceivedEvent(

+            None, account=self._account))

+

+    def get_name_from_bookmark(self, jid):

+        try:

+            return self.bookmarks[jid]['name']

+        except KeyError:

+            return jid.split('@')[0]

+

+    def purge_pubsub_bookmarks(self):

+        log.info('Purge/Delete Bookmarks on PubSub, '

+                 'because publish options are not available')

+        self._con.get_module('PubSub').send_pb_purge('', 'storage:bookmarks')

+        self._con.get_module('PubSub').send_pb_delete('', 'storage:bookmarks')

+

+

+class BookmarksReceivedEvent(NetworkIncomingEvent):

+    name = 'bookmarks-received'

+    base_network_events = []
+# Copyright (C) 2006 Tomasz Melcer <liori AT exroot.org>

+# Copyright (C) 2006-2014 Yann Leboulanger <asterix AT lagaule.org>

+# Copyright (C) 2007 Jean-Marie Traissard <jim AT lapin.org>

+# Copyright (C) 2008 Stephan Erb <steve-e AT h3c.de>

+# Copyright (C) 2018 Philipp Hörist <philipp AT hoerist.com>

+#

+# This file is part of Gajim.

+#

+# Gajim is free software; you can redistribute it and/or modify

+# it under the terms of the GNU General Public License as published

+# by the Free Software Foundation; version 3 only.

+#

+# Gajim is distributed in the hope that it will be useful,

+# but WITHOUT ANY WARRANTY; without even the implied warranty of

+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

+# GNU General Public License for more details.

+#

+# You should have received a copy of the GNU General Public License

+# along with Gajim.  If not, see <http://www.gnu.org/licenses/>.

+

+# XEP-0060: Publish-Subscribe

+

+import logging

+

+import nbxmpp

+

+from gajim.common import app

+

+log = logging.getLogger('gajim.c.m.pubsub')

+

+

+class PubSub:

+    def __init__(self, con):

+        self._con = con

+        self._account = con.name

+

+        self.handlers = []

+

+    def send_pb_subscription_query(self, jid, cb, **kwargs):

+        if not app.account_is_connected(self._account):

+            return

+

+        query = nbxmpp.Iq('get', to=jid)

+        pb = query.addChild('pubsub', namespace=nbxmpp.NS_PUBSUB)

+        pb.addChild('subscriptions')

+

+        self._con.connection.SendAndCallForResponse(query, cb, kwargs)

+

+    def send_pb_subscribe(self, jid, node, cb, **kwargs):

+        if not app.account_is_connected(self._account):

+            return

+

+        our_jid = app.get_jid_from_account(self._account)

+        query = nbxmpp.Iq('set', to=jid)

+        pb = query.addChild('pubsub', namespace=nbxmpp.NS_PUBSUB)

+        pb.addChild('subscribe', {'node': node, 'jid': our_jid})

+

+        self._con.connection.SendAndCallForResponse(query, cb, kwargs)

+

+    def send_pb_unsubscribe(self, jid, node, cb, **kwargs):

+        if not app.account_is_connected(self._account):

+            return

+

+        our_jid = app.get_jid_from_account(self._account)

+        query = nbxmpp.Iq('set', to=jid)

+        pb = query.addChild('pubsub', namespace=nbxmpp.NS_PUBSUB)

+        pb.addChild('unsubscribe', {'node': node, 'jid': our_jid})

+

+        self._con.connection.SendAndCallForResponse(query, cb, kwargs)

+

+    def send_pb_publish(self, jid, node, item,

+                        id_=None, options=None, cb=None, **kwargs):

+        if not app.account_is_connected(self._account):

+            return

+

+        if cb is None:

+            cb = self._default_callback

+

+        query = nbxmpp.Iq('set', to=jid)

+        e = query.addChild('pubsub', namespace=nbxmpp.NS_PUBSUB)

+        p = e.addChild('publish', {'node': node})

+        attrs = {}

+        if id_:

+            attrs = {'id': id_}

+        p.addChild('item', attrs, [item])

+        if options:

+            p = e.addChild('publish-options')

+            p.addChild(node=options)

+

+        self._con.connection.SendAndCallForResponse(query, cb, kwargs)

+

+    @staticmethod

+    def get_pb_retrieve_iq(jid, node, item_id=None):

+        """

+        Get IQ to query items from a node

+        """

+        query = nbxmpp.Iq('get', to=jid)

+        r = query.addChild('pubsub', namespace=nbxmpp.NS_PUBSUB)

+        r = r.addChild('items', {'node': node})

+        if item_id is not None:

+            r.addChild('item', {'id': item_id})

+        return query

+

+    def send_pb_retrieve(self, jid, node, item_id=None, cb=None, **kwargs):

+        """

+        Get items from a node

+        """

+        if not app.account_is_connected(self._account):

+            return

+

+        if cb is None:

+            cb = self._default_callback

+

+        query = self.get_pb_retrieve_iq(jid, node, item_id)

+

+        self._con.connection.SendAndCallForResponse(query, cb, kwargs)

+

+    def send_pb_retract(self, jid, node, id_, cb=None, **kwargs):

+        """

+        Delete item from a node

+        """

+        if not app.account_is_connected(self._account):

+            return

+

+        if cb is None:

+            cb = self._default_callback

+

+        query = nbxmpp.Iq('set', to=jid)

+        r = query.addChild('pubsub', namespace=nbxmpp.NS_PUBSUB)

+        r = r.addChild('retract', {'node': node, 'notify': '1'})

+        r = r.addChild('item', {'id': id_})

+

+        self._con.connection.SendAndCallForResponse(query, cb, kwargs)

+

+    def send_pb_purge(self, jid, node, cb=None, **kwargs):

+        """

+        Purge node: Remove all items

+        """

+        if not app.account_is_connected(self._account):

+            return

+

+        if cb is None:

+            cb = self._default_callback

+

+        query = nbxmpp.Iq('set', to=jid)

+        d = query.addChild('pubsub', namespace=nbxmpp.NS_PUBSUB_OWNER)

+        d = d.addChild('purge', {'node': node})

+

+        self._con.connection.SendAndCallForResponse(query, cb, kwargs)

+

+    def send_pb_delete(self, jid, node, on_ok=None, on_fail=None):

+        """

+        Delete node

+        """

+        if not app.account_is_connected(self._account):

+            return

+        query = nbxmpp.Iq('set', to=jid)

+        d = query.addChild('pubsub', namespace=nbxmpp.NS_PUBSUB_OWNER)

+        d = d.addChild('delete', {'node': node})

+

+        def response(con, resp, jid, node):

+            if resp.getType() == 'result' and on_ok:

+                on_ok(jid, node)

+            elif on_fail:

+                msg = resp.getErrorMsg()

+                on_fail(jid, node, msg)

+

+        self._con.connection.SendAndCallForResponse(

+            query, response, {'jid': jid, 'node': node})

+

+    def send_pb_create(self, jid, node, cb,

+                       configure=False, configure_form=None):

+        """

+        Create a new node

+        """

+        if not app.account_is_connected(self._account):

+            return

+        query = nbxmpp.Iq('set', to=jid)

+        c = query.addChild('pubsub', namespace=nbxmpp.NS_PUBSUB)

+        c = c.addChild('create', {'node': node})

+        if configure:

+            conf = c.addChild('configure')

+            if configure_form is not None:

+                conf.addChild(node=configure_form)

+

+        self._con.connection.SendAndCallForResponse(query, cb)

+

+    def send_pb_configure(self, jid, node, form, cb=None):

+        if not app.account_is_connected(self._account):

+            return

+

+        if cb is None:

+            cb = self._default_callback

+

+        query = nbxmpp.Iq('set', to=jid)

+        c = query.addChild('pubsub', namespace=nbxmpp.NS_PUBSUB_OWNER)

+        c = c.addChild('configure', {'node': node})

+        c.addChild(node=form)

+

+        self._con.connection.SendAndCallForResponse(query, cb)

+

+    def request_pb_configuration(self, jid, node, cb=None):

+        if not app.account_is_connected(self._account):

+            return

+

+        if cb is None:

+            cb = self._default_callback

+

+        query = nbxmpp.Iq('get', to=jid)

+        e = query.addChild('pubsub', namespace=nbxmpp.NS_PUBSUB_OWNER)

+        e = e.addChild('configure', {'node': node})

+

+        self._con.connection.SendAndCallForResponse(query, cb)

+

+    def _default_callback(self, conn, stanza, *args, **kwargs):

+        if not nbxmpp.isResultNode(stanza):

+            log.warning('Error: %s', stanza.getError())
+# This file is part of Gajim.

+#

+# Gajim is free software; you can redistribute it and/or modify

+# it under the terms of the GNU General Public License as published

+# by the Free Software Foundation; version 3 only.

+#

+# Gajim is distributed in the hope that it will be useful,

+# but WITHOUT ANY WARRANTY; without even the implied warranty of

+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

+# GNU General Public License for more details.

+#

+# You should have received a copy of the GNU General Public License

+# along with Gajim.  If not, see <http://www.gnu.org/licenses/>.

+

+# XEP-0084: User Avatar

+

+import logging

+import base64

+import binascii

+

+import nbxmpp

+

+from gajim.common import app

+from gajim.common.exceptions import StanzaMalformed

+

+log = logging.getLogger('gajim.c.m.user_avatar')

+

+

+class UserAvatar:

+    def __init__(self, con):

+        self._con = con

+        self._account = con.name

+

+        self.handlers = []

+

+    def get_pubsub_avatar(self, jid, item_id):

+        log.info('Request: %s %s', jid, item_id)

+        self._con.get_module('PubSub').send_pb_retrieve(

+            jid, 'urn:xmpp:avatar:data', item_id, self._avatar_received)

+

+    def _validate_avatar_node(self, stanza):

+        jid = stanza.getFrom()

+        if jid is None:

+            jid = self._con.get_own_jid().getStripped()

+        else:

+            jid = jid.getStripped()

+

+        if nbxmpp.isErrorNode(stanza):

+            raise StanzaMalformed(stanza.getErrorMsg())

+

+        pubsub_node = stanza.getTag('pubsub')

+        if pubsub_node is None:

+            raise StanzaMalformed('No pubsub node', stanza)

+

+        items_node = pubsub_node.getTag('items')

+        if items_node is None:

+            raise StanzaMalformed('No items node', stanza)

+

+        if items_node.getAttr('node') != 'urn:xmpp:avatar:data':

+            raise StanzaMalformed('Wrong namespace', stanza)

+

+        item = items_node.getTag('item')

+        if item is None:

+            raise StanzaMalformed('No item node', stanza)

+

+        sha = item.getAttr('id')

+        data_tag = item.getTag('data', namespace='urn:xmpp:avatar:data')

+        if sha is None or data_tag is None:

+            raise StanzaMalformed('No id attr or data node found', stanza)

+

+        data = data_tag.getData()

+        if data is None:

+            raise StanzaMalformed('Data node empty', stanza)

+

+        data = base64.b64decode(data.encode('utf-8'))

+

+        return jid, sha, data

+

+    def _avatar_received(self, conn, stanza):

+        try:

+            jid, sha, data = self._validate_avatar_node(stanza)

+        except (StanzaMalformed, binascii.Error) as error:

+            log.warning('Error: %s %s', stanza.getFrom(), error)

+            return

+

+        log.info('Received: %s %s', jid, sha)

+        app.interface.save_avatar(data)

+

+        if self._con.get_own_jid().bareMatch(jid):

+            app.config.set_per('accounts', self._account, 'avatar_sha', sha)

+        else:

+            own_jid = self._con.get_own_jid().getStripped()

+            app.logger.set_avatar_sha(own_jid, jid, sha)

+            app.contacts.set_avatar(self._account, jid, sha)

+

+        app.interface.update_avatar(self._account, jid)
         for item in items.getTags('item'):

             metadata = item.getTag('metadata')

             if metadata is None:

-                app.log('avatar').warning('Invalid avatar stanza:\n%s', items)

+                app.log('c.m.user_avatar').warning(

+                    'Invalid avatar stanza:\n%s', items)

                 break

             info = item.getTag('metadata').getTag('info')

             if info is not None:

         con = app.connections[account]

         if self.avatar is None:

             # Remove avatar

-            app.log('avatar').info('Remove (Pubsub): %s', jid)

+            app.log('c.m.user_avatar').info('Remove: %s', jid)

             app.contacts.set_avatar(account, jid, None)

             own_jid = con.get_own_jid().getStripped()

             app.logger.set_avatar_sha(own_jid, jid, None)

             app.interface.update_avatar(account, jid)

         else:

             sha = app.contacts.get_avatar_sha(account, jid)

-            app.log('avatar').info(

-                'Update (Pubsub): %s %s', jid, self.avatar['id'])

+            app.log('c.m.user_avatar').info(

+                'Update: %s %s', jid, self.avatar['id'])

             if sha == self.avatar['id']:

-                app.log('avatar').info(

-                    'Avatar already known (Pubsub): %s %s',

+                app.log('c.m.user_avatar').info(

+                    'Avatar already known: %s %s',

                     jid, self.avatar['id'])

                 return

-            app.log('avatar').info('Request (Pubsub): %s', jid)

-            con.get_pubsub_avatar(jid, 'urn:xmpp:avatar:data',

-                                  self.avatar['id'])

+            con.get_module('UserAvatar').get_pubsub_avatar(

+                jid, self.avatar['id'])

 SUPPORTED_PERSONAL_USER_EVENTS = [

-# -*- coding:utf-8 -*-

-## src/common/pubsub.py

-##

-## Copyright (C) 2006 Tomasz Melcer <liori AT exroot.org>

-## Copyright (C) 2006-2014 Yann Leboulanger <asterix AT lagaule.org>

-## Copyright (C) 2007 Jean-Marie Traissard <jim AT lapin.org>

-## Copyright (C) 2008 Stephan Erb <steve-e AT h3c.de>

-##

-## This file is part of Gajim.

-##

-## Gajim is free software; you can redistribute it and/or modify

-## it under the terms of the GNU General Public License as published

-## by the Free Software Foundation; version 3 only.

-##

-## Gajim is distributed in the hope that it will be useful,

-## but WITHOUT ANY WARRANTY; without even the implied warranty of

-## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

-## GNU General Public License for more details.

-##

-## You should have received a copy of the GNU General Public License

-## along with Gajim. If not, see <http://www.gnu.org/licenses/>.

-##

-

-import base64

-import binascii

-

-import nbxmpp

-from gajim.common import app

-#TODO: Doesn't work

-#from common.connection_handlers import PEP_CONFIG

-PEP_CONFIG = 'pep_config'

-from gajim.common import ged

-from gajim.common.connection_handlers_events import PubsubReceivedEvent

-from gajim.common.connection_handlers_events import PubsubBookmarksReceivedEvent

-from gajim.common.exceptions import StanzaMalformed

-

-import logging

-log = logging.getLogger('gajim.c.pubsub')

-

-class ConnectionPubSub:

-    def __init__(self):

-        self.__callbacks = {}

-        app.nec.register_incoming_event(PubsubBookmarksReceivedEvent)

-        app.ged.register_event_handler('pubsub-bookmarks-received',

-            ged.CORE, self._nec_pubsub_bookmarks_received)

-

-    def cleanup(self):

-        app.ged.remove_event_handler('pubsub-bookmarks-received',

-            ged.CORE, self._nec_pubsub_bookmarks_received)

-

-    def send_pb_subscription_query(self, jid, cb, *args, **kwargs):

-        if not self.connection or self.connected < 2:

-            return

-        query = nbxmpp.Iq('get', to=jid)

-        pb = query.addChild('pubsub', namespace=nbxmpp.NS_PUBSUB)

-        pb.addChild('subscriptions')

-

-        id_ = self.connection.send(query)

-

-        self.__callbacks[id_] = (cb, args, kwargs)

-

-    def send_pb_subscribe(self, jid, node, cb, *args, **kwargs):

-        if not self.connection or self.connected < 2:

-            return

-        our_jid = app.get_jid_from_account(self.name)

-        query = nbxmpp.Iq('set', to=jid)

-        pb = query.addChild('pubsub', namespace=nbxmpp.NS_PUBSUB)

-        pb.addChild('subscribe', {'node': node, 'jid': our_jid})

-

-        id_ = self.connection.send(query)

-

-        self.__callbacks[id_] = (cb, args, kwargs)

-

-    def send_pb_unsubscribe(self, jid, node, cb, *args, **kwargs):

-        if not self.connection or self.connected < 2:

-            return

-        our_jid = app.get_jid_from_account(self.name)

-        query = nbxmpp.Iq('set', to=jid)

-        pb = query.addChild('pubsub', namespace=nbxmpp.NS_PUBSUB)

-        pb.addChild('unsubscribe', {'node': node, 'jid': our_jid})

-

-        id_ = self.connection.send(query)

-

-        self.__callbacks[id_] = (cb, args, kwargs)

-

-    def send_pb_publish(self, jid, node, item, id_=None, options=None):

-        """

-        Publish item to a node

-        """

-        if not self.connection or self.connected < 2:

-            return

-        query = nbxmpp.Iq('set', to=jid)

-        e = query.addChild('pubsub', namespace=nbxmpp.NS_PUBSUB)

-        p = e.addChild('publish', {'node': node})

-        attrs = {}

-        if id_:

-            attrs = {'id': id_}

-        p.addChild('item', attrs, [item])

-        if options:

-            p = e.addChild('publish-options')

-            p.addChild(node=options)

-

-        self.connection.send(query)

-

-    @staticmethod

-    def get_pb_retrieve_iq(jid, node, item_id=None):

-        """

-        Get IQ to query items from a node

-        """

-        query = nbxmpp.Iq('get', to=jid)

-        r = query.addChild('pubsub', namespace=nbxmpp.NS_PUBSUB)

-        r = r.addChild('items', {'node': node})

-        if item_id is not None:

-            r.addChild('item', {'id': item_id})

-        return query

-

-    def send_pb_retrieve(self, jid, node, item_id=None, cb=None, *args, **kwargs):

-        """

-        Get items from a node

-        """

-        if not self.connection or self.connected < 2:

-            return

-        query = self.get_pb_retrieve_iq(jid, node, item_id)

-        id_ = self.connection.send(query)

-

-        if cb:

-            self.__callbacks[id_] = (cb, args, kwargs)

-

-    def get_pubsub_avatar(self, jid, node, item_id):

-        query = self.get_pb_retrieve_iq(jid, node, item_id)

-        self.connection.SendAndCallForResponse(

-            query, self._nec_pubsub_avatar_received, {'jid': jid})

-

-    def send_pb_retract(self, jid, node, id_):

-        """

-        Delete item from a node

-        """

-        if not self.connection or self.connected < 2:

-            return

-        query = nbxmpp.Iq('set', to=jid)

-        r = query.addChild('pubsub', namespace=nbxmpp.NS_PUBSUB)

-        r = r.addChild('retract', {'node': node, 'notify': '1'})

-        r = r.addChild('item', {'id': id_})

-

-        self.connection.send(query)

-

-    def send_pb_purge(self, jid, node):

-        """

-        Purge node: Remove all items

-        """

-        if not self.connection or self.connected < 2:

-            return

-        query = nbxmpp.Iq('set', to=jid)

-        d = query.addChild('pubsub', namespace=nbxmpp.NS_PUBSUB_OWNER)

-        d = d.addChild('purge', {'node': node})

-

-        self.connection.send(query)

-

-    def send_pb_delete(self, jid, node, on_ok=None, on_fail=None):

-        """

-        Delete node

-        """

-        if not self.connection or self.connected < 2:

-            return

-        query = nbxmpp.Iq('set', to=jid)

-        d = query.addChild('pubsub', namespace=nbxmpp.NS_PUBSUB_OWNER)

-        d = d.addChild('delete', {'node': node})

-

-        def response(con, resp, jid, node):

-            if resp.getType() == 'result' and on_ok:

-                on_ok(jid, node)

-            elif on_fail:

-                msg = resp.getErrorMsg()

-                on_fail(jid, node, msg)

-

-        self.connection.SendAndCallForResponse(query, response, {'jid': jid,

-            'node': node})

-

-    def send_pb_create(self, jid, node, configure=False, configure_form=None):

-        """

-        Create a new node

-        """

-        if not self.connection or self.connected < 2:

-            return

-        query = nbxmpp.Iq('set', to=jid)

-        c = query.addChild('pubsub', namespace=nbxmpp.NS_PUBSUB)

-        c = c.addChild('create', {'node': node})

-        if configure:

-            conf = c.addChild('configure')

-            if configure_form is not None:

-                conf.addChild(node=configure_form)

-

-        self.connection.send(query)

-

-    def send_pb_configure(self, jid, node, form):

-        if not self.connection or self.connected < 2:

-            return

-        query = nbxmpp.Iq('set', to=jid)

-        c = query.addChild('pubsub', namespace=nbxmpp.NS_PUBSUB_OWNER)

-        c = c.addChild('configure', {'node': node})

-        c.addChild(node=form)

-

-        self.connection.send(query)

-

-    def _PubSubCB(self, conn, stanza):

-        log.debug('_PubsubCB')

-        try:

-            cb, args, kwargs = self.__callbacks.pop(stanza.getID())

-            cb(conn, stanza, *args, **kwargs)

-        except Exception:

-            pass

-        app.nec.push_incoming_event(PubsubReceivedEvent(None,

-            conn=self, stanza=stanza))

-

-    def _nec_pubsub_bookmarks_received(self, obj):

-        if obj.conn.name != self.name:

-            return

-        app.log('bookmarks').info('Received Bookmarks (PubSub)')

-        bm_jids = [b['jid'] for b in self.bookmarks]

-        for bm in obj.bookmarks:

-            if bm['jid'] not in bm_jids:

-                self.bookmarks.append(bm)

-        # We got bookmarks from pubsub, now get those from xml to merge them

-        self.get_bookmarks(storage_type='xml')

-

-    def _validate_avatar_node(self, stanza):

-        jid = stanza.getFrom()

-        if jid is None:

-            jid = self.get_own_jid().getStripped()

-        else:

-            jid = jid.getStripped()

-

-        if nbxmpp.isErrorNode(stanza):

-            raise StanzaMalformed(stanza.getErrorMsg())

-

-        pubsub_node = stanza.getTag('pubsub')

-        if pubsub_node is None:

-            raise StanzaMalformed('No pubsub node', stanza)

-

-        items_node = pubsub_node.getTag('items')

-        if items_node is None:

-            raise StanzaMalformed('No items node', stanza)

-

-        if items_node.getAttr('node') != 'urn:xmpp:avatar:data':

-            raise StanzaMalformed('Wrong namespace', stanza)

-

-        item = items_node.getTag('item')

-        if item is None:

-            raise StanzaMalformed('No item node', stanza)

-

-        sha = item.getAttr('id')

-        data_tag = item.getTag('data', namespace='urn:xmpp:avatar:data')

-        if sha is None or data_tag is None:

-            raise StanzaMalformed('No id attr or data node found', stanza)

-

-        data = data_tag.getData()

-        if data is None:

-            raise StanzaMalformed('Data node empty', stanza)

-

-        data = base64.b64decode(data.encode('utf-8'))

-

-        return jid, sha, data

-

-    def _nec_pubsub_avatar_received(self, conn, stanza, jid):

-        try:

-            jid, sha, data = self._validate_avatar_node(stanza)

-        except (StanzaMalformed, binascii.Error) as error:

-            app.log('avatar').warning(

-                'Error loading Avatar (Pubsub): %s %s', jid, error)

-            return

-

-        app.log('avatar').info(

-            'Received Avatar (Pubsub): %s %s', jid, sha)

-        app.interface.save_avatar(data)

-

-        if self.get_own_jid().bareMatch(jid):

-            app.config.set_per('accounts', self.name, 'avatar_sha', sha)

-        else:

-            own_jid = self.get_own_jid().getStripped()

-            app.logger.set_avatar_sha(own_jid, jid, sha)

-            app.contacts.set_avatar(self.name, jid, sha)

-

-        app.interface.update_avatar(self.name, jid)

-

-    def _PubSubErrorCB(self, conn, stanza):

-        log.debug('_PubsubErrorCB')

-        pubsub = stanza.getTag('pubsub')

-        if not pubsub:

-            return

-        items = pubsub.getTag('items')

-        if not items:

-            return

-        if items.getAttr('node') == 'storage:bookmarks':

-            # Receiving bookmarks from pubsub failed, so take them from xml

-            self.get_bookmarks(storage_type='xml')

-

-    def request_pb_configuration(self, jid, node):

-        if not self.connection or self.connected < 2:

-            return

-        query = nbxmpp.Iq('get', to=jid)

-        e = query.addChild('pubsub', namespace=nbxmpp.NS_PUBSUB_OWNER)

-        e = e.addChild('configure', {'node': node})

-        id_ = self.connection.getAnID()

-        query.setID(id_)

-        self.awaiting_answers[id_] = (PEP_CONFIG,)

-        self.connection.send(query)
             iter_ = self.treestore.append(None, [None, account, None, None,

                     None, None, None, None])

-            for bookmark in app.connections[account].bookmarks:

+            con = app.connections[account]

+            bookmarks = con.get_module('Bookmarks').bookmarks

+            for jid, bookmark in bookmarks.items():

                 if not bookmark['name']:

                     # No name was given for this bookmark.

                     # Use the first part of JID instead...

-                    name = bookmark['jid'].split("@")[0]

+                    name = jid.split("@")[0]

                     bookmark['name'] = name

                 # make '1', '0', 'true', 'false' (or other) to True/False

                 self.treestore.append(iter_, [

                                 account,

                                 bookmark['name'],

-                                bookmark['jid'],

+                                jid,

                                 autojoin,

                                 minimize,

                                 bookmark['password'],

         Parse the treestore data into our new bookmarks array, then send the new

         bookmarks to the server.

         """

+

         (model, iter_) = self.selection.get_selected()

         if iter_ and model.iter_parent(iter_):

-            #bookmark selected, check it

+            # bookmark selected, check it

             if not self.check_valid_bookmark():

                 return

         for account in self.treestore:

             acct = account[1]

-            app.connections[acct].bookmarks = []

+            con = app.connections[acct]

+            con.get_module('Bookmarks').bookmarks = {}

             for bm in account.iterchildren():

                 # Convert True/False/None to '1' or '0'

                 nick = bm[6]

                 # create the bookmark-dict

-                bmdict = { 'name': name, 'jid': jid, 'autojoin': autojoin,

-                    'minimize': minimize, 'password': pw, 'nick': nick,

+                bmdict = {

+                    'name': name,

+                    'autojoin': autojoin,

+                    'minimize': minimize,

+                    'password': pw,

+                    'nick': nick,

                     'print_status': bm[7]}

-                app.connections[acct].bookmarks.append(bmdict)

+                con.get_module('Bookmarks').bookmarks[jid] = bmdict

-            app.connections[acct].store_bookmarks()

+            con.get_module('Bookmarks').store_bookmarks()

             gui_menu_builder.build_bookmark_menu(acct)

         self.window.destroy()

         model, iter_ = selection.get_selected()

         node = model[iter_][0]

         our_jid = app.get_jid_from_account(self.account)

-        app.connections[self.account].send_pb_delete(our_jid, node,

-            on_ok=self.node_removed, on_fail=self.node_not_removed)

+        con = app.connections[self.account]

+        con.get_module('PubSub').send_pb_delete(our_jid, node,

+                           on_ok=self.node_removed,

+                           on_fail=self.node_not_removed)

     def on_configure_button_clicked(self, widget):

         selection = self.treeview.get_selection()

         model, iter_ = selection.get_selected()

         node = model[iter_][0]

         our_jid = app.get_jid_from_account(self.account)

-        app.connections[self.account].request_pb_configuration(our_jid, node)

+        con = app.connections[self.account]

+        con.get_module('PubSub').request_pb_configuration(our_jid, node)

     def _nec_pep_config_received(self, obj):

         def on_ok(form, node):

             form.type_ = 'submit'

             our_jid = app.get_jid_from_account(self.account)

-            app.connections[self.account].send_pb_configure(our_jid, node, form)

+            con = app.connections[self.account]

+            con.get_module('PubSub').send_pb_configure(our_jid, node, form)

         window = dialogs.DataFormWindow(obj.form, (on_ok, obj.node))

         title = _('Configure %s') % obj.node

         window.set_title(title)

         self.autojoin_switch.set_sensitive(switch.get_active())

     def _add_bookmark(self, account, nickname, password):

-        if not app.connections[account].private_storage_supported:

+        con = app.connections[account]

+        if not con.private_storage_supported:

             return

         add_bookmark = self.bookmark_switch.get_active()

         # Add as bookmark, with autojoin and not minimized

         name = app.get_nick_from_jid(self.room_jid)

-        app.interface.add_gc_bookmark(

-            account, name, self.room_jid, autojoin, 1, password, nickname)

+        con.get_module('Bookmarks').add_bookmark(

+            name, self.room_jid, autojoin, 1, password, nickname)

     def _on_destroy(self, *args):

         if self.minimal_mode == 0:

         show_account = len(self.accounts) > 1

         for account in self.accounts:

             self.new_groupchat_rows[account] = None

-            bookmarks = app.connections[account].bookmarks

+            con = app.connections[account]

+            bookmarks = con.get_module('Bookmarks').bookmarks

             groupchats = {}

-            for bookmark in bookmarks:

-                groupchats[bookmark['jid']] = bookmark['name']

+            for jid, bookmark in bookmarks.items():

+                groupchats[jid] = bookmark['name']

             for jid in app.contacts.get_gc_list(account):

                 if jid in groupchats:

             self.join_button = None

     def on_bookmark_button_clicked(self, *args):

+        con = app.connections[self.account]

         model, iter = self.window.services_treeview.get_selection().get_selected()

         if not iter:

             return

         name = app.config.get_per('accounts', self.account, 'name')

         room_jid = model[iter][0]

         bm = {

-                'name': room_jid.split('@')[0],

-                'jid': room_jid,

-                'autojoin': '0',

-                'minimize': '0',

-                'password': '',

-                'nick': name

+            'name': room_jid.split('@')[0],

+            'autojoin': '0',

+            'minimize': '0',

+            'password': '',

+            'nick': name

         }

-        for bookmark in app.connections[self.account].bookmarks:

-            if bookmark['jid'] == bm['jid']:

-                dialogs.ErrorDialog( _('Bookmark already set'),

-                _('Group Chat "%s" is already in your bookmarks.') % bm['jid'],

+        if room_jid in con.get_module('Bookmarks').bookmarks:

+            dialogs.ErrorDialog(

+                _('Bookmark already set'),

+                _('Group Chat "%s" is already in your bookmarks.') % room_jid,

                 transient_for=self.window.window)

-                return

+            return

-        app.connections[self.account].bookmarks.append(bm)

-        app.connections[self.account].store_bookmarks()

+        con.get_module('Bookmarks').bookmarks[room_jid] = bm

+        con.get_module('Bookmarks').store_bookmarks()

         gui_menu_builder.build_bookmark_menu(self.account)

         self.subscribe_button = None

         self.unsubscribe_button = None

-        app.connections[account].send_pb_subscription_query(jid,

-            self._on_pep_subscriptions)

+        con = app.connections[account]

+        con.get_module('PubSub').send_pb_subscription_query(

+            jid, self._on_pep_subscriptions)

     def _create_treemodel(self):

         """

         model, iter_ = self.window.services_treeview.get_selection().get_selected()

         if iter_ is None: return

-        groupnode = model.get_value(iter_, 1)   # 1 = groupnode

+        node = model.get_value(iter_, 1)   # 1 = groupnode

-        app.connections[self.account].send_pb_subscribe(self.jid, groupnode,

-            self._on_pep_subscribe, groupnode)

+        con = app.connections[self.account]

+        con.get_module('PubSub').send_pb_subscribe(

+            self.jid, node, self._on_pep_subscribe, groupnode=node)

     def on_unsubscribe_button_clicked(self, widget):

         """

         model, iter_ = self.window.services_treeview.get_selection().get_selected()

         if iter_ is None: return

-        groupnode = model.get_value(iter_, 1) # 1 = groupnode

+        node = model.get_value(iter_, 1) # 1 = groupnode

-        app.connections[self.account].send_pb_unsubscribe(self.jid, groupnode,

-            self._on_pep_unsubscribe, groupnode)

+        con = app.connections[self.account]

+        con.get_module('PubSub').send_pb_unsubscribe(

+            self.jid, node, self._on_pep_unsubscribe, groupnode=node)

     def _on_pep_subscriptions(self, conn, request):

         """

         # we now know subscriptions, update button states

         self.update_actions()

-        raise nbxmpp.NodeProcessed

-

     def _on_pep_subscribe(self, conn, request, groupnode):

         """

         We have just subscribed to a node. Update UI

         self.update_actions()

-        raise nbxmpp.NodeProcessed

-

     def _on_pep_unsubscribe(self, conn, request, groupnode):

         """

         We have just unsubscribed from a node. Update UI

         self.update_actions()

-        raise nbxmpp.NodeProcessed

-

 # Fill the global agent type info dictionary

 _agent_type_info = _gen_agent_type_info()
         self.room_jid = self.contact.jid

         self.nick = nick

         self.new_nick = ''

-        self.name = ''

-        for bm in app.connections[self.account].bookmarks:

-            if bm['jid'] == self.room_jid:

-                self.name = bm['name']

-                break

-        if not self.name:

-            self.name = self.room_jid.split('@')[0]

+

+        bm_module = app.connections[self.account].get_module('Bookmarks')

+        self.name = bm_module.get_name_from_bookmark(self.room_jid)

+

         self.contact.name = self.name

         self.widget_set_visible(self.xml.get_object('banner_eventbox'),

         # Bookmarks

         con = app.connections[self.account]

         bookmark_support = con.bookmarks_available()

-        not_bookmarked = True

-        for bm in con.bookmarks:

-            if bm['jid'] == self.room_jid:

-                not_bookmarked = False

-                break

+        bookmarked = self.room_jid in con.get_module('Bookmarks').bookmarks

         win.lookup_action('bookmark-' + self.control_id).set_enabled(

-            online and bookmark_support and not_bookmarked)

+            online and bookmark_support and not bookmarked)

         # Request Voice

         role = self.get_role(self.nick)

         Bookmark the room, without autojoin and not minimized

         """

         password = app.gc_passwords.get(self.room_jid, '')

-        app.interface.add_gc_bookmark(

-            self.account, self.name, self.room_jid,

-            '0', '0', password, self.nick)

+        con = app.connections[self.account]

+        con.get_module('Bookmarks').add_bookmark(

+            self.name, self.room_jid,

+            '1', '1', password, self.nick)

         self.update_actions()

     def _on_request_voice(self, action, param):

         item.addChild('content', {}, [buf.get_text(buf.get_start_iter(), buf.get_end_iter(), True)])

         # publish it to node

-        app.connections[self.account].send_pb_publish(self.servicejid, self.groupid, item, '0')

+        con = app.connections[self.account]

+        con.get_module('PubSub').send_pb_publish(

+            self.servicejid, self.groupid, item, '0')

         # close the window

         self.window.destroy()
             self.instances[account]['sub_request'][obj.jid].destroy()

     def handle_event_bookmarks(self, obj):

-        # ('BOOKMARKS', account, [{name,jid,autojoin,password,nick}, {}])

-        # We received a bookmark item from the server (JEP48)

-        # Auto join GC windows if necessary

-

-        gui_menu_builder.build_bookmark_menu(obj.conn.name)

-        invisible_show = app.SHOW_LIST.index('invisible')

-        # do not autojoin if we are invisible

-        if obj.conn.connected == invisible_show:

-            return

-

-        GLib.idle_add(self.auto_join_bookmarks, obj.conn.name)

+        gui_menu_builder.build_bookmark_menu(obj.account)

     def handle_event_file_send_error(self, account, array):

         jid = array[0]

             if isinstance(ctrl, ChatControlBase):

                 ctrl.scroll_to_end()

-

     def join_gc_minimal(self, account, room_jid, password=None,

     transient_for=None):

         if account is not None:

                 app.interface.join_gc_room(account, room_jid, '', '')

                 return

-            for bookmark in app.connections[account].bookmarks:

-                if bookmark['jid'] != room_jid:

-                    continue

+            con = app.connections[account]

+            bookmarks = con.get_module('Bookmarks').bookmarks

+            bookmark = bookmarks.get(room_jid, None)

+            if bookmark is not None:

                 app.interface.join_gc_room(

                     account, room_jid, bookmark['nick'], bookmark['password'])

                 return

             return False

         return True

-    def auto_join_bookmarks(self, account):

-        """

-        Autojoin bookmarked GCs that have 'auto join' on for this account

-        """

-        for bm in app.connections[account].bookmarks:

-            if bm['autojoin'] in ('1', 'true'):

-                jid = bm['jid']

-                # Only join non-opened groupchats. Opened one are already

-                # auto-joined on re-connection

-                if not jid in app.gc_connected[account]:

-                    # we are not already connected

-                    minimize = bm['minimize'] in ('1', 'true')

-                    self.join_gc_room(account, jid, bm['nick'],

-                        bm['password'], minimize = minimize)

-

-    def add_gc_bookmark(self, account, name, jid, autojoin, minimize, password,

-                        nick):

-        """

-        Add a bookmark for this account, sorted in bookmark list

-        """

-        bm = {

-                'name': name,

-                'jid': jid,

-                'autojoin': autojoin,

-                'minimize': minimize,

-                'password': password,

-                'nick': nick

-        }

-        place_found = False

-        index = 0

-        # check for duplicate entry and respect alpha order

-        for bookmark in app.connections[account].bookmarks:

-            if bookmark['jid'] == bm['jid']:

-                return

-            if bookmark['name'] > bm['name']:

-                place_found = True

-                break

-            index += 1

-        if place_found:

-            app.connections[account].bookmarks.insert(index, bm)

-        else:

-            app.connections[account].bookmarks.append(bm)

-        app.connections[account].store_bookmarks()

-        gui_menu_builder.build_bookmark_menu(account)

-

     # does JID exist only within a groupchat?

     def is_pm_contact(self, fjid, account):

         bare_jid = app.get_jid_without_resource(fjid)

     rooms2 = [] # a list of (room_jid, account) tuple

     r_jids = [] # list of room jids

     for account in connected_accounts:

-        for room in app.connections[account].bookmarks:

-            r_jid = room['jid']

-            if r_jid in r_jids:

+        con = app.connections[account]

+        boomarks = con.get_module('Bookmarks').bookmarks

+        for jid, bookmark in boomarks.items():

+            if jid in r_jids:

                 continue

-            if r_jid not in app.gc_connected[account] or not \

-            app.gc_connected[account][r_jid]:

-                rooms2.append((r_jid, account))

-                r_jids.append(r_jid)

+            if jid not in app.gc_connected[account] or not \

+            app.gc_connected[account][jid]:

+                rooms2.append((jid, account))

+                r_jids.append(jid)

     if not rooms2:

         return

 def get_bookmarks_menu(account, rebuild=False):

-    if not app.connections[account].bookmarks:

+    con = app.connections[account]

+    boomarks = con.get_module('Bookmarks').bookmarks

+    if not boomarks:

         return None

     menu = Gio.Menu()

     # Build Bookmarks

     section = Gio.Menu()

-    for bookmark in app.connections[account].bookmarks:

+    for jid, bookmark in boomarks.items():

         name = bookmark['name']

         if not name:

             # No name was given for this bookmark.

             # Use the first part of JID instead...

-            name = bookmark['jid'].split("@")[0]

+            name = jid.split("@")[0]

         # Shorten long names

         name = (name[:42] + '..') if len(name) > 42 else name

         # Create Variant Dict

         dict_ = {'account': GLib.Variant('s', account),

-                 'jid': GLib.Variant('s', bookmark['jid'])}

+                 'jid': GLib.Variant('s', jid)}

         if bookmark['nick']:

             dict_['nick'] = GLib.Variant('s', bookmark['nick'])

         if bookmark['password']:

                             auto=auto)

             if was_invisible and status != 'offline':

                 # We come back from invisible, join bookmarks

-                app.interface.auto_join_bookmarks(account)

+                con = app.connections[account]

+                con.get_module('Bookmarks').auto_join_bookmarks()

     def chg_contact_status(self, contact, show, status, account):

 ### FIXME: order callbacks in itself...

 ################################################################################

-    def on_bookmark_menuitem_activate(self, widget, account, bookmark):

-        app.interface.join_gc_room(account, bookmark['jid'], bookmark['nick'],

-                bookmark['password'])

+    def on_bookmark_menuitem_activate(self, widget, account, jid, bookmark):

+        app.interface.join_gc_room(

+            account, jid, bookmark['nick'], bookmark['password'])

     def on_info(self, widget, contact, account):

         """

         gc_sub_menu.append(item)

         # User has at least one bookmark.

-        if app.connections[account].bookmarks:

+        con = app.connections[account]

+        if con.get_module('Bookmarks').bookmarks:

             item = Gtk.SeparatorMenuItem.new()

             gc_sub_menu.append(item)

-        for bookmark in app.connections[account].bookmarks:

+        for jid, bookmark in con.get_module('Bookmarks').bookmarks.items():

             name = bookmark['name']

             if not name:

                 # No name was given for this bookmark.

                 # Use the first part of JID instead...

-                name = bookmark['jid'].split("@")[0]

+                name = jid.split("@")[0]

             # Shorten long names

             name = (name[:42] + '..') if len(name) > 42 else name

             # Do not use underline.

             item = Gtk.MenuItem.new_with_label(name)

             item.set_use_underline(False)

-            item.connect('activate', self.on_bookmark_menuitem_activate,

-                    account, bookmark)

+            item.connect(

+                'activate', self.on_bookmark_menuitem_activate,

+                account, jid, bookmark)

             gc_sub_menu.append(item)

     def show_appropriate_context_menu(self, event, iters):

Philipp Hörist pushed to branch master at gajim / gajim

Commits:

17 changed files:

Changes: