+from gajim.common.modules.pep import PEP

+from gajim.common.modules.user_activity import UserActivity

+        handlers = []

+        for module in self._modules.values():

+            handlers += module.handlers

+        return handlers

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

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

+        self.get_module('PEP').reset_stored_publish()

+    def _messageCB(self, con, stanza):

+        if nbxmpp.NS_PUBSUB_EVENT in stanza.getProperties():

+            return

+            conn=self, stanza=stanza, account=self.name))

+        self.get_module('PEP').send_stored_publish()

+        for handler in self.get_module_handlers():

+            con.RegisterHandler(*handler)

+@unique

+class PEPHandlerType(IntEnum):

+    NOTIFY = 0

+    RETRACT = 1

+

+@unique

+class PEPEventType(IntEnum):

+    ACTIVITY = 0

+

+

+ACTIVITIES = {

+    'doing_chores': {

+        'category': _('Doing Chores'),

+        'buying_groceries': _('Buying Groceries'),

+        'cleaning': _('Cleaning'),

+        'cooking': _('Cooking'),

+        'doing_maintenance': _('Doing Maintenance'),

+        'doing_the_dishes': _('Doing the Dishes'),

+        'doing_the_laundry': _('Doing the Laundry'),

+        'gardening': _('Gardening'),

+        'running_an_errand': _('Running an Errand'),

+        'walking_the_dog': _('Walking the Dog')},

+    'drinking': {

+        'category': _('Drinking'),

+        'having_a_beer': _('Having a Beer'),

+        'having_coffee': _('Having Coffee'),

+        'having_tea': _('Having Tea')},

+    'eating': {

+        'category': _('Eating'),

+        'having_a_snack': _('Having a Snack'),

+        'having_breakfast': _('Having Breakfast'),

+        'having_dinner': _('Having Dinner'),

+        'having_lunch': _('Having Lunch')},

+    'exercising': {

+        'category': _('Exercising'),

+        'cycling': _('Cycling'),

+        'dancing': _('Dancing'),

+        'hiking': _('Hiking'),

+        'jogging': _('Jogging'),

+        'playing_sports': _('Playing Sports'),

+        'running': _('Running'),

+        'skiing': _('Skiing'),

+        'swimming': _('Swimming'),

+        'working_out': _('Working out')},

+    'grooming': {

+        'category': _('Grooming'),

+        'at_the_spa': _('At the Spa'),

+        'brushing_teeth': _('Brushing Teeth'),

+        'getting_a_haircut': _('Getting a Haircut'),

+        'shaving': _('Shaving'),

+        'taking_a_bath': _('Taking a Bath'),

+        'taking_a_shower': _('Taking a Shower')},

+    'having_appointment': {

+        'category': _('Having an Appointment')},

+    'inactive': {

+        'category': _('Inactive'),

+        'day_off': _('Day Off'),

+        'hanging_out': _('Hanging out'),

+        'hiding': _('Hiding'),

+        'on_vacation': _('On Vacation'),

+        'praying': _('Praying'),

+        'scheduled_holiday': _('Scheduled Holiday'),

+        'sleeping': _('Sleeping'),

+        'thinking': _('Thinking')},

+    'relaxing': {

+        'category': _('Relaxing'),

+        'fishing': _('Fishing'),

+        'gaming': _('Gaming'),

+        'going_out': _('Going out'),

+        'partying': _('Partying'),

+        'reading': _('Reading'),

+        'rehearsing': _('Rehearsing'),

+        'shopping': _('Shopping'),

+        'smoking': _('Smoking'),

+        'socializing': _('Socializing'),

+        'sunbathing': _('Sunbathing'),

+        'watching_tv': _('Watching TV'),

+        'watching_a_movie': _('Watching a Movie')},

+    'talking': {

+        'category': _('Talking'),

+        'in_real_life': _('In Real Life'),

+        'on_the_phone': _('On the Phone'),

+        'on_video_phone': _('On Video Phone')},

+    'traveling': {

+        'category': _('Traveling'),

+        'commuting': _('Commuting'),

+        'cycling': _('Cycling'),

+        'driving': _('Driving'),

+        'in_a_car': _('In a Car'),

+        'on_a_bus': _('On a Bus'),

+        'on_a_plane': _('On a Plane'),

+        'on_a_train': _('On a Train'),

+        'on_a_trip': _('On a Trip'),

+        'walking': _('Walking')},

+    'working': {

+        'category': _('Working'),

+        'coding': _('Coding'),

+        'in_a_meeting': _('In a Meeting'),

+        'studying': _('Studying'),

+        'writing': _('Writing')}}

