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

slidge/contact/contact.py

@@ -2,20 +2,19 @@ import datetime
 import logging
 import warnings
 from datetime import date
-from typing import TYPE_CHECKING, Generic, Iterable, Optional, Self, Union
+from typing import TYPE_CHECKING, Generic, Iterable, Iterator, Optional, Union
 from xml.etree import ElementTree as ET
 
 from slixmpp import JID, Message, Presence
 from slixmpp.exceptions import IqError, IqTimeout
 from slixmpp.plugins.xep_0292.stanza import VCard4
 from slixmpp.types import MessageTypes
+from sqlalchemy.exc import IntegrityError
 
-from ..core import config
-from ..core.mixins import AvatarMixin, FullCarbonMixin, StoredAttributeMixin
-from ..core.mixins.db import UpdateInfoMixin
+from ..core.mixins import AvatarMixin, FullCarbonMixin
 from ..core.mixins.disco import ContactAccountDiscoMixin
 from ..core.mixins.recipient import ReactionRecipientMixin, ThreadRecipientMixin
-from ..db.models import Contact
+from ..db.models import Contact, ContactSent, Participant
 from ..util import SubclassableOnce
 from ..util.types import ClientType, LegacyUserIdType, MessageOrPresenceTypeVar
 
@@ -26,13 +25,11 @@ if TYPE_CHECKING:
 
 class LegacyContact(
     Generic[LegacyUserIdType],
-    StoredAttributeMixin,
     AvatarMixin,
     ContactAccountDiscoMixin,
     FullCarbonMixin,
     ReactionRecipientMixin,
     ThreadRecipientMixin,
-    UpdateInfoMixin,
     metaclass=SubclassableOnce,
 ):
     """
@@ -85,104 +82,68 @@ class LegacyContact(
     STRIP_SHORT_DELAY = True
     _NON_FRIEND_PRESENCES_FILTER = {"subscribe", "unsubscribed"}
 
-    _avatar_bare_jid = True
-
     INVITATION_RECIPIENT = True
 
-    def __init__(
-        self,
-        session: "BaseSession",
-        legacy_id: LegacyUserIdType,
-        jid_username: str,
-    ):
-        """
-        :param session: The session this contact is part of
-        :param legacy_id: The contact's legacy ID
-        :param jid_username: User part of this contact's 'puppet' JID.
-            NB: case-insensitive, and some special characters are not allowed
-        """
-        super().__init__()
+    stored: Contact
+    model: Contact
+
+    def __init__(self, session: "BaseSession", stored: Contact) -> None:
         self.session = session
-        self.legacy_id: LegacyUserIdType = legacy_id
-        """
-        The legacy identifier of the :term:`Legacy Contact`.
-        By default, this is the :term:`JID Local Part` of this
-        :term:`XMPP Entity`.
-
-        Controlling what values are valid and how they are translated from a
-        :term:`JID Local Part` is done in :meth:`.jid_username_to_legacy_id`.
-        Reciprocally, in :meth:`legacy_id_to_jid_username` the inverse
-        transformation is defined.
-        """
-        self.jid_username = jid_username
+        self.xmpp = session.xmpp
+        self.stored = stored
+        self._set_logger()
+        super().__init__()
 
-        self._name: Optional[str] = None
+    @property
+    def jid(self):  # type:ignore[override]
+        jid = JID(self.stored.jid)
+        jid.resource = self.RESOURCE
+        return jid
 
-        self.xmpp = session.xmpp
-        self.jid = JID(self.jid_username + "@" + self.xmpp.boundjid.bare)
-        self.jid.resource = self.RESOURCE
-        self.log = logging.getLogger(self.jid.bare)
-        self._set_logger_name()
-        self._is_friend: bool = False
-        self._added_to_roster = False
-        self._caps_ver: str | None = None
-        self._vcard_fetched = False
-        self._vcard: str | None = None
-        self._client_type: ClientType = "pc"
-
-    async def get_vcard(self, fetch=True) -> VCard4 | None:
-        if fetch and not self._vcard_fetched:
+    @property
+    def legacy_id(self):
+        return self.xmpp.LEGACY_CONTACT_ID_TYPE(self.stored.legacy_id)
+
+    async def get_vcard(self, fetch: bool = True) -> VCard4 | None:
+        if fetch and not self.stored.vcard_fetched:
             await self.fetch_vcard()
-        if self._vcard is None:
+        if self.stored.vcard is None:
             return None
 
-        return VCard4(xml=ET.fromstring(self._vcard))
+        return VCard4(xml=ET.fromstring(self.stored.vcard))
 
     @property
-    def is_friend(self):
-        return self._is_friend
+    def is_friend(self) -> bool:
+        return self.stored.is_friend
 
     @is_friend.setter
-    def is_friend(self, value: bool):
-        if value == self._is_friend:
+    def is_friend(self, value: bool) -> None:
+        if value == self.is_friend:
             return
-        self._is_friend = value
-        if self._updating_info:
-            return
-        self.__ensure_pk()
-        assert self.contact_pk is not None
-        self.xmpp.store.contacts.set_friend(self.contact_pk, value)
+        self.stored.is_friend = value
+        self.commit()
 
     @property
-    def added_to_roster(self):
-        return self._added_to_roster
+    def added_to_roster(self) -> bool:
+        return self.stored.added_to_roster
 
     @added_to_roster.setter
-    def added_to_roster(self, value: bool):
-        if value == self._added_to_roster:
-            return
-        self._added_to_roster = value
-        if self._updating_info:
-            return
-        if self.contact_pk is None:
-            # during LegacyRoster.fill()
+    def added_to_roster(self, value: bool) -> None:
+        if value == self.added_to_roster:
             return
-        self.xmpp.store.contacts.set_added_to_roster(self.contact_pk, value)
+        self.stored.added_to_roster = value
+        self.commit()
 
     @property
-    def participants(self) -> list["LegacyParticipant"]:
-        if self.contact_pk is None:
-            return []
-
-        self.__ensure_pk()
-        from ..group.participant import LegacyParticipant
-
-        return [
-            LegacyParticipant.get_self_or_unique_subclass().from_store(
-                self.session, stored, contact=self
-            )
-            for stored in self.xmpp.store.participants.get_for_contact(self.contact_pk)
-        ]
+    def participants(self) -> Iterator["LegacyParticipant"]:
+        with self.xmpp.store.session() as orm:
+            self.stored = orm.merge(self.stored)
+            participants = self.stored.participants
+        for p in participants:
+            with self.xmpp.store.session() as orm:
+                orm.add(p)
+                muc = self.session.bookmarks.from_store(p.room)
+                yield muc.participant_from_store(p, contact=self)
 
     @property
     def user_jid(self):
@@ -190,7 +151,7 @@ class LegacyContact(
 
     @property  # type:ignore
     def DISCO_TYPE(self) -> ClientType:
-        return self._client_type
+        return self.client_type
 
     @DISCO_TYPE.setter
     def DISCO_TYPE(self, value: ClientType) -> None:
@@ -203,47 +164,27 @@ class LegacyContact(
 
         Default is "pc".
         """
