slidge 0.1.2__py3-none-any.whl → 0.2.0__py3-none-any.whl

slidge/group/room.py

@@ -1,10 +1,11 @@
+import json
 import logging
 import re
 import string
 import warnings
 from copy import copy
 from datetime import datetime, timedelta, timezone
-from typing import TYPE_CHECKING, Generic, Optional, Union
+from typing import TYPE_CHECKING, AsyncIterator, Generic, Optional, Self, Union
 from uuid import uuid4
 
 from slixmpp import JID, Iq, Message, Presence
@@ -15,14 +16,19 @@ from slixmpp.plugins.xep_0060.stanza import Item
 from slixmpp.plugins.xep_0082 import parse as str_to_datetime
 from slixmpp.xmlstream import ET
 
+from ..contact.contact import LegacyContact
 from ..contact.roster import ContactIsUser
 from ..core import config
+from ..core.mixins import StoredAttributeMixin
 from ..core.mixins.avatar import AvatarMixin
+from ..core.mixins.db import UpdateInfoMixin
 from ..core.mixins.disco import ChatterDiscoMixin
 from ..core.mixins.lock import NamedLockMixin
 from ..core.mixins.recipient import ReactionRecipientMixin, ThreadRecipientMixin
+from ..db.models import Room
 from ..util import ABCSubclassableOnceAtMost
 from ..util.types import (
+    HoleBound,
     LegacyGroupIdType,
     LegacyMessageType,
     LegacyParticipantType,
@@ -31,21 +37,25 @@ from ..util.types import (
     MucAffiliation,
     MucType,
 )
-from ..util.util import deprecated
+from ..util.util import deprecated, timeit, with_session
 from .archive import MessageArchive
+from .participant import LegacyParticipant
 
 if TYPE_CHECKING:
-    from ..contact import LegacyContact
     from ..core.gateway import BaseGateway
     from ..core.session import BaseSession
 
 ADMIN_NS = "http://jabber.org/protocol/muc#admin"
 
+SubjectSetterType = Union[str, None, "LegacyContact", "LegacyParticipant"]
+
 
 class LegacyMUC(
     Generic[
         LegacyGroupIdType, LegacyMessageType, LegacyParticipantType, LegacyUserIdType
     ],
+    UpdateInfoMixin,
+    StoredAttributeMixin,
     AvatarMixin,
     NamedLockMixin,
     ChatterDiscoMixin,
@@ -60,8 +70,6 @@ class LegacyMUC(
     on the user's :py:class:`slidge.core.session.BaseSession`.
     """
 
-    subject_date: Optional[datetime] = None
-    n_participants: Optional[int] = None
     max_history_fetch = 100
 
     type = MucType.CHANNEL
@@ -117,47 +125,75 @@ class LegacyMUC(
     tries to set the room subject.
     """
 
-    _avatar_pubsub_broadcast = False
     _avatar_bare_jid = True
+    archive: MessageArchive
 
     def __init__(self, session: "BaseSession", legacy_id: LegacyGroupIdType, jid: JID):
-        from .participant import LegacyParticipant
-
         self.session = session
         self.xmpp: "BaseGateway" = session.xmpp
-        self.user = session.user
-        self.log = logging.getLogger(f"{self.user.bare_jid}:muc:{jid}")
 
         self.legacy_id = legacy_id
         self.jid = jid
 
-        self.user_resources = set[str]()
+        self._user_resources = set[str]()
 
         self.Participant = LegacyParticipant.get_self_or_unique_subclass()
 
-        self.xmpp.add_event_handler(
-            "presence_unavailable", self._on_presence_unavailable
-        )
-
         self._subject = ""
-        self.subject_setter: Union[str, "LegacyContact", "LegacyParticipant"] = (
-            self.get_system_participant()
-        )
+        self._subject_setter: Optional[str] = None
 
-        self.archive: MessageArchive = MessageArchive(str(self.jid), self.user)
+        self.pk: Optional[int] = None
         self._user_nick: Optional[str] = None
 
-        self._participants_by_nicknames = dict[str, LegacyParticipantType]()
-        self._participants_by_escaped_nicknames = dict[str, LegacyParticipantType]()
-        self._participants_by_contacts = dict["LegacyContact", LegacyParticipantType]()
-
-        self.__participants_filled = False
-        self.__history_filled = False
+        self._participants_filled = False
+        self._history_filled = False
         self._description = ""
+        self._subject_date: Optional[datetime] = None
+
+        self.__participants_store = self.xmpp.store.participants
+        self.__store = self.xmpp.store.rooms
+
+        self._n_participants: Optional[int] = None
+
+        self.log = logging.getLogger(self.jid.bare)
+        self._set_logger_name()
         super().__init__()
 
+    @property
+    def n_participants(self):
+        return self._n_participants
+
+    @n_participants.setter
+    def n_participants(self, n_participants: Optional[int]):
+        if self._n_participants == n_participants:
+            return
+        self._n_participants = n_participants
+        if self._updating_info:
+            return
+        assert self.pk is not None
+        self.__store.update_n_participants(self.pk, n_participants)
+
+    @property
+    def user_jid(self):
+        return self.session.user_jid
+
+    def _set_logger_name(self):
+        self.log = logging.getLogger(f"{self.user_jid}:muc:{self}")
+
     def __repr__(self):
-        return f"<MUC {self.legacy_id}/{self.jid}/{self.name}>"
+        return f"<MUC #{self.pk} '{self.name}' ({self.legacy_id} - {self.jid.local})'>"
+
+    @property
+    def subject_date(self) -> Optional[datetime]:
+        return self._subject_date
+
+    @subject_date.setter
+    def subject_date(self, when: Optional[datetime]) -> None:
+        self._subject_date = when
+        if self._updating_info:
+            return
+        assert self.pk is not None
+        self.__store.update_subject_date(self.pk, when)
 
     def __send_configuration_change(self, codes):
         part = self.get_system_participant()
@@ -165,50 +201,92 @@ class LegacyMUC(
 
     @property
     def user_nick(self):
-        return (
-            self._user_nick
-            or self.session.bookmarks.user_nick
-            or self.session.user.jid.node
-        )
+        return self._user_nick or self.session.bookmarks.user_nick or self.user_jid.node
 
     @user_nick.setter
     def user_nick(self, nick: str):
         self._user_nick = nick
+        if not self._updating_info:
+            self.__store.update_user_nick(self.pk, nick)
+
+    def add_user_resource(self, resource: str) -> None:
+        self._user_resources.add(resource)
+        assert self.pk is not None
+        self.__store.set_resource(self.pk, self._user_resources)
+
+    def get_user_resources(self) -> set[str]:
+        return self._user_resources
+
+    def remove_user_resource(self, resource: str) -> None:
+        self._user_resources.remove(resource)
+        assert self.pk is not None
+        self.__store.set_resource(self.pk, self._user_resources)
 
     async def __fill_participants(self):
+        if self._participants_filled:
+            return
+        assert self.pk is not None
         async with self.lock("fill participants"):
-            if self.__participants_filled:
-                return
-            self.__participants_filled = True
-            try:
-                await self.fill_participants()
-            except NotImplementedError:
-                pass
+            self._participants_filled = True
+            async for p in self.fill_participants():
+                self.__participants_store.update(p)
+                self.__store.set_participants_filled(self.pk)
+
+    async def get_participants(self) -> AsyncIterator[LegacyParticipant]:
+        assert self.pk is not None
+        if self._participants_filled:
+            for db_participant in self.xmpp.store.participants.get_all(
+                self.pk, user_included=True
+            ):
+                participant = self.Participant.from_store(
+                    self.session, db_participant, muc=self
+                )
+                yield participant
+            return
+
+        async with self.lock("fill participants"):
+            self._participants_filled = True
+            # We only fill the participants list if/when the MUC is first
+            # joined by an XMPP client. But we may have instantiated
+            resources = set[str]()
+            for db_participant in self.xmpp.store.participants.get_all(
+                self.pk, user_included=True
+            ):
+                participant = self.Participant.from_store(
+                    self.session, db_participant, muc=self
+                )
+                resources.add(participant.jid.resource)
+                yield participant
+            async for p in self.fill_participants():
+                if p.jid.resource not in resources:
+                    yield p
+            self.__store.set_participants_filled(self.pk)
+            return
 
     async def __fill_history(self):
         async with self.lock("fill history"):
-            if self.__history_filled:
+            if self._history_filled:
                 log.debug("History has already been fetched %s", self)
                 return
             log.debug("Fetching history for %s", self)
-            for msg in self.archive:
-                try:
-                    legacy_id = self.session.xmpp_to_legacy_msg_id(msg.id)
-                    oldest_date = msg.when
-                except Exception as e:
-                    # not all archived stanzas have a valid legacy msg ID, eg
-                    # reactions, corrections, message with multiple attachments…
-                    self.log.debug(f"Could not convert during history back-filling {e}")
-                else:
-                    break
-            else:
-                legacy_id = None
-                oldest_date = None
             try:
-                await self.backfill(legacy_id, oldest_date)
+                before, after = self.archive.get_hole_bounds()
+                if before is not None:
+                    before = before._replace(
+                        id=self.xmpp.LEGACY_MSG_ID_TYPE(before.id)  # type:ignore
+                    )
+                if after is not None:
+                    after = after._replace(
+                        id=self.xmpp.LEGACY_MSG_ID_TYPE(after.id)  # type:ignore
+                    )
+                await self.backfill(before, after)
             except NotImplementedError:
                 return
-            self.__history_filled = True
+            except Exception as e:
+                log.exception("Could not backfill: %s", e)
+            assert self.pk is not None
+            self.__store.set_history_filled(self.pk, True)
+            self._history_filled = True
 
     @property
     def name(self):
@@ -219,7 +297,12 @@ class LegacyMUC(
         if self.DISCO_NAME == n:
             return
         self.DISCO_NAME = n
+        self._set_logger_name()
         self.__send_configuration_change((104,))
+        if self._updating_info:
+            return
+        assert self.pk is not None
+        self.__store.update_name(self.pk, n)
 
     @property
     def description(self):
@@ -231,21 +314,25 @@ class LegacyMUC(
             return
         self._description = d
         self.__send_configuration_change((104,))
+        if self._updating_info:
+            return
+        assert self.pk is not None
+        self.__store.update_description(self.pk, d)
 
-    def _on_presence_unavailable(self, p: Presence):
+    def on_presence_unavailable(self, p: Presence):
         pto = p.get_to()
         if pto.bare != self.jid.bare:
             return
 
         pfrom = p.get_from()
-        if pfrom.bare != self.user.bare_jid:
+        if pfrom.bare != self.user_jid.bare:
             return
-        if (resource := pfrom.resource) in (resources := self.user_resources):
+        if (resource := pfrom.resource) in self._user_resources:
             if pto.resource != self.user_nick:
                 self.log.debug(
                     "Received 'leave group' request but with wrong nickname. %s", p
                 )
-            resources.remove(resource)
+            self.remove_user_resource(resource)
         else:
             self.log.debug(
                 "Received 'leave group' request but resource was not listed. %s", p
@@ -270,27 +357,35 @@ class LegacyMUC(
 
     async def backfill(
         self,
-        oldest_message_id: Optional[LegacyMessageType] = None,
-        oldest_message_date: Optional[datetime] = None,
+        after: Optional[HoleBound] = None,
+        before: Optional[HoleBound] = None,
     ):
         """
-        Override this if the legacy network provide server-side archive.
-        In it, send history messages using ``self.get_participant().send*``,
-        with the ``archive_only=True`` kwarg.
-
-        You only need to fetch messages older than ``oldest_message_id``.
-
-        :param oldest_message_id: The oldest message ID already present in the archive
-        :param oldest_message_date: The oldest message date already present in the archive
+        Override this if the legacy network provide server-side group archives.
+
+        In it, send history messages using ``self.get_participant(xxx).send_xxxx``,
+        with the ``archive_only=True`` kwarg. This is only called once per slidge
+        run for a given group.
+
+        :param after: Fetch messages after this one. If ``None``, it's up to you
+            to decide how far you want to go in the archive. If it's not ``None``,
+            it means slidge has some messages in this archive and you should really try
+            to complete it to avoid "holes" in the history of this group.
+        :param before: Fetch messages before this one. If ``None``, fetch all messages
+            up to the most recent one
         """
         raise NotImplementedError
 
-    async def fill_participants(self):
+    async def fill_participants(self) -> AsyncIterator[LegacyParticipant]:
         """
-        In here, call self.get_participant(), self.get_participant_by_contact(),
-        of self.get_user_participant() to make an initial list of participants.
+        This method should yield the list of all members of this group.
+
+        Typically, use ``participant = self.get_participant()``, self.get_participant_by_contact(),
+        of self.get_user_participant(), and update their affiliation, hats, etc.
+        before yielding them.
         """
-        raise NotImplementedError
+        return
+        yield
 
     @property
     def subject(self):
@@ -300,34 +395,44 @@ class LegacyMUC(
     def subject(self, s: str):
         if s == self._subject:
             return
-        self.xmpp.loop.create_task(
-            self.__get_subject_setter_participant()
-        ).add_done_callback(
-            lambda task: task.result().set_room_subject(
-                s, None, self.subject_date, False
-            )
+        self.__get_subject_setter_participant().set_room_subject(
+            s, None, self.subject_date, False
         )
+
         self._subject = s
+        if self._updating_info:
+            return
+        assert self.pk is not None
+        self.__store.update_subject(self.pk, s)
 
     @property
     def is_anonymous(self):
         return self.type == MucType.CHANNEL
 
-    async def __get_subject_setter_participant(self):
-        from slidge.contact import LegacyContact
+    @property
+    def subject_setter(self) -> Optional[str]:
+        return self._subject_setter
 
-        from .participant import LegacyParticipant
+    @subject_setter.setter
+    def subject_setter(self, subject_setter: SubjectSetterType) -> None:
+        if isinstance(subject_setter, LegacyContact):
+            subject_setter = subject_setter.name
+        elif isinstance(subject_setter, LegacyParticipant):
+            subject_setter = subject_setter.nickname
 
-        who = self.subject_setter
+        if subject_setter == self._subject_setter:
+            return
+        assert isinstance(subject_setter, str)
+        self._subject_setter = subject_setter
+        if self._updating_info:
+            return
+        assert self.pk is not None
+        self.__store.update_subject_setter(self.pk, subject_setter)
 
-        if isinstance(who, LegacyParticipant):
-            return who
-        elif isinstance(who, str):
-            return await self.get_participant(who, store=False)
-        elif isinstance(self.subject_setter, LegacyContact):
-            return await self.get_participant_by_contact(who)
-        else:
+    def __get_subject_setter_participant(self) -> LegacyParticipant:
+        if self._subject_setter is None:
             return self.get_system_participant()
+        return self.Participant(self, self._subject_setter)
 
     def features(self):
         features = [
@@ -341,6 +446,7 @@ class LegacyMUC(
             "vcard-temp",
             "urn:xmpp:ping",
             "urn:xmpp:occupant-id:0",
+            "jabber:iq:register",
             self.xmpp.plugin["xep_0425"].stanza.NS,
         ]
         if self.type == MucType.GROUP:
@@ -364,10 +470,11 @@ class LegacyMUC(
         form.add_field("muc#maxhistoryfetch", value=str(self.max_history_fetch))
         form.add_field("muc#roominfo_subjectmod", "boolean", value=False)
 
-        if self._ALL_INFO_FILLED_ON_STARTUP or self.__participants_filled:
-            n: Optional[int] = len(await self.get_participants())
+        if self._ALL_INFO_FILLED_ON_STARTUP or self._participants_filled:
+            assert self.pk is not None
+            n: Optional[int] = self.__participants_store.get_count(self.pk)
         else:
-            n = self.n_participants
+            n = self._n_participants
         if n is not None:
             form.add_field("muc#roominfo_occupants", value=str(n))
 
@@ -415,8 +522,8 @@ class LegacyMUC(
             presence.send()
 
     def user_full_jids(self):
-        for r in self.user_resources:
-            j = copy(self.user.jid)
+        for r in self._user_resources:
+            j = copy(self.user_jid)
             j.resource = r
             yield j
 
@@ -427,9 +534,9 @@ class LegacyMUC(
         return user_muc_jid
 
     def _legacy_to_xmpp(self, legacy_id: LegacyMessageType):
-        return self.session.sent.get(legacy_id) or self.session.legacy_to_xmpp_msg_id(
-            legacy_id
-        )
+        return self.xmpp.store.sent.get_group_xmpp_id(
+            self.session.user_pk, str(legacy_id)
+        ) or self.session.legacy_to_xmpp_msg_id(legacy_id)
 
     async def echo(
         self, msg: Message, legacy_msg_id: Optional[LegacyMessageType] = None
@@ -458,7 +565,20 @@ class LegacyMUC(
 
             msg.send()
 
+    def _get_cached_avatar_id(self):
+        if self.pk is None:
+            return None
+        return self.xmpp.store.rooms.get_avatar_legacy_id(self.pk)
+
     def _post_avatar_update(self) -> None:
+        if self.pk is None:
+            return
+        assert self.pk is not None
+        self.xmpp.store.rooms.set_avatar(
+            self.pk,
+            self._avatar_pk,
+            None if self.avatar_id is None else str(self.avatar_id),
+        )
         self.__send_configuration_change((104,))
         self._send_room_presence()
 
@@ -475,15 +595,17 @@ class LegacyMUC(
                 p["vcard_temp_update"]["photo"] = ""
             p.send()
 
+    @timeit
+    @with_session
     async def join(self, join_presence: Presence):
         user_full_jid = join_presence.get_from()
         requested_nickname = join_presence.get_to().resource
         client_resource = user_full_jid.resource
 
-        if client_resource in self.user_resources:
+        if client_resource in self._user_resources:
             self.log.debug("Received join from a resource that is already joined.")
 
-        self.user_resources.add(client_resource)
+        self.add_user_resource(client_resource)
 
         if not requested_nickname or not client_resource:
             raise XMPPError("jid-malformed", by=self.jid)
@@ -491,22 +613,21 @@ class LegacyMUC(
         self.log.debug(
             "Resource %s of %s wants to join room %s with nickname %s",
             client_resource,
-            self.user,
+            self.user_jid,
             self.legacy_id,
             requested_nickname,
         )
 
-        await self.__fill_participants()
-
-        for participant in self._participants_by_nicknames.values():
-            if participant.is_user:  # type:ignore
-                continue
-            if participant.is_system:  # type:ignore
+        user_nick = self.user_nick
+        user_participant = None
+        async for participant in self.get_participants():
+            if participant.is_user:
+                user_participant = participant
                 continue
             participant.send_initial_presence(full_jid=user_full_jid)
 
-        user_nick = self.user_nick
-        user_participant = await self.get_user_participant()
+        if user_participant is None:
+            user_participant = await self.get_user_participant()
         if not user_participant.is_user:  # type:ignore
             self.log.warning("is_user flag not set participant on user_participant")
             user_participant.is_user = True  # type:ignore
@@ -537,7 +658,7 @@ class LegacyMUC(
                 maxstanzas=maxstanzas,
                 since=since,
             )
-        (await self.__get_subject_setter_participant()).set_room_subject(
+        self.__get_subject_setter_participant().set_room_subject(
             self._subject if self.HAS_SUBJECT else (self.description or self.name),
             user_full_jid,
             self.subject_date,
@@ -558,13 +679,13 @@ class LegacyMUC(
         self.__store_participant(p)
         return p
 
-    def __store_participant(self, p: "LegacyParticipantType"):
+    def __store_participant(self, p: "LegacyParticipantType") -> None:
         # we don't want to update the participant list when we're filling history
         if not self.KEEP_BACKFILLED_PARTICIPANTS and self.get_lock("fill history"):
             return
-        self._participants_by_nicknames[p.nickname] = p  # type:ignore
-        if p.contact:
-            self._participants_by_contacts[p.contact] = p
+        assert self.pk is not None
+        p.pk = self.__participants_store.add(self.pk, p.nickname)
+        self.__participants_store.update(p)
 
     async def get_participant(
         self,
@@ -591,25 +712,30 @@ class LegacyMUC(
             construction (optional)
         :return:
         """
-        if fill_first:
-            await self.__fill_participants()
-        p = self._participants_by_nicknames.get(
-            nickname
-        ) or self._participants_by_escaped_nicknames.get(nickname)
-        if p is None:
-            if raise_if_not_found:
-                raise XMPPError("item-not-found")
-            p = self.Participant(self, nickname, **kwargs)
-            if store:
-                self.__store_participant(p)
-            if (
-                not self.get_lock("fill participants")
-                and not self.get_lock("fill history")
-                and self.__participants_filled
-                and not p.is_user
-                and not p.is_system
-            ):
-                p.send_affiliation_change()
+        if fill_first and not self._participants_filled:
+            async for _ in self.get_participants():
+                pass
+        if self.pk is not None:
+            with self.xmpp.store.session():
+                stored = self.__participants_store.get_by_nickname(
+                    self.pk, nickname
+                ) or self.__participants_store.get_by_resource(self.pk, nickname)
+                if stored is not None:
+                    return self.Participant.from_store(self.session, stored)
+
+        if raise_if_not_found:
+            raise XMPPError("item-not-found")
+        p = self.Participant(self, nickname, **kwargs)
+        if store and not self._updating_info:
+            self.__store_participant(p)
+        if (
+            not self.get_lock("fill participants")
+            and not self.get_lock("fill history")
+            and self._participants_filled
+            and not p.is_user
+            and not p.is_system
+        ):
+            p.send_affiliation_change()
         return p
 
     def get_system_participant(self) -> "LegacyParticipantType":
@@ -638,25 +764,45 @@ class LegacyMUC(
         :return:
         """
         await self.session.contacts.ready
-        p = self._participants_by_contacts.get(c)
-        if p is None:
-            nickname = c.name or _unescape_node(c.jid_username)
-            if nickname in self._participants_by_nicknames:
-                self.log.debug("Nickname conflict")
-                nickname = f"{nickname} ({c.jid_username})"
-            p = self.Participant(self, nickname, **kwargs)
-            p.contact = c
-            c.participants.add(p)
-            # FIXME: this is not great but given the current design,
-            #        during participants fill and history backfill we do not
-            #        want to send presence, because we might update affiliation
-            #        and role afterwards.
-            # We need a refactor of the MUC class… later™
-            if not self.get_lock("fill participants") and not self.get_lock(
-                "fill history"
-            ):
-                p.send_last_presence(force=True, no_cache_online=True)
-            self.__store_participant(p)
+
+        if self.pk is not None:
+            c._LegacyContact__ensure_pk()  # type: ignore
+            assert c.contact_pk is not None
+            with self.__store.session():
+                stored = self.__participants_store.get_by_contact(self.pk, c.contact_pk)
+                if stored is not None:
+                    return self.Participant.from_store(
+                        self.session, stored, muc=self, contact=c
+                    )
+
+        nickname = c.name or _unescape_node(c.jid_username)
+
+        if self.pk is None:
+            nick_available = True
+        else:
+            nick_available = self.__store.nickname_is_available(self.pk, nickname)
+
+        if not nick_available:
+            self.log.debug("Nickname conflict")
+            nickname = f"{nickname} ({c.jid_username})"
+        p = self.Participant(self, nickname, **kwargs)
+        p.contact = c
+
+        if self._updating_info:
+            return p
+
+        self.__store_participant(p)
+        # FIXME: this is not great but given the current design,
+        #        during participants fill and history backfill we do not
+        #        want to send presence, because we might :update affiliation
+        #        and role afterwards.
+        # We need a refactor of the MUC class… later™
+        if (
+            self._participants_filled
+            and not self.get_lock("fill participants")
+            and not self.get_lock("fill history")
+        ):
+            p.send_last_presence(force=True, no_cache_online=True)
         return p
 
     async def get_participant_by_legacy_id(
@@ -668,39 +814,24 @@ class LegacyMUC(
             return await self.get_user_participant(**kwargs)
         return await self.get_participant_by_contact(c, **kwargs)
 
-    async def get_participants(self):
-        """
-        Get all known participants of the group, ensure :meth:`.LegacyMUC.fill_participants`
-        has been awaited once before. Plugins should not use that, internal
-        slidge use only.
-        :return:
-        """
-        await self.__fill_participants()
-        return list(self._participants_by_nicknames.values())
-
-    def remove_participant(self, p: "LegacyParticipantType", kick=False, ban=False):
+    def remove_participant(
+        self,
+        p: "LegacyParticipantType",
+        kick=False,
+        ban=False,
+        reason: str | None = None,
+    ):
         """
         Call this when a participant leaves the room
 
         :param p: The participant
         :param kick: Whether the participant left because they were kicked
         :param ban: Whether the participant left because they were banned
+        :param reason: Optionally, a reason why the participant was removed.
         """
         if kick and ban:
             raise TypeError("Either kick or ban")
-        if p.contact is not None:
-            try:
-                del self._participants_by_contacts[p.contact]
-            except KeyError:
-                self.log.warning(
-                    "Removed a participant we didn't know was here?, %s", p
-                )
-            else:
-                p.contact.participants.remove(p)
-        try:
-            del self._participants_by_nicknames[p.nickname]  # type:ignore
-        except KeyError:
-            self.log.warning("Removed a participant we didn't know was here?, %s", p)
+        self.__participants_store.delete(p.pk)
         if kick:
             codes = {307}
         elif ban:
@@ -710,17 +841,20 @@ class LegacyMUC(
         presence = p._make_presence(ptype="unavailable", status_codes=codes)
         p._affiliation = "outcast" if ban else "none"
         p._role = "none"
+        if reason:
+            presence["muc"].set_item_attr("reason", reason)
         p._send(presence)
 
     def rename_participant(self, old_nickname: str, new_nickname: str):
-        try:
-            p = self._participants_by_nicknames.pop(old_nickname)
-        except KeyError:
-            # when called by participant.nickname.setter
-            return
-        self._participants_by_nicknames[new_nickname] = p
-        if p.nickname == old_nickname:
-            p.nickname = new_nickname
+        assert self.pk is not None
+        with self.xmpp.store.session():
+            stored = self.__participants_store.get_by_nickname(self.pk, old_nickname)
+            if stored is None:
+                self.log.debug("Tried to rename a participant that we didn't know")
+                return
+            p = self.Participant.from_store(self.session, stored)
+            if p.nickname == old_nickname:
+                p.nickname = new_nickname
 
     async def __old_school_history(
         self,
@@ -849,7 +983,7 @@ class LegacyMUC(
 
         :param r: The resource to kick
         """
-        pto = self.user.jid
+        pto = self.user_jid
         pto.resource = r
         p = self.xmpp.make_presence(
             pfrom=(await self.get_user_participant()).jid, pto=pto
@@ -882,7 +1016,7 @@ class LegacyMUC(
         item = Item()
         item["id"] = self.jid
 
-        iq = Iq(stype="get", sfrom=self.user.jid, sto=self.user.jid)
+        iq = Iq(stype="get", sfrom=self.user_jid, sto=self.user_jid)
         iq["pubsub"]["items"]["node"] = self.xmpp["xep_0402"].stanza.NS
         iq["pubsub"]["items"].append(item)
 
@@ -912,7 +1046,7 @@ class LegacyMUC(
             item["conference"]["autojoin"] = auto_join
 
         item["conference"]["nick"] = self.user_nick
-        iq = Iq(stype="set", sfrom=self.user.jid, sto=self.user.jid)
+        iq = Iq(stype="set", sfrom=self.user_jid, sto=self.user_jid)
         iq["pubsub"]["publish"]["node"] = self.xmpp["xep_0402"].stanza.NS
         iq["pubsub"]["publish"].append(item)
 
@@ -974,10 +1108,9 @@ class LegacyMUC(
     ):
         """
         Triggered when the user requests changing the affiliation of a contact
-        for this group,
+        for this group.
 
-        Examples: promotion them to moderator, kick (affiliation=none),
-        ban (affiliation=outcast).
+        Examples: promotion them to moderator, ban (affiliation=outcast).
 
         :param contact: The contact whose affiliation change is requested
         :param affiliation: The new affiliation
@@ -986,6 +1119,16 @@ class LegacyMUC(
         """
         raise NotImplementedError
 
+    async def on_kick(self, contact: "LegacyContact", reason: Optional[str]):
+        """
+        Triggered when the user requests changing the role of a contact
+        to "none" for this group. Action commonly known as "kick".
+
+        :param contact: Contact to be kicked
+        :param reason: A reason for this kick
+        """
+        raise NotImplementedError
+
     async def on_set_config(
         self,
         name: Optional[str],
@@ -1015,30 +1158,39 @@ class LegacyMUC(
         raise NotImplementedError
 
     async def parse_mentions(self, text: str) -> list[Mention]:
-        await self.__fill_participants()
-
-        if len(self._participants_by_nicknames) == 0:
-            return []
-
-        result = []
-        for match in re.finditer(
-            "|".join(
-                sorted(
-                    [re.escape(nick) for nick in self._participants_by_nicknames],
-                    key=lambda nick: len(nick),
-                    reverse=True,
-                )
-            ),
-            text,
-        ):
-            span = match.span()
-            nick = match.group()
-            if span[0] != 0 and text[span[0] - 1] not in _WHITESPACE_OR_PUNCTUATION:
-                continue
-            if span[1] == len(text) or text[span[1]] in _WHITESPACE_OR_PUNCTUATION:
-                participant = self._participants_by_nicknames[nick]
-                if contact := participant.contact:
-                    result.append(Mention(contact=contact, start=span[0], end=span[1]))
+        with self.__store.session():
+            await self.__fill_participants()
+            assert self.pk is not None
+            participants = {
+                p.nickname: p for p in self.__participants_store.get_all(self.pk)
+            }
+
+            if len(participants) == 0:
+                return []
+
+            result = []
+            for match in re.finditer(
+                "|".join(
+                    sorted(
+                        [re.escape(nick) for nick in participants.keys()],
+                        key=lambda nick: len(nick),
+                        reverse=True,
+                    )
+                ),
+                text,
+            ):
+                span = match.span()
+                nick = match.group()
+                if span[0] != 0 and text[span[0] - 1] not in _WHITESPACE_OR_PUNCTUATION:
+                    continue
+                if span[1] == len(text) or text[span[1]] in _WHITESPACE_OR_PUNCTUATION:
+                    participant = self.Participant.from_store(
+                        self.session, participants[nick]
+                    )
+                    if contact := participant.contact:
+                        result.append(
+                            Mention(contact=contact, start=span[0], end=span[1])
+                        )
         return result
 
     async def on_set_subject(self, subject: str) -> None:
@@ -1052,6 +1204,43 @@ class LegacyMUC(
         """
         raise NotImplementedError
 
+    @classmethod
+    def from_store(cls, session, stored: Room, *args, **kwargs) -> Self:
+        muc = cls(
+            session,
+            cls.xmpp.LEGACY_ROOM_ID_TYPE(stored.legacy_id),
+            stored.jid,
+            *args,  # type: ignore
+            **kwargs,  # type: ignore
+        )
+        muc.pk = stored.id
+        muc.type = stored.muc_type  # type: ignore
+        muc._user_nick = stored.user_nick
+        if stored.name:
+            muc.DISCO_NAME = stored.name
+        if stored.description:
+            muc._description = stored.description
+        if (data := stored.extra_attributes) is not None:
+            muc.deserialize_extra_attributes(data)
+        muc._subject = stored.subject or ""
+        if stored.subject_date is not None:
+            muc._subject_date = stored.subject_date.replace(tzinfo=timezone.utc)
+        muc._participants_filled = stored.participants_filled
+        muc._n_participants = stored.n_participants
+        muc._history_filled = stored.history_filled
+        if stored.user_resources is not None:
+            muc._user_resources = set(json.loads(stored.user_resources))
+        muc._subject_setter = stored.subject_setter
+        muc.archive = MessageArchive(muc.pk, session.xmpp.store.mam)
+        muc._set_logger_name()
+        muc._AvatarMixin__avatar_unique_id = (  # type:ignore
+            None
+            if stored.avatar_legacy_id is None
+            else session.xmpp.AVATAR_ID_TYPE(stored.avatar_legacy_id)
+        )
+        muc._avatar_pk = stored.avatar_id
+        return muc
+
 
 def set_origin_id(msg: Message, origin_id: str):
     sub = ET.Element("{urn:xmpp:sid:0}origin-id")