slidge 0.2.11__py3-none-any.whl → 0.3.0__py3-none-any.whl

slidge/group/participant.py

@@ -5,19 +5,17 @@ import warnings
 from copy import copy
 from datetime import datetime
 from functools import cached_property
-from typing import TYPE_CHECKING, Optional, Self, Union
+from typing import TYPE_CHECKING, Any, Optional, Union
+from xml.etree import ElementTree as ET
 
 from slixmpp import JID, InvalidJID, Message, Presence
 from slixmpp.plugins.xep_0045.stanza import MUCAdminItem
 from slixmpp.types import MessageTypes, OptJid
+from sqlalchemy.orm.exc import DetachedInstanceError
 
 from ..contact import LegacyContact
-from ..core.mixins import (
-    ChatterDiscoMixin,
-    MessageMixin,
-    PresenceMixin,
-    StoredAttributeMixin,
-)
+from ..core.mixins import ChatterDiscoMixin, MessageMixin, PresenceMixin
+from ..core.mixins.db import DBMixin
 from ..db.models import Participant
 from ..util import SubclassableOnce, strip_illegal_chars
 from ..util.types import (
@@ -43,97 +41,134 @@ def strip_non_printable(nickname: str):
 
 
 class LegacyParticipant(
-    StoredAttributeMixin,
     PresenceMixin,
     MessageMixin,
     ChatterDiscoMixin,
+    DBMixin,
     metaclass=SubclassableOnce,
 ):
     """
     A legacy participant of a legacy group chat.
     """
 
+    is_participant = True
+
     mtype: MessageTypes = "groupchat"
     _can_send_carbon = False
     USE_STANZA_ID = True
     STRIP_SHORT_DELAY = False
-    pk: int
+    stored: Participant
+    contact: LegacyContact[Any] | None
 
     def __init__(
         self,
         muc: "LegacyMUC",
-        nickname: Optional[str] = None,
-        is_user=False,
-        is_system=False,
-        role: MucRole = "participant",
-        affiliation: MucAffiliation = "member",
-        resource: str | None = None,
-        nickname_no_illegal: str | None = None,
-    ):
-        self.session = session = muc.session
-        self.xmpp = session.xmpp
-        super().__init__()
-        self._hats = list[Hat]()
+        stored: Participant,
+        is_system: bool = False,
+        contact: LegacyContact[Any] | None = None,
+    ) -> None:
         self.muc = muc
-        self._role = role
-        self._affiliation = affiliation
-        self.is_user: bool = is_user
-        self.is_system: bool = is_system
+        self.session = muc.session
+        self.xmpp = muc.session.xmpp
+        self.is_system = is_system
 
-        self._nickname = nickname
+        if contact is None and stored.contact is not None:
+            contact = self.session.contacts.from_store(stored=stored.contact)
+        if contact is not None and stored.contact is None:
+            stored.contact = contact.stored
 
-        if resource is None:
-            self.__update_jid(nickname)
-        else:
-            assert nickname_no_illegal is not None
-            self._nickname_no_illegal = nickname_no_illegal
-            self.jid = JID(self.muc.jid)
-            self.jid.resource = resource
+        self.stored = stored
+        self.contact = contact
 
-        log.debug("Instantiation of: %r", self)
+        super().__init__()
+
+        if stored.resource is None:
+            self.__update_resource(stored.nickname)
 
-        self.contact: Optional["LegacyContact"] = None
-        # we track if we already sent a presence for this participant.
-        # if we didn't, we send it before the first message.
-        # this way, event in plugins that don't map "user has joined" events,
-        # we send a "join"-presence from the participant before the first message
-        self._presence_sent: bool = False
         self.log = logging.getLogger(f"{self.user_jid.bare}:{self.jid}")
-        self.__part_store = self.xmpp.store.participants
 
     @property
