def testCaseLookupTypeCheck(self):
case = CommCareCase(domain=self.domain, type='nonmatch-type')
case.save()
self.assertEqual(1, len(get_case_ids_in_domain(self.domain)))
config = self._config(self.default_headers)
file = MockExcelFile(header_columns=self.default_headers, num_rows=3,
row_generator=id_match_generator(case._id))
res = do_import(file, config, self.domain)
# because the type is wrong these shouldn't match
self.assertEqual(3, res['created_count'])
self.assertEqual(0, res['match_count'])
self.assertEqual(4, len(get_case_ids_in_domain(self.domain)))
def handle(self, *args, **options):
with open('bihar_case_cleanup.csv', 'wb') as f:
csv_file = csv.writer(f)
csv_file.writerow(CaseRow.headers)
blank_case_ids = get_case_ids_in_domain('care-bihar',
type=('', None))
task_case_ids = get_case_ids_in_domain('care-bihar', type='task')
case_ids = set(blank_case_ids) | set(task_case_ids)
to_save = []
logger.info("Total cases to process: {}".format(len(case_ids)))
for i, doc in enumerate(iter_docs(CommCareCase.get_db(), case_ids)):
case = CommCareCase.wrap(doc)
if case.type and case.type != "task":
continue
parent = None
if case.indices:
parent_id = case.indices[0].referenced_id
try:
parent = CommCareCase.get(parent_id)
except ResourceNotFound:
parent = MissingParent(get_id=parent_id, owner_id='Parent Missing')
case_row = CaseRow(case, parent)
if case.type != 'task':
if case.user_id == MOTECH_ID:
case_row.update_type('task')
if parent and not isinstance(parent, MissingParent) and parent.owner_id != case.owner_id:
case_row.update_owner(parent.owner_id)
if case_row.save:
csv_file.writerow(case_row.to_row())
to_save.append(case_row.case)
if len(to_save) > 100:
CommCareCase.get_db().bulk_save(to_save)
to_save = []
if i % 100 == 0:
logger.info("{current}/{count} cases completed".format(current=i, count=len(case_ids)))
if to_save:
CommCareCase.get_db().bulk_save(to_save)
def _get_cases(self):
case_ids = get_case_ids_in_domain(self.domain)
return CommCareCase.view(
'_all_docs',
keys=case_ids,
include_docs=True,
)
def update_indicators_for_case_type(self, case_type, domain):
print "\n\n\nFetching %s cases in domain %s...." % (case_type, domain)
relevant_indicators = CaseIndicatorDefinition.get_all(
namespace=MVP.NAMESPACE, domain=domain, case_type=case_type
)
if relevant_indicators:
num_cases = get_number_of_cases_in_domain(domain, type=case_type)
print ("\nFound the following Case Indicator Definitions " "for Case Type %s in Domain %s") % (
case_type,
domain,
)
print "--%s\n" % "\n--".join([i.slug for i in relevant_indicators])
print "Found %d possible cases for update." % num_cases
case_ids = get_case_ids_in_domain(domain, type=case_type)
self._throttle_updates(
"Cases of type %s in %s" % (case_type, domain),
relevant_indicators,
num_cases,
domain,
case_ids,
CommCareCase,
)
def testImportNamedColumns(self):
config = self._config(self.default_headers, named_columns=True)
file = MockExcelFile(header_columns=self.default_headers, num_rows=5)
res = do_import(file, config, self.domain)
# we create 1 less since we knock off the header column
self.assertEqual(4, res['created_count'])
self.assertEqual(4, len(get_case_ids_in_domain(self.domain)))
def handle_one(self, domain, case_type, chunk_size):
self.log('Copying {case_type} cases in {domain}'
.format(case_type=case_type, domain=domain))
old_db = CommCareCase.get_db()
new_db = IndicatorCase.get_db()
assert old_db.uri != new_db.uri
# this dbaccessor pulls from old_db
case_ids = get_case_ids_in_domain(domain, case_type)
self.delete_bad_doc_types(case_ids, chunk_size)
case_dict_chunks = chunked(iter_docs(old_db, case_ids, chunk_size),
chunk_size)
for case_dicts in case_dict_chunks:
for case_dict in case_dicts:
del case_dict['_rev']
case_dict.pop('_attachments', None)
case_dict['doc_type'] = "IndicatorCase"
try:
results = new_db.bulk_save(case_dicts)
except BulkSaveError as error:
results = error.results
for result in results:
if result.get('error') == 'conflict':
self.log('- OK: [{id}] is already in the indicator db'
.format(id=result.get('id')))
elif 'error' in result:
self.log('- ERROR: [{id}] ({result})'.format(
id=result.get('id'),
result=json.dumps(result)
))
else:
self.log('- ADDED: [{id}] saved to indicator db'.format(
id=result.get('id')
))
def testImportNone(self, update_state):
res = bulk_import_async.delay(self._config(['anything']), self.domain, None)
self.assertIsInstance(res.result, Ignore)
update_state.assert_called_with(
state=states.FAILURE,
meta={'errors': 'Sorry, your session has expired. Please start over and try again.'})
self.assertEqual(0, len(get_case_ids_in_domain(self.domain)))
def testBasicChunking(self):
config = self._config(self.default_headers)
file = MockExcelFile(header_columns=self.default_headers, num_rows=5)
res = do_import(file, config, self.domain, chunksize=2)
# 5 cases in chunks of 2 = 3 chunks
self.assertEqual(3, res['num_chunks'])
self.assertEqual(5, res['created_count'])
self.assertEqual(5, len(get_case_ids_in_domain(self.domain)))
def testNoCreateNew(self):
config = self._config(self.default_headers, create_new_cases=False)
file = MockExcelFile(header_columns=self.default_headers, num_rows=5)
res = do_import(file, config, self.domain)
# no matching and no create new set - should do nothing
self.assertEqual(0, res['created_count'])
self.assertEqual(0, res['match_count'])
self.assertEqual(0, len(get_case_ids_in_domain(self.domain)))
def testExternalIdMatching(self):
# bootstrap a stub case
case = CommCareCase(domain=self.domain, type=self.default_case_type)
external_id = 'importer-test-external-id'
case.external_id = external_id
case.save()
self.assertEqual(1, len(get_case_ids_in_domain(self.domain)))
headers = ['external_id', 'age', 'sex', 'location']
config = self._config(headers, search_field='external_id')
file = MockExcelFile(header_columns=headers, num_rows=3,
row_generator=id_match_generator(external_id))
res = do_import(file, config, self.domain)
self.assertEqual(0, res['created_count'])
self.assertEqual(3, res['match_count'])
self.assertFalse(res['errors'])
# shouldn't create any more cases, just the one
self.assertEqual(1, len(get_case_ids_in_domain(self.domain)))
def update_schedule_case_properties():
"""
Iterate through all pact patient cases in the domain and set schedule case properties if necessary.
"""
case_ids = get_case_ids_in_domain("pact", "cc_path_client")
# this is intentionally not user iter_docs since pact cases are *huge* and we want to use
# get_lite and only load one at a time.
for case_id in case_ids:
case = PactPatientCase.get_lite(case_id)
set_schedule_case_properties(case)
def print_stats(self, domain, short=True, diffs_only=False):
status = get_couch_sql_migration_status(domain)
print("Couch to SQL migration status for {}: {}".format(domain, status))
db = get_diff_db(domain)
try:
diff_stats = db.get_diff_stats()
except OperationalError:
diff_stats = {}
has_diffs = False
for doc_type in doc_types():
form_ids_in_couch = set(get_form_ids_by_type(domain, doc_type))
form_ids_in_sql = set(FormAccessorSQL.get_form_ids_in_domain_by_type(domain, doc_type))
diff_count, num_docs_with_diffs = diff_stats.pop(doc_type, (0, 0))
has_diffs |= self._print_status(
doc_type, form_ids_in_couch, form_ids_in_sql, diff_count, num_docs_with_diffs, short, diffs_only
)
form_ids_in_couch = set(get_doc_ids_in_domain_by_type(
domain, "XFormInstance-Deleted", XFormInstance.get_db())
)
form_ids_in_sql = set(FormAccessorSQL.get_deleted_form_ids_in_domain(domain))
diff_count, num_docs_with_diffs = diff_stats.pop("XFormInstance-Deleted", (0, 0))
has_diffs |= self._print_status(
"XFormInstance-Deleted", form_ids_in_couch, form_ids_in_sql,
diff_count, num_docs_with_diffs, short, diffs_only
)
case_ids_in_couch = set(get_case_ids_in_domain(domain))
case_ids_in_sql = set(CaseAccessorSQL.get_case_ids_in_domain(domain))
diff_count, num_docs_with_diffs = diff_stats.pop("CommCareCase", (0, 0))
has_diffs |= self._print_status(
'CommCareCase', case_ids_in_couch, case_ids_in_sql, diff_count, num_docs_with_diffs, short, diffs_only
)
case_ids_in_couch = set(get_doc_ids_in_domain_by_type(
domain, "CommCareCase-Deleted", XFormInstance.get_db())
)
case_ids_in_sql = set(CaseAccessorSQL.get_deleted_case_ids_in_domain(domain))
diff_count, num_docs_with_diffs = diff_stats.pop("CommCareCase-Deleted", (0, 0))
has_diffs |= self._print_status(
'CommCareCase-Deleted', case_ids_in_couch, case_ids_in_sql,
diff_count, num_docs_with_diffs, short, diffs_only
)
if diff_stats:
for key, counts in diff_stats.items():
diff_count, num_docs_with_diffs = counts
has_diffs |= self._print_status(
key, set(), set(), diff_count, num_docs_with_diffs, short, diffs_only
)
if diffs_only and not has_diffs:
print(shell_green("No differences found between old and new docs!"))
return has_diffs
def testImportTrailingWhitespace(self):
cols = ['case_id', 'age', u'sex\xa0', 'location']
config = self._config(cols, named_columns=True)
file = MockExcelFile(header_columns=cols, num_rows=2)
res = do_import(file, config, self.domain)
# we create 1 less since we knock off the header column
self.assertEqual(1, res['created_count'])
case_ids = get_case_ids_in_domain(self.domain)
self.assertEqual(1, len(case_ids))
case = CommCareCase.get(case_ids[0])
self.assertTrue(bool(case.sex)) # make sure the value also got properly set
def get_all(self):
status = self.status or CASE_STATUS_ALL
if status == CASE_STATUS_ALL:
case_ids = get_case_ids_in_domain(self.domain, type=self.case_type)
elif status == CASE_STATUS_OPEN:
case_ids = get_open_case_ids_in_domain(self.domain, type=self.case_type)
elif status == CASE_STATUS_CLOSED:
_assert = soft_assert('@'.join(['droberts', 'dimagi.com']))
_assert(False, "I'm surprised CaseAPIHelper "
"ever gets called with status=closed")
# this is rare so we don't care if it requires two calls to get
# all the ids
case_ids = (
set(get_case_ids_in_domain(self.domain, type=self.case_type))
- set(get_open_case_ids_in_domain(self.domain, type=self.case_type))
)
else:
raise ValueError("Invalid value for 'status': '%s'" % status)
return self._case_results(case_ids)
def handle(self, domain, reason, **options):
if should_use_sql_backend(domain):
raise CommandError('This command only works for couch-based domains.')
ids = get_case_ids_in_domain(domain)
for count, case_id in enumerate(ids):
try:
rebuild_case_from_forms(domain, case_id, RebuildWithReason(reason=reason))
if count % 100 == 0:
print('rebuilt %s/%s cases' % (count, len(ids)))
except Exception as e:
logging.exception("couldn't rebuild case {id}. {msg}".format(id=case_id, msg=str(e)))
def testCaseIdMatching(self):
# bootstrap a stub case
case = CommCareCase(domain=self.domain, type=self.default_case_type)
case.importer_test_prop = 'foo'
case.save()
self.assertEqual(1, len(get_case_ids_in_domain(self.domain)))
config = self._config(self.default_headers)
file = MockExcelFile(header_columns=self.default_headers, num_rows=3, row_generator=id_match_generator(case._id))
res = do_import(file, config, self.domain)
self.assertEqual(0, res['created_count'])
self.assertEqual(3, res['match_count'])
self.assertFalse(res['errors'])
# shouldn't create any more cases, just the one
self.assertEqual(1, len(get_case_ids_in_domain(self.domain)))
[case] = get_cases_in_domain(self.domain)
for prop in self.default_headers[1:]:
self.assertTrue(prop in case.get_case_property(prop))
# shouldn't touch existing properties
self.assertEqual('foo', case.importer_test_prop)
def testBlankRows(self):
# don't create new cases for rows left blank
config = self._config(['case_id', 'age', 'sex', 'location'], create_new_cases=True)
file = make_worksheet_wrapper(
['case_id', 'age', 'sex', 'location'],
[None, None, None, None],
['', '', '', ''],
)
res = do_import(file, config, self.domain)
# no matching and no create new set - should do nothing
self.assertEqual(0, res['created_count'])
self.assertEqual(0, res['match_count'])
self.assertEqual(0, len(get_case_ids_in_domain(self.domain)))
def testBlankRows(self):
# don't create new cases for rows left blank
config = self._config(self.default_headers, create_new_cases=True)
file = MockExcelFile(
header_columns=self.default_headers,
num_rows=5,
row_generator=blank_row_generator
)
res = do_import(file, config, self.domain)
# no matching and no create new set - should do nothing
self.assertEqual(0, res['created_count'])
self.assertEqual(0, res['match_count'])
self.assertEqual(0, len(get_case_ids_in_domain(self.domain)))
def handle(self, *args, **options):
if len(args) == 1:
domain = args[0]
else:
raise CommandError('Usage: %s\n%s' % (self.args, self.help))
ids = get_case_ids_in_domain(domain)
for count, case_id in enumerate(ids):
try:
rebuild_case_from_forms(case_id)
if count % 100 == 0:
print 'rebuilt %s/%s cases' % (count, len(ids))
except Exception, e:
logging.exception("couldn't rebuild case {id}. {msg}".format(id=case_id, msg=str(e)))
def test_skip_user_case(self):
caseblock = CaseBlock(
create=True,
case_id=uuid.uuid4().hex,
user_id=self.user_id,
owner_id=self.user_id,
case_type='commcare-user',
).as_string()
submit_case_blocks([caseblock], self.domain.name)
self.assertEqual(1, len(get_case_ids_in_domain(self.domain.name)))
explode_cases(self.user_id, self.domain.name, 10)
cases_back = list(get_cases_in_domain(self.domain.name))
self.assertEqual(1, len(cases_back))
for case in cases_back:
self.assertEqual(self.user_id, case.owner_id)
def testBasicChunking(self):
config = self._config(['case_id', 'age', 'sex', 'location'])
file = make_worksheet_wrapper(
['case_id', 'age', 'sex', 'location'],
['case_id-0', 'age-0', 'sex-0', 'location-0'],
['case_id-1', 'age-1', 'sex-1', 'location-1'],
['case_id-2', 'age-2', 'sex-2', 'location-2'],
['case_id-3', 'age-3', 'sex-3', 'location-3'],
['case_id-4', 'age-4', 'sex-4', 'location-4'],
)
res = do_import(file, config, self.domain, chunksize=2)
# 5 cases in chunks of 2 = 3 chunks
self.assertEqual(3, res['num_chunks'])
self.assertEqual(5, res['created_count'])
self.assertEqual(5, len(get_case_ids_in_domain(self.domain)))
def testNoCreateNew(self):
config = self._config(['case_id', 'age', 'sex', 'location'], create_new_cases=False)
file = make_worksheet_wrapper(
['case_id', 'age', 'sex', 'location'],
['case_id-0', 'age-0', 'sex-0', 'location-0'],
['case_id-1', 'age-1', 'sex-1', 'location-1'],
['case_id-2', 'age-2', 'sex-2', 'location-2'],
['case_id-3', 'age-3', 'sex-3', 'location-3'],
['case_id-4', 'age-4', 'sex-4', 'location-4'],
)
res = do_import(file, config, self.domain)
# no matching and no create new set - should do nothing
self.assertEqual(0, res['created_count'])
self.assertEqual(0, res['match_count'])
self.assertEqual(0, len(get_case_ids_in_domain(self.domain)))
def handle(self, *args, **options):
if len(args) != 1:
raise CommandError('Usage: %s\n%s' % (self.args, self.help))
domain = args[0]
case_ids = get_case_ids_in_domain(domain)
print 'loading %s cases in %s' % (len(case_ids), domain)
def stream_cases(all_case_ids):
for case_ids in chunked(all_case_ids, 1000):
for case in wrapped_docs(CommCareCase, keys=case_ids):
# for case in CommCareCase.view('_all_docs', keys=case_ids, include_docs=True):
yield case
count = 0
for c in stream_cases(case_ids):
count += 1
print 'read %s cases' % count
def valiate_forms_and_cases(self, domain):
form_ids_in_couch = set(get_form_ids_by_type(domain, 'XFormInstance'))
form_ids_in_sqlite = set(self.planning_db.get_all_form_ids())
print 'Forms in Couch: {}'.format(len(form_ids_in_couch))
print 'Forms in Sqlite: {}'.format(len(form_ids_in_sqlite))
if form_ids_in_couch ^ form_ids_in_sqlite:
print 'In Couch only: {}'.format(
list(form_ids_in_couch - form_ids_in_sqlite))
case_ids_in_couch = set(get_case_ids_in_domain(domain))
case_ids_in_sqlite = set(self.planning_db.get_all_case_ids())
print 'Cases in Couch: {}'.format(len(case_ids_in_couch))
print 'Cases in Sqlite: {}'.format(len(case_ids_in_sqlite))
if case_ids_in_couch ^ case_ids_in_sqlite:
print 'In Couch only: {}'.format(
list(case_ids_in_couch - case_ids_in_sqlite))
print 'In Sqlite only: {}'.format(
list(case_ids_in_sqlite - case_ids_in_couch))
def obj_get_list(self, bundle, **kwargs):
domain = kwargs['domain']
include_closed = {
'true': True,
'false': False,
'any': True
}[bundle.request.GET.get('closed', 'false')]
case_type = bundle.request.GET.get('case_type')
key = [domain]
if case_type:
key.append(case_type)
if include_closed:
case_ids = get_case_ids_in_domain(domain, type=case_type)
else:
case_ids = get_open_case_ids_in_domain(domain, type=case_type)
cases = imap(CommCareCase.wrap,
iter_docs(CommCareCase.get_db(), case_ids))
return list(cases)
def get_diff_stats(self, domain):
db = get_diff_db(domain)
diff_stats = db.get_diff_stats()
stats = {}
def _update_stats(doc_type, couch_count, sql_count):
diff_count, num_docs_with_diffs = diff_stats.pop(doc_type, (0, 0))
if diff_count or couch_count != sql_count:
stats[doc_type] = (couch_count, sql_count, diff_count, num_docs_with_diffs)
for doc_type in doc_types():
form_ids_in_couch = len(set(get_form_ids_by_type(domain, doc_type)))
form_ids_in_sql = len(set(FormAccessorSQL.get_form_ids_in_domain_by_type(domain, doc_type)))
_update_stats(doc_type, form_ids_in_couch, form_ids_in_sql)
form_ids_in_couch = len(set(get_doc_ids_in_domain_by_type(
domain, "XFormInstance-Deleted", XFormInstance.get_db())
))
form_ids_in_sql = len(set(FormAccessorSQL.get_deleted_form_ids_in_domain(domain)))
_update_stats("XFormInstance-Deleted", form_ids_in_couch, form_ids_in_sql)
case_ids_in_couch = len(set(get_case_ids_in_domain(domain)))
case_ids_in_sql = len(set(CaseAccessorSQL.get_case_ids_in_domain(domain)))
_update_stats("CommCareCase", case_ids_in_couch, case_ids_in_sql)
if self.strict:
# only care about these in strict mode
case_ids_in_couch = len(set(get_doc_ids_in_domain_by_type(
domain, "CommCareCase-Deleted", XFormInstance.get_db())
))
case_ids_in_sql = len(set(CaseAccessorSQL.get_deleted_case_ids_in_domain(domain)))
_update_stats("CommCareCase-Deleted", case_ids_in_couch, case_ids_in_sql)
if diff_stats:
for key in diff_stats.keys():
_update_stats(key, 0, 0)
return stats
def testExternalIdChunking(self):
# bootstrap a stub case
external_id = 'importer-test-external-id'
headers = ['external_id', 'age', 'sex', 'location']
config = self._config(headers, search_field='external_id')
file = MockExcelFile(header_columns=headers, num_rows=3,
row_generator=id_match_generator(external_id))
# the first one should create the case, and the remaining two should update it
res = do_import(file, config, self.domain)
self.assertEqual(1, res['created_count'])
self.assertEqual(2, res['match_count'])
self.assertFalse(res['errors'])
self.assertEqual(2, res['num_chunks']) # the lookup causes an extra chunk
# should just create the one case
self.assertEqual(1, len(get_case_ids_in_domain(self.domain)))
[case] = get_cases_in_domain(self.domain)
self.assertEqual(external_id, case.external_id)
for prop in self.default_headers[1:]:
self.assertTrue(prop in case.get_case_property(prop))
def test_parent_child(self):
parent_id = uuid.uuid4().hex
parent_type = 'exploder-parent-type'
parent_block = CaseBlock(
create=True,
case_id=parent_id,
user_id=self.user_id,
owner_id=self.user_id,
case_type=parent_type,
version=V2
).as_string()
child_id = uuid.uuid4().hex
child_block = CaseBlock(
create=True,
case_id=child_id,
user_id=self.user_id,
owner_id=self.user_id,
case_type='exploder-child-type',
index={'parent': (parent_type, parent_id)},
version=V2
).as_string()
submit_case_blocks([parent_block, child_block], self.domain.name)
self.assertEqual(2, len(get_case_ids_in_domain(self.domain.name)))
explode_cases(self.user_id, self.domain.name, 5)
cases_back = list(get_cases_in_domain(self.domain.name))
self.assertEqual(10, len(cases_back))
parent_cases = {p._id: p for p in filter(lambda case: case.type == parent_type, cases_back)}
self.assertEqual(5, len(parent_cases))
child_cases = filter(lambda case: case.type == 'exploder-child-type', cases_back)
self.assertEqual(5, len(child_cases))
child_indices = [child.indices[0].referenced_id for child in child_cases]
# make sure they're different
self.assertEqual(len(child_cases), len(set(child_indices)))
for child in child_cases:
self.assertEqual(1, len(child.indices))
self.assertTrue(child.indices[0].referenced_id in parent_cases)
def testImportNone(self):
res = bulk_import_async(self._config(), self.domain, None)
self.assertEqual(
'Sorry, your session has expired. Please start over and try again.',
unicode(res['errors']))
self.assertEqual(0, len(get_case_ids_in_domain(self.domain)))
def iter_case_ids_by_domain_and_type(domain, type_=None):
return get_case_ids_in_domain(domain, type=type_)
def get_case_ids_in_domain(domain, type=None):
return get_case_ids_in_domain(domain, type=type)
def get_case_ids_in_domain(domain, type=None):
return get_case_ids_in_domain(domain, type=type)
def print_stats(self, domain, short=True, diffs_only=False):
status = get_couch_sql_migration_status(domain)
print("Couch to SQL migration status for {}: {}".format(domain, status))
db = open_state_db(domain, self.state_dir)
try:
diff_stats = db.get_diff_stats()
except OperationalError:
diff_stats = {}
has_diffs = False
for doc_type in doc_types():
form_ids_in_couch = set(get_form_ids_by_type(domain, doc_type))
if doc_type == "XFormInstance":
form_ids_in_couch.update(get_doc_ids_in_domain_by_type(
domain, "HQSubmission", XFormInstance.get_db()))
form_ids_in_sql = set(FormAccessorSQL.get_form_ids_in_domain_by_type(domain, doc_type))
diff_count, num_docs_with_diffs = diff_stats.pop(doc_type, (0, 0))
has_diffs |= self._print_status(
doc_type, form_ids_in_couch, form_ids_in_sql, diff_count, num_docs_with_diffs, short, diffs_only
)
form_ids_in_couch = set(get_doc_ids_in_domain_by_type(
domain, "XFormInstance-Deleted", XFormInstance.get_db())
)
form_ids_in_sql = set(FormAccessorSQL.get_deleted_form_ids_in_domain(domain))
diff_count, num_docs_with_diffs = diff_stats.pop("XFormInstance-Deleted", (0, 0))
has_diffs |= self._print_status(
"XFormInstance-Deleted", form_ids_in_couch, form_ids_in_sql,
diff_count, num_docs_with_diffs, short, diffs_only
)
ZERO = Counts(0, 0)
if db.has_doc_counts():
doc_counts = db.get_doc_counts()
couch_missing_cases = doc_counts.get("CommCareCase-couch", ZERO).missing
else:
doc_counts = None
couch_missing_cases = 0
for doc_type in CASE_DOC_TYPES:
if doc_counts is not None:
counts = doc_counts.get(doc_type, ZERO)
case_ids_in_couch = db.get_missing_doc_ids(doc_type) if counts.missing else set()
case_ids_in_sql = counts
elif doc_type == "CommCareCase":
case_ids_in_couch = set(get_case_ids_in_domain(domain))
case_ids_in_sql = set(CaseAccessorSQL.get_case_ids_in_domain(domain))
elif doc_type == "CommCareCase-Deleted":
case_ids_in_couch = set(get_doc_ids_in_domain_by_type(
domain, "CommCareCase-Deleted", XFormInstance.get_db())
)
case_ids_in_sql = set(CaseAccessorSQL.get_deleted_case_ids_in_domain(domain))
else:
raise NotImplementedError(doc_type)
diff_count, num_docs_with_diffs = diff_stats.pop(doc_type, (0, 0))
has_diffs |= self._print_status(
doc_type,
case_ids_in_couch,
case_ids_in_sql,
diff_count,
num_docs_with_diffs,
short,
diffs_only,
)
if doc_type == "CommCareCase" and couch_missing_cases:
has_diffs = True
print(shell_red("%s cases could not be loaded from Couch" % couch_missing_cases))
if not short:
for case_id in db.get_missing_doc_ids("CommCareCase-couch"):
print(case_id)
if diff_stats:
for key, counts in diff_stats.items():
diff_count, num_docs_with_diffs = counts
has_diffs |= self._print_status(
key, set(), set(), diff_count, num_docs_with_diffs, short, diffs_only
)
if diffs_only and not has_diffs:
print(shell_green("No differences found between old and new docs!"))
return has_diffs
def test_get_case_ids_in_domain(self):
self.assertEqual(
set(get_case_ids_in_domain(self.domain)),
{case.get_id
for case in self.cases if case.domain == self.domain})
