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 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 _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_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)
