def post(self, request, *args, **kwargs):
rule_form_valid = self.rule_form.is_valid()
criteria_form_valid = self.criteria_form.is_valid()
actions_form_valid = self.actions_form.is_valid()
if self.read_only_mode:
# Don't allow making changes to rules that have custom
# criteria/actions unless the user has permission to
return HttpResponseBadRequest()
if rule_form_valid and criteria_form_valid and actions_form_valid:
if not self.is_system_admin and (
self.criteria_form.requires_system_admin_to_save or
self.actions_form.requires_system_admin_to_save
):
# Don't allow adding custom criteria/actions to rules
# unless the user has permission to
return HttpResponseBadRequest()
with transaction.atomic():
if self.initial_rule:
rule = self.initial_rule
else:
rule = AutomaticUpdateRule(
domain=self.domain,
active=True,
workflow=AutomaticUpdateRule.WORKFLOW_CASE_UPDATE,
)
rule.name = self.rule_form.cleaned_data['name']
self.criteria_form.save_criteria(rule)
self.actions_form.save_actions(rule)
return HttpResponseRedirect(reverse(AutomaticUpdateRuleListView.urlname, args=[self.domain]))
return self.get(request, *args, **kwargs)
def post(self, request, *args, **kwargs):
rule_form_valid = self.rule_form.is_valid()
criteria_form_valid = self.criteria_form.is_valid()
actions_form_valid = self.actions_form.is_valid()
if self.read_only_mode:
# Don't allow making changes to rules that have custom
# criteria/actions unless the user has permission to
return HttpResponseBadRequest()
if rule_form_valid and criteria_form_valid and actions_form_valid:
if not self.is_system_admin and (
self.criteria_form.requires_system_admin_to_save or
self.actions_form.requires_system_admin_to_save
):
# Don't allow adding custom criteria/actions to rules
# unless the user has permission to
return HttpResponseBadRequest()
with transaction.atomic():
if self.initial_rule:
rule = self.initial_rule
else:
rule = AutomaticUpdateRule(
domain=self.domain,
active=True,
workflow=AutomaticUpdateRule.WORKFLOW_CASE_UPDATE,
)
rule.name = self.rule_form.cleaned_data['name']
self.criteria_form.save_criteria(rule)
self.actions_form.save_actions(rule)
return HttpResponseRedirect(reverse(AutomaticUpdateRuleListView.urlname, args=[self.domain]))
return self.get(request, *args, **kwargs)
def post(self, request, *args, **kwargs):
if self.async_response is not None:
return self.async_response
basic_info_form_valid = self.basic_info_form.is_valid()
criteria_form_valid = self.criteria_form.is_valid()
schedule_form_valid = self.schedule_form.is_valid()
if self.read_only_mode:
# Don't allow making changes to rules that have custom
# criteria/actions unless the user has permission to
return HttpResponseBadRequest()
if basic_info_form_valid and criteria_form_valid and schedule_form_valid:
if not self.is_system_admin and (
self.criteria_form.requires_system_admin_to_save or
self.schedule_form.requires_system_admin_to_save
):
# Don't allow adding custom criteria/actions to rules
# unless the user has permission to
return HttpResponseBadRequest()
if not self.can_use_inbound_sms and self.schedule_form.uses_sms_survey:
return HttpResponseBadRequest(
"Cannot create or edit survey reminders because subscription "
"does not have access to inbound SMS"
)
with transaction.atomic():
if self.rule:
rule = self.rule
else:
rule = AutomaticUpdateRule(
domain=self.domain,
active=True,
workflow=AutomaticUpdateRule.WORKFLOW_SCHEDULING,
)
rule.name = self.basic_info_form.cleaned_data['name']
self.criteria_form.save_criteria(rule)
self.schedule_form.save_rule_action_and_schedule(rule)
if not (
self.new_reminders_migrator and
self.schedule_form.cleaned_data['skip_running_rule_post_save']
):
initiate_messaging_rule_run(rule.domain, rule.pk)
return HttpResponseRedirect(reverse(ConditionalAlertListView.urlname, args=[self.domain]))
return self.get(request, *args, **kwargs)
def post(self, request, *args, **kwargs):
if self.async_response is not None:
return self.async_response
basic_info_form_valid = self.basic_info_form.is_valid()
criteria_form_valid = self.criteria_form.is_valid()
schedule_form_valid = self.schedule_form.is_valid()
if self.read_only_mode:
# Don't allow making changes to rules that have custom
# criteria/actions unless the user has permission to
return HttpResponseBadRequest()
if basic_info_form_valid and criteria_form_valid and schedule_form_valid:
if not self.is_system_admin and (
self.criteria_form.requires_system_admin_to_save or
self.schedule_form.requires_system_admin_to_save
):
# Don't allow adding custom criteria/actions to rules
# unless the user has permission to
return HttpResponseBadRequest()
if not self.can_use_inbound_sms and self.schedule_form.uses_sms_survey:
return HttpResponseBadRequest(
"Cannot create or edit survey reminders because subscription "
"does not have access to inbound SMS"
)
with transaction.atomic():
if self.rule:
rule = self.rule
else:
rule = AutomaticUpdateRule(
domain=self.domain,
active=True,
workflow=AutomaticUpdateRule.WORKFLOW_SCHEDULING,
)
rule.name = self.basic_info_form.cleaned_data['name']
self.criteria_form.save_criteria(rule)
self.schedule_form.save_rule_action_and_schedule(rule)
initiate_messaging_rule_run(rule.domain, rule.pk)
return HttpResponseRedirect(reverse(ConditionalAlertListView.urlname, args=[self.domain]))
return self.get(request, *args, **kwargs)
def update_auto_update_rules(domain_link):
if domain_link.is_remote:
upstream_rules = remote_get_auto_update_rules(domain_link)
else:
upstream_rules = local_get_auto_update_rules(domain_link.master_domain)
downstream_rules = AutomaticUpdateRule.by_domain(
domain_link.linked_domain,
AutomaticUpdateRule.WORKFLOW_CASE_UPDATE,
active_only=False
)
for upstream_rule_def in upstream_rules:
# Grab local rule by upstream ID (preferred) or by name
try:
downstream_rule = downstream_rules.get(upstream_id=upstream_rule_def['rule']['id'])
except AutomaticUpdateRule.DoesNotExist:
try:
downstream_rule = downstream_rules.get(name=upstream_rule_def['rule']['name'])
except AutomaticUpdateRule.MultipleObjectsReturned:
# If there are multiple rules with the same name, overwrite the first.
downstream_rule = downstream_rules.filter(name=upstream_rule_def['rule']['name']).first()
except AutomaticUpdateRule.DoesNotExist:
downstream_rule = None
# If no corresponding local rule, make a new rule
if not downstream_rule:
downstream_rule = AutomaticUpdateRule(
domain=domain_link.linked_domain,
active=upstream_rule_def['rule']['active'],
workflow=AutomaticUpdateRule.WORKFLOW_CASE_UPDATE,
upstream_id=upstream_rule_def['rule']['id']
)
# Copy all the contents from old rule to new rule
with transaction.atomic():
downstream_rule.name = upstream_rule_def['rule']['name']
downstream_rule.case_type = upstream_rule_def['rule']['case_type']
downstream_rule.filter_on_server_modified = upstream_rule_def['rule']['filter_on_server_modified']
downstream_rule.server_modified_boundary = upstream_rule_def['rule']['server_modified_boundary']
downstream_rule.active = upstream_rule_def['rule']['active']
downstream_rule.save()
downstream_rule.delete_criteria()
downstream_rule.delete_actions()
# Largely from data_interfaces/forms.py - save_criteria()
for criteria in upstream_rule_def['criteria']:
definition = None
if criteria['match_property_definition']:
definition = MatchPropertyDefinition.objects.create(
property_name=criteria['match_property_definition']['property_name'],
property_value=criteria['match_property_definition']['property_value'],
match_type=criteria['match_property_definition']['match_type'],
)
elif criteria['custom_match_definition']:
definition = CustomMatchDefinition.objects.create(
name=criteria['custom_match_definition']['name'],
)
elif criteria['closed_parent_definition']:
definition = ClosedParentDefinition.objects.create()
new_criteria = CaseRuleCriteria(rule=downstream_rule)
new_criteria.definition = definition
new_criteria.save()
# Largely from data_interfacees/forms.py - save_actions()
for action in upstream_rule_def['actions']:
definition = None
if action['update_case_definition']:
definition = UpdateCaseDefinition(close_case=action['update_case_definition']['close_case'])
properties = []
for propertyItem in action['update_case_definition']['properties_to_update']:
properties.append(
UpdateCaseDefinition.PropertyDefinition(
name=propertyItem['name'],
value_type=propertyItem['value_type'],
value=propertyItem['value'],
)
)
definition.set_properties_to_update(properties)
definition.save()
elif action['custom_action_definition']:
definition = CustomActionDefinition.objects.create(
name=action['custom_action_definition']['name'],
)
action = CaseRuleAction(rule=downstream_rule)
action.definition = definition
action.save()
