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

slidge/core/mixins/message_text.py

@@ -2,6 +2,9 @@ import logging
 from datetime import datetime
 from typing import Iterable, Optional
 
+from slixmpp import Message
+
+from ...util.archive_msg import HistoryMessage
 from ...util.types import (
     LegacyMessageType,
     LegacyThreadType,
@@ -9,6 +12,7 @@ from ...util.types import (
     MessageReference,
     ProcessingHint,
 )
+from ...util.util import add_quote_prefix
 from .message_maker import MessageMaker
 
 
@@ -23,9 +27,13 @@ class TextMessageMixin(MessageMaker):
 
     def _replace_id(self, legacy_msg_id: LegacyMessageType):
         if self.mtype == "groupchat":
-            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)
+            with self.xmpp.store.session() as orm:
+                ids = self.xmpp.store.id_map.get_xmpp(
+                    orm, self._recipient_pk(), str(legacy_msg_id), True
+                )
+                if ids:
+                    return ids[0]
+                return self.session.legacy_to_xmpp_msg_id(legacy_msg_id)
         else:
             return self._legacy_to_xmpp(legacy_msg_id)
 
@@ -38,9 +46,9 @@ class TextMessageMixin(MessageMaker):
         reply_to: Optional[MessageReference] = None,
         thread: Optional[LegacyThreadType] = None,
         hints: Optional[Iterable[ProcessingHint]] = None,
-        carbon=False,
-        archive_only=False,
-        correction=False,
+        carbon: bool = False,
+        archive_only: bool = False,
+        correction: bool = False,
         correction_event_id: Optional[LegacyMessageType] = None,
         link_previews: Optional[list[LinkPreview]] = None,
         **send_kwargs,
@@ -69,24 +77,28 @@ class TextMessageMixin(MessageMaker):
             but store it in the archive. Meant to be used during ``MUC.backfill()``
         """
         if carbon and not hasattr(self, "muc"):
-            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
-            if hasattr(self, "muc") and not self.is_user:  # type:ignore
-                log.warning(
-                    "send_text() called with carbon=True on a participant who is not the user",
-                    legacy_msg_id,
+            with self.xmpp.store.session() as orm:
+                if not correction and self.xmpp.store.id_map.was_sent_by_user(
+                    orm, self._recipient_pk(), str(legacy_msg_id), self.is_group
+                ):
+                    log.warning(
+                        "Carbon message for a message an XMPP has sent? This is a bug! %s",
+                        legacy_msg_id,
+                    )
+                    return
+                if hasattr(self, "muc") and not self.is_user:  # type:ignore
+                    log.warning(
+                        "send_text() called with carbon=True on a participant who is not the user",
+                        legacy_msg_id,
+                    )
+                self.xmpp.store.id_map.set_msg(
+                    orm,
+                    self._recipient_pk(),
+                    str(legacy_msg_id),
+                    [self.session.legacy_to_xmpp_msg_id(legacy_msg_id)],
+                    self.is_group,
                 )
-            self.xmpp.store.sent.set_message(
-                self.session.user_pk,
-                str(legacy_msg_id),
-                self.session.legacy_to_xmpp_msg_id(legacy_msg_id),
-            )
+                orm.commit()
         hints = self.__default_hints(hints)
         msg = self._make_message(
             mbody=body,
@@ -117,12 +129,12 @@ class TextMessageMixin(MessageMaker):
         reply_to: Optional[MessageReference] = None,
         thread: Optional[LegacyThreadType] = None,
         hints: Optional[Iterable[ProcessingHint]] = None,
-        carbon=False,
-        archive_only=False,
+        carbon: bool = False,
+        archive_only: bool = False,
         correction_event_id: Optional[LegacyMessageType] = None,
         link_previews: Optional[list[LinkPreview]] = None,
         **send_kwargs,
-    ):
+    ) -> None:
         """
         Modify a message that was previously sent by this :term:`XMPP Entity`.
 
