libervia-backend: sat/plugins/plugin_exp

comparison sat/plugins/plugin_exp_events.py @ 3462:12dc234f698c

plugin invitation: pubsub invitations: - new Pubsub invitation plugin, to have a generic way to manage invitation on Pubsub based features - `invitePreflight` and `onInvitationPreflight` method can be implemented to customise invitation for a namespace - refactored events invitations to use the new plugin - a Pubsub invitation can now be for a whole node instead of a specific item - if invitation is for a node, a namespace can be specified to indicate what this node is about. It is then added in `extra` data - an element (domish.Element) can be added in `extra` data, it will then be added in the invitation - some code modernisation

author	Goffi <goffi@goffi.org>
date	Fri, 19 Feb 2021 15:50:22 +0100
parents	559a625a236b
children	be6d91572633

comparison

equal deleted inserted replaced

-:02a8d227d5bb
+:12dc234f698c
 # GNU Affero General Public License for more details.
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
+from typing import Optional
 import shortuuid
 from sat.core.i18n import _
 from sat.core import exceptions
 from sat.core.constants import Const as C
 from sat.core.log import getLogger
+from sat.core.xmpp import SatXMPPEntity
 from sat.tools import utils
 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
 PLUGIN_INFO = {
 C.PI_NAME: "Events",
 C.PI_IMPORT_NAME: "EVENTS",
 C.PI_TYPE: "EXP",
 C.PI_PROTOCOLS: [],
-C.PI_DEPENDENCIES: ["XEP-0060", "INVITATION", "LIST_INTEREST"],
+C.PI_DEPENDENCIES: ["XEP-0060", "INVITATION", "PUBSUB_INVITATION", "LIST_INTEREST"],
 C.PI_RECOMMENDATIONS: ["XEP-0277", "EMAIL_INVITATION"],
 C.PI_MAIN: "Events",
 C.PI_HANDLER: "yes",
 C.PI_DESCRIPTION: _("""Experimental implementation of XMPP events management"""),
 }
 self.host = host
 self._p = self.host.plugins["XEP-0060"]
 self._i = self.host.plugins.get("EMAIL_INVITATION")
 self._b = self.host.plugins.get("XEP-0277")
 self.host.registerNamespace("event", NS_EVENT)
