class USSDSession(ChannelSession):
USSD_PULL = INCOMING = 'I'
USSD_PUSH = OUTGOING = 'O'
objects = USSDQuerySet.as_manager()
class Meta:
proxy = True
@property
def should_end(self):
return self.status == self.ENDING
def mark_ending(self): # session to be ended
if self.status != self.ENDING:
self.status = self.ENDING
self.save(update_fields=['status'])
def close(self): # session has successfully ended
if self.status == self.ENDING:
self.status = self.COMPLETED
else:
self.status = self.INTERRUPTED
self.ended_on = timezone.now()
self.save(update_fields=['status', 'ended_on'])
def start_async(self, flow, date, message_id):
from temba.msgs.models import Msg, USSD
message = Msg.objects.create(channel=self.channel,
contact=self.contact,
contact_urn=self.contact_urn,
sent_on=date,
connection=self,
msg_type=USSD,
external_id=message_id,
created_on=timezone.now(),
modified_on=timezone.now(),
org=self.channel.org,
direction=self.INCOMING)
flow.start([], [self.contact],
start_msg=message,
restart_participants=True,
connection=self)
def handle_async(self, urn, content, date, message_id):
from temba.msgs.models import Msg, USSD
Msg.create_incoming(channel=self.channel,
org=self.org,
urn=urn,
text=content or '',
date=date,
connection=self,
msg_type=USSD,
external_id=message_id)
def handle_sync(self): # pragma: needs cover
# TODO: implement for InfoBip and other sync APIs
pass
@classmethod
def handle_incoming(cls,
channel,
urn,
date,
external_id,
contact=None,
message_id=None,
status=None,
content=None,
starcode=None,
org=None,
async=True):
trigger = None
contact_urn = None
# handle contact with channel
urn = URN.from_tel(urn)
if not contact:
contact, contact_urn = Contact.get_or_create(
channel.org, urn, channel)
elif urn:
contact_urn = ContactURN.get_or_create(org,
contact,
urn,
channel=channel)
contact.set_preferred_channel(channel)
if contact_urn:
contact_urn.update_affinity(channel)
# setup session
defaults = dict(channel=channel,
contact=contact,
contact_urn=contact_urn,
org=channel.org if channel else contact.org)
if status == cls.TRIGGERED:
trigger = Trigger.find_trigger_for_ussd_session(contact, starcode)
if not trigger:
return False
defaults.update(
dict(started_on=date, direction=cls.USSD_PULL, status=status))
elif status == cls.INTERRUPTED:
defaults.update(dict(ended_on=date, status=status))
else:
defaults.update(dict(status=cls.IN_PROGRESS))
# check if there's an initiated PUSH connection
connection = cls.objects.get_initiated_push(contact)
created = False
if not connection:
try:
connection = cls.objects.select_for_update().exclude(status__in=ChannelSession.DONE)\
.get(external_id=external_id)
created = False
for k, v in six.iteritems(defaults):
setattr(connection, k, v() if callable(v) else v)
connection.save()
except cls.DoesNotExist:
defaults['external_id'] = external_id
connection = cls.objects.create(**defaults)
FlowSession.create(contact, connection=connection)
created = True
else:
defaults.update(dict(external_id=external_id))
for key, value in six.iteritems(defaults):
setattr(connection, key, value)
connection.save()
created = None
# start session
if created and async and trigger:
connection.start_async(trigger.flow, date, message_id)
def handle_incoming(
cls,
channel,
urn,
date,
external_id,
contact=None,
message_id=None,
status=None,
content=None,
starcode=None,
org=None,
do_async=True,
):
trigger = None
contact_urn = None
# handle contact with channel
urn = URN.from_tel(urn)
if not contact:
contact, contact_urn = Contact.get_or_create(channel.org, urn, channel)
elif urn:
contact_urn = ContactURN.get_or_create(org, contact, urn, channel=channel)
contact.set_preferred_channel(channel)
if contact_urn:
contact_urn.update_affinity(channel)
# setup session
defaults = dict(
channel=channel, contact=contact, contact_urn=contact_urn, org=channel.org if channel else contact.org
)
if status == cls.TRIGGERED:
trigger = Trigger.find_trigger_for_ussd_session(contact, starcode)
if not trigger:
return False
defaults.update(dict(started_on=date, direction=cls.USSD_PULL, status=status))
elif status == cls.INTERRUPTED:
defaults.update(dict(ended_on=date, status=status))
else:
defaults.update(dict(status=cls.IN_PROGRESS))
# check if there's an initiated PUSH connection
connection = cls.objects.get_initiated_push(contact)
created = False
if not connection:
try:
connection = (
cls.objects.select_for_update()
.exclude(status__in=ChannelConnection.DONE)
.get(external_id=external_id)
)
created = False
for k, v in defaults.items():
setattr(connection, k, v() if callable(v) else v)
connection.save()
except cls.DoesNotExist:
defaults["external_id"] = external_id
connection = cls.objects.create(**defaults)
FlowSession.create(contact, connection=connection)
created = True
else:
defaults.update(dict(external_id=external_id))
for key, value in defaults.items():
setattr(connection, key, value)
connection.save()
created = None
# start session
if created and do_async and trigger:
connection.start_async(trigger.flow, date, message_id)
# resume session, deal with incoming content and all the other states
else:
connection.handle_async(urn, content, date, message_id)
return connection
class USSDSession(ChannelSession):
USSD_PULL = INCOMING = 'I'
USSD_PUSH = OUTGOING = 'O'
objects = USSDQuerySet.as_manager()
class Meta:
proxy = True
def start_session_async(self, flow, urn, content, date, message_id):
from temba.msgs.models import Msg, USSD
message = Msg.objects.create(channel=self.channel,
contact=self.contact,
contact_urn=self.contact_urn,
sent_on=date,
session=self,
msg_type=USSD,
external_id=message_id,
created_on=timezone.now(),
modified_on=timezone.now(),
org=self.channel.org,
direction=self.INCOMING)
flow.start([], [self.contact],
start_msg=message,
restart_participants=True,
session=self)
def handle_session_async(self, urn, content, date, message_id):
from temba.msgs.models import Msg, USSD
Msg.create_incoming(channel=self.channel,
urn=urn,
text=content or '',
date=date,
session=self,
msg_type=USSD,
external_id=message_id)
def handle_ussd_session_sync(self): # pragma: needs cover
# TODO: implement for InfoBip and other sync APIs
pass
@classmethod
def handle_incoming(cls,
channel,
urn,
date,
external_id,
message_id=None,
status=None,
flow=None,
content=None,
starcode=None,
org=None,
async=True):
trigger = None
# handle contact with channel
urn = URN.from_tel(urn)
contact = Contact.get_or_create(channel.org,
channel.created_by,
urns=[urn],
channel=channel)
contact_urn = contact.urn_objects[urn]
contact.set_preferred_channel(channel)
contact_urn.update_affinity(channel)
# setup session
defaults = dict(channel=channel,
contact=contact,
contact_urn=contact_urn,
org=channel.org)
if status == cls.TRIGGERED:
trigger = Trigger.find_trigger_for_ussd_session(contact, starcode)
if not trigger:
return False
defaults.update(
dict(started_on=date, direction=cls.USSD_PULL, status=status))
elif status == cls.INTERRUPTED:
defaults.update(dict(ended_on=date, status=status))
else:
defaults.update(dict(status=USSDSession.IN_PROGRESS))
# check if there's an initiated PUSH session
session = cls.objects.get_initiated_push_session(contact)
if not session:
session, created = cls.objects.update_or_create(
external_id=external_id, defaults=defaults)
else:
defaults.update(dict(external_id=external_id))
for key, value in six.iteritems(defaults):
setattr(session, key, value)
session.save()
created = None
# start session
if created and async and trigger:
session.start_session_async(trigger.flow, urn, content, date,
message_id)
def handle_incoming(
cls,
channel,
urn,
date,
external_id,
contact=None,
message_id=None,
status=None,
content=None,
starcode=None,
org=None,
do_async=True,
):
trigger = None
contact_urn = None
# handle contact with channel
urn = URN.from_tel(urn)
if not contact:
contact, contact_urn = Contact.get_or_create(
channel.org, urn, channel)
elif urn:
contact_urn = ContactURN.get_or_create(org,
contact,
urn,
channel=channel)
contact.set_preferred_channel(channel)
if contact_urn:
contact_urn.update_affinity(channel)
# setup session
defaults = dict(channel=channel,
contact=contact,
contact_urn=contact_urn,
org=channel.org if channel else contact.org)
if status == cls.TRIGGERED:
trigger = Trigger.find_trigger_for_ussd_session(contact, starcode)
if not trigger:
return False
defaults.update(
dict(started_on=date, direction=cls.USSD_PULL, status=status))
elif status == cls.INTERRUPTED:
defaults.update(dict(ended_on=date, status=status))
else:
defaults.update(dict(status=cls.IN_PROGRESS))
# check if there's an initiated PUSH connection
connection = cls.objects.get_initiated_push(contact)
created = False
if not connection:
try:
connection = (cls.objects.select_for_update().exclude(
status__in=ChannelSession.DONE).get(
external_id=external_id))
created = False
for k, v in defaults.items():
setattr(connection, k, v() if callable(v) else v)
connection.save()
except cls.DoesNotExist:
defaults["external_id"] = external_id
connection = cls.objects.create(**defaults)
FlowSession.create(contact, connection=connection)
created = True
else:
defaults.update(dict(external_id=external_id))
for key, value in defaults.items():
setattr(connection, key, value)
connection.save()
created = None
# start session
if created and do_async and trigger:
connection.start_async(trigger.flow, date, message_id)
# resume session, deal with incoming content and all the other states
else:
connection.handle_async(urn, content, date, message_id)
return connection