-    def contact_pk(self) -> Optional[int]:  # type:ignore
-        if self.contact:
-            return self.contact.contact_pk
-        return None
+    def is_user(self) -> bool:
+        try:
+            return self.stored.is_user
+        except DetachedInstanceError:
+            self.merge()
+            return self.stored.is_user
+
+    @is_user.setter
+    def is_user(self, is_user: bool) -> None:
+        with self.xmpp.store.session(expire_on_commit=True) as orm:
+            orm.add(self.stored)
+            self.stored.is_user = is_user
+            orm.commit()
+
+    @property
+    def jid(self) -> JID:
+        jid = JID(self.muc.jid)
+        if self.stored.resource:
+            jid.resource = self.stored.resource
+        return jid
+
+    @jid.setter
+    def jid(self, x: JID):
+        # FIXME: without this, mypy yields
+        #        "Cannot override writeable attribute with read-only property"
+        #        But it does not happen for LegacyContact. WTF?
+        raise RuntimeError
+
+    def commit(self, *args, **kwargs) -> None:
+        if self.is_system:
+            return
+        if self.muc.get_lock("fill participants") or self.muc.get_lock("fill history"):
+            return
+        super().commit(*args, **kwargs)
 
     @property
     def user_jid(self):
         return self.session.user_jid
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return f"<Participant '{self.nickname}'/'{self.jid}' of '{self.muc}'>"
 
+    @property
+    def _presence_sent(self) -> bool:
+        # we track if we already sent a presence for this participant.
+        # if we didn't, we send it before the first message.
+        # this way, event in plugins that don't map "user has joined" events,
+        # we send a "join"-presence from the participant before the first message
+        return self.stored.presence_sent
+
+    @_presence_sent.setter
+    def _presence_sent(self, val: bool) -> None:
+        if self._presence_sent == val:
+            return
+        self.stored.presence_sent = val
+        self.commit(merge=True)
+
+    @property
+    def nickname_no_illegal(self) -> str:
+        return self.stored.nickname_no_illegal
+
     @property
     def affiliation(self):
-        return self._affiliation
+        return self.stored.affiliation
 
     @affiliation.setter
-    def affiliation(self, affiliation: MucAffiliation):
-        if self._affiliation == affiliation:
+    def affiliation(self, affiliation: MucAffiliation) -> None:
+        if self.affiliation == affiliation:
             return
-        self._affiliation = affiliation
-        if not self.muc._participants_filled:
+        self.stored.affiliation = affiliation
+        if not self.muc.participants_filled:
             return
-        self.__part_store.set_affiliation(self.pk, affiliation)
+        self.commit()
         if not self._presence_sent:
             return
         self.send_last_presence(force=True, no_cache_online=True)
 
-    def send_affiliation_change(self):
+    def send_affiliation_change(self) -> None:
         # internal use by slidge
         msg = self._make_message()
-        msg["muc"]["affiliation"] = self._affiliation
+        msg["muc"]["affiliation"] = self.affiliation
         msg["type"] = "normal"
         if not self.muc.is_anonymous and not self.is_system:
             if self.contact:
