def test_get_repeat_records_by_payload_id(self):
id_1_records = list(get_repeat_records_by_payload_id(self.domain, self.payload_id_1))
self.assertEqual(len(id_1_records), 2)
self.assertItemsEqual([r._id for r in id_1_records], [r._id for r in self.records[0:2]])
id_2_records = list(get_repeat_records_by_payload_id(self.domain, self.payload_id_2))
self.assertEqual(len(id_2_records), 4)
self.assertItemsEqual([r._id for r in id_2_records], [r._id for r in self.records[2:6]])
def find_missing_form_repeat_records_for_form(form, domain, repeaters, enddate,
should_create):
if form.is_duplicate:
return 0, 0
missing_count = 0
successful_count = 0
repeat_records = get_repeat_records_by_payload_id(domain, form.get_id)
triggered_repeater_ids = [record.repeater_id for record in repeat_records]
for repeater in repeaters:
if not repeater.allowed_to_forward(form):
continue
if repeater.started_at.date() >= enddate:
# don't count a repeater that was created after the window we care about
continue
if repeater.get_id in triggered_repeater_ids:
successful_count += 1
else:
missing_count += 1
if should_create:
logger.info(
f"Registering form {form.get_id} for repeater {repeater.get_id}"
)
repeater.register(form)
else:
logger.info(
f"Missing form {form.get_id} for repeater {repeater.get_id}"
)
return missing_count, successful_count
def _get_voucher_repeat_records(self, voucher_id):
repeat_records = get_repeat_records_by_payload_id(
self.domain, voucher_id)
return [
r for r in repeat_records
if r.repeater_id in self._get_voucher_repeater_ids()
]
def queued_payload(domain, payload_id):
records = get_repeat_records_by_payload_id(domain, payload_id)
for record in records:
if record.state in [RECORD_FAILURE_STATE, RECORD_PENDING_STATE]:
# these states are "queued", i.e. they will send the latest version
# of the payload at some point in the future
return True
def _get_all_records_by_payload(self):
# It is assumed that there are relatively few repeat records for a given payload,
# so this is just filtered in memory. If that changes, we should filter in the db.
return [
r for r in get_repeat_records_by_payload_id(self.domain, self.payload_id)
if (not self.repeater_id or r.repeater_id == self.repeater_id)
and (not self.state or r.state == self.state)
]
def _get_all_records_by_payload(self):
# It is assumed that there are relatively few repeat records for a given payload,
# so this is just filtered in memory. If that changes, we should filter in the db.
return [
r for r in get_repeat_records_by_payload_id(self.domain, self.payload_id)
if (not self.repeater_id or r.repeater_id == self.repeater_id)
and (not self.state or r.state == self.state)
]
def _get_repeat_record_ids(
payload_id: Optional[str],
repeater_id: Optional[str],
domain: str,
) -> List[str]:
if not payload_id and not repeater_id:
return []
if payload_id:
results = get_repeat_records_by_payload_id(domain, payload_id)
else:
results = iter_repeat_records_by_repeater(domain, repeater_id)
ids = [x['id'] for x in results]
return ids
def _get_ids(data, domain):
if not data:
return []
if data.get('payload_id', None):
results = get_repeat_records_by_payload_id(domain, data['payload_id'])
else:
from corehq.motech.repeaters.models import RepeatRecord
kwargs = {
'include_docs': True,
'reduce': False,
'descending': True,
}
kwargs.update(_get_startkey_endkey_all_records(domain, data['repeater']))
results = RepeatRecord.get_db().view('repeaters/repeat_records', **kwargs).all()
ids = [x['id'] for x in results]
return ids
def find_missing_repeat_records_in_domain(domain, repeaters, payload, enddate,
should_create):
"""
Generic method to obtain repeat records (used for Locations, Users)
NOTE: Assumes the payload passed in was modified since the startdate
"""
missing_count = 0
repeat_records = get_repeat_records_by_payload_id(domain, payload.get_id)
records_since_last_modified_date = [
record for record in repeat_records
if record.registered_on.date() >= payload.last_modified.date()
]
fired_repeater_ids_and_counts = defaultdict(int)
for record in records_since_last_modified_date:
fired_repeater_ids_and_counts[record.repeater_id] += 1
for repeater in repeaters:
if repeater.started_at.date() >= enddate:
# don't count a repeater that was created after the outage
continue
if fired_repeater_ids_and_counts.get(repeater.get_id, 0) > 0:
# no need to trigger a repeater if it has fired since startdate
continue
# if we've made it this far, the repeater should have fired
missing_count += 1
if should_create:
logger.info(
f"Registering {type(payload)} {payload.get_id} for repeater {repeater.get_id}"
)
repeater.register(payload)
else:
logger.info(
f"Missing {type(payload)} {payload.get_id} for repeater {repeater.get_id}"
)
return missing_count
def _find_fowarding_attempts(episode_id):
return get_repeat_records_by_payload_id(DOMAIN, episode_id)