@@ -165,7 +177,7 @@ class TextMessageMixin(MessageMaker):
         emojis: Iterable[str] = (),
         thread: Optional[LegacyThreadType] = None,
         **kwargs,
-    ):
+    ) -> None:
         """
         Send a reaction (:xep:`0444`) from this :term:`XMPP Entity`.
 
@@ -174,20 +186,45 @@ class TextMessageMixin(MessageMaker):
         :param thread:
         """
         msg = self._make_message(
-            hints={"store"}, carbon=kwargs.get("carbon"), thread=thread
+            hints={"store"}, carbon=bool(kwargs.get("carbon")), thread=thread
         )
         xmpp_id = kwargs.pop("xmpp_id", None)
         if not xmpp_id:
             xmpp_id = self._legacy_to_xmpp(legacy_msg_id)
         self.xmpp["xep_0444"].set_reactions(msg, to_id=xmpp_id, reactions=emojis)
+        self.__add_reaction_fallback(msg, legacy_msg_id, emojis)
         self._send(msg, **kwargs)
 
+    def __add_reaction_fallback(
+        self,
+        msg: Message,
+        legacy_msg_id: LegacyMessageType,
+        emojis: Iterable[str] = (),
+    ) -> None:
+        if not self.session.user.preferences.get("reaction_fallback", False):
+            return
+        msg["fallback"]["for"] = self.xmpp.plugin["xep_0444"].namespace
+        msg["fallback"].enable("body")
+        msg["body"] = " ".join(emojis)
+        if not self.is_participant:
+            return
+        with self.xmpp.store.session() as orm:
+            archived = self.xmpp.store.mam.get_by_legacy_id(
+                orm, self.muc.stored.id, str(legacy_msg_id)
+            )
+            if archived is None:
+                return
+            history_msg = HistoryMessage(archived.stanza)
+            msg["body"] = (
+                add_quote_prefix(history_msg.stanza["body"]) + "\n" + msg["body"]
+            )
+
     def retract(
         self,
         legacy_msg_id: LegacyMessageType,
         thread: Optional[LegacyThreadType] = None,
         **kwargs,
-    ):
+    ) -> None:
         """
         Send a message retraction (:XEP:`0424`) from this :term:`XMPP Entity`.
 
@@ -198,7 +235,7 @@ class TextMessageMixin(MessageMaker):
             state=None,
             hints={"store"},
             mbody=f"/me retracted the message {legacy_msg_id}",
-            carbon=kwargs.get("carbon"),
+            carbon=bool(kwargs.get("carbon")),
             thread=thread,
         )
         msg.enable("fallback")

slidge/core/mixins/presence.py

@@ -1,13 +1,20 @@
 import re
 from asyncio import Task, sleep
 from datetime import datetime, timedelta, timezone
-from typing import Optional
+from functools import partial
+from typing import TYPE_CHECKING, Optional
 
 from slixmpp.types import PresenceShows, PresenceTypes
+from sqlalchemy.exc import InvalidRequestError
+from sqlalchemy.orm.exc import DetachedInstanceError
 
+from ...db.models import Contact, Participant
 from ...util.types import CachedPresence
-from .. import config
 from .base import BaseSender
+from .db import DBMixin
+
+if TYPE_CHECKING:
+    from ..session import BaseSession
 
 
 class _NoChange(Exception):
@@ -15,43 +22,85 @@ class _NoChange(Exception):
 
 
 _FRIEND_REQUEST_PRESENCES = {"subscribe", "unsubscribe", "subscribed", "unsubscribed"}
+_UPDATE_LAST_SEEN_FALLBACK_TASKS = dict[int, Task]()
+_ONE_WEEK_SECONDS = 3600 * 24 * 7
+
+
+async def _update_last_seen_fallback(session: "BaseSession", contact_pk: int) -> None:
+    await sleep(_ONE_WEEK_SECONDS)
+    with session.xmpp.store.session() as orm:
+        stored = orm.get(Contact, contact_pk)
+        if stored is None:
+            return
+        contact = session.contacts.from_store(stored)
+    contact.send_last_presence(force=True, no_cache_online=False)
 
 
-class PresenceMixin(BaseSender):
+def _clear_last_seen_task(contact_pk: int, _task) -> None:
+    try:
+        del _UPDATE_LAST_SEEN_FALLBACK_TASKS[contact_pk]
+    except KeyError:
+        pass
+
+
+class PresenceMixin(BaseSender, DBMixin):
     _ONLY_SEND_PRESENCE_CHANGES = False
-    contact_pk: Optional[int] = None
 
-    def __init__(self, *a, **k):
+    stored: Contact | Participant
+
+    def __init__(self, *a, **k) -> None:
         super().__init__(*a, **k)
-        # FIXME: this should not be an attribute of this mixin to allow garbage
-        #        collection of instances
-        self.__update_last_seen_fallback_task: Optional[Task] = None
         # this is only used when a presence is set during Contact.update_info(),
         # when the contact does not have a DB primary key yet, and is written
         # to DB at the end of update_info()
         self.cached_presence: Optional[CachedPresence] = None
 
-    async def __update_last_seen_fallback(self):
-        await sleep(3600 * 7)
-        self.send_last_presence(force=True, no_cache_online=False)
+    def __stored(self) -> Contact | None:
+        if isinstance(self.stored, Contact):
+            return self.stored
+        else:
+            try:
+                return self.stored.contact
+            except DetachedInstanceError:
+                with self.xmpp.store.session() as orm:
+                    orm.add(self.stored)
+                    return self.stored.contact
+
+    @property
+    def __contact_pk(self) -> int | None:
+        stored = self.__stored()
+        return None if stored is None else stored.id
 
     def _get_last_presence(self) -> Optional[CachedPresence]:
-        if self.contact_pk is None:
+        stored = self.__stored()
+        if stored is None or not stored.cached_presence:
             return None
-        return self.xmpp.store.contacts.get_presence(self.contact_pk)
+        return CachedPresence(
+            None
+            if stored.last_seen is None
+            else stored.last_seen.replace(tzinfo=timezone.utc),
+            stored.ptype,  # type:ignore
+            stored.pstatus,
+            stored.pshow,  # type:ignore
+        )
 
-    def _store_last_presence(self, new: CachedPresence):
-        if self.contact_pk is None:
-            self.cached_presence = new
-            return
-        self.xmpp.store.contacts.set_presence(self.contact_pk, new)
+    def _store_last_presence(self, new: CachedPresence) -> None:
+        stored = self.__stored()
+        if stored is not None:
+            stored.cached_presence = True
+            for k, v in new._asdict().items():
+                setattr(stored, k, v)
+            try:
+                self.commit()
+            except InvalidRequestError:
+                self.commit(merge=True)
 
     def _make_presence(
         self,
         *,
         last_seen: Optional[datetime] = None,
-        force=False,
-        bare=False,
+        force: bool = False,
+        bare: bool = False,
         ptype: Optional[PresenceTypes] = None,
         pstatus: Optional[str] = None,
         pshow: Optional[PresenceShows] = None,
@@ -67,8 +116,10 @@ class PresenceMixin(BaseSender):
             )
             if old != new:
                 if hasattr(self, "muc") and ptype == "unavailable":
-                    if self.contact_pk is not None:
-                        self.xmpp.store.contacts.reset_presence(self.contact_pk)
+                    stored = self.__stored()
+                    if stored is not None:
+                        stored.cached_presence = False
+                        self.commit(merge=True)
                 else:
                     self._store_last_presence(new)
             if old and not force and self._ONLY_SEND_PRESENCE_CHANGES:
@@ -87,27 +138,33 @@ class PresenceMixin(BaseSender):
         )
         if last_seen:
             # it's ugly to check for the presence of this string, but a better fix is more work
-            if config.LAST_SEEN_FALLBACK and not re.match(
+            if not re.match(
                 ".*Last seen .*", p["status"]
-            ):
+            ) and self.session.user.preferences.get("last_seen_fallback", True):
                 last_seen_fallback, recent = get_last_seen_fallback(last_seen)
                 if p["status"]:
                     p["status"] = p["status"] + " -- " + last_seen_fallback
                 else:
                     p["status"] = last_seen_fallback
-                if recent:
+                pk = self.__contact_pk
+                if recent and pk is not None:
                     # if less than a week, we use sth like 'Last seen: Monday, 8:05",
                     # but if lasts more than a week, this is not very informative, so
                     # we need to force resend an updated presence status
-                    if self.__update_last_seen_fallback_task:
-                        self.__update_last_seen_fallback_task.cancel()
-                    self.__update_last_seen_fallback_task = self.xmpp.loop.create_task(
-                        self.__update_last_seen_fallback()
+                    task = _UPDATE_LAST_SEEN_FALLBACK_TASKS.get(pk)
+                    if task is not None:
+                        task.cancel()
+                    task = self.session.create_task(
+                        _update_last_seen_fallback(self.session, pk)
                     )
+                    _UPDATE_LAST_SEEN_FALLBACK_TASKS[pk] = task
+                    task.add_done_callback(partial(_clear_last_seen_task, pk))
             p["idle"]["since"] = last_seen
         return p
 
-    def send_last_presence(self, force=False, no_cache_online=False):
+    def send_last_presence(
+        self, force: bool = False, no_cache_online: bool = False
+    ) -> None:
         if (cache := self._get_last_presence()) is None:
             if force:
                 if no_cache_online:
@@ -129,7 +186,7 @@ class PresenceMixin(BaseSender):
         self,
         status: Optional[str] = None,
         last_seen: Optional[datetime] = None,
-    ):
+    ) -> None:
         """
         Send an "online" presence from this contact to the user.
 
