def get_all_rows(self):
repeater_id = self.request.GET.get('repeater', None)
state = self.request.GET.get('record_state', None)
if self.is_rendered_as_email:
same_time_yesterday = datetime.today() - timedelta(days=1)
return [
[
get_repeat_record_count(self.domain, repeater_id, "SUCCESS"),
get_repeat_record_count(self.domain, repeater_id, "SUCCESS", same_time_yesterday),
get_repeat_record_count(self.domain, repeater_id, "CANCELLED"),
get_repeat_record_count(self.domain, repeater_id, "CANCELLED", same_time_yesterday),
]
]
return [self._make_row(record) for record in
iter_repeat_records_by_domain(self.domain, repeater_id=repeater_id, state=state)]
def handle(self, *args, **options):
domain = options.get('domain')
repeater_id = options.get('repeater_id')
state = options.get('state')
records_file_path = options.get('records_file_path')
if records_file_path:
self._load_record_ids_from_file(records_file_path)
records = self.record_ids
record_count = len(records)
elif domain and repeater_id:
records = iter_repeat_records_by_domain(domain,
repeater_id=repeater_id,
state=state)
record_count = get_repeat_record_count(domain,
repeater_id=repeater_id,
state=state)
else:
raise CommandError("Insufficient Arguments")
for record in with_progress_bar(records, length=record_count):
if isinstance(record, str):
record_id = record
try:
record = RepeatRecord.get(record_id)
except ResourceNotFound:
self.ws.append([record_id, '', 'Not Found'])
continue
self._add_row(record)
file_name = self._save_file(repeater_id, state)
print("Report saved in file:{filename}".format(filename=file_name))
def handle(self, *args, **options):
domain = options.get('domain')
repeater_id = options.get('repeater_id')
state = options.get('state')
records_file_path = options.get('records_file_path')
if records_file_path:
self._load_record_ids_from_file(records_file_path)
records = self.record_ids
record_count = len(records)
elif domain and repeater_id:
records = iter_repeat_records_by_domain(domain, repeater_id=repeater_id, state=state)
record_count = get_repeat_record_count(domain, repeater_id=repeater_id, state=state)
else:
raise CommandError("Insufficient Arguments")
for record in with_progress_bar(records, length=record_count):
if isinstance(record, str):
record_id = record
try:
record = RepeatRecord.get(record_id)
except ResourceNotFound:
self.ws.append([record_id, '', 'Not Found'])
continue
self._add_row(record)
file_name = self._save_file(repeater_id, state)
print("Report saved in file:{filename}".format(filename=file_name))
def report_context(self):
context = super(DomainForwardingRepeatRecords, self).report_context
total = get_repeat_record_count(self.domain, self.repeater_id)
total_cancel = get_pending_repeat_record_count(self.domain,
self.repeater_id)
total_requeue = get_cancelled_repeat_record_count(
self.domain, self.repeater_id)
form_query_string = self.request.GET.urlencode()
form_query_string_requeue = _change_record_state(
form_query_string, 'CANCELLED')
form_query_string_cancellable = _change_record_state(
form_query_string, 'PENDING')
context.update(
email_bulk_payload_form=EmailBulkPayload(domain=self.domain),
total=total,
total_cancel=total_cancel,
total_requeue=total_requeue,
form_query_string=form_query_string,
form_query_string_cancellable=form_query_string_cancellable,
form_query_string_requeue=form_query_string_requeue,
)
return context
def reconcile_repeat_records(self, voucher_updates):
"""
Mark updated records as "succeeded", all others as "cancelled"
Delete duplicate records if any exist
"""
print "Reconciling repeat records"
chemist_voucher_repeater_id = 'be435d3f407bfb1016cc89ebbf8146b1'
lab_voucher_repeater_id = 'be435d3f407bfb1016cc89ebbfc42a47'
already_seen = set()
updates_by_voucher_id = {update.id: update for update in voucher_updates}
headers = ['record_id', 'voucher_id', 'status']
rows = []
get_db = (lambda: IterDB(RepeatRecord.get_db())) if self.commit else MagicMock
with get_db() as iter_db:
for repeater_id in [chemist_voucher_repeater_id, lab_voucher_repeater_id]:
print "repeater {}".format(repeater_id)
records = iter_repeat_records_by_domain(self.domain, repeater_id=repeater_id)
record_count = get_repeat_record_count(self.domain, repeater_id=repeater_id)
for record in with_progress_bar(records, record_count):
if record.payload_id in already_seen:
status = "deleted"
iter_db.delete(record)
elif record.payload_id in updates_by_voucher_id:
# add successful attempt
status = "succeeded"
attempt = RepeatRecordAttempt(
cancelled=False,
datetime=datetime.datetime.utcnow(),
failure_reason=None,
success_response="Paid offline via import_voucher_confirmations",
next_check=None,
succeeded=True,
)
record.add_attempt(attempt)
iter_db.save(record)
else:
# mark record as canceled
record.add_attempt(RepeatRecordAttempt(
cancelled=True,
datetime=datetime.datetime.utcnow(),
failure_reason="Cancelled during import_voucher_confirmations",
success_response=None,
next_check=None,
succeeded=False,
))
iter_db.save(record)
already_seen.add(record.payload_id)
rows.append([record._id, record.payload_id, status])
self.write_csv('repeat_records', headers, rows)
def create_repeat_records_on_dest_repeater(self, source_repeater_id,
dest_repeater_id, state):
dest_repeater = Repeater.get(dest_repeater_id)
retriggered = set()
records = iter_repeat_records_by_domain(domain,
repeater_id=source_repeater_id,
state=state)
record_count = get_repeat_record_count(domain,
repeater_id=source_repeater_id,
state=state)
accessor = CaseAccessors(domain)
print("Iterating over records and adding new record for them")
for record in with_progress_bar(records, length=record_count):
if record.payload_id in retriggered:
self.record_failure(record.get_id,
record.payload_id,
error_message="Already triggered")
continue
try:
episode = accessor.get_case(record.payload_id)
episode_case_properties = episode.dynamic_case_properties()
if (episode_case_properties.get('nikshay_registered', 'false')
== 'false' and episode_case_properties.get(
'private_nikshay_registered', 'false') == 'false'
and not episode_case_properties.get('nikshay_id')
and episode_case_properties.get('episode_type')
== 'confirmed_tb'
and is_valid_episode_submission(episode)):
new_record = RepeatRecord(
domain=domain,
next_check=datetime.utcnow(),
repeater_id=dest_repeater_id,
repeater_type=dest_repeater.doc_type,
payload_id=record.payload_id,
)
if not self.dry_run:
new_record.save()
retriggered.add(record.payload_id)
self.add_row(
record,
episode_case_properties.get('migration_created_case'),
new_record.get_id)
else:
self.record_failure(record.get_id,
record.payload_id,
error_message="Not to be re-triggered")
except Exception as e:
self.record_failure(record.get_id,
record.payload_id,
error_message="{error}: {message}".format(
error=e.__name__, message=e.message))
def handle(self, domain, **options):
# For all successful registration records
# If any have an attempt that id "A patient with this beneficiary_id already exists"
# Check the episode case. If this doesn't have "dots_99_registered" then set this property to "true"
self.commit = options['commit']
repeater_id = 'dc73c3da43d42acd964d80b287926833' # 99dots register
accessor = CaseAccessors(domain)
existing_message = "A patient with this beneficiary_id already exists"
count = get_repeat_record_count(domain, repeater_id, state="SUCCESS")
records = iter_repeat_records_by_domain(domain,
repeater_id,
state="SUCCESS")
cases_to_update = set()
print("Filtering successful cases")
for repeat_record in with_progress_bar(records, length=count):
if any((existing_message in
attempt.message if attempt.message is not None else "")
for attempt in repeat_record.attempts):
try:
episode = accessor.get_case(repeat_record.payload_id)
except CaseNotFound:
continue
if episode.get_case_property('dots_99_registered') != 'true':
cases_to_update.add(episode)
timestamp = datetime.utcnow().strftime("%Y-%m-%d-%H-%M-%S")
with open('{}_set_99dots_to_registered.csv'.format(timestamp),
'w') as f:
writer = csv.writer(f)
writer.writerow([
'beneficiary_id', 'episode_id', 'UpdatePatient Status',
'Adherence Status', 'TreatmentOutcome Status'
])
print("Updating {} successful cases in 99DOTS".format(
len(cases_to_update)))
for case in with_progress_bar(cases_to_update):
writer.writerow([
get_person_case_from_episode(domain, case.case_id).case_id,
case.case_id,
self.update_registered_status(domain, case),
self.update_patients(domain, case),
self.send_adherence(domain, case),
self.send_treatment_outcome(domain, case),
])
def report_context(self):
context = super(DomainForwardingRepeatRecords, self).report_context
total = get_repeat_record_count(self.domain, self.repeater_id)
total_pending = get_pending_repeat_record_count(
self.domain, self.repeater_id)
total_cancelled = get_cancelled_repeat_record_count(
self.domain, self.repeater_id)
form_query_string = self.request.GET.urlencode()
form_query_string_cancelled = _change_record_state(
self.request.GET, 'CANCELLED').urlencode()
form_query_string_pending = _change_record_state(
self.request.GET, 'PENDING').urlencode()
context.update(
total=total,
total_pending=total_pending,
total_cancelled=total_cancelled,
form_query_string=form_query_string,
form_query_string_pending=form_query_string_pending,
form_query_string_cancelled=form_query_string_cancelled,
)
return context
def test_get_paged_repeat_records_with_state_and_no_records(self):
count = get_repeat_record_count('wrong-domain', state=RECORD_PENDING_STATE)
self.assertEqual(count, 0)
def test_get_repeat_record_count_with_repeater_id_and_no_state(self):
count = get_repeat_record_count(self.domain, repeater_id=self.other_id)
self.assertEqual(count, 1)
def test_get_repeat_record_count_with_state_and_no_repeater(self):
count = get_repeat_record_count(self.domain, state=RECORD_PENDING_STATE)
self.assertEqual(count, 3)
def handle(self, domain, repeater_id, filename, **options):
accessor = CaseAccessors(domain)
records = iter_repeat_records_by_domain(domain, repeater_id=repeater_id)
record_count = get_repeat_record_count(domain, repeater_id=repeater_id)
row_names = [
'VoucherID',
'EventOccurDate',
'EventID',
'BeneficiaryUUID',
'BeneficiaryType',
'Location',
'Amount',
'DTOLocation',
'InvestigationType',
'PersonId',
'AgencyId',
'EnikshayApprover',
'EnikshayRole',
'EnikshayApprovalDate',
'Succeeded', # Some records did succeed when we sent them.
# Include this so they don't re-pay people.
]
seen_voucher_ids = set()
duplicate_voucher_ids = set()
errors = []
with open(filename, 'w') as f:
writer = csv.writer(f)
writer.writerow(row_names)
for record in with_progress_bar(records, length=record_count):
try:
payload = json.loads(record.get_payload())['voucher_details'][0]
voucher_id = record.payload_id
payload['Succeeded'] = record.succeeded
except Exception as e:
errors.append([record.payload_id, six.text_type(e)])
continue
if voucher_id in seen_voucher_ids:
duplicate_voucher_ids.add(voucher_id)
else:
seen_voucher_ids.add(voucher_id)
row = [
payload.get(name) if payload.get(name) is not None else ""
for name in row_names
]
writer.writerow(row)
print("{} duplicates found".format(len(duplicate_voucher_ids)))
if duplicate_voucher_ids:
with open('duplicates_{}'.format(filename), 'w') as f:
writer = csv.writer(f)
for duplicate_id in duplicate_voucher_ids:
writer.writerow([duplicate_id])
print("{} errors".format(len(errors)))
if errors:
with open('errors_{}'.format(filename), 'w') as f:
writer = csv.writer(f)
writer.writerow(['episode_id', 'error'])
for error in errors:
writer.writerow(errors)
def total_records(self):
if self.payload_id:
return len(self._get_all_records_by_payload())
else:
return get_repeat_record_count(self.domain, self.repeater_id,
self.state)
def handle(self, domain, repeater_id, filename, **options):
records = iter_repeat_records_by_domain(domain,
repeater_id=repeater_id)
record_count = get_repeat_record_count(domain, repeater_id=repeater_id)
row_names = [
'EpisodeID',
'EventOccurDate',
'EventID',
'BeneficiaryUUID',
'BeneficiaryType',
'Location',
'DTOLocation',
'PersonId',
'AgencyId',
'EnikshayApprover',
'EnikshayRole',
'EnikshayApprovalDate',
'Succeeded', # Some records did succeed when we sent them.
# Include this so they don't re-pay people.
]
errors = []
seen_incentive_ids = set()
duplicate_incentive_ids = set()
with open(filename, 'w') as f:
writer = csv.writer(f)
writer.writerow(row_names)
for record in with_progress_bar(records, length=record_count):
try:
payload = json.loads(
record.get_payload())['incentive_details'][0]
except Exception as e:
errors.append(
[record.payload_id, record._id,
six.text_type(e)])
continue
payload['Succeeded'] = record.succeeded
incentive_episode_pair = (
payload.get('EpisodeID'),
payload.get('EventID'),
)
if incentive_episode_pair in seen_incentive_ids:
duplicate_incentive_ids.add(incentive_episode_pair)
else:
seen_incentive_ids.add(incentive_episode_pair)
row = [payload.get(name) for name in row_names]
writer.writerow(row)
print("{} duplicates found".format(len(duplicate_incentive_ids)))
if duplicate_incentive_ids:
with open('duplicates_{}'.format(filename), 'w') as f:
writer = csv.writer(f)
writer.writerow(['episode_id', 'event_id'])
for duplicate_id in duplicate_incentive_ids:
writer.writerow(duplicate_id)
print("{} errors".format(len(errors)))
if errors:
with open('errors_{}'.format(filename), 'w') as f:
writer = csv.writer(f)
writer.writerow(['episode_id', 'repeat_record_id', 'error'])
for error in errors:
writer.writerow(error)
def total_records(self):
if self.payload_id:
return len(self._get_all_records_by_payload())
else:
return get_repeat_record_count(self.domain, self.repeater_id, self.state)
