slidge 0.1.0rc1__py3-none-any.whl → 0.1.2__py3-none-any.whl

slidge/{util → slixfix}/xep_0356_old/privilege.py

@@ -4,16 +4,15 @@ from collections import defaultdict
 
 from slixmpp import JID, Iq, Message
 from slixmpp.plugins.base import BasePlugin
-from slixmpp.types import JidStr
-from slixmpp.xmlstream import StanzaBase
-from slixmpp.xmlstream.handler import Callback
-from slixmpp.xmlstream.matcher import StanzaPath
-
-from slidge.util.xep_0356.permissions import (
+from slixmpp.plugins.xep_0356.permissions import (
     MessagePermission,
     Permissions,
     RosterAccess,
 )
+from slixmpp.types import JidStr
+from slixmpp.xmlstream import StanzaBase
+from slixmpp.xmlstream.handler import Callback
+from slixmpp.xmlstream.matcher import StanzaPath
 
 from . import stanza
 
@@ -72,7 +71,10 @@ class XEP_0356_OLD(BasePlugin):
         self.xmpp.event("privileges_advertised_old")
 
     def send_privileged_message(self, msg: Message):
-        if self.granted_privileges[msg.get_from().domain].message != MessagePermission.OUTGOING:
+        if (
+            self.granted_privileges[msg.get_from().domain].message
+            != MessagePermission.OUTGOING
+        ):
             raise PermissionError(
                 "The server hasn't authorized us to send messages on behalf of other users"
             )

slidge/slixfix/xep_0424/__init__.py

@@ -0,0 +1,9 @@
+# Slixmpp: The Slick XMPP Library
+# Copyright (C) 2020 Mathieu Pasquet <mathieui@mathieui.net>
+# This file is part of Slixmpp.
+# See the file LICENSE for copying permission.
+from slixmpp.plugins.base import register_plugin
+
+from .retraction import XEP_0424
+
+register_plugin(XEP_0424)

slidge/slixfix/xep_0424/retraction.py

@@ -0,0 +1,77 @@
+# Slixmpp: The Slick XMPP Library
+# Copyright (C) 2020 Mathieu Pasquet <mathieui@mathieui.net>
+# This file is part of Slixmpp.
+# See the file LICENSE for copying permission.
+from typing import Optional
+
+from slixmpp import JID, Message
+from slixmpp.exceptions import IqError, IqTimeout
+from slixmpp.plugins import BasePlugin
+from slixmpp.xmlstream.handler import Callback
+from slixmpp.xmlstream.matcher import StanzaPath
+
+from . import stanza
+
+DEFAULT_FALLBACK = (
+    "This person attempted to retract a previous message, but your client "
+    "does not support it."
+)
+
+
+class XEP_0424(BasePlugin):
+    """XEP-0424: Message Retraction"""
+
+    name = "xep_0424"
+    description = "XEP-0424: Message Retraction (fix Slidge)"
+    dependencies = {"xep_0422", "xep_0030", "xep_0359", "xep_0428", "xep_0334"}
+    stanza = stanza
+    namespace = stanza.NS
+
+    def plugin_init(self) -> None:
+        stanza.register_plugins()
+        self.xmpp.register_handler(
+            Callback(
+                "Message Retracted",
+                StanzaPath("message/retract"),
+                self._handle_retract_message,
+            )
+        )
+
+    def session_bind(self, jid):
+        self.xmpp.plugin["xep_0030"].add_feature(feature=stanza.NS)
+
+    def plugin_end(self):
+        self.xmpp.plugin["xep_0030"].del_feature(feature=stanza.NS)
+
+    def _handle_retract_message(self, message: Message):
+        self.xmpp.event("message_retract", message)
+
+    def send_retraction(
+        self,
+        mto: JID,
+        id: str,
+        mtype: str = "chat",
+        include_fallback: bool = True,
+        fallback_text: Optional[str] = None,
+        *,
+        mfrom: Optional[JID] = None
+    ):
+        """
+        Send a message retraction
+
+        :param JID mto: The JID to retract the message from
+        :param str id: Message ID to retract
+        :param str mtype: Message type
+        :param bool include_fallback: Whether to include a fallback body
+        :param Optional[str] fallback_text: The content of the fallback
+                                            body. None will set the default value.
+        """
+        if fallback_text is None:
+            fallback_text = DEFAULT_FALLBACK
+        msg = self.xmpp.make_message(mto=mto, mtype=mtype, mfrom=mfrom)
+        if include_fallback:
+            msg["body"] = fallback_text
+            msg.enable("fallback")
+        msg["retract"]["id"] = id
+        msg.enable("store")
+        msg.send()

slidge/slixfix/xep_0424/stanza.py

@@ -0,0 +1,28 @@
+# Slixmpp: The Slick XMPP Library
+# Copyright (C) 2020 Mathieu Pasquet <mathieui@mathieui.net>
+# This file is part of Slixmpp.
+# See the file LICENSE for copying permissio
+from slixmpp.plugins.xep_0359 import OriginID
+from slixmpp.stanza import Message
+from slixmpp.xmlstream import ElementBase, register_stanza_plugin
+
+NS = "urn:xmpp:message-retract:1"
+
+
+class Retract(ElementBase):
+    namespace = NS
+    name = "retract"
+    plugin_attrib = "retract"
+
+
+class Retracted(ElementBase):
+    namespace = NS
+    name = "retracted"
+    plugin_attrib = "retracted"
+    interfaces = {"stamp"}
+
+
+def register_plugins():
+    register_stanza_plugin(Message, Retract)
+    register_stanza_plugin(Message, Retracted)
+    register_stanza_plugin(Retracted, OriginID)

slidge/slixfix/xep_0490/__init__.py

@@ -0,0 +1,8 @@
+from slixmpp.plugins.base import register_plugin
+
+from . import stanza
+from .mds import XEP_0490
+
+register_plugin(XEP_0490)
+
+__all__ = ["stanza", "XEP_0490"]

slidge/slixfix/xep_0490/mds.py

@@ -0,0 +1,47 @@
+from slixmpp import Iq
+from slixmpp.plugins import BasePlugin
+from slixmpp.plugins.xep_0004 import Form
+from slixmpp.types import JidStr
+
+from . import stanza
+
+
+class XEP_0490(BasePlugin):
+    """
+    XEP-0490: Message Displayed Synchronization
+    """
+
+    name = "xep_0490"
+    description = "XEP-0490: Message Displayed Synchronization"
+    dependencies = {"xep_0060", "xep_0163", "xep_0359"}
+    stanza = stanza
+
+    def plugin_init(self):
+        stanza.register_plugin()
+        self.xmpp.plugin["xep_0163"].register_pep(
+            "message_displayed_synchronization",
+            stanza.Displayed,
+        )
+
+    def flag_chat(self, chat: JidStr, stanza_id: str, **kwargs) -> Iq:
+        displayed = stanza.Displayed()
+        displayed["stanza_id"]["id"] = stanza_id
+        return self.xmpp.plugin["xep_0163"].publish(
+            displayed, node=stanza.NS, options=PUBLISH_OPTIONS, id=str(chat), **kwargs
+        )
+
+    def catch_up(self, **kwargs):
+        return self.xmpp.plugin["xep_0060"].get_items(
+            self.xmpp.boundjid.bare, stanza.NS, **kwargs
+        )
+
+
+PUBLISH_OPTIONS = Form()
+PUBLISH_OPTIONS["type"] = "submit"
+PUBLISH_OPTIONS.add_field(
+    "FORM_TYPE", "hidden", value="http://jabber.org/protocol/pubsub#publish-options"
+)
+PUBLISH_OPTIONS.add_field("pubsub#persist_items", value="true")
+PUBLISH_OPTIONS.add_field("pubsub#max_items", value="max")
+PUBLISH_OPTIONS.add_field("pubsub#send_last_published_item", value="never")
+PUBLISH_OPTIONS.add_field("pubsub#access_model", value="whitelist")

slidge/slixfix/xep_0490/stanza.py

@@ -0,0 +1,17 @@
+from slixmpp import register_stanza_plugin
+from slixmpp.plugins.xep_0060.stanza import Item
+from slixmpp.plugins.xep_0359.stanza import StanzaID
+from slixmpp.xmlstream import ElementBase
+
+NS = "urn:xmpp:mds:displayed:0"
+
+
+class Displayed(ElementBase):
+    namespace = NS
+    name = "displayed"
+    plugin_attrib = "displayed"
+
+
+def register_plugin():
+    register_stanza_plugin(Displayed, StanzaID)
+    register_stanza_plugin(Item, Displayed)

slidge/util/__init__.py

@@ -1,17 +1,15 @@
 from .util import (
     ABCSubclassableOnceAtMost,
-    BiDict,
-    FormField,
-    SearchResult,
     SubclassableOnce,
     is_valid_phone_number,
+    replace_mentions,
+    strip_illegal_chars,
 )
 
 __all__ = [
-    "BiDict",
-    "SearchResult",
-    "FormField",
     "SubclassableOnce",
     "ABCSubclassableOnceAtMost",
     "is_valid_phone_number",
+    "replace_mentions",
+    "strip_illegal_chars",
 ]

slidge/util/archive_msg.py

@@ -0,0 +1,61 @@
+from copy import copy
+from datetime import datetime, timezone
+from typing import Optional, Union
+from xml.etree import ElementTree as ET
+
+from slixmpp import Message
+from slixmpp.plugins.xep_0297 import Forwarded
+
+
+def fix_namespaces(xml, old="{jabber:component:accept}", new="{jabber:client}"):
+    """
+    Hack to fix namespaces between jabber:component and jabber:client
+
+    Acts in-place.
+
+    :param xml:
+    :param old:
+    :param new:
+    """
+    xml.tag = xml.tag.replace(old, new)
+    for child in xml:
+        fix_namespaces(child, old, new)
+
+
+class HistoryMessage:
+    def __init__(self, stanza: Union[Message, str], when: Optional[datetime] = None):
+        if isinstance(stanza, str):
+            from_db = True
+            stanza = Message(xml=ET.fromstring(stanza))
+        else:
+            from_db = False
+
+        self.id = stanza["stanza_id"]["id"]
+        self.when: datetime = (
+            when or stanza["delay"]["stamp"] or datetime.now(tz=timezone.utc)
+        )
+
+        if not from_db:
+            del stanza["delay"]
+            del stanza["markable"]
+            del stanza["hint"]
+            del stanza["chat_state"]
+            if not stanza["body"]:
+                del stanza["body"]
+            fix_namespaces(stanza.xml)
+
+        self.stanza: Message = stanza
+
+    @property
+    def stanza_component_ns(self):
+        stanza = copy(self.stanza)
+        fix_namespaces(
+            stanza.xml, old="{jabber:client}", new="{jabber:component:accept}"
+        )
+        return stanza
+
+    def forwarded(self):
+        forwarded = Forwarded()
+        forwarded["delay"]["stamp"] = self.when
+        forwarded.append(self.stanza)
+        return forwarded

slidge/util/conf.py

@@ -97,7 +97,6 @@ class ConfigModule:
     def __init__(
         self, config_obj, parser: Optional[configargparse.ArgumentParser] = None
     ):
-
         self.config_obj = config_obj
         if parser is None:
             parser = configargparse.ArgumentParser()
@@ -127,13 +126,25 @@ class ConfigModule:
                 if skip_next:
                     skip_next = False
                     continue
+                force_keep = False
                 if "=" in a:
                     real_name, _value = a.split("=")
                     opt: Optional[Option] = options_long.get(
                         _argv_to_option_name(real_name)
                     )
                     if opt and opt.type is bool:
-                        a = real_name
+                        if opt.default:
+                            if _value in _TRUEISH or not _value:
+                                continue
+                            else:
+                                a = real_name
+                                force_keep = True
+                        else:
+                            if _value in _TRUEISH:
+                                a = real_name
+                                force_keep = True
+                            else:
+                                continue
                 else:
                     upper = _argv_to_option_name(a)
                     opt = options_long.get(upper)
@@ -142,7 +153,14 @@ class ConfigModule:
                             log.debug("Removing %s from argv", aa)
                             skip_next = True
 
-                no_explicit_bool.append(a)
+                if opt:
+                    if opt.type is bool:
+                        if force_keep or not opt.default:
+                            no_explicit_bool.append(a)
+                    else:
+                        no_explicit_bool.append(a)
+                else:
+                    no_explicit_bool.append(a)
             log.debug("Removed boolean values from %s to %s", argv, no_explicit_bool)
             argv = no_explicit_bool
 
@@ -163,7 +181,7 @@ class ConfigModule:
 
     def add_options_to_parser(self):
         p = self.parser
-        for o in self.options:
+        for o in sorted(self.options, key=lambda x: (not x.required, x.name)):
             p.add_argument(*o.names, **o.kwargs)
 
     def update_dynamic_defaults(self, args):
@@ -182,4 +200,7 @@ def _argv_to_option_name(arg: str):
     return arg.upper().removeprefix("--").replace("-", "_")
 
 
+_TRUEISH = {"true", "True", "1", "on", "enabled"}
+
+
 log = logging.getLogger(__name__)

slidge/util/db.py

@@ -15,6 +15,8 @@ from typing import Iterable, Optional, Union
 from pickle_secure import Pickler, Unpickler
 from slixmpp import JID, Iq, Message, Presence
 
+from .sql import db
+
 
 # noinspection PyUnresolvedReferences
 class EncryptedShelf(shelve.DbfilenameShelf):
@@ -35,7 +37,7 @@ class EncryptedShelf(shelve.DbfilenameShelf):
             value = self.cache[key]
         except KeyError:
             f = BytesIO(self.dict[key.encode(self.keyencoding)])
-            value = Unpickler(f, key=self.secret_key).load()
+            value = Unpickler(f, key=self.secret_key).load()  # type:ignore
             if self.writeback:
                 self.cache[key] = value
         return value
@@ -44,7 +46,7 @@ class EncryptedShelf(shelve.DbfilenameShelf):
         if self.writeback:
             self.cache[key] = value
         f = BytesIO()
-        p = Pickler(f, self._protocol, key=self.secret_key)
+        p = Pickler(f, self._protocol, key=self.secret_key)  # type:ignore
         p.dump(value)
         self.dict[key.encode(self.keyencoding)] = f.getvalue()
 
@@ -52,7 +54,7 @@ class EncryptedShelf(shelve.DbfilenameShelf):
 @dataclasses.dataclass
 class GatewayUser:
     """
-    A dataclass representing a gateway user
+    A gateway user
     """
 
     bare_jid: str
@@ -82,17 +84,18 @@ class GatewayUser:
         return JID(self.bare_jid)
 
     def get(self, field: str, default: str = "") -> Optional[str]:
-        """
-        Get fields from the registration form (required to comply with slixmpp backend protocol)
-
-        :param field: Name of the field
-        :param default: Default value to return if the field is not present
-
-        :return: Value of the field
-        """
+        # """
+        # Get fields from the registration form (required to comply with slixmpp backend protocol)
+        #
+        # :param field: Name of the field
+        # :param default: Default value to return if the field is not present
+        #
+        # :return: Value of the field
+        # """
         return self.registration_form.get(field, default)
 
     def commit(self):
+        db.user_store(self)
         user_store.commit(self)
 
 
@@ -123,6 +126,8 @@ class UserStore:
             self._users = EncryptedShelf(filename, key=secret_key)
         else:
             self._users = shelve.open(str(filename))
+        for user in self._users.values():
+            db.user_store(user)
         log.info("Registered users in the DB: %s", list(self._users.keys()))
 
     def get_all(self) -> Iterable[GatewayUser]:
@@ -144,12 +149,13 @@ class UserStore:
         :param registration_form: Content of the registration form (:xep:`0077`)
         """
         log.debug("Adding user %s", jid)
-        self._users[jid.bare] = GatewayUser(
+        self._users[jid.bare] = user = GatewayUser(
             bare_jid=jid.bare,
             registration_form=registration_form,
             registration_date=datetime.datetime.now(),
         )
         self._users.sync()
+        user.commit()
         log.debug("Store: %s", self._users)
 
     def commit(self, user: GatewayUser):
@@ -187,6 +193,7 @@ class UserStore:
         """
         j = jid.bare
         log.debug("Removing user %s", j)
+        db.user_del(self._users[j])
         del self._users[j]
         self._users.sync()
 
@@ -213,63 +220,10 @@ class UserStore:
         self._users.close()
 
 
-class YesSet(set):
-    """
-    A pseudo-set which always test True for membership
-    """
-
-    def __contains__(self, item):
-        log.debug("Test in")
-        return True
-
-
-class RosterBackend:
-    """
-    A pseudo-roster for the gateway component.
-
-    If a user is in the user store, this will behave as if the user is part of the
-    roster with subscription "both", and "none" otherwise.
-
-    This is rudimentary but the only sane way I could come up with so far.
-    """
-
-    @staticmethod
-    def entries(_owner_jid, _default=None):
-        return YesSet()
-
-    @staticmethod
-    def save(_owner_jid, _jid, _item_state, _db_state):
-        pass
-
-    @staticmethod
-    def load(_owner_jid, jid, _db_state):
-        log.debug("Load %s", jid)
-        user = user_store.get_by_jid(JID(jid))
-        log.debug("User %s", user)
-        if user is None:
-            return {
-                "name": "",
-                "groups": [],
-                "from": False,
-                "to": False,
-                "pending_in": False,
-                "pending_out": False,
-                "whitelisted": False,
-                "subscription": "both",
-            }
-        else:
-            return {
-                "name": "",
-                "groups": [],
-                "from": True,
-                "to": True,
-                "pending_in": False,
-                "pending_out": False,
-                "whitelisted": False,
-                "subscription": "none",
-            }
-
-
 user_store = UserStore()
+"""
+A persistent store for slidge users. Not public, but I didn't find how to hide
+it from the docs!
+"""
 
 log = logging.getLogger(__name__)

slidge/util/schema.sql

@@ -0,0 +1,126 @@
+CREATE TABLE user(
+  id INTEGER PRIMARY KEY,
+  jid TEXT UNIQUE
+);
+
+CREATE TABLE muc(
+  id INTEGER PRIMARY KEY,
+  jid TEXT,
+  user_id INTEGER,
+  FOREIGN KEY(user_id) REFERENCES user(id),
+  UNIQUE(user_id, jid)
+);
+
+CREATE TABLE mam_message(
+  id INTEGER PRIMARY KEY,
+  message_id TEXT,
+  sent_on INTEGER,
+  sender_jid TEXT,
+  xml TEXT,
+  muc_id INTEGER,
+  user_id INTEGER,
+  FOREIGN KEY(muc_id) REFERENCES muc(id),
+  FOREIGN KEY(user_id) REFERENCES user(id),
+  UNIQUE(user_id, muc_id, message_id)
+);
+
+CREATE INDEX mam_sent_on ON mam_message(sent_on);
+CREATE INDEX muc_jid ON muc(jid);
+
+CREATE TABLE session_message_sent(
+  id INTEGER PRIMARY KEY,
+  legacy_id UNIQUE,
+  xmpp_id TEXT,
+  user_id INTEGER,
+  FOREIGN KEY(user_id) REFERENCES user(id)
+);
+
+CREATE INDEX session_message_sent_legacy_id
+    ON session_message_sent(legacy_id);
+CREATE INDEX session_message_sent_xmpp_id
+    ON session_message_sent(xmpp_id);
+
+CREATE TABLE session_message_sent_muc(
+  id INTEGER PRIMARY KEY,
+  legacy_id UNIQUE,
+  xmpp_id TEXT,
+  user_id INTEGER,
+  FOREIGN KEY(user_id) REFERENCES user(id)
+);
+
+CREATE INDEX session_message_sent_muc_legacy_id
+    ON session_message_sent_muc(legacy_id);
+CREATE INDEX session_message_sent_muc_xmpp_id
+    ON session_message_sent_muc(xmpp_id);
+
+CREATE TABLE session_thread_sent_muc(
+  id INTEGER PRIMARY KEY,
+  legacy_id UNIQUE,
+  xmpp_id TEXT,
+  user_id INTEGER,
+  FOREIGN KEY(user_id) REFERENCES user(id)
+);
+
+CREATE INDEX session_thread_sent_muc_legacy_id
+    ON session_thread_sent_muc(legacy_id);
+CREATE INDEX session_thread_sent_muc_xmpp_id
+    ON session_thread_sent_muc(xmpp_id);
+
+
+CREATE TABLE attachment(
+  id INTEGER PRIMARY KEY,
+  legacy_id UNIQUE,
+  url TEXT UNIQUE,
+  sims TEXT,
+  sfs TEXT
+);
+
+CREATE INDEX attachment_legacy_id ON attachment(legacy_id);
+CREATE INDEX attachment_url ON attachment(url);
+
+CREATE TABLE attachment_legacy_msg_id(
+  id INTEGER PRIMARY KEY,
+  legacy_id UNIQUE
+);
+
+CREATE TABLE attachment_xmpp_ids(
+  id INTEGER PRIMARY KEY,
+  legacy_msg_id INTEGER,
+  xmpp_id TEXT,
+  FOREIGN KEY(legacy_msg_id) REFERENCES attachment_legacy_msg_id(id)
+);
+
+CREATE TABLE nick(
+  id INTEGER PRIMARY KEY,
+  jid UNIQUE,
+  nick TEXT,
+  user_id INTEGER,
+  FOREIGN KEY(user_id) REFERENCES user(id),
+  UNIQUE(jid, user_id)
+);
+
+CREATE INDEX nick_jid ON nick(jid);
+
+
+CREATE TABLE avatar(
+  id INTEGER PRIMARY KEY,
+  jid TEXT UNIQUE,
+  cached_id TEXT
+);
+
+CREATE INDEX avatar_jid ON avatar(jid);
+
+
+CREATE TABLE presence(
+  id INTEGER PRIMARY KEY,
+  jid TEXT,
+  last_seen INTEGER,
+  ptype TEXT,
+  pstatus TEXT,
+  pshow TEXT,
+  user_id INTEGER,
+  FOREIGN KEY(user_id) REFERENCES user(id),
+  UNIQUE(jid, user_id)
+);
+
+CREATE INDEX presence_jid ON presence(jid);