def clean(self, value):
if value.startswith("[_NEW_]"):
value = value[7:]
# we must get groups for this org only
group = ContactGroup.get_user_group(self.user.get_org(), value)
if not group:
group = ContactGroup.create_static(self.user.get_org(), self.user, name=value)
return group
return super(RegisterTriggerForm.AddNewGroupChoiceField, self).clean(value)
def clean(self, value):
if value.startswith("[_NEW_]"): # pragma: needs cover
value = value[7:]
# we must get groups for this org only
group = ContactGroup.get_user_group(self.user.get_org(), value)
if not group:
group = ContactGroup.create_static(self.user.get_org(), self.user, name=value)
return group
return super().clean(value)
def clean(self, value):
if value.startswith("[_NEW_]"):
value = value[7:]
# we must get groups for this org only
group = ContactGroup.get_user_group(self.user.get_org(), value)
if not group:
group = ContactGroup.create(self.user.get_org(), self.user, name=value)
return group
return super(RegisterTriggerForm.AddNewGroupChoiceField, self).clean(value)
def clean(self, value):
if value.startswith("[_NEW_]"): # pragma: needs cover
value = value[7:]
# we must get groups for this org only
group = ContactGroup.get_user_group(self.user.get_org(), value)
if not group:
group = ContactGroup.create_static(self.user.get_org(), self.user, name=value)
return group
return super().clean(value)
def remap_group(group):
if type(group) is dict:
# we haven't been mapped yet (also, non-uuid groups can't be mapped)
if "uuid" not in group or group["uuid"] not in uuid_map:
group_instance = ContactGroup.get_user_group(
flow.org, group["name"])
if group_instance:
# map group references that started with a uuid
if "uuid" in group:
uuid_map[group["uuid"]] = group_instance.uuid
group["uuid"] = group_instance.uuid
# we were already mapped
elif group["uuid"] in uuid_map:
group["uuid"] = uuid_map[group["uuid"]]
def import_triggers(cls, exported_json, org, user, same_site=False):
"""
Import triggers from our export file
"""
from temba.orgs.models import EARLIEST_IMPORT_VERSION
if exported_json.get('version', 0) < EARLIEST_IMPORT_VERSION:
raise ValueError(_("Unknown version (%s)" % exported_json.get('version', 0)))
# first things first, let's create our groups if necesary and map their ids accordingly
if 'triggers' in exported_json:
for trigger_spec in exported_json['triggers']:
# resolve our groups
groups = []
for group_spec in trigger_spec['groups']:
group = None
if same_site:
group = ContactGroup.user_groups.filter(org=org, pk=group_spec['id']).first()
if not group:
group = ContactGroup.get_user_group(org, group_spec['name'])
if not group:
group = ContactGroup.create(org, user, group_spec['name'])
if not group.is_active:
group.is_active = True
group.save()
groups.append(group)
flow = Flow.objects.get(org=org, pk=trigger_spec['flow']['id'])
# see if that trigger already exists
trigger = Trigger.objects.filter(org=org, trigger_type=trigger_spec['trigger_type'])
if trigger_spec['keyword']:
trigger = trigger.filter(keyword__iexact=trigger_spec['keyword'])
if groups:
trigger = trigger.filter(groups__in=groups)
trigger = trigger.first()
if trigger:
trigger.is_archived = False
trigger.flow = flow
trigger.save()
else:
# if we have a channel resolve it
channel = trigger_spec.get('channel', None) # older exports won't have a channel
if channel:
channel = Channel.objects.filter(pk=channel.pk, org=org).first()
trigger = Trigger.objects.create(org=org, trigger_type=trigger_spec['trigger_type'],
keyword=trigger_spec['keyword'], flow=flow,
created_by=user, modified_by=user,
channel=channel)
for group in groups:
trigger.groups.add(group)
def import_campaigns(cls, exported_json, org, user, same_site=False):
"""
Import campaigns from our export file
"""
from temba.orgs.models import EARLIEST_IMPORT_VERSION
if Flow.is_before_version(exported_json.get("version", "0"), EARLIEST_IMPORT_VERSION): # pragma: needs cover
raise ValueError(_("Unknown version (%s)" % exported_json.get("version", 0)))
if "campaigns" in exported_json:
for campaign_spec in exported_json["campaigns"]:
name = campaign_spec["name"]
campaign = None
group = None
# first check if we have the objects by id
if same_site:
group = ContactGroup.user_groups.filter(uuid=campaign_spec["group"]["uuid"], org=org).first()
if group: # pragma: needs cover
group.name = campaign_spec["group"]["name"]
group.save()
campaign = Campaign.objects.filter(org=org, uuid=campaign_spec["uuid"]).first()
if campaign: # pragma: needs cover
campaign.name = Campaign.get_unique_name(org, name, ignore=campaign)
campaign.save()
# fall back to lookups by name
if not group:
group = ContactGroup.get_user_group(org, campaign_spec["group"]["name"])
if not campaign:
campaign = Campaign.objects.filter(org=org, name=name).first()
# all else fails, create the objects from scratch
if not group:
group = ContactGroup.create_static(org, user, campaign_spec["group"]["name"])
if not campaign:
campaign_name = Campaign.get_unique_name(org, name)
campaign = Campaign.create(org, user, campaign_name, group)
else:
campaign.group = group
campaign.save()
# deactivate all of our events, we'll recreate these
for event in campaign.events.all():
event.release()
# fill our campaign with events
for event_spec in campaign_spec["events"]:
field_key = event_spec["relative_to"]["key"]
if field_key == "created_on":
relative_to = ContactField.system_fields.filter(org=org, key=field_key).first()
else:
relative_to = ContactField.get_or_create(
org, user, key=field_key, label=event_spec["relative_to"]["label"], value_type="D"
)
start_mode = event_spec.get("start_mode", CampaignEvent.MODE_INTERRUPT)
# create our message flow for message events
if event_spec["event_type"] == CampaignEvent.TYPE_MESSAGE:
message = event_spec["message"]
base_language = event_spec.get("base_language")
if not isinstance(message, dict):
try:
message = json.loads(message)
except ValueError:
# if it's not a language dict, turn it into one
message = dict(base=message)
base_language = "base"
event = CampaignEvent.create_message_event(
org,
user,
campaign,
relative_to,
event_spec["offset"],
event_spec["unit"],
message,
event_spec["delivery_hour"],
base_language=base_language,
start_mode=start_mode,
)
event.update_flow_name()
else:
flow = Flow.objects.filter(
org=org, is_active=True, is_system=False, uuid=event_spec["flow"]["uuid"]
).first()
if flow:
CampaignEvent.create_flow_event(
org,
user,
campaign,
relative_to,
event_spec["offset"],
event_spec["unit"],
flow,
event_spec["delivery_hour"],
start_mode=start_mode,
)
# update our scheduled events for this campaign
EventFire.update_campaign_events(campaign)
def import_campaigns(cls, exported_json, org, user, same_site=False):
"""
Import campaigns from our export file
"""
from temba.orgs.models import EARLIEST_IMPORT_VERSION
if Flow.is_before_version(
exported_json.get('version', "0"),
EARLIEST_IMPORT_VERSION): # pragma: needs cover
raise ValueError(
_("Unknown version (%s)" % exported_json.get('version', 0)))
if 'campaigns' in exported_json:
for campaign_spec in exported_json['campaigns']:
name = campaign_spec['name']
campaign = None
group = None
# first check if we have the objects by id
if same_site:
group = ContactGroup.user_groups.filter(
uuid=campaign_spec['group']['uuid'], org=org).first()
if group: # pragma: needs cover
group.name = campaign_spec['group']['name']
group.save()
campaign = Campaign.objects.filter(
org=org, uuid=campaign_spec['uuid']).first()
if campaign: # pragma: needs cover
campaign.name = Campaign.get_unique_name(
org, name, ignore=campaign)
campaign.save()
# fall back to lookups by name
if not group:
group = ContactGroup.get_user_group(
org, campaign_spec['group']['name'])
if not campaign:
campaign = Campaign.objects.filter(org=org,
name=name).first()
# all else fails, create the objects from scratch
if not group:
group = ContactGroup.create_static(
org, user, campaign_spec['group']['name'])
if not campaign:
campaign_name = Campaign.get_unique_name(org, name)
campaign = Campaign.create(org, user, campaign_name, group)
else:
campaign.group = group
campaign.save()
# we want to nuke old single message flows
for event in campaign.events.all():
if event.flow.flow_type == Flow.MESSAGE:
event.flow.release()
# and all of the events, we'll recreate these
campaign.events.all().delete()
# fill our campaign with events
for event_spec in campaign_spec['events']:
relative_to = ContactField.get_or_create(
org,
user,
key=event_spec['relative_to']['key'],
label=event_spec['relative_to']['label'])
# create our message flow for message events
if event_spec['event_type'] == CampaignEvent.TYPE_MESSAGE:
message = event_spec['message']
base_language = event_spec.get('base_language')
if not isinstance(message, dict):
try:
message = json.loads(message)
except ValueError:
# if it's not a language dict, turn it into one
message = dict(base=message)
base_language = 'base'
event = CampaignEvent.create_message_event(
org,
user,
campaign,
relative_to,
event_spec['offset'],
event_spec['unit'],
message,
event_spec['delivery_hour'],
base_language=base_language)
event.update_flow_name()
else:
flow = Flow.objects.filter(
org=org,
is_active=True,
uuid=event_spec['flow']['uuid']).first()
if flow:
CampaignEvent.create_flow_event(
org, user, campaign, relative_to,
event_spec['offset'], event_spec['unit'], flow,
event_spec['delivery_hour'])
# update our scheduled events for this campaign
EventFire.update_campaign_events(campaign)
def import_triggers(cls, exported_json, org, user, same_site=False):
"""
Import triggers from our export file
"""
from temba.orgs.models import EARLIEST_IMPORT_VERSION
if exported_json.get('version', 0) < EARLIEST_IMPORT_VERSION:
raise ValueError(
_("Unknown version (%s)" % exported_json.get('version', 0)))
# first things first, let's create our groups if necesary and map their ids accordingly
if 'triggers' in exported_json:
for trigger_spec in exported_json['triggers']:
# resolve our groups
groups = []
for group_spec in trigger_spec['groups']:
group = None
if same_site:
group = ContactGroup.user_groups.filter(
org=org, uuid=group_spec['uuid']).first()
if not group:
group = ContactGroup.get_user_group(
org, group_spec['name'])
if not group:
group = ContactGroup.create_static(
org, user, group_spec['name'])
if not group.is_active:
group.is_active = True
group.save()
groups.append(group)
flow = Flow.objects.get(org=org,
uuid=trigger_spec['flow']['uuid'],
is_active=True)
# see if that trigger already exists
trigger = Trigger.objects.filter(
org=org, trigger_type=trigger_spec['trigger_type'])
if trigger_spec['keyword']:
trigger = trigger.filter(
keyword__iexact=trigger_spec['keyword'])
if groups:
trigger = trigger.filter(groups__in=groups)
trigger = trigger.first()
if trigger:
trigger.is_archived = False
trigger.flow = flow
trigger.save()
else:
# if we have a channel resolve it
channel = trigger_spec.get(
'channel', None) # older exports won't have a channel
if channel:
channel = Channel.objects.filter(uuid=channel,
org=org).first()
trigger = Trigger.objects.create(
org=org,
trigger_type=trigger_spec['trigger_type'],
keyword=trigger_spec['keyword'],
flow=flow,
created_by=user,
modified_by=user,
channel=channel)
for group in groups:
trigger.groups.add(group)
def import_campaigns(cls, exported_json, org, user, same_site=False):
"""
Import campaigns from our export file
"""
from temba.orgs.models import EARLIEST_IMPORT_VERSION
if exported_json.get('version', 0) < EARLIEST_IMPORT_VERSION:
raise ValueError(_("Unknown version (%s)" % exported_json.get('version', 0)))
if 'campaigns' in exported_json:
for campaign_spec in exported_json['campaigns']:
name = campaign_spec['name']
campaign = None
group = None
# first check if we have the objects by id
if same_site:
group = ContactGroup.user_groups.filter(id=campaign_spec['group']['id'], org=org).first()
if group:
group.name = campaign_spec['group']['name']
group.save()
campaign = Campaign.objects.filter(org=org, id=campaign_spec['id']).first()
if campaign:
campaign.name = Campaign.get_unique_name(org, name, ignore=campaign)
campaign.save()
# fall back to lookups by name
if not group:
group = ContactGroup.get_user_group(org, campaign_spec['group']['name'])
if not campaign:
campaign = Campaign.objects.filter(org=org, name=name).first()
# all else fails, create the objects from scratch
if not group:
group = ContactGroup.create(org, user, campaign_spec['group']['name'])
if not campaign:
campaign_name = Campaign.get_unique_name(org, name)
campaign = Campaign.create(org, user, campaign_name, group)
else:
campaign.group = group
campaign.save()
# we want to nuke old single message flows
for event in campaign.events.all():
if event.flow.flow_type == Flow.MESSAGE:
event.flow.delete()
# and all of the events, we'll recreate these
campaign.events.all().delete()
# fill our campaign with events
for event_spec in campaign_spec['events']:
relative_to = ContactField.get_or_create(org, user,
key=event_spec['relative_to']['key'],
label=event_spec['relative_to']['label'])
# create our message flow for message events
if event_spec['event_type'] == MESSAGE_EVENT:
event = CampaignEvent.create_message_event(org, user, campaign, relative_to,
event_spec['offset'],
event_spec['unit'],
event_spec['message'],
event_spec['delivery_hour'])
event.update_flow_name()
else:
flow = Flow.objects.filter(org=org, is_active=True, id=event_spec['flow']['id']).first()
if flow:
CampaignEvent.create_flow_event(org, user, campaign, relative_to,
event_spec['offset'],
event_spec['unit'],
flow,
event_spec['delivery_hour'])
# update our scheduled events for this campaign
EventFire.update_campaign_events(campaign)
def import_campaigns(cls, exported_json, org, user, same_site=False):
"""
Import campaigns from our export file
"""
from temba.orgs.models import EARLIEST_IMPORT_VERSION
if Flow.is_before_version(
exported_json.get("version", "0"),
EARLIEST_IMPORT_VERSION): # pragma: needs cover
raise ValueError(
_("Unknown version (%s)" % exported_json.get("version", 0)))
if "campaigns" in exported_json:
for campaign_spec in exported_json["campaigns"]:
name = campaign_spec["name"]
campaign = None
group = None
# first check if we have the objects by id
if same_site:
group = ContactGroup.user_groups.filter(
uuid=campaign_spec["group"]["uuid"], org=org).first()
if group: # pragma: needs cover
group.name = campaign_spec["group"]["name"]
group.save()
campaign = Campaign.objects.filter(
org=org, uuid=campaign_spec["uuid"]).first()
if campaign: # pragma: needs cover
campaign.name = Campaign.get_unique_name(
org, name, ignore=campaign)
campaign.save()
# fall back to lookups by name
if not group:
group = ContactGroup.get_user_group(
org, campaign_spec["group"]["name"])
if not campaign:
campaign = Campaign.objects.filter(org=org,
name=name).first()
# all else fails, create the objects from scratch
if not group:
group = ContactGroup.create_static(
org, user, campaign_spec["group"]["name"])
if not campaign:
campaign_name = Campaign.get_unique_name(org, name)
campaign = Campaign.create(org, user, campaign_name, group)
else:
campaign.group = group
campaign.save()
# release all of our events, we'll recreate these
for event in campaign.events.all():
event.release()
# fill our campaign with events
for event_spec in campaign_spec["events"]:
relative_to = ContactField.get_or_create(
org,
user,
key=event_spec["relative_to"]["key"],
label=event_spec["relative_to"]["label"],
value_type="D",
)
# create our message flow for message events
if event_spec["event_type"] == CampaignEvent.TYPE_MESSAGE:
message = event_spec["message"]
base_language = event_spec.get("base_language")
if not isinstance(message, dict):
try:
message = json.loads(message)
except ValueError:
# if it's not a language dict, turn it into one
message = dict(base=message)
base_language = "base"
event = CampaignEvent.create_message_event(
org,
user,
campaign,
relative_to,
event_spec["offset"],
event_spec["unit"],
message,
event_spec["delivery_hour"],
base_language=base_language,
)
event.update_flow_name()
else:
flow = Flow.objects.filter(
org=org,
is_active=True,
uuid=event_spec["flow"]["uuid"]).first()
if flow:
CampaignEvent.create_flow_event(
org,
user,
campaign,
relative_to,
event_spec["offset"],
event_spec["unit"],
flow,
event_spec["delivery_hour"],
)
# update our scheduled events for this campaign
EventFire.update_campaign_events(campaign)
def import_triggers(cls, exported_json, org, user, same_site=False):
"""
Import triggers from our export file
"""
from temba.orgs.models import EARLIEST_IMPORT_VERSION
if Flow.is_before_version(exported_json.get("version", 0), EARLIEST_IMPORT_VERSION): # pragma: needs cover
raise ValueError(_("Unknown version (%s)" % exported_json.get("version", 0)))
# first things first, let's create our groups if necesary and map their ids accordingly
if "triggers" in exported_json:
for trigger_spec in exported_json["triggers"]:
# resolve our groups
groups = []
for group_spec in trigger_spec["groups"]:
group = None
if same_site: # pragma: needs cover
group = ContactGroup.user_groups.filter(org=org, uuid=group_spec["uuid"]).first()
if not group:
group = ContactGroup.get_user_group(org, group_spec["name"])
if not group:
group = ContactGroup.create_static(org, user, group_spec["name"])
if not group.is_active: # pragma: needs cover
group.is_active = True
group.save()
groups.append(group)
flow = Flow.objects.get(org=org, uuid=trigger_spec["flow"]["uuid"], is_active=True)
# see if that trigger already exists
trigger = Trigger.objects.filter(org=org, trigger_type=trigger_spec["trigger_type"])
if trigger_spec["keyword"]:
trigger = trigger.filter(keyword__iexact=trigger_spec["keyword"])
if groups:
trigger = trigger.filter(groups__in=groups)
trigger = trigger.first()
if trigger:
trigger.is_archived = False
trigger.flow = flow
trigger.save()
else:
# if we have a channel resolve it
channel = trigger_spec.get("channel", None) # older exports won't have a channel
if channel:
channel = Channel.objects.filter(uuid=channel, org=org).first()
trigger = Trigger.objects.create(
org=org,
trigger_type=trigger_spec["trigger_type"],
keyword=trigger_spec["keyword"],
flow=flow,
created_by=user,
modified_by=user,
channel=channel,
)
for group in groups:
trigger.groups.add(group)
def import_campaigns(cls, exported_json, org, user, same_site=False):
"""
Import campaigns from our export file
"""
from temba.orgs.models import EARLIEST_IMPORT_VERSION
if exported_json.get('version', 0) < EARLIEST_IMPORT_VERSION:
raise ValueError(_("Unknown version (%s)" % exported_json.get('version', 0)))
if 'campaigns' in exported_json:
for campaign_spec in exported_json['campaigns']:
name = campaign_spec['name']
campaign = None
group = None
# first check if we have the objects by id
if same_site:
group = ContactGroup.user_groups.filter(id=campaign_spec['group']['id'], org=org, is_active=True).first()
if group:
group.name = campaign_spec['group']['name']
group.save()
campaign = Campaign.objects.filter(org=org, id=campaign_spec['id']).first()
if campaign:
campaign.name = Campaign.get_unique_name(org, name, ignore=campaign)
campaign.save()
# fall back to lookups by name
if not group:
group = ContactGroup.get_user_group(org, campaign_spec['group']['name'])
if not campaign:
campaign = Campaign.objects.filter(org=org, name=name).first()
# all else fails, create the objects from scratch
if not group:
group = ContactGroup.create(org, user, campaign_spec['group']['name'])
if not campaign:
campaign_name = Campaign.get_unique_name(org, name)
campaign = Campaign.create(org, user, campaign_name, group)
else:
campaign.group = group
campaign.save()
# we want to nuke old single message flows
for event in campaign.events.all():
if event.flow.flow_type == Flow.MESSAGE:
event.flow.delete()
# and all of the events, we'll recreate these
campaign.events.all().delete()
# fill our campaign with events
for event_spec in campaign_spec['events']:
relative_to = ContactField.get_or_create(org, user,
key=event_spec['relative_to']['key'],
label=event_spec['relative_to']['label'])
# create our message flow for message events
if event_spec['event_type'] == MESSAGE_EVENT:
event = CampaignEvent.create_message_event(org, user, campaign, relative_to,
event_spec['offset'],
event_spec['unit'],
event_spec['message'],
event_spec['delivery_hour'])
event.update_flow_name()
else:
flow = Flow.objects.filter(org=org, id=event_spec['flow']['id']).first()
if flow:
CampaignEvent.create_flow_event(org, user, campaign, relative_to,
event_spec['offset'],
event_spec['unit'],
flow,
event_spec['delivery_hour'])
# update our scheduled events for this campaign
EventFire.update_campaign_events(campaign)
def import_triggers(cls, org, user, trigger_defs, same_site=False):
"""
Import triggers from a list of exported triggers
"""
for trigger_def in trigger_defs:
# resolve our groups
groups = []
for group_spec in trigger_def[Trigger.EXPORT_GROUPS]:
group = None
if same_site: # pragma: needs cover
group = ContactGroup.user_groups.filter(org=org, uuid=group_spec["uuid"]).first()
if not group:
group = ContactGroup.get_user_group(org, group_spec["name"])
if not group:
group = ContactGroup.create_static(org, user, group_spec["name"]) # pragma: needs cover
if not group.is_active: # pragma: needs cover
group.is_active = True
group.save()
groups.append(group)
flow = Flow.objects.get(org=org, uuid=trigger_def[Trigger.EXPORT_FLOW]["uuid"], is_active=True)
# see if that trigger already exists
trigger = Trigger.objects.filter(org=org, trigger_type=trigger_def[Trigger.EXPORT_TYPE])
if trigger_def[Trigger.EXPORT_KEYWORD]:
trigger = trigger.filter(keyword__iexact=trigger_def[Trigger.EXPORT_KEYWORD])
if groups:
trigger = trigger.filter(groups__in=groups)
trigger = trigger.first()
if trigger:
trigger.is_archived = False
trigger.flow = flow
trigger.save()
else:
# if we have a channel resolve it
channel = trigger_def.get(Trigger.EXPORT_CHANNEL, None) # older exports won't have a channel
if channel:
channel = Channel.objects.filter(uuid=channel, org=org).first()
trigger = Trigger.objects.create(
org=org,
trigger_type=trigger_def[Trigger.EXPORT_TYPE],
keyword=trigger_def[Trigger.EXPORT_KEYWORD],
flow=flow,
created_by=user,
modified_by=user,
channel=channel,
)
for group in groups:
trigger.groups.add(group)
def import_campaigns(cls, org, user, campaign_defs, same_site=False):
"""
Import campaigns from a list of exported campaigns
"""
for campaign_def in campaign_defs:
name = campaign_def[Campaign.EXPORT_NAME]
campaign = None
group = None
# first check if we have the objects by UUID
if same_site:
group = ContactGroup.user_groups.filter(
uuid=campaign_def[Campaign.EXPORT_GROUP]["uuid"],
org=org).first()
if group: # pragma: needs cover
group.name = campaign_def[Campaign.EXPORT_GROUP]["name"]
group.save()
campaign = Campaign.objects.filter(
org=org, uuid=campaign_def[Campaign.EXPORT_UUID]).first()
if campaign: # pragma: needs cover
campaign.name = Campaign.get_unique_name(org,
name,
ignore=campaign)
campaign.save()
# fall back to lookups by name
if not group:
group = ContactGroup.get_user_group(
org, campaign_def[Campaign.EXPORT_GROUP]["name"])
if not campaign:
campaign = Campaign.objects.filter(org=org, name=name).first()
# all else fails, create the objects from scratch
if not group:
group = ContactGroup.create_static(
org, user, campaign_def[Campaign.EXPORT_GROUP]["name"])
if not campaign:
campaign_name = Campaign.get_unique_name(org, name)
campaign = Campaign.create(org, user, campaign_name, group)
else:
campaign.group = group
campaign.save()
# deactivate all of our events, we'll recreate these
for event in campaign.events.all():
event.release()
# fill our campaign with events
for event_spec in campaign_def[Campaign.EXPORT_EVENTS]:
field_key = event_spec["relative_to"]["key"]
if field_key == "created_on":
relative_to = ContactField.system_fields.filter(
org=org, key=field_key).first()
else:
relative_to = ContactField.get_or_create(
org,
user,
key=field_key,
label=event_spec["relative_to"]["label"],
value_type="D")
start_mode = event_spec.get("start_mode",
CampaignEvent.MODE_INTERRUPT)
# create our message flow for message events
if event_spec["event_type"] == CampaignEvent.TYPE_MESSAGE:
message = event_spec["message"]
base_language = event_spec.get("base_language")
if not isinstance(message, dict):
try:
message = json.loads(message)
except ValueError:
# if it's not a language dict, turn it into one
message = dict(base=message)
base_language = "base"
event = CampaignEvent.create_message_event(
org,
user,
campaign,
relative_to,
event_spec["offset"],
event_spec["unit"],
message,
event_spec["delivery_hour"],
base_language=base_language,
start_mode=start_mode,
)
event.update_flow_name()
else:
flow = Flow.objects.filter(
org=org,
is_active=True,
is_system=False,
uuid=event_spec["flow"]["uuid"]).first()
if flow:
CampaignEvent.create_flow_event(
org,
user,
campaign,
relative_to,
event_spec["offset"],
event_spec["unit"],
flow,
event_spec["delivery_hour"],
start_mode=start_mode,
)
# update our scheduled events for this campaign
EventFire.update_campaign_events(campaign)
