libervia-backend: sat/plugins/plugin_exp

comparison sat/plugins/plugin_exp_events.py @ 2616:1cc88adb5142

plugin events: invitations improvments + personal list - added invitation by <message> mechanism - added a personal list in PEP which keep events created by user, or in which she has been invited - new bridge methods: eventsList, and eventInviteByEmail. eventInvite is now used to invite a entity by jid (not email like before) - on invite, an invitation message is send to invitee's jid - when an invitation message is received, event is automatically linked in personal list - when creating a new event, event is automatically linked in personal list

author	Goffi <goffi@goffi.org>
date	Thu, 21 Jun 2018 01:21:44 +0200
parents	3e4e78de9cca
children	56f94936df1e

comparison

equal deleted inserted replaced

-:b4ecbcc2fd08
+:1cc88adb5142
 from sat.core import exceptions
 from sat.core.constants import Const as C
 from sat.core.log import getLogger
 log = getLogger(__name__)
 from sat.tools import utils
-from sat.tools.common import uri as uri_parse
+from sat.tools.common import uri as xmpp_uri
 from sat.tools.common import date_utils
 from twisted.internet import defer
 from twisted.words.protocols.jabber import jid, error
 from twisted.words.xish import domish
+from wokkel import disco, iwokkel
+from zope.interface import implements
+from twisted.words.protocols.jabber.xmlstream import XMPPHandler
 from wokkel import pubsub
+import shortuuid
 PLUGIN_INFO = {
 C.PI_NAME: "Event plugin",
 C.PI_IMPORT_NAME: "EVENTS",
 C.PI_TYPE: "EXP",
 C.PI_PROTOCOLS: [],
 C.PI_DEPENDENCIES: ["XEP-0060"],
 C.PI_RECOMMENDATIONS: ["INVITATIONS", "XEP-0277"],
 C.PI_MAIN: "Events",
-C.PI_HANDLER: "no",
+C.PI_HANDLER: "yes",
 C.PI_DESCRIPTION: _("""Experimental implementation of XMPP events management""")
 }
 NS_EVENT = 'org.salut-a-toi.event:0'
+NS_EVENT_LIST = NS_EVENT + '#list'
+NS_EVENT_INVIT = NS_EVENT + '#invitation'
+INVITATION = '/message[@type="chat"]/invitation[@xmlns="{ns_invit}"]'.format(
+ns_invit=NS_EVENT_INVIT)
 class Events(object):
 """Q&D module to handle event attendance answer, experimentation only"""
 async=True)
 host.bridge.addMethod("eventModify", ".plugin",
 in_sign='sssia{ss}s', out_sign='',
 method=self._eventModify,
 async=True)
+host.bridge.addMethod("eventsList", ".plugin",
+in_sign='sss', out_sign='aa{ss}',
+method=self._eventsList,
+async=True)
 host.bridge.addMethod("eventInviteeGet", ".plugin",
 in_sign='sss', out_sign='a{ss}',
 method=self._eventInviteeGet,
 async=True)
 host.bridge.addMethod("eventInviteeSet", ".plugin",
 async=True)
 host.bridge.addMethod("eventInviteesList", ".plugin",
 in_sign='sss', out_sign='a{sa{ss}}',
 method=self._eventInviteesList,
 async=True),