-self.host.plugins["INVITATION"].registerNamespace(NS_EVENT,
+self.host.plugins["PUBSUB_INVITATION"].register(NS_EVENT, self)
-self.register)
 host.bridge.addMethod(
 "eventGet",
 ".plugin",
 in_sign="ssss",
 out_sign="(ia{ss})",
 raise exceptions.NotFound(_("No event element has been found"))
 except IndexError:
 raise exceptions.NotFound(_("No event with this id has been found"))
 defer.returnValue(event_elt)
-def register(self, client, name, extra, service, node, event_id, item_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
-"""
-event_elt = item_elt.event
-link_elt = event_elt.addElement("link")
-link_elt["service"] = service.full()
-link_elt["node"] = node
-link_elt["item"] = event_id
-__, event_data = self._parseEventElt(event_elt)
-name = event_data.get('name')
-if 'image' in event_data:
-extra = {'thumb_url': event_data['image']}
-else:
-extra = None
-return self.host.plugins['LIST_INTEREST'].registerPubsub(
-client, NS_EVENT, service, node, event_id, creator,
-name=name, element=event_elt, extra=extra)
 def _eventGet(self, service, node, id_="", 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_)
 ):
 service = jid.JID(service) if service else None
 node = node or None
 client = self.host.getClient(profile_key)
 data["register"] = C.bool(data.get("register", C.BOOL_FALSE))
-return self.eventCreate(client, timestamp, data, service, node, id_ or NS_EVENT)
+return defer.ensureDeferred(
+self.eventCreate(client, timestamp, data, service, node, id_ or NS_EVENT)
-@defer.inlineCallbacks
+)
-def eventCreate(self, client, timestamp, data, service, node=None, event_id=NS_EVENT):
+async 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.
 k = uri_type + "_" + to_delete
 if k in data:
 del data[k]
 if key not in data:
 # FIXME: affiliate invitees
-uri_node = yield self._p.createNode(client, service)
+uri_node = await self._p.createNode(client, service)
-yield self._p.setConfiguration(
+await self._p.setConfiguration(
 client,
 service,
 uri_node,
 {self._p.OPT_ACCESS_MODEL: self._p.ACCESS_WHITELIST},
 )
 elt["name"] = key
 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)
+node = await self._p.createNode(client, service, nodeIdentifier=node)
 except error.StanzaError as e:
 if e.condition == "conflict":
 log.debug(_("requested node already exists"))
-yield self._p.publish(client, service, node, items=[item_elt])
+await self._p.publish(client, service, node, items=[item_elt])
 if register:
-yield self.register(
+extra = {}
-client, None, {}, service, node, event_id, item_elt, creator=True)
+self.onInvitationPreflight(
-defer.returnValue(node)
+client, "", extra, service, node, event_id, item_elt
+)
+await self.host.plugins['LIST_INTEREST'].registerPubsub(
+client, NS_EVENT, service, node, event_id, True,
+extra.pop("name", ""), extra.pop("element"), extra
+)
+return 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
 if not node:
 raise ValueError(_("missing node"))
 client = self.host.getClient(profile_key)
-return self.eventModify(
+return defer.ensureDeferred(
-client, service, node, id_ or NS_EVENT, timestamp_update or None, data_update
+self.eventModify(
-)
+client, service, node, id_ or NS_EVENT, timestamp_update or None,
+data_update
-@defer.inlineCallbacks
+)
-def eventModify(
+)
+async def eventModify(
 self, client, service, node, id_=NS_EVENT, timestamp_update=None, data_update=None
 ):
 """Update an event
 Similar as create instead that it update existing item instead of
 creating or replacing it. Params are the same as for [eventCreate].
 """
-event_timestamp, event_metadata = yield self.eventGet(client, service, node, id_)
+event_timestamp, event_metadata = await self.eventGet(client, service, node, id_)
 new_timestamp = event_timestamp if timestamp_update is None else timestamp_update
 new_data = event_metadata
 if data_update:
 for k, v in data_update.items():
 new_data[k] = v
-yield self.eventCreate(client, new_timestamp, new_data, service, node, id_)
+await self.eventCreate(client, new_timestamp, new_data, service, node, id_)
 def _eventsListSerialise(self, events):
 for timestamp, data in events:
 data["date"] = str(timestamp)
 data["creator"] = C.boolConst(data.get("creator", False))
 except KeyError:
 continue
 invitees[item["id"]] = data
 defer.returnValue(invitees)
-def _invite(self, invitee_jid, service, node, item_id, profile):
+async def invitePreflight(
-client = self.host.getClient(profile)
+self,
-service = jid.JID(service) if service else None
+client: SatXMPPEntity,
-node = node or None
+invitee_jid: jid.JID,
-item_id = item_id or None
+service: jid.JID,
-invitee_jid = jid.JID(invitee_jid)
+node: str,
-return self.invite(client, invitee_jid, service, node, item_id)
+item_id: Optional[str] = None,
+name: str = '',
-@defer.inlineCallbacks
+extra: Optional[dict] = None,
-def invite(self, client, invitee_jid, service, node, item_id=NS_EVENT):
+) -> None:
-"""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
-"""
-# FIXME: handle name and extra
-name = ''
-extra = {}
 if self._b is None:
 raise exceptions.FeatureNotFound(
 _('"XEP-0277" (blog) plugin is needed for this feature')
 )
 if item_id is None:
-item_id = NS_EVENT
+item_id = extra["default_item_id"] = NS_EVENT
-# first we authorize our invitee to see the nodes of interest
+__, event_data = await self.eventGet(client, service, node, item_id)
-yield self._p.setNodeAffiliations(client, service, node, {invitee_jid: "member"})
-log.debug(_("affiliation set on event node"))
-__, event_data = yield self.eventGet(client, service, node, item_id)
 log.debug(_("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(
+await self._p.setNodeAffiliations(
 client, invitees_service, invitees_node, {invitee_jid: "publisher"}
 )
-log.debug(_("affiliation set on invitee node"))
+log.debug(
-yield self._p.setNodeAffiliations(
+f"affiliation set on invitee node (jid: {invitees_service}, "
+f"node: {invitees_node!r})"
+)
+await self._p.setNodeAffiliations(
 client, blog_service, blog_node, {invitee_jid: "member"}
 )
-blog_items, __ = yield self._b.mbGet(client, blog_service, blog_node, None)
+blog_items, __ = await 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"]
 "no comment service set for item {item_id}".format(
 item_id=item["id"]
 )
 )
 else:
-yield self._p.setNodeAffiliations(
+await self._p.setNodeAffiliations(
 client, comments_service, comments_node, {invitee_jid: "publisher"}
 )
 log.debug(_("affiliation set on blog and comments nodes"))
-# now we send the invitation
+def _invite(self, invitee_jid, service, node, item_id, profile):
-pubsub_invitation = self.host.plugins['INVITATION']
+return self.host.plugins["PUBSUB_INVITATION"]._sendPubsubInvitation(
-pubsub_invitation.sendPubsubInvitation(client, invitee_jid, service, node,
+invitee_jid, service, node, item_id or NS_EVENT, profile_key=profile
-item_id, name, extra)
+)
 def _inviteByEmail(self, service, node, id_=NS_EVENT, email="", emails_extra=None,
 name="", host_name="", language="", url_template="",
 message_subject="", message_body="",
 profile_key=C.PROF_KEY_NONE):
 "message_subject",
 "message_body",
 ):
 value = locals()[key]
 kwargs[key] = str(value)
-return self.inviteByEmail(
+return defer.ensureDeferred(self.inviteByEmail(
 client, jid.JID(service) if service else None, node, id_ or NS_EVENT, **kwargs
-)
+))
-@defer.inlineCallbacks
+async def inviteByEmail(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
 service = service or client.jid.userhostJID()
 event_uri = xmpp_uri.buildXMPPUri(
 "pubsub", path=service.full(), node=node, item=id_
 )
 kwargs["extra"] = {"event_uri": event_uri}
-invitation_data = yield self._i.create(**kwargs)
+invitation_data = await self._i.create(**kwargs)
 invitee_jid = invitation_data["jid"]
 log.debug(_("invitation created"))
 # now that we have a jid, we can send normal invitation
-yield self.invite(client, invitee_jid, service, node, id_)
+await self.invite(client, invitee_jid, service, node, id_)
+def onInvitationPreflight(
+self,
+client: SatXMPPEntity,
+name: str,
+extra: dict,
+service: jid.JID,
+node: str,
+item_id: Optional[str],
+item_elt: domish.Element
+) -> None:
+event_elt = item_elt.event
+link_elt = event_elt.addElement("link")
+link_elt["service"] = service.full()
+link_elt["node"] = node
+link_elt["item"] = item_id
+__, event_data = self._parseEventElt(event_elt)
+try:
+name = event_data["name"]
+except KeyError:
+pass
+else:
+extra["name"] = name
+if 'image' in event_data:
+extra["thumb_url"] = event_data['image']
+extra["element"] = event_elt
 @implementer(iwokkel.IDisco)
 class EventsHandler(XMPPHandler):

Mercurial > libervia-backend

comparison sat/plugins/plugin_exp_events.py @ 3462:12dc234f698c