@@ -145,7 +202,7 @@ class PresenceMixin(BaseSender):
         self,
         status: Optional[str] = None,
         last_seen: Optional[datetime] = None,
-    ):
+    ) -> None:
         """
         Send an "away" presence from this contact to the user.
 
@@ -166,7 +223,7 @@ class PresenceMixin(BaseSender):
         self,
         status: Optional[str] = None,
         last_seen: Optional[datetime] = None,
-    ):
+    ) -> None:
         """
         Send an "extended away" presence from this contact to the user.
 
@@ -187,7 +244,7 @@ class PresenceMixin(BaseSender):
         self,
         status: Optional[str] = None,
         last_seen: Optional[datetime] = None,
-    ):
+    ) -> None:
         """
         Send a "busy" (ie, "dnd") presence from this contact to the user,
 
@@ -205,7 +262,7 @@ class PresenceMixin(BaseSender):
         self,
         status: Optional[str] = None,
         last_seen: Optional[datetime] = None,
-    ):
+    ) -> None:
         """
         Send an "offline" presence from this contact to the user.
 
@@ -222,9 +279,9 @@ class PresenceMixin(BaseSender):
             pass
 
 
-def get_last_seen_fallback(last_seen: datetime):
+def get_last_seen_fallback(last_seen: datetime) -> tuple[str, bool]:
     now = datetime.now(tz=timezone.utc)
     if now - last_seen < timedelta(days=7):