-host.bridge.addMethod("eventInvite", ".plugin", in_sign='ssssassssssss', out_sign='',
+host.bridge.addMethod("eventInvite", ".plugin", in_sign='sssss', out_sign='',
 method=self._invite,
 async=True)
+host.bridge.addMethod("eventInviteByEmail", ".plugin", in_sign='ssssassssssss', out_sign='',
-def _eventGet(self, service, node, id_=u'', profile_key=C.PROF_KEY_NONE):
+method=self._inviteByEmail,
-service = jid.JID(service) if service else None
+async=True)
-node = node if node else NS_EVENT
-client = self.host.getClient(profile_key)
+def getHandler(self, client):
-return self.eventGet(client, service, node, id_)
+return EventsHandler(self)
-@defer.inlineCallbacks
+def _parseEventElt(self, event_elt):
-def eventGet(self, client, service, node, id_=NS_EVENT):
+"""Helper method to parse event element
-"""Retrieve event data
+@param (domish.Element): event_elt
-@param service(unicode, None): PubSub service
+@return (tupple[int, dict[unicode, unicode]): timestamp, event_data
-@param node(unicode): PubSub node of the event
+"""
-@param id_(unicode): id_ with even data
-@return (tuple[int, dict[unicode, unicode]): event data:
-- timestamp of the event
-- event metadata where key can be:
-location: location of the event
-image: URL of a picture to use to represent event
-background-image: URL of a picture to use in background
-"""
-if not id_:
-id_ = NS_EVENT
-items, metadata = yield self._p.getItems(client, service, node, item_ids=[id_])
-try:
-event_elt = next(items[0].elements(NS_EVENT, u'event'))
-except IndexError:
-raise exceptions.NotFound(_(u"No event with this id has been found"))
 try:
 timestamp = date_utils.date_parse(next(event_elt.elements(NS_EVENT, "date")))
 except StopIteration:
 timestamp = -1
 for uri_type in (u'invitees', u'blog'):
 try:
 elt = next(event_elt.elements(NS_EVENT, uri_type))
 uri = data[uri_type + u'_uri'] = elt['uri']
-uri_data = uri_parse.parseXMPPUri(uri)
+uri_data = xmpp_uri.parseXMPPUri(uri)
 if uri_data[u'type'] != u'pubsub':
 raise ValueError
 except StopIteration:
 log.warning(_(u"no {uri_type} element found!").format(uri_type=uri_type))
 except KeyError:
 key = meta_elt[u'name']
 if key in data:
 log.warning(u'Ignoring conflicting meta element: {xml}'.format(xml=meta_elt.toXml()))
 continue
 data[key] = unicode(meta_elt)
+if event_elt.link:
-defer.returnValue((timestamp, data))
+link_elt = event_elt.link
+data['service'] = link_elt['service']
-def _eventCreate(self, timestamp, data, service, node, id_=u'', profile_key=C.PROF_KEY_NONE):
+data['node'] = link_elt['node']
+data['item'] = link_elt['item']
+if event_elt.getAttribute('creator') == 'true':
+data['creator'] = True
+return timestamp, data
+@defer.inlineCallbacks
+def getEventElement(self, client, service, node, id_):
+"""Retrieve event element
+@param service(jid.JID): pubsub service
+@param node(unicode): pubsub node
+@param id_(unicode, None): event id
+@return (domish.Element): event element
+@raise exceptions.NotFound: no event element found
+"""
+if not id_:
+id_ = NS_EVENT
+items, metadata = yield self._p.getItems(client, service, node, item_ids=[id_])
+try:
+event_elt = next(items[0].elements(NS_EVENT, u'event'))
+except IndexError:
+raise exceptions.NotFound(_(u"No event with this id has been found"))
+defer.returnValue(event_elt)
+@defer.inlineCallbacks
+def register(self, client, service, node, event_id, event_elt, creator=False):
+"""register evenement in personal events list
+@param service(jid.JID): pubsub service of the event
+@param node(unicode): event node
+@param event_id(unicode): event id
+@param event_elt(domish.Element): event element
+note that this element will be modified in place
+@param creator(bool): True if client's profile is the creator of the node
+"""
+# we save a link to the event in our local list
+try:
+# TODO: check auto-create, no need to create node first if available
+options = {self._p.OPT_ACCESS_MODEL: self._p.ACCESS_WHITELIST}
+yield self._p.createNode(client,
+client.jid.userhostJID(),
+nodeIdentifier=NS_EVENT_LIST,
+options=options)
+except error.StanzaError as e:
+if e.condition == u'conflict':
+log.debug(_(u"requested node already exists"))
+link_elt = event_elt.addElement((NS_EVENT_LIST, 'link'))
+link_elt["service"] = service.full()
+link_elt["node"] = node
+link_elt["item"] = event_id
+item_id = xmpp_uri.buildXMPPUri(u'pubsub',
+path=service.full(),
+node=node,
+item=event_id)
+if creator:
+event_elt['creator'] = 'true'
+item_elt = pubsub.Item(id=item_id, payload=event_elt)
+yield self._p.publish(client,
+client.jid.userhostJID(),
+NS_EVENT_LIST,
+items=[item_elt])
+def _eventGet(self, service, node, id_=u'', profile_key=C.PROF_KEY_NONE):
 service = jid.JID(service) if service else None
 node = node if node else NS_EVENT
 client = self.host.getClient(profile_key)
+return self.eventGet(client, service, node, id_)
+@defer.inlineCallbacks
+def eventGet(self, client, service, node, id_=NS_EVENT):
+"""Retrieve event data
+@param service(unicode, None): PubSub service
+@param node(unicode): PubSub node of the event
+@param id_(unicode): id_ with even data
+@return (tuple[int, dict[unicode, unicode]): event data:
+- timestamp of the event
+- event metadata where key can be:
+location: location of the event
+image: URL of a picture to use to represent event
+background-image: URL of a picture to use in background
+"""
+event_elt = yield self.getEventElement(client, service, node, id_)
+defer.returnValue(self._parseEventElt(event_elt))
+def _eventCreate(self, timestamp, data, service, node, id_=u'', profile_key=C.PROF_KEY_NONE):
+service = jid.JID(service) if service else None
+node = node or None
+client = self.host.getClient(profile_key)
+data[u'register'] = C.bool(data.get(u'register', C.BOOL_FALSE))
 return self.eventCreate(client, timestamp, data, service, node, id_ or NS_EVENT)
 @defer.inlineCallbacks
-def eventCreate(self, client, timestamp, data, service, node=None, item_id=NS_EVENT):
+def eventCreate(self, client, timestamp, data, service, node=None, event_id=NS_EVENT):
 """Create or replace an event
 @param service(jid.JID, None): PubSub service
 @param node(unicode, None): PubSub node of the event
 None will create instant node.
-@param item_id(unicode): ID of the item to create.
+@param event_id(unicode): ID of the item to create.
 @param timestamp(timestamp, None)
 @param data(dict[unicode, unicode]): data to update
 dict will be cleared, do a copy if data are still needed
 key can be:
 - name: name of the event
 - description: details
 - image: main picture of the event
 - background-image: image to use as background
+- register: bool, True if we want to register the event in our local list
 @return (unicode): created node
 """
-if not item_id:
+if not event_id:
-raise ValueError(_(u"item_id must be set"))
+raise ValueError(_(u"event_id must be set"))
 if not service:
 service = client.jid.userhostJID()
+if not node:
+node = NS_EVENT + u'__' + shortuuid.uuid()
 event_elt = domish.Element((NS_EVENT, 'event'))
 if timestamp is not None and timestamp != -1:
 formatted_date = utils.xmpp_date(timestamp)
 event_elt.addElement((NS_EVENT, 'date'), content=formatted_date)
+register = data.pop('register', False)
 for key in (u'name',):
 if key in data:
 event_elt[key] = data.pop(key)
 for key in (u'description',):
 if key in data:
 uri_node = yield self._p.createNode(client, service)
 yield self._p.setConfiguration(client, service, uri_node, {self._p.OPT_ACCESS_MODEL: self._p.ACCESS_WHITELIST})
 uri_service = service
 else:
 uri = data.pop(key)
-uri_data = uri_parse.parseXMPPUri(uri)
+uri_data = xmpp_uri.parseXMPPUri(uri)
 if uri_data[u'type'] != u'pubsub':
 raise ValueError(_(u'The given URI is not valid: {uri}').format(uri=uri))
 uri_service = jid.JID(uri_data[u'path'])
 uri_node = uri_data[u'node']
 elt = event_elt.addElement((NS_EVENT, uri_type))
-elt['uri'] = uri_parse.buildXMPPUri('pubsub', path=uri_service.full(), node=uri_node)
+elt['uri'] = xmpp_uri.buildXMPPUri('pubsub', path=uri_service.full(), node=uri_node)
 # remaining data are put in <meta> elements
 for key in data.keys():
 elt = event_elt.addElement((NS_EVENT, 'meta'), content = data.pop(key))
 elt['name'] = key
-item_elt = pubsub.Item(id=item_id, payload=event_elt)
+item_elt = pubsub.Item(id=event_id, payload=event_elt)
 try:
 # TODO: check auto-create, no need to create node first if available
 node = yield self._p.createNode(client, service, nodeIdentifier=node)
 except error.StanzaError as e:
 if e.condition == u'conflict':
 log.debug(_(u"requested node already exists"))
 yield self._p.publish(client, service, node, items=[item_elt])
+if register:
+yield self.register(client, service, node, event_id, event_elt, creator=True)
 defer.returnValue(node)
 def _eventModify(self, service, node, id_, timestamp_update, data_update, profile_key=C.PROF_KEY_NONE):
 service = jid.JID(service) if service else None
 node = node if node else NS_EVENT
 new_data = event_metadata
 if data_update:
 for k, v in data_update.iteritems():
 new_data[k] = v
 yield self.eventCreate(client, new_timestamp, new_data, service, node, id_)
+def _eventsListSerialise(self, events):
+for timestamp, data in events:
+data['date'] = unicode(timestamp)
+data['creator'] = C.boolConst(data.get('creator', False))
+return [e[1] for e in events]
+def _eventsList(self, service, node, profile):
+service = jid.JID(service) if service else None
+node = node or None
+client = self.host.getClient(profile)
+d = self.eventsList(client, service, node)
+d.addCallback(self._eventsListSerialise)
+return d
+@defer.inlineCallbacks
+def eventsList(self, client, service, node):
+"""Retrieve list of registered events
+@return list(tuple(int, dict)): list of events (timestamp + metadata)
+"""
+if not node:
+node = NS_EVENT_LIST
+items = yield self._p.getItems(client, service, node)
+events = []
+for item in items[0]:
+try:
+event_elt = next(item.elements(NS_EVENT, u'event'))
+except IndexError:
+log.error(_(u"No event found in item {item_id}").format(
+item_id = item['id']))
+timestamp, data = self._parseEventElt(event_elt)
+events.append((timestamp, data))
+defer.returnValue(events)
 def _eventInviteeGet(self, service, node, profile_key):
 service = jid.JID(service) if service else None
 node = node if node else NS_EVENT
 client = self.host.getClient(profile_key)
 items, metadata = yield self._p.getItems(client, service, node)
 invitees = {}
 for item in items:
 try:
 event_elt = next(item.elements(NS_EVENT, u'invitee'))
-except IndexError:
+except StopIteration:
 # no item found, event data are not set yet
 log.warning(_(u"no data found for {item_id} (service: {service}, node: {node})".format(
 item_id=item['id'],
 service=service,
 node=node
 )))
-data = {}
+else:
-for key in (u'attend', u'guests'):
+data = {}
-try:
+for key in (u'attend', u'guests'):
-data[key] = event_elt[key]
+try:
-except KeyError:
+data[key] = event_elt[key]
-continue
+except KeyError:
-invitees[item['id']] = data
+continue
+invitees[item['id']] = data
 defer.returnValue(invitees)
-def _invite(self, service, node, id_=NS_EVENT, email=u'', emails_extra=None, name=u'', host_name=u'', language=u'', url_template=u'',
+def sendMessageInvitation(self, client, invitee_jid, service, node, item_id):
+"""Send an invitation in a <message> stanza
+@param invitee_jid(jid.JID): entitee to send invitation to
+@param service(jid.JID): pubsub service of the event
+@param node(unicode): node of the event
+@param item_id(unicode): id of the event
+"""
+mess_data = {
+'from': client.jid,
+'to': invitee_jid,
+'uid': '',
+'message': {},
+'type': C.MESS_TYPE_CHAT,
+'subject': {},
+'extra': {},
+}
+client.generateMessageXML(mess_data)
+event_elt = mess_data['xml'].addElement('invitation', NS_EVENT_INVIT)
+event_elt['service'] = service.full()
+event_elt['node'] = node
+event_elt['item'] = item_id
+client.send(mess_data['xml'])
+def _invite(self, invitee_jid, service, node, item_id, profile):
+client = self.host.getClient(profile)
+service = jid.JID(service) if service else None
+node = node or None
+item_id = item_id or None
+invitee_jid = jid.JID(invitee_jid)
+return self.invite(client, invitee_jid, service, node, item_id)
+@defer.inlineCallbacks
+def invite(self, client, invitee_jid, service, node, item_id=NS_EVENT):
+"""Invite an entity to the event
+This will set permission to let the entity access everything needed
+@pararm invitee_jid(jid.JID): entity to invite
+@param service(jid.JID, None): pubsub service
+None to use client's PEP
+@param node(unicode): event node
+@param item_id(unicode): event id
+"""
+if self._b is None:
+raise exceptions.FeatureNotFound(_(u'"XEP-0277" (blog) plugin is needed for this feature'))
+if item_id is None:
+item_id = NS_EVENT
+# first we authorize our invitee to see the nodes of interest
+yield self._p.setNodeAffiliations(client, service, node, {invitee_jid: u'member'})
+log.debug(_(u'affiliation set on event node'))
+dummy, event_data = yield self.eventGet(client, service, node, item_id)
+log.debug(_(u'got event data'))
+invitees_service = jid.JID(event_data['invitees_service'])
+invitees_node = event_data['invitees_node']
+blog_service = jid.JID(event_data['blog_service'])
+blog_node = event_data['blog_node']
+yield self._p.setNodeAffiliations(client, invitees_service, invitees_node, {invitee_jid: u'publisher'})
+log.debug(_(u'affiliation set on invitee node'))
+yield self._p.setNodeAffiliations(client, blog_service, blog_node, {invitee_jid: u'member'})
+blog_items, dummy = yield self._b.mbGet(client, blog_service, blog_node, None)
+for item in blog_items:
+try:
+comments_service = jid.JID(item['comments_service'])
+comments_node = item['comments_node']
+except KeyError:
+log.debug(u"no comment service set for item {item_id}".format(item_id=item['id']))
+else:
+yield self._p.setNodeAffiliations(client, comments_service, comments_node, {invitee_jid: u'publisher'})
+log.debug(_(u'affiliation set on blog and comments nodes'))
+# now we send the invitation
+self.sendMessageInvitation(client, invitee_jid, service, node, item_id)
+def _inviteByEmail(self, service, node, id_=NS_EVENT, email=u'', emails_extra=None, name=u'', host_name=u'', language=u'', url_template=u'',
 message_subject=u'', message_body=u'', profile_key=C.PROF_KEY_NONE):
 client = self.host.getClient(profile_key)
 kwargs = {u'profile': client.profile,
 u'emails_extra': [unicode(e) for e in emails_extra]
 }
 for key in ("email", "name", "host_name", "language", "url_template", "message_subject", "message_body"):
 value = locals()[key]
 kwargs[key] = unicode(value)
-return self.invite(client,
+return self.inviteByEmail(client,
 jid.JID(service) if service else None,
 node,
 id_ or NS_EVENT,
 **kwargs)
 @defer.inlineCallbacks
-def invite(self, client, service, node, id_=NS_EVENT, **kwargs):
+def inviteByEmail(self, client, service, node, id_=NS_EVENT, **kwargs):
 """High level method to create an email invitation to an event
 @param service(unicode, None): PubSub service
 @param node(unicode): PubSub node of the event
 @param id_(unicode): id_ with even data
 """
 if self._i is None:
 raise exceptions.FeatureNotFound(_(u'"Invitations" plugin is needed for this feature'))
 if self._b is None:
 raise exceptions.FeatureNotFound(_(u'"XEP-0277" (blog) plugin is needed for this feature'))
-event_service = (service or client.jid.userhostJID())
+service = service or client.jid.userhostJID()
-event_uri = uri_parse.buildXMPPUri('pubsub',
+event_uri = xmpp_uri.buildXMPPUri('pubsub',
-path=event_service.full(),
+path=service.full(),
 node=node,
 item=id_)
 kwargs['extra'] = {u'event_uri': event_uri}
 invitation_data = yield self._i.create(**kwargs)
 invitee_jid = invitation_data[u'jid']
 log.debug(_(u'invitation created'))
-yield self._p.setNodeAffiliations(client, event_service, node, {invitee_jid: u'member'})
+# now that we have a jid, we can send normal invitation
-log.debug(_(u'affiliation set on event node'))
+yield self.invite(client, invitee_jid, service, node, id_)
-dummy, event_data = yield self.eventGet(client, service, node, id_)
-log.debug(_(u'got event data'))
+@defer.inlineCallbacks
-invitees_service = jid.JID(event_data['invitees_service'])
+def onInvitation(self, message_elt, client):
-invitees_node = event_data['invitees_node']
+invitation_elt = message_elt.invitation
-blog_service = jid.JID(event_data['blog_service'])
+try:
-blog_node = event_data['blog_node']
+service = jid.JID(invitation_elt['service'])
-yield self._p.setNodeAffiliations(client, invitees_service, invitees_node, {invitee_jid: u'publisher'})
+node = invitation_elt['node']
-log.debug(_(u'affiliation set on invitee node'))
+event_id = invitation_elt['item']
-yield self._p.setNodeAffiliations(client, blog_service, blog_node, {invitee_jid: u'member'})
+except (RuntimeError, KeyError):
-# FIXME: what follow is crazy, we have no good way to handle comments affiliations for blog
+log.warning(_(u"Bad invitation: {xml}").format(xml=message_elt.toXml()))
-blog_items, dummy = yield self._b.mbGet(client, blog_service, blog_node, None)
+event_elt = yield self.getEventElement(client, service, node, event_id)
-for item in blog_items:
+yield self.register(client, service, node, event_id, event_elt, creator=False)
-comments_service = jid.JID(item['comments_service'])
-comments_node = item['comments_node']
-yield self._p.setNodeAffiliations(client, comments_service, comments_node, {invitee_jid: u'publisher'})
+class EventsHandler(XMPPHandler):
-log.debug(_(u'affiliation set on blog and comments nodes'))
+implements(iwokkel.IDisco)
+def __init__(self, plugin_parent):
+self.plugin_parent = plugin_parent
+@property
+def host(self):
+return self.plugin_parent.host
+def connectionInitialized(self):
+self.xmlstream.addObserver(INVITATION,
+self.plugin_parent.onInvitation,
+client=self.parent)
+def getDiscoInfo(self, requestor, target, nodeIdentifier=''):
+return [disco.DiscoFeature(NS_EVENT),
+disco.DiscoFeature(NS_EVENT_LIST),
+disco.DiscoFeature(NS_EVENT_INVIT)]
+def getDiscoItems(self, requestor, target, nodeIdentifier=''):
+return []

Mercurial > libervia-backend

comparison sat/plugins/plugin_exp_events.py @ 2616:1cc88adb5142