libervia-backend: sat/core/xmpp.py comparison

comparison sat/core/xmpp.py @ 3715:b9718216a1c0 0.9

merge bookmark 0.9

author	Goffi <goffi@goffi.org>
date	Wed, 01 Dec 2021 16:13:31 +0100
parents	e3dddf65fa88 09f5ac48ffe3
children	e52de21873d3

comparison

equal deleted inserted replaced

-:af09b5aaa5d7
+:b9718216a1c0
 from wokkel import client as wokkel_client, disco, xmppim, generic, iwokkel
 from wokkel import component
 from wokkel import delay
 from sat.core.log import getLogger
 from sat.core import exceptions
+from sat.core import core_types
 from sat.memory import encryption
 from sat.memory import persistent
 from sat.tools import xml_tools
 from sat.tools import utils
 from sat.tools.common import data_format
 else:
 return lambda *args, **kwargs: missing
 return partial(getattr(self.plugin, attr), self.client)
-class SatXMPPEntity:
+class SatXMPPEntity(core_types.SatXMPPEntity):
 """Common code for Client and Component"""
 # profile is added there when startConnection begins and removed when it is finished
 profiles_connecting = set()
 def __init__(self, host_app, profile, max_retries):
 mess_data["message"] or mess_data["subject"]
 or mess_data["extra"].get(C.MESS_KEY_ATTACHMENTS)
 or mess_data["type"] == C.MESS_TYPE_INFO
 )
-def messageAddToHistory(self, data):
+async def messageAddToHistory(self, data):
 """Store message into database (for local history)
 @param data: message data dictionnary
 @param client: profile's client
 """
 # we don't add groupchat message to history, as we get them back
 # and they will be added then
 # we need a message to store
 if self.isMessagePrintable(data):
-self.host_app.memory.addToHistory(self, data)
+await self.host_app.memory.addToHistory(self, data)
 else:
 log.warning(
 "No message found"
 )  # empty body should be managed by plugins before this point
 return data
 # we want to be sure that we got the roster
 return self.roster.got_roster
 def addPostXmlCallbacks(self, post_xml_treatments):
 post_xml_treatments.addCallback(self.messageProt.completeAttachments)
-post_xml_treatments.addCallback(self.messageAddToHistory)
+post_xml_treatments.addCallback(
+lambda ret: defer.ensureDeferred(self.messageAddToHistory(ret))
+)
 post_xml_treatments.addCallback(self.messageSendToBridge)
 def send(self, obj):
 # original send method accept string
 # but we restrict to domish.Element to make trigger treatments easier
 else:
 return start_cb(self)
 def addPostXmlCallbacks(self, post_xml_treatments):
 if self.sendHistory:
-post_xml_treatments.addCallback(self.messageAddToHistory)
+post_xml_treatments.addCallback(
+lambda ret: defer.ensureDeferred(self.messageAddToHistory(ret))
+)
 def getOwnerFromJid(self, to_jid: jid.JID) -> jid.JID:
 """Retrieve "owner" of a component resource from the destination jid of the request
 This method needs plugin XEP-0106 for unescaping, if you use it you must add the
 if not cont:
 return
 data = self.parseMessage(message_elt)
 post_treat.addCallback(self.completeAttachments)
 post_treat.addCallback(self.skipEmptyMessage)
-post_treat.addCallback(self.addToHistory)
+post_treat.addCallback(
+lambda ret: defer.ensureDeferred(self.addToHistory(ret))
+)
 post_treat.addCallback(self.bridgeSignal, data)
 post_treat.addErrback(self.cancelErrorTrap)
 post_treat.callback(data)
 def onMessage(self, message_elt):
 def skipEmptyMessage(self, data):
 if not data["message"] and not data["extra"] and not data["subject"]:
 raise failure.Failure(exceptions.CancelError("Cancelled empty message"))
 return data
-def addToHistory(self, data):
+async def addToHistory(self, data):
 if data.pop("history", None) == C.HISTORY_SKIP:
 log.debug("history is skipped as requested")
 data["extra"]["history"] = C.HISTORY_SKIP
 else:
 # we need a message to store
 if self.parent.isMessagePrintable(data):
-return self.host.memory.addToHistory(self.parent, data)
+return await self.host.memory.addToHistory(self.parent, data)
 else:
 log.debug("not storing empty message to history: {data}"
 .format(data=data))
 def bridgeSignal(self, __, data):
 except KeyError:
 pass  # no previous item registration (or it's been cleared)
 self._jids[entity] = item
 self._registerItem(item)
 self.host.bridge.newContact(
-entity.full(), self.getAttributes(item), item.groups, self.parent.profile
+entity.full(), self.getAttributes(item), list(item.groups),
+self.parent.profile
 )
 def removeReceived(self, request):
 entity = request.item.entity
 log.info(_("removing {entity} from roster").format(entity=entity.full()))
 if not isinstance(entity_jid, jid.JID):
 raise exceptions.InternalError(
 f"a JID is expected, not {type(entity_jid)}: {entity_jid!r}")
 return entity_jid in self._jids
-def isPresenceAuthorised(self, entity_jid):
+def isSubscribedFrom(self, entity_jid: jid.JID) -> bool:
 """Return True if entity is authorised to see our presence"""
 try:
 item = self._jids[entity_jid.userhostJID()]
 except KeyError:
 return False
 return item.subscriptionFrom
+def isSubscribedTo(self, entity_jid: jid.JID) -> bool:
+"""Return True if we are subscribed to entity"""
+try:
+item = self._jids[entity_jid.userhostJID()]
+except KeyError:
+return False
+return item.subscriptionTo
 def getItems(self):
 """Return all items of the roster"""
 return list(self._jids.values())

Mercurial > libervia-backend

comparison sat/core/xmpp.py @ 3715:b9718216a1c0 0.9