slidge 0.1.3__py3-none-any.whl → 0.2.0a0__py3-none-any.whl

slidge/core/gateway/session_dispatcher.py

@@ -9,7 +9,6 @@ from slixmpp.plugins.xep_0084.stanza import Info
 
 from ... import LegacyContact
 from ...group.room import LegacyMUC
-from ...util.sql import db
 from ...util.types import LinkPreview, Recipient, RecipientType
 from ...util.util import (
     dict_to_named_tuple,
@@ -62,6 +61,13 @@ class SessionDispatcher:
                 _exceptions_to_xmpp_errors(self.on_muc_owner_set),  # type: ignore
             )
         )
+        xmpp.register_handler(
+            CoroutineCallback(
+                "ibr_remove",
+                StanzaPath("/iq/register"),
+                _exceptions_to_xmpp_errors(self.on_ibr_remove),  # type: ignore
+            )
+        )
 
         for event in (
             "legacy_message",
@@ -157,7 +163,7 @@ class SessionDispatcher:
         reply_fallback = None
         if msg.get_plugin("reply", check=True):
             try:
-                reply_to_msg_xmpp_id = _xmpp_msg_id_to_legacy(
+                reply_to_msg_xmpp_id = self._xmpp_msg_id_to_legacy(
                     session, msg["reply"]["id"]
                 )
             except XMPPError:
@@ -170,7 +176,7 @@ class SessionDispatcher:
             else:
                 reply_to_jid = JID(msg["reply"]["to"])
                 if msg["type"] == "chat":
-                    if reply_to_jid.bare != session.user.jid.bare:
+                    if reply_to_jid.bare != session.user_jid.bare:
                         try:
                             reply_to = await session.contacts.by_jid(reply_to_jid)
                         except XMPPError:
@@ -242,13 +248,17 @@ class SessionDispatcher:
         if isinstance(e, LegacyMUC):
             await e.echo(msg, legacy_msg_id)
             if legacy_msg_id is not None:
-                session.muc_sent_msg_ids[legacy_msg_id] = msg.get_id()
+                self.xmpp.store.sent.set_group_message(
+                    session.user_pk, legacy_msg_id, msg.get_id()
+                )
         else:
             self.__ack(msg)
             if legacy_msg_id is not None:
-                session.sent[legacy_msg_id] = msg.get_id()
+                self.xmpp.store.sent.set_message(
+                    session.user_pk, legacy_msg_id, msg.get_id()
+                )
                 if session.MESSAGE_IDS_ARE_THREAD_IDS and (t := msg["thread"]):
-                    session.threads[t] = legacy_msg_id
+                    self.xmpp.store.sent.set_thread(session.user_pk, t, legacy_msg_id)
 
     async def on_groupchat_message(self, msg: Message):
         await self.on_legacy_message(msg)
@@ -257,9 +267,11 @@ class SessionDispatcher:
         session, entity, thread = await self.__get_session_entity_thread(msg)
         xmpp_id = msg["replace"]["id"]
         if isinstance(entity, LegacyMUC):
-            legacy_id = session.muc_sent_msg_ids.inverse.get(xmpp_id)
+            legacy_id = self.xmpp.store.sent.get_group_legacy_id(
+                session.user_pk, xmpp_id
+            )
         else:
-            legacy_id = _xmpp_msg_id_to_legacy(session, xmpp_id)
+            legacy_id = self._xmpp_msg_id_to_legacy(session, xmpp_id)
 
         if isinstance(entity, LegacyMUC):
             mentions = await entity.parse_mentions(msg["body"])
@@ -323,12 +335,16 @@ class SessionDispatcher:
 
         if isinstance(entity, LegacyMUC):
             if new_legacy_msg_id is not None:
-                session.muc_sent_msg_ids[new_legacy_msg_id] = msg.get_id()
+                self.xmpp.store.sent.set_group_message(
+                    session.user_pk, new_legacy_msg_id, msg.get_id()
+                )
             await entity.echo(msg, new_legacy_msg_id)
         else:
             self.__ack(msg)
             if new_legacy_msg_id is not None:
-                session.sent[new_legacy_msg_id] = msg.get_id()
+                self.xmpp.store.sent.set_message(
+                    session.user_pk, new_legacy_msg_id, msg.get_id()
+                )
 
     async def on_message_retract(self, msg: Message):
         session, entity, thread = await self.__get_session_entity_thread(msg)
@@ -338,7 +354,7 @@ class SessionDispatcher:
                 "This legacy service does not support message retraction.",
             )
         xmpp_id: str = msg["retract"]["id"]
-        legacy_id = _xmpp_msg_id_to_legacy(session, xmpp_id)
+        legacy_id = self._xmpp_msg_id_to_legacy(session, xmpp_id)
         if legacy_id:
             await session.on_retract(entity, legacy_id, thread=thread)
             if isinstance(entity, LegacyMUC):
@@ -362,7 +378,7 @@ class SessionDispatcher:
             to_mark = [displayed_msg_id]
         for xmpp_id in to_mark:
             await session.on_displayed(
-                e, _xmpp_msg_id_to_legacy(session, xmpp_id), legacy_thread
+                e, self._xmpp_msg_id_to_legacy(session, xmpp_id), legacy_thread
             )
             if isinstance(e, LegacyMUC):
                 await e.echo(msg, None)
@@ -397,7 +413,7 @@ class SessionDispatcher:
         if special_msg:
             legacy_id = react_to
         else:
-            legacy_id = _xmpp_msg_id_to_legacy(session, react_to)
+            legacy_id = self._xmpp_msg_id_to_legacy(session, react_to)
 
         if not legacy_id:
             log.debug("Ignored reaction from user")
@@ -434,9 +450,10 @@ class SessionDispatcher:
         else:
             self.__ack(msg)
 
-        multi = db.attachment_get_associated_xmpp_ids(react_to)
+        multi = self.xmpp.store.multi.get_xmpp_ids(session.user_pk, react_to)
         if not multi:
             return
+        multi = [m for m in multi if react_to != m]
 
         if isinstance(entity, LegacyMUC):
             for xmpp_id in multi:
@@ -461,14 +478,17 @@ class SessionDispatcher:
 
         pto = p.get_to()
         if pto == self.xmpp.boundjid.bare:
-            # NB: get_type() returns either a proper presence type or
-            #     a presence show if available. Weird, weird, weird slix.
+            session.log.debug("Received a presence from %s", p.get_from())
             if (ptype := p.get_type()) not in _USEFUL_PRESENCES:
                 return
+            if not session.user.preferences.get("sync_presence", False):
+                session.log.debug("User does not want to sync their presence")
+                return
+            # NB: get_type() returns either a proper presence type or
+            #     a presence show if available. Weird, weird, weird slix.
             resources = self.xmpp.roster[self.xmpp.boundjid.bare][
                 p.get_from()
             ].resources
-            session.log.debug("Received a presence from %s", p.get_from())
             await session.on_presence(
                 p.get_from().resource,
                 ptype,  # type: ignore
@@ -478,8 +498,12 @@ class SessionDispatcher:
             )
             return
 
-        muc = session.bookmarks._mucs_by_bare_jid.get(pto.bare)
-        if muc is None or p.get_from().resource not in muc.user_resources:
+        muc = session.bookmarks.by_jid_only_if_exists(JID(pto.bare))
+
+        if muc is not None and p.get_type() == "unavailable":
+            return muc.on_presence_unavailable(p)
+
+        if muc is None or p.get_from().resource not in muc.get_user_resources():
             return
 
         if pto.resource == muc.user_nick:
@@ -530,29 +554,36 @@ class SessionDispatcher:
             return
 
         stanza_id = msg["pubsub_event"]["items"]["item"]["displayed"]["stanza_id"]["id"]
-        await session.on_displayed(chat, _xmpp_msg_id_to_legacy(session, stanza_id))
+        await session.on_displayed(
+            chat, self._xmpp_msg_id_to_legacy(session, stanza_id)
+        )
 
     async def on_avatar_metadata_publish(self, m: Message):
-        if not config.SYNC_AVATAR:
-            return
-
         session = await self.__get_session(m, timeout=None)
+        if not session.user.preferences.get("sync_avatar", False):
+            session.log.debug("User does not want to sync their avatar")
+            return
         info = m["pubsub_event"]["items"]["item"]["avatar_metadata"]["info"]
 
         await self.on_avatar_metadata_info(session, info)
 
     async def on_avatar_metadata_info(self, session: BaseSession, info: Info):
-        session.log.debug("Avatar metadata info: %s", info)
         hash_ = info["id"]
 
-        if session.avatar_hash == hash_:
+        if session.user.avatar_hash == hash_:
+            session.log.debug("We already know this avatar hash")
             return
-        session.avatar_hash = hash_
+        with self.xmpp.store.session() as orm_session:
+            user = self.xmpp.store.users.get(session.user_jid)
+            assert user is not None
+            user.avatar_hash = hash_
+            orm_session.add(user)
+            orm_session.commit()
 
         if hash_:
             try:
                 iq = await self.xmpp.plugin["xep_0084"].retrieve_avatar(
-                    session.user.jid, hash_, ifrom=self.xmpp.boundjid.bare
+                    session.user_jid, hash_, ifrom=self.xmpp.boundjid.bare
                 )
             except IqError as e:
                 session.log.warning("Could not fetch the user's avatar: %s", e)
@@ -593,7 +624,7 @@ class SessionDispatcher:
                 "Slidge only implements moderation/retraction",
             )
 