@@ -146,48 +181,53 @@ class LegacyParticipant(
 
     @property
     def role(self):
-        return self._role
+        return self.stored.role
 
     @role.setter
-    def role(self, role: MucRole):
-        if self._role == role:
+    def role(self, role: MucRole) -> None:
+        if self.role == role:
             return
-        self._role = role
-        if not self.muc._participants_filled:
+        self.stored.role = role
+        if not self.muc.participants_filled:
             return
-        self.__part_store.set_role(self.pk, role)
+        self.commit()
         if not self._presence_sent:
             return
         self.send_last_presence(force=True, no_cache_online=True)
 
-    def set_hats(self, hats: list[Hat]):
-        if self._hats == hats:
+    @property
+    def hats(self) -> list[Hat]:
+        return [Hat(*h) for h in self.stored.hats] if self.stored.hats else []
+
+    def set_hats(self, hats: list[Hat]) -> None:
+        if self.hats == hats:
             return
-        self._hats = hats
-        if not self.muc._participants_filled:
+        self.stored.hats = hats  # type:ignore[assignment]
+        if not self.muc.participants_filled:
             return
-        self.__part_store.set_hats(self.pk, hats)
+        self.commit(merge=True)
         if not self._presence_sent:
             return
         self.send_last_presence(force=True, no_cache_online=True)
 
-    def __update_jid(self, unescaped_nickname: Optional[str]):
+    def __update_resource(self, unescaped_nickname: Optional[str]) -> None:
         if not unescaped_nickname:
-            self.jid = JID(self.muc.jid)
+            self.stored.resource = ""
             if self.is_system:
-                self._nickname_no_illegal = ""
+                self.stored.nickname_no_illegal = ""
             else:
                 warnings.warn(
                     "Only the system participant is allowed to not have a nickname"
                 )
                 nickname = f"unnamed-{uuid.uuid4()}"
-                self.jid.resource = self._nickname_no_illegal = nickname
+                self.stored.resource = self.stored.nickname_no_illegal = nickname
             return
 
-        self._nickname_no_illegal, self.jid = escape_nickname(
+        self.stored.nickname_no_illegal, jid = escape_nickname(
             self.muc.jid,
             unescaped_nickname,
         )
+        self.stored.resource = jid.resource
 
     def send_configuration_change(self, codes: tuple[int]):
         if not self.is_system:
@@ -198,11 +238,11 @@ class LegacyParticipant(
 
     @property
     def nickname(self):
-        return self._nickname
+        return self.stored.nickname
 
     @nickname.setter
-    def nickname(self, new_nickname: str):
-        old = self._nickname
+    def nickname(self, new_nickname: str) -> None:
+        old = self.nickname
         if new_nickname == old:
             return
 
@@ -219,18 +259,16 @@ class LegacyParticipant(
         p = self._make_presence(ptype="unavailable", last_seen=last_seen, **kwargs)
         # in this order so pfrom=old resource and we actually use the escaped nick
         # in the muc/item/nick element
-        self.__update_jid(new_nickname)
+        self.__update_resource(new_nickname)
         p["muc"]["item"]["nick"] = self.jid.resource
         self._send(p)
 
-        self._nickname = new_nickname
-
+        self.stored.nickname = new_nickname
+        self.commit()
         kwargs["status_codes"] = set()
         p = self._make_presence(ptype="available", last_seen=last_seen, **kwargs)
         self._send(p)
 
-        self.__part_store.update(self)
-
     def _make_presence(
         self,
         *,
@@ -242,8 +280,8 @@ class LegacyParticipant(
         p = super()._make_presence(last_seen=last_seen, **presence_kwargs)
         p["muc"]["affiliation"] = self.affiliation
         p["muc"]["role"] = self.role
-        if self._hats:
-            p["hats"].add_hats(self._hats)
+        if self.hats:
+            p["hats"].add_hats(self.hats)
         codes = status_codes or set()
         if self.is_user:
             codes.add(110)
@@ -254,9 +292,7 @@ class LegacyParticipant(
                 else:
                     jid = JID(self.user_jid)
                     try:
-                        jid.resource = next(
-                            iter(self.muc.get_user_resources())  # type:ignore
-                        )
+                        jid.resource = next(iter(self.muc.get_user_resources()))
                     except StopIteration:
                         jid.resource = "pseudo-resource"
                     p["muc"]["jid"] = self.user_jid
@@ -275,12 +311,12 @@ class LegacyParticipant(
         return p
 
     @property
-    def DISCO_NAME(self):
+    def DISCO_NAME(self):  # type:ignore[override]
         return self.nickname
 
     def __send_presence_if_needed(
         self, stanza: Union[Message, Presence], full_jid: JID, archive_only: bool
-    ):
+    ) -> None:
         if (
             archive_only
             or self.is_system
@@ -309,8 +345,9 @@ class LegacyParticipant(
         self,
         stanza: MessageOrPresenceTypeVar,
         full_jid: Optional[JID] = None,
-        archive_only=False,
+        archive_only: bool = False,
         legacy_msg_id=None,
+        initial_presence=False,
         **send_kwargs,
     ) -> MessageOrPresenceTypeVar:
         if stanza.get_from().resource:
@@ -321,8 +358,10 @@ class LegacyParticipant(
         if not self.is_user and isinstance(stanza, Presence):
             if stanza["type"] == "unavailable" and not self._presence_sent:
                 return stanza  # type:ignore
-            self._presence_sent = True
-            self.__part_store.set_presence_sent(self.pk)
+            if initial_presence:
+                self.stored.presence_sent = True
+            else:
+                self._presence_sent = True
         if full_jid:
             stanza["to"] = full_jid
             self.__send_presence_if_needed(stanza, full_jid, archive_only)
@@ -362,8 +401,8 @@ class LegacyParticipant(
                 )
         return item
 
-    def __add_nick_element(self, stanza: Union[Presence, Message]):
-        if (nick := self._nickname_no_illegal) != self.jid.resource:
+    def __add_nick_element(self, stanza: Union[Presence, Message]) -> None:
+        if (nick := self.nickname_no_illegal) != self.jid.resource:
             n = self.xmpp.plugin["xep_0172"].stanza.UserNick()
             n["nick"] = nick
             stanza.append(n)
@@ -377,9 +416,9 @@ class LegacyParticipant(
     def send_initial_presence(
         self,
         full_jid: JID,
-        nick_change=False,
+        nick_change: bool = False,
         presence_id: Optional[str] = None,
-    ):
+    ) -> None:
         """
         Called when the user joins a MUC, as a mechanism
         to indicate to the joining XMPP client the list of "participants".
@@ -418,21 +457,21 @@ class LegacyParticipant(
         )
         if presence_id:
             p["id"] = presence_id
-        self._send(p, full_jid)
+        self._send(p, full_jid, initial_presence=True)
 
-    def leave(self):
+    def leave(self) -> None:
         """
         Call this when the participant leaves the room
         """
         self.muc.remove_participant(self)
 
-    def kick(self, reason: str | None = None):
+    def kick(self, reason: str | None = None) -> None:
         """
         Call this when the participant is kicked from the room
         """
         self.muc.remove_participant(self, kick=True, reason=reason)
 
-    def ban(self, reason: str | None = None):
+    def ban(self, reason: str | None = None) -> None:
         """
         Call this when the participant is banned from the room
         """
@@ -443,15 +482,16 @@ class LegacyParticipant(
             return self.contact.get_disco_info()
         return super().get_disco_info()
 
-    def moderate(self, legacy_msg_id: LegacyMessageType, reason: Optional[str] = None):
+    def moderate(
+        self, legacy_msg_id: LegacyMessageType, reason: Optional[str] = None
+    ) -> None:
         xmpp_id = self._legacy_to_xmpp(legacy_msg_id)
-        multi = self.xmpp.store.multi.get_xmpp_ids(self.session.user_pk, xmpp_id)
-        if multi is None:
-            msg_ids = [xmpp_id]
-        else:
-            msg_ids = multi + [xmpp_id]
+        with self.xmpp.store.session() as orm:
+            msg_ids = self.xmpp.store.id_map.get_xmpp(
+                orm, self.muc.stored.id, str(legacy_msg_id), True
+            )
 
-        for i in msg_ids:
+        for i in set(msg_ids + [xmpp_id]):
             m = self.muc.get_system_participant()._make_message()
             m["retract"]["id"] = i
             if self.is_system:
@@ -468,8 +508,8 @@ class LegacyParticipant(
         subject: str,
         full_jid: Optional[JID] = None,
         when: Optional[datetime] = None,
-        update_muc=True,
-    ):
+        update_muc: bool = True,
+    ) -> None:
         if update_muc:
             self.muc._subject = subject  # type: ignore
             self.muc.subject_setter = self.nickname
@@ -479,47 +519,13 @@ class LegacyParticipant(
         if when is not None:
             msg["delay"].set_stamp(when)
             msg["delay"]["from"] = self.muc.jid
-        msg["subject"] = subject or str(self.muc.name)
+        if subject:
+            msg["subject"] = subject
+        else:
+            # may be simplified if slixmpp lets it do it more easily some day
+            msg.xml.append(ET.Element(f"{{{msg.namespace}}}subject"))
         self._send(msg, full_jid)
 
-    @classmethod
-    def from_store(
-        cls,
-        session,
-        stored: Participant,
-        contact: Optional[LegacyContact] = None,
-        muc: Optional["LegacyMUC"] = None,
-    ) -> Self:
-        from slidge.group.room import LegacyMUC
-
-        if muc is None:
-            muc = LegacyMUC.get_self_or_unique_subclass().from_store(
-                session, stored.room
-            )
-        part = cls(
-            muc,
-            stored.nickname,
-            role=stored.role,
-            affiliation=stored.affiliation,
-            resource=stored.resource,
-            nickname_no_illegal=stored.nickname_no_illegal,
-        )
-        part.pk = stored.id
-        if contact is not None:
-            part.contact = contact
-        elif stored.contact is not None:
-            contact = LegacyContact.get_self_or_unique_subclass().from_store(
-                session, stored.contact
-            )
-            part.contact = contact
-
-        part.is_user = stored.is_user
-        if (data := stored.extra_attributes) is not None:
-            muc.deserialize_extra_attributes(data)
-        part._presence_sent = stored.presence_sent
-        part._hats = [Hat(h.uri, h.title) for h in stored.hats]
-        return part
-
 
 def escape_nickname(muc_jid: JID, nickname: str) -> tuple[str, JID]:
     nickname = nickname_no_illegal = strip_illegal_chars(nickname)