+

+

+# 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-0163: Personal Eventing Protocol

+

+import logging

+

+import nbxmpp

+

+from gajim.common import app

+from gajim.common.nec import NetworkIncomingEvent

+from gajim.common.const import PEPHandlerType, PEPEventType

+

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

+

+

+class PEP:

+    def __init__(self, con):

+        self._con = con

+        self._account = con.name

+

+        self.handlers = [

+            ('message', self._pep_event_received,

+             'headline', nbxmpp.NS_PUBSUB_EVENT)

+        ]

+

+        self._pep_handlers = {}

+        self._store_publish_modules = []

+

+    def register_pep_handler(self, namespace, notify_handler, retract_handler):

+        if namespace in self._pep_handlers:

+            self._pep_handlers[namespace].append(

+                (notify_handler, retract_handler))

+        else:

+            self._pep_handlers[namespace] = [(notify_handler, retract_handler)]

+        if notify_handler:

+            module_instance = notify_handler.__self__

+            if hasattr(module_instance, 'send_stored_publish'):

+                if module_instance not in self._store_publish_modules:

+                    self._store_publish_modules.append(module_instance)

+

+    def _pep_event_received(self, conn, stanza):

+        jid = stanza.getFrom()

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

+        items = event.getTag('items')

+        if items is None:

+            log.warning('Malformed PEP event (no items node): %s', stanza)

+            raise nbxmpp.NodeProcessed

+

+        namespace = items.getAttr('node')

+        if namespace is None:

+            log.warning('Malformed PEP event (no node attr): %s', stanza)

+            raise nbxmpp.NodeProcessed

+

+        log.info('PEP notification received: %s %s', jid, namespace)

+

+        handlers = self._pep_handlers.get(namespace, None)

+        if handlers is None:

+            # Old Fallback

+            from gajim.common.connection_handlers_events import PEPReceivedEvent as OldPEPReceivedEvent

+            app.nec.push_incoming_event(

+                OldPEPReceivedEvent(None, conn=self._con, stanza=stanza))

+            raise nbxmpp.NodeProcessed

+        else:

+            # Check if this is a retraction

+            retract = items.getTag('retract')

+            if retract is not None:

+                for handler in handlers:

+                    handler[PEPHandlerType.RETRACT](jid, retract.getID())

+                    raise nbxmpp.NodeProcessed

+

+            # Check if we have items

+            items_ = items.getTags('item')

+            if items_ is None:

+                log.warning('Malformed PEP event received: %s', stanza)

+                raise nbxmpp.NodeProcessed

+            for handler in handlers:

+                handler[PEPHandlerType.NOTIFY](jid, items_[0])

+                raise nbxmpp.NodeProcessed

+

+    def send_stored_publish(self):

+        for module in self._store_publish_modules:

+            module.send_stored_publish()

+

+    def reset_stored_publish(self):

+        for module in self._store_publish_modules:

+            module.reset_stored_publish()

+

+

+class PEPEvent:

+

+    name = ''

+

+    def __init__(self, con, account):

+        self.__account = account

+        self.__con = con

+

+    def _update_contacts(self, jid, user_pep):

+        for contact in app.contacts.get_contacts(self.__account, str(jid)):

+            if user_pep:

+                contact.pep[self.name] = user_pep

+            else:

+                contact.pep.pop(self.name, None)

+

+        if jid == self.__con.get_own_jid().getStripped():

+            if user_pep:

+                self.__con.pep[self.name] = user_pep

+            else:

+                self.__con.pep.pop(self.name, None)

+

+

+class AbstractPEP:

+

+    type_ = PEPEventType

+

+    def __eq__(self, other):

+        return other == self.type_

+

+    def __bool__(self):

+        return self._pep_specific_data is not None

+

+    def __str__(self):

+        return str(self._pep_specific_data)

+

+

+class PEPReceivedEvent(NetworkIncomingEvent):

+    name = 'pep-received'

+    base_network_events = []

+# 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-0108: User Activity

+

+import logging

+

+import nbxmpp

+from gi.repository import GLib

+

+from gajim.common import app

+from gajim.common.const import PEPEventType, ACTIVITIES

+from gajim.common.exceptions import StanzaMalformed