-        return self._client_type
+        return self.stored.client_type
 
     @client_type.setter
     def client_type(self, value: ClientType) -> None:
-        self._client_type = value
-        if self._updating_info:
+        if self.stored.client_type == value:
             return
-        self.__ensure_pk()
-        assert self.contact_pk is not None
-        self.xmpp.store.contacts.set_client_type(self.contact_pk, value)
-
-    def _set_logger_name(self):
-        self.log.name = f"{self.user_jid.bare}:contact:{self}"
+        self.stored.client_type = value
+        self.commit()
 
-    def __repr__(self):
-        return f"<Contact #{self.contact_pk} '{self.name}' ({self.legacy_id} - {self.jid.user})'>"
+    def _set_logger(self) -> None:
+        self.log = logging.getLogger(f"{self.user_jid.bare}:contact:{self}")
 
-    def __ensure_pk(self):
-        if self.contact_pk is not None:
-            return
-        # This happens for legacy modules that don't follow the Roster.fill /
-        # populate contact attributes in Contact.update_info() method.
-        # This results in (even) less optimised SQL writes and read, but
-        # we allow it because it fits some legacy network libs better.
-        with self.xmpp.store.session() as orm:
-            orm.commit()
-            stored = self.xmpp.store.contacts.get_by_legacy_id(
-                self.user_pk, str(self.legacy_id)
-            )
-            if stored is None:
-                self.contact_pk = self.xmpp.store.contacts.update(self, commit=True)
-            else:
-                self.contact_pk = stored.id
-        assert self.contact_pk is not None
+    def __repr__(self) -> str:
+        return f"<Contact #{self.stored.id} '{self.name}' ({self.legacy_id} - {self.jid.user})'>"
 
