libervia-backend: sat/plugins/plugin_exp

comparison sat/plugins/plugin_exp_events.py @ 3028:ab2696e34d29

Python 3 port: /!\ this is a huge commit /!\ starting from this commit, SàT is needs Python 3.6+ /!\ SàT maybe be instable or some feature may not work anymore, this will improve with time This patch port backend, bridge and frontends to Python 3. Roughly this has been done this way: - 2to3 tools has been applied (with python 3.7) - all references to python2 have been replaced with python3 (notably shebangs) - fixed files not handled by 2to3 (notably the shell script) - several manual fixes - fixed issues reported by Python 3 that where not handled in Python 2 - replaced "async" with "async_" when needed (it's a reserved word from Python 3.7) - replaced zope's "implements" with @implementer decorator - temporary hack to handle data pickled in database, as str or bytes may be returned, to be checked later - fixed hash comparison for password - removed some code which is not needed anymore with Python 3 - deactivated some code which needs to be checked (notably certificate validation) - tested with jp, fixed reported issues until some basic commands worked - ported Primitivus (after porting dependencies like urwid satext) - more manual fixes

author	Goffi <goffi@goffi.org>
date	Tue, 13 Aug 2019 19:08:41 +0200
parents	83cbd4545274
children	fee60f17ebac

comparison

equal deleted inserted replaced

-:ff5bcb12ae60
+:ab2696e34d29
-#!/usr/bin/env python2
+#!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 # SAT plugin to detect language (experimental)
 # Copyright (C) 2009-2019 Jérôme Poisson (goffi@goffi.org)
 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 zope.interface import implementer
 from twisted.words.protocols.jabber.xmlstream import XMPPHandler
 from wokkel import pubsub
 log = getLogger(__name__)
 PLUGIN_INFO = {
 C.PI_NAME: "Events",
 C.PI_IMPORT_NAME: "EVENTS",
 C.PI_TYPE: "EXP",
 C.PI_PROTOCOLS: [],
-C.PI_DEPENDENCIES: [u"XEP-0060", u"INVITATION", u"LIST_INTEREST"],
+C.PI_DEPENDENCIES: ["XEP-0060", "INVITATION", "LIST_INTEREST"],
 C.PI_RECOMMENDATIONS: ["XEP-0277", "EMAIL_INVITATION"],
 C.PI_MAIN: "Events",
 C.PI_HANDLER: "yes",
-C.PI_DESCRIPTION: _(u"""Experimental implementation of XMPP events management"""),
+C.PI_DESCRIPTION: _("""Experimental implementation of XMPP events management"""),
 }
 NS_EVENT = "org.salut-a-toi.event:0"
 class Events(object):
 """Q&D module to handle event attendance answer, experimentation only"""
 def __init__(self, host):
-log.info(_(u"Event plugin initialization"))
+log.info(_("Event plugin initialization"))
 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(u"event", NS_EVENT)
+self.host.registerNamespace("event", NS_EVENT)
-self.host.plugins[u"INVITATION"].registerNamespace(NS_EVENT,
+self.host.plugins["INVITATION"].registerNamespace(NS_EVENT,
 self.register)
 host.bridge.addMethod(
 "eventGet",
 ".plugin",
 in_sign="ssss",
 out_sign="(ia{ss})",
 method=self._eventGet,
-async=True,
+async_=True,
 )
 host.bridge.addMethod(
 "eventCreate",
 ".plugin",
 in_sign="ia{ss}ssss",
 out_sign="s",
 method=self._eventCreate,
-async=True,
+async_=True,
 )
 host.bridge.addMethod(
 "eventModify",
 ".plugin",
 in_sign="sssia{ss}s",
 out_sign="",
 method=self._eventModify,
-async=True,
+async_=True,
 )
 host.bridge.addMethod(
 "eventsList",
 ".plugin",
 in_sign="sss",
 out_sign="aa{ss}",
 method=self._eventsList,
-async=True,
+async_=True,
 )
 host.bridge.addMethod(
 "eventInviteeGet",
 ".plugin",
 in_sign="sss",
 out_sign="a{ss}",
 method=self._eventInviteeGet,
-async=True,
+async_=True,
 )
 host.bridge.addMethod(
 "eventInviteeSet",
 ".plugin",
 in_sign="ssa{ss}s",
 out_sign="",
 method=self._eventInviteeSet,
-async=True,
+async_=True,
 )
 host.bridge.addMethod(
 "eventInviteesList",
 ".plugin",
 in_sign="sss",
 out_sign="a{sa{ss}}",
 method=self._eventInviteesList,
-async=True,
+async_=True,
 ),
 host.bridge.addMethod(
 "eventInvite",
 ".plugin",
 in_sign="sssss",
 out_sign="",
 method=self._invite,
-async=True,
+async_=True,
 )
 host.bridge.addMethod(
 "eventInviteByEmail",
 ".plugin",
 in_sign="ssssassssssss",
 out_sign="",
 method=self._inviteByEmail,
-async=True,
+async_=True,
 )
 def getHandler(self, client):
 return EventsHandler(self)
 except StopIteration:
 timestamp = -1
 data = {}
-for key in (u"name",):
+for key in ("name",):
 try:
 data[key] = event_elt[key]
 except KeyError:
 continue
-for elt_name in (u"description",):
+for elt_name in ("description",):
 try:
 elt = next(event_elt.elements(NS_EVENT, elt_name))
 except StopIteration:
 continue
 else:
-data[elt_name] = unicode(elt)
+data[elt_name] = str(elt)
-for elt_name in (u"image", "background-image"):
+for elt_name in ("image", "background-image"):
 try:
 image_elt = next(event_elt.elements(NS_EVENT, elt_name))
 data[elt_name] = image_elt["src"]
 except StopIteration:
 continue
 except KeyError:
-log.warning(_(u"no src found for image"))
+log.warning(_("no src found for image"))
-for uri_type in (u"invitees", u"blog"):
+for uri_type in ("invitees", "blog"):
 try:
 elt = next(event_elt.elements(NS_EVENT, uri_type))
-uri = data[uri_type + u"_uri"] = elt["uri"]
+uri = data[uri_type + "_uri"] = elt["uri"]
 uri_data = xmpp_uri.parseXMPPUri(uri)
-if uri_data[u"type"] != u"pubsub":
+if uri_data["type"] != "pubsub":
 raise ValueError
 except StopIteration:
-log.warning(_(u"no {uri_type} element found!").format(uri_type=uri_type))
+log.warning(_("no {uri_type} element found!").format(uri_type=uri_type))
 except KeyError:
-log.warning(_(u"incomplete {uri_type} element").format(uri_type=uri_type))
+log.warning(_("incomplete {uri_type} element").format(uri_type=uri_type))
 except ValueError:
-log.warning(_(u"bad {uri_type} element").format(uri_type=uri_type))
+log.warning(_("bad {uri_type} element").format(uri_type=uri_type))
 else:
-data[uri_type + u"_service"] = uri_data[u"path"]
+data[uri_type + "_service"] = uri_data["path"]
-data[uri_type + u"_node"] = uri_data[u"node"]
+data[uri_type + "_node"] = uri_data["node"]
 for meta_elt in event_elt.elements(NS_EVENT, "meta"):
-key = meta_elt[u"name"]
+key = meta_elt["name"]
 if key in data:
 log.warning(
-u"Ignoring conflicting meta element: {xml}".format(
+"Ignoring conflicting meta element: {xml}".format(
 xml=meta_elt.toXml()
 )
 )
 continue
-data[key] = unicode(meta_elt)
+data[key] = str(meta_elt)
 if event_elt.link:
 link_elt = event_elt.link
 data["service"] = link_elt["service"]
 data["node"] = link_elt["node"]
 data["item"] = link_elt["item"]
 """
 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"))
+event_elt = next(items[0].elements(NS_EVENT, "event"))
 except StopIteration:
-raise exceptions.NotFound(_(u"No event element has been found"))
+raise exceptions.NotFound(_("No event element has been found"))
 except IndexError:
-raise exceptions.NotFound(_(u"No event with this id has been found"))
+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
 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(u'name')
+name = event_data.get('name')
-if u'image' in event_data:
+if 'image' in event_data:
-extra = {u'thumb_url': event_data[u'image']}
+extra = {'thumb_url': event_data['image']}
 else:
 extra = None
-return self.host.plugins[u'LIST_INTEREST'].registerPubsub(
+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_=u"", profile_key=C.PROF_KEY_NONE):
+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_)
 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
+self, timestamp, data, service, node, id_="", 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))
+data["register"] = C.bool(data.get("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, event_id=NS_EVENT):
 """Create or replace an 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 event_id:
-raise ValueError(_(u"event_id must be set"))
+raise ValueError(_("event_id must be set"))
 if not service:
 service = client.jid.userhostJID()
 if not node:
-node = NS_EVENT + u"__" + shortuuid.uuid()
+node = NS_EVENT + "__" + 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",):
+for key in ("name",):
 if key in data:
 event_elt[key] = data.pop(key)
-for key in (u"description",):
+for key in ("description",):
 if key in data:
 event_elt.addElement((NS_EVENT, key), content=data.pop(key))
-for key in (u"image", u"background-image"):
+for key in ("image", "background-image"):
 if key in data:
 elt = event_elt.addElement((NS_EVENT, key))
 elt["src"] = data.pop(key)
 # we first create the invitees and blog nodes (if not specified in data)
-for uri_type in (u"invitees", u"blog"):
+for uri_type in ("invitees", "blog"):
-key = uri_type + u"_uri"
+key = uri_type + "_uri"
-for to_delete in (u"service", u"node"):
+for to_delete in ("service", "node"):
-k = uri_type + u"_" + to_delete
+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_service = service
 else:
 uri = data.pop(key)
 uri_data = xmpp_uri.parseXMPPUri(uri)
-if uri_data[u"type"] != u"pubsub":
+if uri_data["type"] != "pubsub":
 raise ValueError(
-_(u"The given URI is not valid: {uri}").format(uri=uri)
+_("The given URI is not valid: {uri}").format(uri=uri)
 )
-uri_service = jid.JID(uri_data[u"path"])
+uri_service = jid.JID(uri_data["path"])
-uri_node = uri_data[u"node"]
+uri_node = uri_data["node"]
 elt = event_elt.addElement((NS_EVENT, uri_type))
 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():
+for key in list(data.keys()):
 elt = event_elt.addElement((NS_EVENT, "meta"), content=data.pop(key))
 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)
 except error.StanzaError as e:
-if e.condition == u"conflict":
+if e.condition == "conflict":
-log.debug(_(u"requested node already exists"))
+log.debug(_("requested node already exists"))
 yield self._p.publish(client, service, node, items=[item_elt])
 if register:
 yield self.register(
 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(_(u"missing node"))
+raise ValueError(_("missing node"))
 client = self.host.getClient(profile_key)
 return self.eventModify(
 client, service, node, id_ or NS_EVENT, timestamp_update or None, data_update
 )
 """
 event_timestamp, event_metadata = yield 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.iteritems():
+for k, v in data_update.items():
 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["date"] = str(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
 def eventsList(self, client, service, node=None):
 """Retrieve list of registered events
 @return list(tuple(int, dict)): list of events (timestamp + metadata)
 """
-items, metadata = yield self.host.plugins[u'LIST_INTEREST'].listInterests(
+items, metadata = yield self.host.plugins['LIST_INTEREST'].listInterests(
 client, service, node, namespace=NS_EVENT)
 events = []
 for item in items:
 try:
-event_elt = next(item.interest.pubsub.elements(NS_EVENT, u"event"))
+event_elt = next(item.interest.pubsub.elements(NS_EVENT, "event"))
 except StopIteration:
 log.warning(
-_(u"No event found in item {item_id}, ignoring").format(
+_("No event found in item {item_id}, ignoring").format(
 item_id=item["id"])
 )
 else:
 timestamp, data = self._parseEventElt(event_elt)
 events.append((timestamp, data))
 """
 try:
 items, metadata = yield self._p.getItems(
 client, service, node, item_ids=[client.jid.userhost()]
 )
-event_elt = next(items[0].elements(NS_EVENT, u"invitee"))
+event_elt = next(items[0].elements(NS_EVENT, "invitee"))
 except (exceptions.NotFound, IndexError):
 # no item found, event data are not set yet
 defer.returnValue({})
 data = {}
-for key in (u"attend", u"guests"):
+for key in ("attend", "guests"):
 try:
 data[key] = event_elt[key]
 except KeyError:
 continue
 defer.returnValue(data)
 key can be:
 attend: one of "yes", "no", "maybe"
 guests: an int
 """
 event_elt = domish.Element((NS_EVENT, "invitee"))
-for key in (u"attend", u"guests"):
+for key in ("attend", "guests"):
 try:
 event_elt[key] = data.pop(key)
 except KeyError:
 pass
 item_elt = pubsub.Item(id=client.jid.userhost(), payload=event_elt)
 """
 items, metadata = yield self._p.getItems(client, service, node)
 invitees = {}
 for item in items:
 try:
-event_elt = next(item.elements(NS_EVENT, u"invitee"))
+event_elt = next(item.elements(NS_EVENT, "invitee"))
 except StopIteration:
 # no item found, event data are not set yet
 log.warning(_(
-u"no data found for {item_id} (service: {service}, node: {node})"
+"no data found for {item_id} (service: {service}, node: {node})"
 .format(item_id=item["id"], service=service, node=node)))
 else:
 data = {}
-for key in (u"attend", u"guests"):
+for key in ("attend", "guests"):
 try:
 data[key] = event_elt[key]
 except KeyError:
 continue
 invitees[item["id"]] = data
 None to use client's PEP
 @param node(unicode): event node
 @param item_id(unicode): event id
 """
 # FIXME: handle name and extra
-name = u''
+name = ''
 extra = {}
 if self._b is None:
 raise exceptions.FeatureNotFound(
-_(u'"XEP-0277" (blog) plugin is needed for this feature')
+_('"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"})
+yield self._p.setNodeAffiliations(client, service, node, {invitee_jid: "member"})
-log.debug(_(u"affiliation set on event node"))
+log.debug(_("affiliation set on event node"))
 __, event_data = yield self.eventGet(client, service, node, item_id)
-log.debug(_(u"got event data"))
+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(
-client, invitees_service, invitees_node, {invitee_jid: u"publisher"}
+client, invitees_service, invitees_node, {invitee_jid: "publisher"}
 )
-log.debug(_(u"affiliation set on invitee node"))
+log.debug(_("affiliation set on invitee node"))
 yield self._p.setNodeAffiliations(
-client, blog_service, blog_node, {invitee_jid: u"member"}
+client, blog_service, blog_node, {invitee_jid: "member"}
 )
 blog_items, __ = 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(
+"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"}
+client, comments_service, comments_node, {invitee_jid: "publisher"}
 )
-log.debug(_(u"affiliation set on blog and comments nodes"))
+log.debug(_("affiliation set on blog and comments nodes"))
 # now we send the invitation
-pubsub_invitation = self.host.plugins[u'INVITATION']
+pubsub_invitation = self.host.plugins['INVITATION']
 pubsub_invitation.sendPubsubInvitation(client, invitee_jid, service, node,
 item_id, name, extra)
-def _inviteByEmail(self, service, node, id_=NS_EVENT, email=u"", emails_extra=None,
+def _inviteByEmail(self, service, node, id_=NS_EVENT, email="", emails_extra=None,
-name=u"", host_name=u"", language=u"", url_template=u"",
+name="", host_name="", language="", url_template="",
-message_subject=u"", message_body=u"",
+message_subject="", message_body="",
 profile_key=C.PROF_KEY_NONE):
 client = self.host.getClient(profile_key)
 kwargs = {
-u"profile": client.profile,
+"profile": client.profile,
-u"emails_extra": [unicode(e) for e in emails_extra],
+"emails_extra": [str(e) for e in emails_extra],
 }
 for key in (
 "email",
 "name",
 "host_name",
 "url_template",
 "message_subject",
 "message_body",
 ):
 value = locals()[key]
-kwargs[key] = unicode(value)
+kwargs[key] = str(value)
 return self.inviteByEmail(
 client, jid.JID(service) if service else None, node, id_ or NS_EVENT, **kwargs
 )
 @defer.inlineCallbacks
 @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')
+_('"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')
+_('"XEP-0277" (blog) plugin is needed for this feature')
 )
 service = service or client.jid.userhostJID()
 event_uri = xmpp_uri.buildXMPPUri(
 "pubsub", path=service.full(), node=node, item=id_
 )
-kwargs["extra"] = {u"event_uri": event_uri}
+kwargs["extra"] = {"event_uri": event_uri}
 invitation_data = yield self._i.create(**kwargs)
-invitee_jid = invitation_data[u"jid"]
+invitee_jid = invitation_data["jid"]
-log.debug(_(u"invitation created"))
+log.debug(_("invitation created"))
 # now that we have a jid, we can send normal invitation
 yield self.invite(client, invitee_jid, service, node, id_)
+@implementer(iwokkel.IDisco)
 class EventsHandler(XMPPHandler):
-implements(iwokkel.IDisco)
 def __init__(self, plugin_parent):
 self.plugin_parent = plugin_parent
 def getDiscoInfo(self, requestor, target, nodeIdentifier=""):

Mercurial > libervia-backend

comparison sat/plugins/plugin_exp_events.py @ 3028:ab2696e34d29