-        return f"Last seen {last_seen:%A %H:%M GMT}", True
+        return f"Last seen {last_seen:%A %H:%M %p GMT}", True
     else:
         return f"Last seen {last_seen:%b %-d %Y}", False

slidge/core/pubsub.py

@@ -21,8 +21,8 @@ from slixmpp.plugins.xep_0292.stanza import VCard4
 from slixmpp.types import JidStr, OptJidStr
 
 from ..db.avatar import CachedAvatar, avatar_cache
-from ..db.store import ContactStore, SlidgeStore
-from .mixins.lock import NamedLockMixin
+from ..db.models import GatewayUser
+from ..util.lock import NamedLockMixin
 
 if TYPE_CHECKING:
     from slidge.core.gateway import BaseGateway
@@ -32,14 +32,8 @@ if TYPE_CHECKING:
 VCARD4_NAMESPACE = "urn:xmpp:vcard4"
 
 
-class PepItem:
-    pass
-
-
-class PepAvatar(PepItem):
-    store: SlidgeStore
-
-    def __init__(self):
+class PepAvatar:
+    def __init__(self) -> None:
         self.metadata: Optional[AvatarMetadata] = None
         self.id: Optional[str] = None
         self._avatar_data_path: Optional[Path] = None
@@ -52,7 +46,7 @@ class PepAvatar(PepItem):
         data.set_value(self._avatar_data_path.read_bytes())
         return data
 
