Continue AI features and improve protocol support

core/modules/router.py

@@ -1,5 +1,12 @@
+from asgiref.sync import sync_to_async
+
+from core.clients import transport
+from core.clients.instagram import InstagramClient
 from core.clients.signal import SignalClient
+from core.clients.whatsapp import WhatsAppClient
 from core.clients.xmpp import XMPPClient
+from core.messaging import history
+from core.models import PersonIdentifier
 from core.util import logs
 
 
@@ -16,11 +23,15 @@ class UnifiedRouter(object):
 
         self.xmpp = XMPPClient(self, loop, "xmpp")
         self.signal = SignalClient(self, loop, "signal")
+        self.whatsapp = WhatsAppClient(self, loop, "whatsapp")
+        self.instagram = InstagramClient(self, loop, "instagram")
 
     def _start(self):
         print("UR _start")
         self.xmpp.start()
         self.signal.start()
+        self.whatsapp.start()
+        self.instagram.start()
 
     def run(self):
         try:
@@ -37,14 +48,66 @@ class UnifiedRouter(object):
     async def message_received(self, protocol, *args, **kwargs):
         self.log.info(f"Message received ({protocol}) {args} {kwargs}")
 
+    async def _resolve_identifier_objects(self, protocol, identifier):
+        if isinstance(identifier, PersonIdentifier):
+            return [identifier]
+        value = str(identifier or "").strip()
+        if not value:
+            return []
+        return await sync_to_async(list)(
+            PersonIdentifier.objects.filter(
+                identifier=value,
+                service=protocol,
+            )
+        )
+
     async def message_read(self, protocol, *args, **kwargs):
         self.log.info(f"Message read ({protocol}) {args} {kwargs}")
+        identifier = kwargs.get("identifier")
+        timestamps = kwargs.get("message_timestamps") or []
+        read_ts = kwargs.get("read_ts")
+        payload = kwargs.get("payload") or {}
+        read_by = kwargs.get("read_by") or ""
+
+        identifiers = await self._resolve_identifier_objects(protocol, identifier)
+        for row in identifiers:
+            await history.apply_read_receipts(
+                user=row.user,
+                identifier=row,
+                message_timestamps=timestamps,
+                read_ts=read_ts,
+                source_service=protocol,
+                read_by_identifier=read_by or row.identifier,
+                payload=payload,
+            )
 
     async def started_typing(self, protocol, *args, **kwargs):
         self.log.info(f"Started typing ({protocol}) {args} {kwargs}")
+        identifier = kwargs.get("identifier")
+        identifiers = await self._resolve_identifier_objects(protocol, identifier)
+        for src in identifiers:
+            targets = await sync_to_async(list)(
+                PersonIdentifier.objects.filter(
+                    user=src.user,
+                    person=src.person,
+                ).exclude(service=protocol)
+            )
+            for target in targets:
+                await transport.start_typing(target.service, target.identifier)
 
     async def stopped_typing(self, protocol, *args, **kwargs):
         self.log.info(f"Stopped typing ({protocol}) {args} {kwargs}")
+        identifier = kwargs.get("identifier")
+        identifiers = await self._resolve_identifier_objects(protocol, identifier)
+        for src in identifiers:
+            targets = await sync_to_async(list)(
+                PersonIdentifier.objects.filter(
+                    user=src.user,
+                    person=src.person,
+                ).exclude(service=protocol)
+            )
+            for target in targets:
+                await transport.stop_typing(target.service, target.identifier)
 
     async def reacted(self, protocol, *args, **kwargs):
         self.log.info(f"Reacted ({protocol}) {args} {kwargs}")