-        legacy_id = _xmpp_msg_id_to_legacy(session, xmpp_id)
+        legacy_id = self._xmpp_msg_id_to_legacy(session, xmpp_id)
         await session.on_moderate(muc, legacy_id, moderate["reason"] or None)
         iq.reply(clear=True).send()
 
@@ -718,25 +749,39 @@ class SessionDispatcher:
             )
         await muc.on_set_subject(msg["subject"])
 
+    async def on_ibr_remove(self, iq: Iq):
+        if iq.get_to() == self.xmpp.boundjid.bare:
+            return
+
+        session = await self.__get_session(iq)
+        session.raise_if_not_logged()
 
-def _xmpp_msg_id_to_legacy(session: "BaseSession", xmpp_id: str):
-    sent = session.sent.inverse.get(xmpp_id)
-    if sent:
-        return sent
+        if iq["type"] == "set" and iq["register"]["remove"]:
+            muc = await session.bookmarks.by_jid(iq.get_to())
+            await session.on_leave_group(muc.legacy_id)
+            iq.reply().send()
+            return
 
-    multi = db.attachment_get_legacy_id_for_xmpp_id(xmpp_id)
-    if multi:
-        return multi
+        raise XMPPError("feature-not-implemented")
 
-    try:
-        return session.xmpp_to_legacy_msg_id(xmpp_id)
-    except XMPPError:
-        raise
-    except Exception as e:
-        log.debug("Couldn't convert xmpp msg ID to legacy ID.", exc_info=e)
-        raise XMPPError(
-            "internal-server-error", "Couldn't convert xmpp msg ID to legacy ID."
-        )
+    def _xmpp_msg_id_to_legacy(self, session: "BaseSession", xmpp_id: str):
+        sent = self.xmpp.store.sent.get_legacy_id(session.user_pk, xmpp_id)
+        if sent is not None:
+            return self.xmpp.LEGACY_MSG_ID_TYPE(sent)
+
+        multi = self.xmpp.store.multi.get_legacy_id(session.user_pk, xmpp_id)
+        if multi:
+            return self.xmpp.LEGACY_MSG_ID_TYPE(multi)
+
+        try:
+            return session.xmpp_to_legacy_msg_id(xmpp_id)
+        except XMPPError:
+            raise
+        except Exception as e:
+            log.debug("Couldn't convert xmpp msg ID to legacy ID.", exc_info=e)
+            raise XMPPError(
+                "internal-server-error", "Couldn't convert xmpp msg ID to legacy ID."
+            )
 
 
 def _ignore(session: "BaseSession", msg: Message):
