117 lines
4.2 KiB
Python
117 lines
4.2 KiB
Python
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
|
|
|
|
|
|
class UnifiedRouter(object):
|
|
"""
|
|
Unified Router. Contains generic functions for handling XMPP and Signal events.
|
|
"""
|
|
|
|
def __init__(self, loop):
|
|
self.loop = loop
|
|
|
|
self.log = logs.get_logger("router")
|
|
self.log.info("Initialised Unified Router Interface.")
|
|
|
|
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:
|
|
# self.xmpp.client.client.process()
|
|
# self.xmpp.start()
|
|
print("IN RUN BEFORE START")
|
|
self._start()
|
|
self.loop.run_forever()
|
|
except (KeyboardInterrupt, SystemExit):
|
|
self.log.info("Process terminating")
|
|
finally:
|
|
self.loop.close()
|
|
|
|
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}")
|
|
|
|
async def replied(self, protocol, *args, **kwargs):
|
|
self.log.info(f"Replied ({protocol}) {args} {kwargs}")
|