def tearDown(self):
for rule in AutomaticUpdateRule.objects.filter(domain=self.domain):
rule.hard_delete()
for instance in run_query_across_partitioned_databases(
CaseAlertScheduleInstance, Q(domain=self.domain)):
delete_case_schedule_instance(instance)
for instance in run_query_across_partitioned_databases(
CaseTimedScheduleInstance, Q(domain=self.domain)):
delete_case_schedule_instance(instance)
for schedule in AlertSchedule.objects.filter(domain=self.domain):
for event in schedule.memoized_events:
event.content.delete()
event.delete()
schedule.delete()
for schedule in TimedSchedule.objects.filter(domain=self.domain):
for event in schedule.memoized_events:
event.content.delete()
event.delete()
schedule.delete()
def get_case_schedule_instances_for_domain(self, domain):
instances = list(
run_query_across_partitioned_databases(CaseAlertScheduleInstance,
Q(domain=domain)))
instances.extend(
run_query_across_partitioned_databases(CaseTimedScheduleInstance,
Q(domain=domain)))
return instances
def tearDown(self):
for rule in AutomaticUpdateRule.objects.filter(domain=self.domain):
rule.hard_delete()
for instance in run_query_across_partitioned_databases(CaseAlertScheduleInstance, Q(domain=self.domain)):
delete_case_schedule_instance(instance)
for instance in run_query_across_partitioned_databases(CaseTimedScheduleInstance, Q(domain=self.domain)):
delete_case_schedule_instance(instance)
delete_alert_schedules(self.domain)
delete_timed_schedules(self.domain)
def get_target_instances(self):
if isinstance(self.schedule, AlertSchedule):
return list(run_query_across_partitioned_databases(
self.get_alert_schedule_instance_class(),
Q(alert_schedule_id=self.schedule.schedule_id),
))
elif isinstance(self.schedule, TimedSchedule):
return list(run_query_across_partitioned_databases(
self.get_timed_schedule_instance_class(),
Q(timed_schedule_id=self.schedule.schedule_id),
))
else:
raise TypeError("Expected AlertSchedule or TimedSchedule")
def get_timed_schedule_instances_for_schedule(schedule):
from corehq.messaging.scheduling.models import TimedSchedule
from corehq.messaging.scheduling.scheduling_partitioned.models import TimedScheduleInstance
_validate_class(schedule, TimedSchedule)
return run_query_across_partitioned_databases(
TimedScheduleInstance, Q(timed_schedule_id=schedule.schedule_id))
def get_active_case_schedule_instance_ids(cls, due_before, due_after=None):
from corehq.messaging.scheduling.scheduling_partitioned.models import (
CaseAlertScheduleInstance,
CaseTimedScheduleInstance,
)
if cls not in (CaseAlertScheduleInstance, CaseTimedScheduleInstance):
raise TypeError(
"Expected CaseAlertScheduleInstance or CaseTimedScheduleInstance")
active_filter = Q(
active=True,
next_event_due__lte=due_before,
)
if due_after:
if due_before <= due_after:
raise ValueError("Expected due_before > due_after")
active_filter = active_filter & Q(next_event_due__gt=due_after)
for domain, case_id, schedule_instance_id, next_event_due in run_query_across_partitioned_databases(
cls,
active_filter,
values=[
'domain', 'case_id', 'schedule_instance_id', 'next_event_due'
]):
yield (domain, case_id, schedule_instance_id, next_event_due)
def get_active_schedule_instance_ids(cls, due_before, due_after=None):
from corehq.messaging.scheduling.scheduling_partitioned.models import (
AlertScheduleInstance,
TimedScheduleInstance,
)
if cls not in (AlertScheduleInstance, TimedScheduleInstance):
raise TypeError("Expected AlertScheduleInstance or TimedScheduleInstance")
active_filter = Q(
active=True,
next_event_due__lte=due_before,
)
if due_after:
if due_before <= due_after:
raise ValueError("Expected due_before > due_after")
active_filter = active_filter & Q(next_event_due__gt=due_after)
for domain, schedule_instance_id, next_event_due in run_query_across_partitioned_databases(
cls,
active_filter,
values=['domain', 'schedule_instance_id', 'next_event_due']
):
yield domain, schedule_instance_id, next_event_due
def _get_active_schedule_instance_ids(cls, start_timestamp, end_timestamp):
active_filter = Q(
active=True,
next_event_due__gt=start_timestamp,
next_event_due__lte=end_timestamp,
)
for schedule_instance_id in run_query_across_partitioned_databases(
cls, active_filter, values=['schedule_instance_id']):
yield schedule_instance_id
def get_timed_schedule_instances_for_schedule(schedule):
from corehq.messaging.scheduling.models import TimedSchedule
from corehq.messaging.scheduling.scheduling_partitioned.models import TimedScheduleInstance
_validate_class(schedule, TimedSchedule)
return run_query_across_partitioned_databases(
TimedScheduleInstance,
Q(timed_schedule_id=schedule.schedule_id)
)
def get_case_ids_for_messaging_rule(domain, case_type):
if not should_use_sql_backend(domain):
return CaseAccessors(domain).get_case_ids_in_domain(case_type)
else:
return run_query_across_partitioned_databases(
CommCareCaseSQL,
Q(domain=domain, type=case_type, deleted=False),
values=['case_id']
)
def get_case_ids_for_messaging_rule(domain, case_type):
if not should_use_sql_backend(domain):
return CaseAccessors(domain).get_case_ids_in_domain(case_type)
else:
return run_query_across_partitioned_databases(
CommCareCaseSQL,
Q(domain=domain, type=case_type, deleted=False),
values=['case_id']
)
def _get_case_ids_from_postgres(cls,
domain,
case_type,
boundary_date=None):
q_expression = Q(
domain=domain,
type=case_type,
closed=False,
deleted=False,
)
if boundary_date:
q_expression = q_expression & Q(
server_modified_on__lte=boundary_date)
return run_query_across_partitioned_databases(CommCareCaseSQL,
q_expression,
values=['case_id'])
def iter_form_ids_by_last_modified(start_datetime, end_datetime):
from corehq.sql_db.util import run_query_across_partitioned_databases
annotate = {
'last_modified': Greatest('received_on', 'edited_on', 'deleted_on'),
}
return run_query_across_partitioned_databases(
XFormInstanceSQL,
(Q(last_modified__gt=start_datetime, last_modified__lt=end_datetime) &
Q(state=F('state').bitand(XFormInstanceSQL.DELETED) +
F('state').bitand(XFormInstanceSQL.DEPRECATED) +
F('state').bitand(XFormInstanceSQL.DUPLICATE) +
F('state').bitand(XFormInstanceSQL.ERROR) +
F('state').bitand(XFormInstanceSQL.SUBMISSION_ERROR_LOG) +
F('state'))),
annotate=annotate,
values=['form_id'],
)
def iter_form_ids_by_last_modified(start_datetime, end_datetime):
from corehq.sql_db.util import run_query_across_partitioned_databases
annotate = {
'last_modified': Greatest('received_on', 'edited_on', 'deleted_on'),
}
return run_query_across_partitioned_databases(
XFormInstanceSQL,
(Q(last_modified__gt=start_datetime, last_modified__lt=end_datetime)
& Q(state=F('state').bitand(XFormInstanceSQL.DELETED) +
F('state').bitand(XFormInstanceSQL.DEPRECATED) +
F('state').bitand(XFormInstanceSQL.DUPLICATE) +
F('state').bitand(XFormInstanceSQL.ERROR) +
F('state').bitand(XFormInstanceSQL.SUBMISSION_ERROR_LOG) +
F('state'))),
annotate=annotate,
values=['form_id'],
)
def iter_forms_by_last_modified(start_datetime, end_datetime):
'''
Returns all forms that have been modified within a time range. The start date is
exclusive while the end date is inclusive (start_datetime, end_datetime].
NOTE: This does not include archived forms
:param start_datetime: The start date of which modified forms must be greater than
:param end_datetime: The end date of which modified forms must be less than or equal to
:returns: An iterator of XFormInstanceSQL objects
'''
from corehq.sql_db.util import run_query_across_partitioned_databases
annotate = {
'last_modified': Greatest('received_on', 'edited_on', 'deleted_on'),
}
return run_query_across_partitioned_databases(
XFormInstanceSQL,
Q(last_modified__gt=start_datetime),
annotate=annotate,
)
def _get_all_ledger_transactions(self, q_):
return list(run_query_across_partitioned_databases(LedgerTransaction, q_))
def _get_all_ledger_transactions(self, q_):
return list(
run_query_across_partitioned_databases(LedgerTransaction, q_))
def get_case_schedule_instances_for_domain(self, domain):
instances = list(run_query_across_partitioned_databases(CaseAlertScheduleInstance, Q(domain=domain)))
instances.extend(run_query_across_partitioned_databases(CaseTimedScheduleInstance, Q(domain=domain)))
return instances