-    def set_avatar_from_cache(self, cached_avatar: CachedAvatar):
+    def set_avatar_from_cache(self, cached_avatar: CachedAvatar) -> None:
         metadata = AvatarMetadata()
         self.id = cached_avatar.hash
         metadata.add_info(
@@ -66,17 +60,6 @@ class PepAvatar(PepItem):
         self._avatar_data_path = cached_avatar.path
 
 
-class PepNick(PepItem):
-    contact_store: ContactStore
-
-    def __init__(self, nick: Optional[str] = None):
-        nickname = UserNick()
-        if nick is not None:
-            nickname["nick"] = nick
-        self.nick = nickname
-        self.__nick_str = nick
-
-
 class PubSubComponent(NamedLockMixin, BasePlugin):
     xmpp: "BaseGateway"
 
@@ -91,11 +74,11 @@ class PubSubComponent(NamedLockMixin, BasePlugin):
     default_config = {"component_name": None}
     component_name: str
 
-    def __init__(self, *a, **kw):
+    def __init__(self, *a, **kw) -> None:
         super(PubSubComponent, self).__init__(*a, **kw)
         register_stanza_plugin(EventItem, UserNick)
 
-    def plugin_init(self):
+    def plugin_init(self) -> None:
         self.xmpp.register_handler(
             CoroutineCallback(
                 "pubsub_get_avatar_data",
@@ -144,7 +127,7 @@ class PubSubComponent(NamedLockMixin, BasePlugin):
 
     async def on_presence_available(
         self, p: Presence, contact: Optional["LegacyContact"]
-    ):
+    ) -> None:
         if p.get_plugin("muc_join", check=True) is not None:
             log.debug("Ignoring MUC presence here")
             return
@@ -177,14 +160,16 @@ class PubSubComponent(NamedLockMixin, BasePlugin):
             except XMPPError:
                 pass
             else:
-                await self.__broadcast(data=pep_nick.nick, from_=p.get_to(), to=from_)
+                await self.__broadcast(data=pep_nick, from_=p.get_to(), to=from_)
 
         if contact is not None and VCARD4_NAMESPACE + "+notify" in features:
             await self.broadcast_vcard_event(
                 p.get_to(), from_, await contact.get_vcard()
             )
 
-    async def broadcast_vcard_event(self, from_: JID, to: JID, vcard: VCard4 | None):
+    async def broadcast_vcard_event(
+        self, from_: JID, to: JID, vcard: VCard4 | None
+    ) -> None:
         item = Item()
         item.namespace = VCARD4_NAMESPACE
         item["id"] = "current"
@@ -211,33 +196,33 @@ class PubSubComponent(NamedLockMixin, BasePlugin):
     ) -> PepAvatar:
         if stanza.get_to() == self.xmpp.boundjid.bare:
             item = PepAvatar()
-            if hasattr(self.xmpp, "avatar_pk"):
-                item.set_avatar_from_cache(avatar_cache.get_by_pk(self.xmpp.avatar_pk))
+            if self.xmpp.avatar is not None:
+                item.set_avatar_from_cache(self.xmpp.avatar)
             return item
 
         if contact is None:
             contact = await self.__get_contact(stanza)
 
         item = PepAvatar()
-        if contact.avatar_pk is not None:
-            stored = avatar_cache.get_by_pk(contact.avatar_pk)
+        if contact.stored.avatar is not None:
+            stored = avatar_cache.get(contact.stored.avatar)
             assert stored is not None
             item.set_avatar_from_cache(stored)
         return item
 
     async def _get_authorized_nick(
         self, stanza: Union[Iq, Presence], contact: Optional["LegacyContact"] = None
-    ) -> PepNick:
+    ) -> UserNick:
         if stanza.get_to() == self.xmpp.boundjid.bare:
