def get_groups(cls, org, json_obj): # pragma: no cover
# for backwards compatibility
group_data = json_obj.get(AddToGroupAction.GROUP, None)
if not group_data:
group_data = json_obj.get(AddToGroupAction.GROUPS)
else:
group_data = [group_data]
groups = []
for g in group_data:
if isinstance(g, dict):
group_uuid = g.get("uuid", None)
group_name = g.get("name")
group = ContactGroup.get_or_create(org,
org.created_by,
group_name,
uuid=group_uuid)
groups.append(group)
else:
if g and g[0] == "@":
groups.append(g)
else: # pragma: needs cover
group = ContactGroup.get_user_group_by_name(org, g)
if group:
groups.append(group)
else:
groups.append(
ContactGroup.create_static(org, org.get_user(), g))
return groups
def test_serialize_group(self):
spammers = ContactGroup.create_static(self.org, self.admin, "Spammers")
self.assertEqual(serialize_group(spammers), {
"uuid": str(spammers.uuid),
"name": "Spammers",
"query": None
})
def create_group(self, name, contacts=(), query=None, org=None):
assert not (contacts and query), "can't provide contact list for a dynamic group"
if query:
return ContactGroup.create_dynamic(org or self.org, self.user, name, query=query)
else:
group = ContactGroup.create_static(org or self.org, self.user, name)
if contacts:
group.contacts.add(*contacts)
return group
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 create_group(self, name, contacts=(), query=None):
if contacts and query:
raise ValueError("Can't provide contact list for a dynamic group")
if query:
return ContactGroup.create_dynamic(self.org, self.user, name, query=query)
else:
group = ContactGroup.create_static(self.org, self.user, name)
if contacts:
group.contacts.add(*contacts)
return group
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_by_name(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_]"): # 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 create_group(self, name, contacts=(), query=None):
if contacts and query:
raise ValueError("Can't provide contact list for a dynamic group")
if query:
return ContactGroup.create_dynamic(self.org, self.user, name, query=query)
else:
group = ContactGroup.create_static(self.org, self.user, name)
if contacts:
group.contacts.add(*contacts)
return group
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 _create_groups(self, count, base_names, contacts):
"""
Creates the given number of groups and fills them with contacts
"""
groups = []
num_bases = len(base_names)
for g in range(0, count):
name = '%s %d' % (base_names[g % num_bases], g + 1)
group = ContactGroup.create_static(self.org, self.user, name)
group.contacts.add(*contacts[(g % num_bases)::num_bases])
groups.append(ContactGroup.user_groups.get(pk=group.pk))
return groups
def create_groups(self, spec, org, user):
self._log(f"Creating {len(spec['groups'])} groups... ")
for g in spec["groups"]:
if g.get("query"):
group = ContactGroup.create_dynamic(org, user, g["name"], g["query"], evaluate=False)
else:
group = ContactGroup.create_static(org, user, g["name"])
group.uuid = g["uuid"]
group.save(update_fields=["uuid"])
self._log(self.style.SUCCESS("OK") + "\n")
def _create_groups(self, count, base_names, contacts):
"""
Creates the given number of groups and fills them with contacts
"""
groups = []
num_bases = len(base_names)
for g in range(0, count):
name = '%s %d' % (base_names[g % num_bases], g + 1)
group = ContactGroup.create_static(self.org, self.user, name)
group.contacts.add(*contacts[(g % num_bases)::num_bases])
groups.append(ContactGroup.user_groups.get(pk=group.pk))
return groups
def create_groups(self, orgs):
"""
Creates the contact groups for each org
"""
self._log("Creating %d groups... " % (len(orgs) * len(GROUPS)))
for org in orgs:
user = org.cache["users"][0]
for g in GROUPS:
if g["query"]:
group = ContactGroup.create_dynamic(org, user, g["name"], g["query"], evaluate=False)
else:
group = ContactGroup.create_static(org, user, g["name"])
group.member = g["member"]
group.count = 0
org.cache["groups"].append(group)
self._log(self.style.SUCCESS("OK") + "\n")
def create_groups(self, orgs):
"""
Creates the contact groups for each org
"""
self._log("Creating %d groups... " % (len(orgs) * len(GROUPS)))
for org in orgs:
user = org.cache["users"][0]
for g in GROUPS:
if g["query"]:
group = ContactGroup.create_dynamic(org, user, g["name"], g["query"], evaluate=False)
else:
group = ContactGroup.create_static(org, user, g["name"])
group.member = g["member"]
group.count = 0
org.cache["groups"].append(group)
self._log(self.style.SUCCESS("OK") + "\n")
def _resolve_import_groups(cls, org, user, same_site: bool, specs):
groups = []
for spec in specs:
group = None
if same_site: # pragma: needs cover
group = ContactGroup.user_groups.filter(org=org, uuid=spec["uuid"]).first()
if not group:
group = ContactGroup.get_user_group_by_name(org, spec["name"])
if not group:
group = ContactGroup.create_static(org, user, spec["name"]) # pragma: needs cover
if not group.is_active: # pragma: needs cover
group.is_active = True
group.save()
groups.append(group)
return groups
def import_campaigns(cls,
org,
user,
campaign_defs,
same_site=False) -> List:
"""
Import campaigns from a list of exported campaigns
"""
imported = []
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_by_name(
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,
)
imported.append(campaign)
return imported
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_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_by_name(
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_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 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 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_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(uuid=campaign_spec['group']['uuid'], org=org).first()
if group:
group.name = campaign_spec['group']['name']
group.save()
campaign = Campaign.objects.filter(org=org, uuid=campaign_spec['uuid']).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_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:
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, 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, pk=group_spec['id']).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, pk=trigger_spec['flow']['id'], 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(pk=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)