+from gajim.common.modules.pep import PEPReceivedEvent, PEPEvent, AbstractPEP

+

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

+

+

+class UserActivity(PEPEvent):

+

+    name = 'activity'

+

+    def __init__(self, con):

+        PEPEvent.__init__(self, con, con.name)

+        self._con = con

+        self._account = con.name

+

+        self.handlers = []

+

+        self._stored_publish = None

+

+        self._con.get_module('PEP').register_pep_handler(

+            nbxmpp.NS_ACTIVITY,

+            self._pep_notify_received,

+            self._pep_retract_received)

+

+    def _pep_notify_received(self, jid, item):

+        try:

+            activity = self._extract_info(item)

+        except StanzaMalformed as error:

+            log.warning('%s, %s: %s', jid, error, item)

+            return

+

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

+        self._push_event(jid, UserActivityPEP(activity))

+

+    def _pep_retract_received(self, jid, id_):

+        log.info('Retract: %s %s', jid, id_)

+        self._push_event(jid, UserActivityPEP(None))

+

+    def _push_event(self, jid, user_pep):

+        self._update_contacts(jid, user_pep)

+        app.nec.push_incoming_event(

+            PEPReceivedEvent(None, conn=self._con,

+                             jid=str(jid),

+                             pep_type=self.name))

+

+    def _extract_info(self, item):

+        activity_dict = {}

+        activity_tag = item.getTag('activity', namespace=nbxmpp.NS_ACTIVITY)

+        if activity_tag is None:

+            raise StanzaMalformed('No activity node')

+

+        for child in activity_tag.getChildren():

+            name = child.getName().strip()

+            data = child.getData().strip()

+            if name == 'text':

+                activity_dict['text'] = data

+            else:

+                activity_dict['activity'] = name

+                for subactivity in child.getChildren():

+                    subactivity_name = subactivity.getName().strip()

+                    activity_dict['subactivity'] = subactivity_name

+

+        return activity_dict or None

+

+    def send_stored_publish(self):

+        if self._stored_publish is not None:

+            log.info('Send stored publish')

+            self.send_activity(*self._stored_publish)

+            self._stored_publish = None

+

+    def reset_stored_publish(self):

+        log.info('Reset stored publish')

+        self._stored_publish = None

+

+    def send_activity(self, activity=None, subactivity=None, message=None):

+        if not self._con.pep_supported:

+            return

+

+        if self._con.connected == 1:

+            # We are connecting, save activity and send it later

+            self._stored_publish = (activity, subactivity, message)

+            return

+

+        if activity:

+            log.info('Send activity: %s %s %s', activity, subactivity, message)

+        else:

+            log.info('Remove activity')

+

+        item = self._build_activity_node(activity, subactivity, message)

+

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

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

+

+    def _build_activity_node(self, activity, subactivity=None, message=None):

+        item = nbxmpp.Node('activity', {'xmlns': nbxmpp.NS_ACTIVITY})

+        if activity:

+            i = item.addChild(activity)

+            if subactivity:

+                i.addChild(subactivity)

+        if message:

+            i = item.addChild('text')

+            i.addData(message)

+        return item

+

+    def retract_activity(self):

+        if not self._con.pep_supported:

+            return

+        self.send_activity()

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

+            '', nbxmpp.NS_ACTIVITY, 'current')

+

+

+class UserActivityPEP(AbstractPEP):

+

+    type_ = PEPEventType.ACTIVITY

+

+    def __init__(self, activity):

+        self._pep_specific_data = activity

+

+    def asMarkupText(self):

+        pep = self._pep_specific_data

+        activity = pep['activity']

+        subactivity = pep['subactivity'] if 'subactivity' in pep else None

+        text = pep['text'] if 'text' in pep else None

+

+        if activity in ACTIVITIES:

+            # Translate standard activities

+            if subactivity in ACTIVITIES[activity]:

+                subactivity = ACTIVITIES[activity][subactivity]

+            activity = ACTIVITIES[activity]['category']

+

+        markuptext = '<b>' + GLib.markup_escape_text(activity)

+        if subactivity:

+            markuptext += ': ' + GLib.markup_escape_text(subactivity)

+        markuptext += '</b>'

+        if text:

+            markuptext += ' (%s)' % GLib.markup_escape_text(text)

+        return markuptext

+    UserMoodPEP, UserTunePEP,

+from gajim.common.const import Option, OptionKind, OptionType, ACTIVITIES