-    def __get_subscription_string(self):
+    def __get_subscription_string(self) -> str:
         if self.is_friend:
             return "both"
         return "none"
 
-    def __propagate_to_participants(self, stanza: Presence):
+    def __propagate_to_participants(self, stanza: Presence) -> None:
         if not self.PROPAGATE_PRESENCE_TO_GROUPS:
             return
 
@@ -274,7 +215,11 @@ class LegacyContact(
             func(**kw)
 
     def _send(
-        self, stanza: MessageOrPresenceTypeVar, carbon=False, nick=False, **send_kwargs
+        self,
+        stanza: MessageOrPresenceTypeVar,
+        carbon: bool = False,
+        nick: bool = False,
+        **send_kwargs,
     ) -> MessageOrPresenceTypeVar:
         if carbon and isinstance(stanza, Message):
             stanza["to"] = self.jid.bare
@@ -299,9 +244,15 @@ class LegacyContact(
             and self.xmpp.MARK_ALL_MESSAGES
             and is_markable(stanza)
         ):
-            self.__ensure_pk()
-            assert self.contact_pk is not None
-            self.xmpp.store.contacts.add_to_sent(self.contact_pk, stanza["id"])
+            try:
+                with self.xmpp.store.session(expire_on_commit=False) as orm:
+                    self.stored = orm.merge(self.stored)
+                    new = ContactSent(contact=self.stored, msg_id=stanza["id"])
+                    orm.add(new)
+                    self.stored.sent_order.append(new)
+                    orm.commit()
+            except IntegrityError:
+                self.log.warning("Contact  has already sent message %s", stanza["id"])
         stanza["to"] = self.user_jid
         stanza.send()
         return stanza
@@ -320,50 +271,42 @@ class LegacyContact(
         :param horizon_xmpp_id: The latest message
         :return: A list of XMPP ids or None if horizon_xmpp_id was not found
         """
-        self.__ensure_pk()
-        assert self.contact_pk is not None
-        return self.xmpp.store.contacts.pop_sent_up_to(self.contact_pk, horizon_xmpp_id)
+        with self.xmpp.store.session() as orm:
+            assert self.stored.id is not None
+            ids = self.xmpp.store.contacts.pop_sent_up_to(
+                orm, self.stored.id, horizon_xmpp_id
+            )
+            orm.commit()
+            return ids
 
     @property
-    def name(self):
+    def name(self) -> str:
         """
         Friendly name of the contact, as it should appear in the user's roster
         """
-        return self._name
+        return self.stored.nick or ""
 
     @name.setter
-    def name(self, n: Optional[str]):
-        if self._name == n:
+    def name(self, n: Optional[str]) -> None:
+        if self.stored.nick == n:
             return
-        self._name = n
-        self._set_logger_name()
+        self.stored.nick = n
+        self._set_logger()
         if self.is_friend and self.added_to_roster:
             self.xmpp.pubsub.broadcast_nick(
                 user_jid=self.user_jid, jid=self.jid.bare, nick=n
             )
-        if self._updating_info:
-            # means we're in update_info(), so no participants, and no need
-            # to write to DB now, it will be called in Roster.__finish_init_contact
-            return
+        self.commit()
         for p in self.participants:
-            p.nickname = n
-        self.__ensure_pk()
-        assert self.contact_pk is not None
-        self.xmpp.store.contacts.update_nick(self.contact_pk, n)
+            p.nickname = n or str(self.legacy_id)
 
-    def _get_cached_avatar_id(self) -> Optional[str]:
-        if self.contact_pk is None:
-            return None
-        return self.xmpp.store.contacts.get_avatar_legacy_id(self.contact_pk)
-
-    def _post_avatar_update(self):
-        self.__ensure_pk()
-        assert self.contact_pk is not None
-        self.xmpp.store.contacts.set_avatar(
-            self.contact_pk,
-            self._avatar_pk,
-            None if self.avatar_id is None else str(self.avatar_id),
-        )
+    def _post_avatar_update(self, cached_avatar) -> None:
+        if self.is_friend and self.added_to_roster:
+            self.session.create_task(
+                self.session.xmpp.pubsub.broadcast_avatar(
+                    self.jid.bare, self.session.user_jid, cached_avatar
+                )
+            )
         for p in self.participants:
             self.log.debug("Propagating new avatar to %s", p.muc)
             p.send_last_presence(force=True, no_cache_online=True)
@@ -382,7 +325,8 @@ class LegacyContact(
         email: Optional[str] = None,
         country: Optional[str] = None,
         locality: Optional[str] = None,
-    ):
+        pronouns: Optional[str] = None,
+    ) -> None:
         vcard = VCard4()
         vcard.add_impp(f"xmpp:{self.jid.bare}")
 
@@ -414,18 +358,16 @@ class LegacyContact(
             vcard.add_address(country, locality)
         elif country:
             vcard.add_address(country, locality)
+        if pronouns:
+            vcard["pronouns"]["text"] = pronouns
 
-        self._vcard = str(vcard)
-        self._vcard_fetched = True
+        self.stored.vcard = str(vcard)
+        self.stored.vcard_fetched = True
         self.session.create_task(
             self.xmpp.pubsub.broadcast_vcard_event(self.jid, self.user_jid, vcard)
         )
 
-        if self._updating_info:
-            return
-
-        assert self.contact_pk is not None
-        self.xmpp.store.contacts.set_vcard(self.contact_pk, self._vcard)
+        self.commit()
 
     def get_roster_item(self):
         item = {
@@ -436,7 +378,7 @@ class LegacyContact(
             item["name"] = n
         return {self.jid.bare: item}
 
-    async def add_to_roster(self, force=False):
+    async def add_to_roster(self, force: bool = False) -> None:
         """
         Add this contact to the user roster using :xep:`0356`
 
@@ -444,7 +386,7 @@ class LegacyContact(
         """
         if self.added_to_roster and not force:
             return
-        if config.NO_ROSTER_PUSH:
+        if not self.session.user.preferences.get("roster_push", True):
             log.debug("Roster push request by plugin ignored (--no-roster-push)")
             return
         try:
@@ -452,16 +394,16 @@ class LegacyContact(
                 jid=self.user_jid, roster_items=self.get_roster_item()
             )
         except PermissionError:
+            from slidge import __version__
+
             warnings.warn(
-                "Slidge does not have privileges to add contacts to the roster. Refer"
-                " to https://slidge.im/docs/slidge/main/admin/privilege.html for"
-                " more info."
+                "Slidge does not have the privilege to manage rosters. See "
+                f"https://slidge.im/docs/slidge/{__version__}/admin/privilege.html"
+            )
+            self.send_friend_request(
+                f"I'm already your friend on {self.xmpp.COMPONENT_TYPE}, but "
+                "slidge is not allowed to manage your roster."
             )
-            if config.ROSTER_PUSH_PRESENCE_SUBSCRIPTION_REQUEST_FALLBACK:
-                self.send_friend_request(
-                    f"I'm already your friend on {self.xmpp.COMPONENT_TYPE}, but "
-                    "slidge is not allowed to manage your roster."
-                )
             return
         except (IqError, IqTimeout) as e:
             self.log.warning("Could not add to roster", exc_info=e)
@@ -471,7 +413,7 @@ class LegacyContact(
             self.added_to_roster = True
             self.send_last_presence()
 
-    async def __broadcast_pubsub_items(self):
+    async def __broadcast_pubsub_items(self) -> None:
         if not self.is_friend:
             return
         if not self.added_to_roster:
@@ -490,11 +432,11 @@ class LegacyContact(
                 nick,
             )
 
-    def send_friend_request(self, text: Optional[str] = None):
+    def send_friend_request(self, text: Optional[str] = None) -> None:
         presence = self._make_presence(ptype="subscribe", pstatus=text, bare=True)
         self._send(presence, nick=True)
 
-    async def accept_friend_request(self, text: Optional[str] = None):
+    async def accept_friend_request(self, text: Optional[str] = None) -> None:
         """
         Call this to signify that this Contact has accepted to be a friend
         of the user.
@@ -503,7 +445,6 @@ class LegacyContact(
         """
         self.is_friend = True
         self.added_to_roster = True
-        self.__ensure_pk()
         self.log.debug("Accepting friend request")
         presence = self._make_presence(ptype="subscribed", pstatus=text, bare=True)
         self._send(presence, nick=True)
@@ -511,7 +452,7 @@ class LegacyContact(
         await self.__broadcast_pubsub_items()
         self.log.debug("Accepted friend request")
 
-    def reject_friend_request(self, text: Optional[str] = None):
+    def reject_friend_request(self, text: Optional[str] = None) -> None:
         """
         Call this to signify that this Contact has refused to be a contact
         of the user (or that they don't want to be friends anymore)
@@ -523,7 +464,7 @@ class LegacyContact(
         self._send(presence, nick=True)
         self.is_friend = False
 
-    async def on_friend_request(self, text=""):
+    async def on_friend_request(self, text: str = "") -> None:
         """
         Called when receiving a "subscribe" presence, ie, "I would like to add
         you to my contacts/friends", from the user to this contact.
@@ -540,7 +481,7 @@ class LegacyContact(
         """
         pass
 
-    async def on_friend_delete(self, text=""):
+    async def on_friend_delete(self, text: str = "") -> None:
         """
         Called when receiving an "unsubscribed" presence, ie, "I would like to
         remove you to my contacts/friends" or "I refuse your friend request"
@@ -551,7 +492,7 @@ class LegacyContact(
         """
         pass
 
-    async def on_friend_accept(self):
+    async def on_friend_accept(self) -> None:
         """
         Called when receiving a "subscribed"  presence, ie, "I accept to be
         your/confirm that you are my friend" from the user to this contact.
@@ -560,7 +501,7 @@ class LegacyContact(
         """
         pass
 
-    def unsubscribe(self):
+    def unsubscribe(self) -> None:
         """
         (internal use by slidge)
 
@@ -569,9 +510,9 @@ class LegacyContact(
         their 'friends'".
         """
         for ptype in "unsubscribe", "unsubscribed", "unavailable":
-            self.xmpp.send_presence(pfrom=self.jid, pto=self.user_jid.bare, ptype=ptype)  # type: ignore
+            self.xmpp.send_presence(pfrom=self.jid, pto=self.user_jid.bare, ptype=ptype)
 
-    async def update_info(self):
+    async def update_info(self) -> None:
         """
         Fetch information about this contact from the legacy network
 
@@ -587,7 +528,7 @@ class LegacyContact(
         """
         pass
 
-    async def fetch_vcard(self):
+    async def fetch_vcard(self) -> None:
         """
         It the legacy network doesn't like that you fetch too many profiles on startup,
         it's also possible to fetch it here, which will be called when XMPP clients
@@ -606,40 +547,12 @@ class LegacyContact(
     ):
         p = super()._make_presence(last_seen=last_seen, **presence_kwargs)
         caps = self.xmpp.plugin["xep_0115"]
-        if p.get_from().resource and self._caps_ver:
+        if p.get_from().resource and self.stored.caps_ver:
             p["caps"]["node"] = caps.caps_node
             p["caps"]["hash"] = caps.hash
-            p["caps"]["ver"] = self._caps_ver
+            p["caps"]["ver"] = self.stored.caps_ver
         return p
 
-    @classmethod
-    def from_store(cls, session, stored: Contact, *args, **kwargs) -> Self:
-        contact = cls(
-            session,
-            cls.xmpp.LEGACY_CONTACT_ID_TYPE(stored.legacy_id),
-            stored.jid.user,  # type: ignore
-            *args,  # type: ignore
-            **kwargs,  # type: ignore
-        )
-        contact.contact_pk = stored.id
-        contact._name = stored.nick
-        contact._is_friend = stored.is_friend
-        contact._added_to_roster = stored.added_to_roster
-        if (data := stored.extra_attributes) is not None:
-            contact.deserialize_extra_attributes(data)
-        contact._caps_ver = stored.caps_ver
-        contact._set_logger_name()
-        contact._AvatarMixin__avatar_unique_id = (  # type:ignore
-            None
-            if stored.avatar_legacy_id is None
-            else session.xmpp.AVATAR_ID_TYPE(stored.avatar_legacy_id)
-        )
-        contact._avatar_pk = stored.avatar_id
-        contact._vcard = stored.vcard
-        contact._vcard_fetched = stored.vcard_fetched
-        contact._client_type = stored.client_type
-        return contact
-
 
 def is_markable(stanza: Union[Message, Presence]):
     if isinstance(stanza, Presence):