@@ -755,14 +800,18 @@ async def _xmpp_to_legacy_thread(
         return
 
     if session.MESSAGE_IDS_ARE_THREAD_IDS:
-        return session.threads.get(xmpp_thread)
+        return session.xmpp.store.sent.get_legacy_thread(session.user_pk, xmpp_thread)
 
     async with session.thread_creation_lock:
-        legacy_thread = session.threads.get(xmpp_thread)
-        if legacy_thread is None:
-            legacy_thread = await recipient.create_thread(xmpp_thread)
-            session.threads[xmpp_thread] = legacy_thread
-    return legacy_thread
+        legacy_thread_str = session.xmpp.store.sent.get_legacy_thread(
+            session.user_pk, xmpp_thread
+        )
+        if legacy_thread_str is None:
+            legacy_thread = str(await recipient.create_thread(xmpp_thread))
+            session.xmpp.store.sent.set_thread(
+                session.user_pk, xmpp_thread, legacy_thread
+            )
+    return session.xmpp.LEGACY_MSG_ID_TYPE(legacy_thread)
 
 
 async def _get_entity(session: "BaseSession", m: Message) -> RecipientType:
@@ -770,7 +819,7 @@ async def _get_entity(session: "BaseSession", m: Message) -> RecipientType:
     if m.get_type() == "groupchat":
         muc = await session.bookmarks.by_jid(m.get_to())
         r = m.get_from().resource
-        if r not in muc.user_resources:
+        if r not in muc.get_user_resources():
             session.create_task(muc.kick_resource(r))
             raise XMPPError("not-acceptable", "You are not connected to this chat")
         return muc

slidge/core/gateway/vcard_temp.py

@@ -40,11 +40,13 @@ class VCardTemp:
             return await self.__handle_set_vcard_temp(iq)
 
     async def __fetch_user_avatar(self, session: BaseSession):
-        hash_ = session.avatar_hash
+        hash_ = session.user.avatar_hash
         if not hash_:
-            raise XMPPError("item-not-found", "This participant has no contact")
+            raise XMPPError(
+                "item-not-found", "The slidge user does not have any avatar set"
+            )
         meta_iq = await self.xmpp.plugin["xep_0060"].get_item(
-            session.user.jid,
+            session.user_jid,
             MetaData.namespace,
             hash_,
             ifrom=self.xmpp.boundjid.bare,
@@ -52,7 +54,7 @@ class VCardTemp:
         info = meta_iq["pubsub"]["items"]["item"]["avatar_metadata"]["info"]
         type_ = info["type"]
         data_iq = await self.xmpp.plugin["xep_0084"].retrieve_avatar(
-            session.user.jid, hash_, ifrom=self.xmpp.boundjid.bare
+            session.user_jid, hash_, ifrom=self.xmpp.boundjid.bare
         )
         bytes_ = data_iq["pubsub"]["items"]["item"]["avatar_data"]["value"]
         return bytes_, type_

slidge/core/mixins/__init__.py

@@ -2,6 +2,8 @@
 Mixins
 """
 
+from typing import Optional
+
 from .avatar import AvatarMixin
 from .disco import ChatterDiscoMixin
 from .message import MessageCarbonMixin, MessageMixin
@@ -16,4 +18,12 @@ class FullCarbonMixin(ChatterDiscoMixin, MessageCarbonMixin, PresenceMixin):
     pass
 
 
-__all__ = ("AvatarMixin",)
+class StoredAttributeMixin:
+    def serialize_extra_attributes(self) -> Optional[dict]:
+        return None
+
+    def deserialize_extra_attributes(self, data: dict) -> None:
+        pass
+
+
+__all__ = ("AvatarMixin", "FullCarbonMixin", "StoredAttributeMixin")

slidge/core/mixins/attachment.py

@@ -22,7 +22,7 @@ from slixmpp.plugins.xep_0363 import FileUploadError
 from slixmpp.plugins.xep_0385.stanza import Sims
 from slixmpp.plugins.xep_0447.stanza import StatelessFileSharing
 
-from ...util.sql import db
+from ...db.avatar import avatar_cache
 from ...util.types import (
     LegacyAttachment,
     LegacyMessageType,
@@ -31,11 +31,14 @@ from ...util.types import (
 )
 from ...util.util import fix_suffix
 from .. import config
-from ..cache import avatar_cache
 from .message_maker import MessageMaker
 
 
 class AttachmentMixin(MessageMaker):
+    def __init__(self, *a, **kw):
+        super().__init__(*a, **kw)
+        self.__store = self.xmpp.store.attachments
+
     def send_text(self, *_, **k) -> Optional[Message]:
         raise NotImplementedError
 
@@ -146,13 +149,13 @@ class AttachmentMixin(MessageMaker):
         legacy_file_id: Optional[Union[str, int]] = None,
     ) -> tuple[bool, Optional[Path], str]:
         if legacy_file_id:
-            cache = db.attachment_get_url(legacy_file_id)
+            cache = self.__store.get_url(str(legacy_file_id))
             if cache is not None:
                 async with self.session.http.head(cache) as r:
                     if r.status < 400:
                         return False, None, cache
                     else:
-                        db.attachment_remove(legacy_file_id)
+                        self.__store.remove(str(legacy_file_id))
 
         if file_url and config.USE_ATTACHMENT_ORIGINAL_URLS:
             return False, None, file_url
@@ -198,7 +201,7 @@ class AttachmentMixin(MessageMaker):
             local_path = file_path
             new_url = await self.__upload(file_path, file_name, content_type)
         if legacy_file_id:
-            db.attachment_store_url(legacy_file_id, new_url)
+            self.__store.set_url(self.session.user_pk, str(legacy_file_id), new_url)
 
         return is_temp, local_path, new_url
 
@@ -211,7 +214,7 @@ class AttachmentMixin(MessageMaker):
         caption: Optional[str] = None,
         file_name: Optional[str] = None,
     ):
-        cache = db.attachment_get_sims(uploaded_url)
+        cache = self.__store.get_sims(uploaded_url)
         if cache:
             msg.append(Sims(xml=ET.fromstring(cache)))
             return
@@ -238,7 +241,7 @@ class AttachmentMixin(MessageMaker):
                 thumbnail["media-type"] = "image/blurhash"
                 thumbnail["uri"] = "data:image/blurhash," + urlquote(h)
 
-        db.attachment_store_sims(uploaded_url, str(sims))
+        self.__store.set_sims(uploaded_url, str(sims))
 
         msg.append(sims)
 
@@ -251,7 +254,7 @@ class AttachmentMixin(MessageMaker):
         caption: Optional[str] = None,
         file_name: Optional[str] = None,
     ):
-        cache = db.attachment_get_sfs(uploaded_url)
+        cache = self.__store.get_sfs(uploaded_url)
         if cache:
             msg.append(StatelessFileSharing(xml=ET.fromstring(cache)))
             return
@@ -262,7 +265,7 @@ class AttachmentMixin(MessageMaker):
         sfs = self.xmpp["xep_0447"].get_sfs(path, [uploaded_url], content_type, caption)
         if file_name:
             sfs["file"]["name"] = file_name
-        db.attachment_store_sfs(uploaded_url, str(sfs))
+        self.__store.set_sfs(uploaded_url, str(sfs))
 
         msg.append(sfs)
 
@@ -472,7 +475,9 @@ class AttachmentMixin(MessageMaker):
                 ids.append(stanza_id["id"])
             else:
                 ids.append(msg.get_id())
-        db.attachment_store_legacy_to_multi_xmpp_msg_ids(legacy_msg_id, ids)
+        self.xmpp.store.multi.set_xmpp_ids(
+            self.session.user_pk, str(legacy_msg_id), ids
+        )
 
 
 def get_blurhash(path: Path, n=9) -> tuple[str, int, int]:

slidge/core/mixins/avatar.py

@@ -5,6 +5,7 @@ from typing import TYPE_CHECKING, Optional
 
 from slixmpp import JID
 
+from ...db.avatar import CachedAvatar, avatar_cache
 from ...util.types import (
     URL,
     AnyBaseSession,
@@ -12,7 +13,6 @@ from ...util.types import (
     AvatarType,
     LegacyFileIdType,
 )
-from ..cache import avatar_cache
 
 if TYPE_CHECKING:
     from ..pubsub import PepAvatar
@@ -34,7 +34,9 @@ class AvatarMixin:
     def __init__(self) -> None:
         super().__init__()
         self._set_avatar_task: Optional[Task] = None
+        self.__broadcast_task: Optional[Task] = None
         self.__avatar_unique_id: Optional[AvatarIdType] = None
+        self._avatar_pk: Optional[int] = None
 
     @property
     def __avatar_jid(self):
@@ -86,13 +88,28 @@ class AvatarMixin:
 
     async def __set_avatar(self, a: Optional[AvatarType], uid: Optional[AvatarIdType]):
         self.__avatar_unique_id = uid
-        await self.session.xmpp.pubsub.set_avatar(
-            jid=self.__avatar_jid,
-            avatar=a,
-            unique_id=None if isinstance(uid, URL) else uid,
-            broadcast_to=self.session.user.jid.bare,
-            broadcast=self._avatar_pubsub_broadcast,
-        )
+
+        if a is None:
+            cached_avatar = None
+            self._avatar_pk = None
+        else:
+            try:
+                cached_avatar = await avatar_cache.convert_or_get(
+                    URL(a) if isinstance(a, URL) else a,
+                    None if isinstance(uid, URL) else uid,
+                )
+            except Exception as e:
+                self.session.log.error("Failed to set avatar %s", a, exc_info=e)
+                self._avatar_pk = None
+                self.__avatar_unique_id = uid
+                return
+            self._avatar_pk = cached_avatar.pk
+
+        if self._avatar_pubsub_broadcast:
+            await self.session.xmpp.pubsub.broadcast_avatar(
+                self.__avatar_jid, self.session.user_jid, cached_avatar
+            )
+
         self._post_avatar_update()
 
     async def _no_change(self, a: Optional[AvatarType], uid: Optional[AvatarIdType]):
@@ -103,7 +120,7 @@ class AvatarMixin:
         if isinstance(uid, URL):
             if self.__avatar_unique_id != uid:
                 return False
-            return not await avatar_cache.url_has_changed(uid)
+            return not await avatar_cache.url_modified(uid)
         return self.__avatar_unique_id == uid
 
     async def set_avatar(
@@ -136,32 +153,63 @@ class AvatarMixin:
         if blocking:
             await awaitable
 
-    def get_avatar(self) -> Optional["PepAvatar"]:
+    def get_cached_avatar(self) -> Optional["CachedAvatar"]:
         if not self.__avatar_unique_id:
             return None
-        return self.session.xmpp.pubsub.get_avatar(self.__avatar_jid)
+        return avatar_cache.get(self.__avatar_unique_id)
+
+    def get_avatar(self) -> Optional["PepAvatar"]:
+        cached_avatar = self.get_cached_avatar()
+        if cached_avatar is None:
+            return None
+        from ..pubsub import PepAvatar
+
+        item = PepAvatar()
+        item.set_avatar_from_cache(cached_avatar)
+        return item
 
     def _post_avatar_update(self) -> None:
         return
 
+    def __get_cached_avatar_id(self):
+        i = self._get_cached_avatar_id()
+        if i is None:
+            return None
+        return self.session.xmpp.AVATAR_ID_TYPE(i)
+
+    def _get_cached_avatar_id(self) -> Optional[str]:
+        raise NotImplementedError
+
     async def avatar_wrap_update_info(self):
-        cached_id = avatar_cache.get_cached_id_for(self.__avatar_jid)
+        cached_id = self.__get_cached_avatar_id()
         self.__avatar_unique_id = cached_id
         try:
             await self.update_info()  # type:ignore
         except NotImplementedError:
             return
         new_id = self.avatar
-        if isinstance(new_id, URL) and not await avatar_cache.url_has_changed(new_id):
+        if isinstance(new_id, URL) and not await avatar_cache.url_modified(new_id):
             return
         elif new_id != cached_id:
             # at this point it means that update_info set the avatar, and we don't
             # need to do anything else
             return
 
-        await self.session.xmpp.pubsub.set_avatar_from_cache(
-            self.__avatar_jid,
-            new_id is None and cached_id is not None,
-            self.session.user.jid.bare,
-            self._avatar_pubsub_broadcast,
+        if self._avatar_pubsub_broadcast:
+            if new_id is None and cached_id is None:
+                return
+            cached_avatar = avatar_cache.get(cached_id)
+            self.__broadcast_task = self.session.xmpp.loop.create_task(
+                self.session.xmpp.pubsub.broadcast_avatar(
+                    self.__avatar_jid, self.session.user_jid, cached_avatar
+                )
+            )
+
+    def _set_avatar_from_store(self, stored):
+        if stored.avatar_id is None:
+            return
+        self.__avatar_unique_id = (
+            stored.avatar.legacy_id
+            if stored.avatar.legacy_id is not None
+            else URL(stored.avatar.url)
         )

slidge/core/mixins/base.py

@@ -8,7 +8,6 @@ from ...util.types import MessageOrPresenceTypeVar
 if TYPE_CHECKING:
     from slidge.core.gateway import BaseGateway
     from slidge.core.session import BaseSession
-    from slidge.util.db import GatewayUser
 
 
 class MetaBase(ABCMeta):
@@ -18,11 +17,18 @@ class MetaBase(ABCMeta):
 class Base:
     session: "BaseSession" = NotImplemented
     xmpp: "BaseGateway" = NotImplemented
-    user: "GatewayUser" = NotImplemented
 
     jid: JID = NotImplemented
     name: str = NotImplemented
 
+    @property
+    def user_jid(self):
+        return self.session.user_jid
+
+    @property
+    def user_pk(self):
+        return self.session.user_pk
+
 
 class BaseSender(Base):
     def _send(

slidge/core/mixins/message.py

@@ -111,7 +111,7 @@ class MarkerMixin(MessageMaker):
                 self.xmpp.delivery_receipt.make_ack(
                     self._legacy_to_xmpp(legacy_msg_id),
                     mfrom=self.jid,
-                    mto=self.user.jid,
+                    mto=self.user_jid,
                 )
             )
         self._send(
@@ -144,7 +144,7 @@ class MarkerMixin(MessageMaker):
             # We'll see if we need to implement that later
             return
         xmpp_msg_id = self._legacy_to_xmpp(legacy_msg_id)
-        iq = Iq(sto=self.user.bare_jid, sfrom=self.user.bare_jid, stype="set")
+        iq = Iq(sto=self.user_jid.bare, sfrom=self.user_jid.bare, stype="set")
         iq["pubsub"]["publish"]["node"] = self.xmpp["xep_0490"].stanza.NS
         iq["pubsub"]["publish"]["item"]["id"] = muc_jid
         displayed = self.xmpp["xep_0490"].stanza.Displayed()
@@ -169,8 +169,8 @@ class ContentMessageMixin(AttachmentMixin):
 
     def __replace_id(self, legacy_msg_id: LegacyMessageType):
         if self.mtype == "groupchat":
-            return self.session.muc_sent_msg_ids.get(
-                legacy_msg_id
+            return self.xmpp.store.sent.get_group_xmpp_id(
+                self.session.user_pk, str(legacy_msg_id)
             ) or self._legacy_to_xmpp(legacy_msg_id)
         else:
             return self._legacy_to_xmpp(legacy_msg_id)
@@ -215,14 +215,18 @@ class ContentMessageMixin(AttachmentMixin):
             but store it in the archive. Meant to be used during ``MUC.backfill()``
         """
         if carbon:
-            if not correction and legacy_msg_id in self.session.sent:
+            if not correction and self.xmpp.store.sent.was_sent_by_user(
+                self.session.user_pk, str(legacy_msg_id)
+            ):
                 log.warning(
                     "Carbon message for a message an XMPP has sent? This is a bug! %s",
                     legacy_msg_id,
                 )
                 return
-            self.session.sent[legacy_msg_id] = self.session.legacy_to_xmpp_msg_id(
-                legacy_msg_id
+            self.xmpp.store.sent.set_message(
+                self.session.user_pk,
+                str(legacy_msg_id),
+                self.session.legacy_to_xmpp_msg_id(legacy_msg_id),
             )
         hints = self.__default_hints(hints)
         msg = self._make_message(