-            return PepNick(self.xmpp.COMPONENT_NAME)
+            return get_user_nick(self.xmpp.COMPONENT_NAME)
 
         if contact is None:
             contact = await self.__get_contact(stanza)
 
         if contact.name is not None:
-            return PepNick(contact.name)
+            return get_user_nick(contact.name)
         else:
-            return PepNick()
+            return UserNick()
 
     def __reply_with(
         self, iq: Iq, content: AvatarData | AvatarMetadata | None, item_id: str | None
@@ -254,11 +239,11 @@ class PubSubComponent(NamedLockMixin, BasePlugin):
             else:
                 raise XMPPError("item-not-found")
 
-    async def _get_avatar_data(self, iq: Iq):
+    async def _get_avatar_data(self, iq: Iq) -> None:
         pep_avatar = await self._get_authorized_avatar(iq)
         self.__reply_with(iq, pep_avatar.data, pep_avatar.id)
 
-    async def _get_avatar_metadata(self, iq: Iq):
+    async def _get_avatar_metadata(self, iq: Iq) -> None:
         pep_avatar = await self._get_authorized_avatar(iq)
         self.__reply_with(iq, pep_avatar.metadata, pep_avatar.id)
 
@@ -279,7 +264,7 @@ class PubSubComponent(NamedLockMixin, BasePlugin):
         payload: Optional[Union[AvatarMetadata, AvatarData, VCard4]],
         id_: Optional[str],
         namespace: Optional[str] = None,
-    ):
+    ) -> None:
         result = iq.reply()
         item = Item()
         if payload:
@@ -291,7 +276,9 @@ class PubSubComponent(NamedLockMixin, BasePlugin):
         result["pubsub"]["items"].append(item)
         result.send()
 
-    async def __broadcast(self, data, from_: JidStr, to: OptJidStr = None, **kwargs):
+    async def __broadcast(
+        self, data, from_: JidStr, to: OptJidStr = None, **kwargs
+    ) -> None:
         from_ = JID(from_)
         if from_ != self.xmpp.boundjid.bare and to is not None:
             to = JID(to)
@@ -319,10 +306,11 @@ class PubSubComponent(NamedLockMixin, BasePlugin):
         msg.append(event)
 
         if to is None:
-            for u in self.xmpp.store.users.get_all():
-                new_msg = copy(msg)
-                new_msg.set_to(u.jid.bare)
-                new_msg.send()
+            with self.xmpp.store.session() as orm:
+                for u in orm.query(GatewayUser).all():
+                    new_msg = copy(msg)
+                    new_msg.set_to(u.jid.bare)
+                    new_msg.send()
         else:
             msg.set_to(to)
             msg.send()
@@ -345,11 +333,18 @@ class PubSubComponent(NamedLockMixin, BasePlugin):
         user_jid: JID,
         jid: JidStr,
         nick: Optional[str] = None,
-    ):
+    ) -> None:
         jid = JID(jid)
-        nickname = PepNick(nick)
-        log.debug("New nickname: %s", nickname.nick)
-        self.xmpp.loop.create_task(self.__broadcast(nickname.nick, jid, user_jid.bare))
+        nickname = get_user_nick(nick)
+        log.debug("New nickname: %s", nickname)
+        self.xmpp.loop.create_task(self.__broadcast(nickname, jid, user_jid.bare))
+
+
+def get_user_nick(nick: Optional[str] = None) -> UserNick:
+    user_nick = UserNick()
+    if nick is not None:
+        user_nick["nick"] = nick
+    return user_nick
 
 
 log = logging.getLogger(__name__)