def claim_case(domain, owner_id, host_id, host_type=None, host_name=None): """ Claim a case identified by host_id for claimant identified by owner_id. Creates an extension case so that the claimed case is synced to the claimant's device. """ claim_id = uuid4().hex if not (host_type and host_name): case = CaseAccessors(domain).get_case(host_id) host_type = case.type host_name = case.name identifier = DEFAULT_CASE_INDEX_IDENTIFIERS[CASE_INDEX_EXTENSION] claim_case_block = CaseBlock( create=True, case_id=claim_id, case_name=host_name, case_type=CLAIM_CASE_TYPE, owner_id=owner_id, index={ identifier: IndexAttrs( case_type=host_type, case_id=host_id, relationship=CASE_INDEX_EXTENSION, ) } ).as_xml() post_case_blocks([claim_case_block], {'domain': domain}) return claim_id
def _close_case(self, case_id): case_block = CaseBlock( create=False, case_id=case_id, close=True ).as_xml() post_case_blocks([case_block], {'domain': DOMAIN})
def testCacheNonInvalidation(self): original_payload = RestoreConfig( self.user, version=V2, caching_enabled=True, restore_id=self.sync_log._id, ).get_payload() self.sync_log = SyncLog.get(self.sync_log._id) self.assertTrue(self.sync_log.has_cached_payload(V2)) # posting a case associated with this sync token should invalidate the cache # submitting a case not with the token will not touch the cache for that token case_id = "cache_noninvalidation" post_case_blocks([ CaseBlock( create=True, case_id=case_id, user_id=self.user.user_id, owner_id=self.user.user_id, case_type=PARENT_TYPE, version=V2, ).as_xml() ]) next_payload = RestoreConfig( self.user, version=V2, caching_enabled=True, restore_id=self.sync_log._id, ).get_payload() self.assertEqual(original_payload, next_payload) self.assertFalse(case_id in next_payload)
def _create_case(user, type, close=False, **extras): case_id = uuid.uuid4().hex blocks = [CaseBlock( create=True, case_id=case_id, case_name=_type_to_name(type), case_type=type, user_id=user.user_id, owner_id=user.user_id, version=V2, **extras ).as_xml(format_datetime=date_to_xml_string)] if close: blocks.append(CaseBlock( create=False, case_id=case_id, close=True, version=V2, ).as_xml(format_datetime=date_to_xml_string)) post_case_blocks(blocks) case = CommCareCase.get(case_id) assert case.closed == close case.domain = TEST_DOMAIN case.save() return case
def test_archie_modified_on(self): case_id = uuid.uuid4().hex now = datetime.utcnow().replace(microsecond=0) earlier = now - timedelta(hours=1) way_earlier = now - timedelta(days=1) # make sure we timestamp everything so they have the right order create_block = CaseBlock(case_id, create=True, date_modified=way_earlier) post_case_blocks([create_block.as_xml()], form_extras={'received_on': way_earlier}) update_block = CaseBlock(case_id, update={'foo': 'bar'}, date_modified=earlier) post_case_blocks([update_block.as_xml()], form_extras={'received_on': earlier}) case = CommCareCase.objects.get_case(case_id, 'test-domain') self.assertEqual(earlier, case.modified_on) second_form = XFormInstance.objects.get_form(case.xform_ids[-1], 'test-domain') second_form.archive() case = CommCareCase.objects.get_case(case_id, 'test-domain') self.assertEqual(way_earlier, case.modified_on)
def _run_test(self, event_type, expected_records_after_create, expected_records_after_update): ZapierSubscription.objects.create( domain=self.domain, user_id=str(self.web_user._id), event_name=event_type, url='http://example.com/lets-make-some-cases/', case_type='animal', ) # create case and run checks case_id = uuid.uuid4().hex post_case_blocks([ CaseBlock( create=True, case_id=case_id, case_type='animal', ).as_xml() ], domain=self.domain) repeat_records = list(RepeatRecord.all(domain=self.domain)) self.assertEqual(expected_records_after_create, len(repeat_records)) for record in repeat_records: self.assertEqual(case_id, record.payload_id) # update case and run checks post_case_blocks([CaseBlock( create=False, case_id=case_id, ).as_xml()], domain=self.domain) repeat_records = list(RepeatRecord.all(domain=self.domain)) self.assertEqual(expected_records_after_update, len(repeat_records)) for record in repeat_records: self.assertEqual(case_id, record.payload_id)
def test_archie_modified_on(self): case_id = uuid.uuid4().hex now = datetime.utcnow().replace(microsecond=0) earlier = now - timedelta(hours=1) way_earlier = now - timedelta(days=1) # make sure we timestamp everything so they have the right order create_block = CaseBlock(case_id, create=True, date_modified=way_earlier) post_case_blocks([create_block.as_xml()], form_extras={'received_on': way_earlier}) update_block = CaseBlock(case_id, update={'foo': 'bar'}, date_modified=earlier) post_case_blocks([update_block.as_xml()], form_extras={'received_on': earlier}) case_accessors = CaseAccessors(REBUILD_TEST_DOMAIN) case = case_accessors.get_case(case_id) self.assertEqual(earlier, case.modified_on) second_form = FormAccessors(REBUILD_TEST_DOMAIN).get_form( case.xform_ids[-1]) second_form.archive() case = case_accessors.get_case(case_id) self.assertEqual(way_earlier, case.modified_on)
def _post_util(create=False, case_id=None, user_id=None, owner_id=None, case_type=None, form_extras=None, close=False, date_modified=None, **kwargs): form_extras = form_extras or {} form_extras['domain'] = REBUILD_TEST_DOMAIN uid = lambda: uuid.uuid4().hex case_id = case_id or uid() block = CaseBlock(create=create, case_id=case_id, user_id=user_id or uid(), owner_id=owner_id or uid(), case_type=case_type or 'test', date_modified=date_modified, update=kwargs, close=close) block = block.as_xml() post_case_blocks([block], form_extras) return case_id
def setUp(self): delete_all_xforms() delete_all_cases() post_case_blocks([ CaseBlock( create=True, case_id='mother_case_id', case_type='mother-case', ).as_xml() ], {'domain': TEST_DOMAIN}) self.case_id = 'test_case_1' self.date_modified = datetime.utcnow() - timedelta(hours=1) self.date_modified = self.date_modified.replace(microsecond=0) post_case_blocks([ CaseBlock( create=True, case_id=self.case_id, owner_id="owner", user_id='user', case_type='c_type', case_name=('a' * TEST_NAME_LEN) + '123456789', external_id='external_id', date_modified=self.date_modified, update={'foo': 'bar'}, index={'mom': ('mother-case', 'mother_case_id')} ).as_xml() ], {'domain': TEST_DOMAIN}) instance = CommCareCase.get(self.case_id) self.casedata = CaseData.create_or_update_from_instance(instance)
def testBadIndexReferenceDomain(self): case_in_other_domain = self.MOTHER_CASE_ID parent_domain = 'parent' child_domain = 'child' post_case_blocks([ CaseBlock(create=True, case_id=case_in_other_domain, user_id=USER_ID, version=V2).as_xml() ], form_extras={'domain': parent_domain}) block = CaseBlock(create=True, case_id='child-case-id', user_id=USER_ID, version=V2, index={'bad': ('bad-case', case_in_other_domain)}) xform, _ = post_case_blocks([block.as_xml()], form_extras={'domain': child_domain}) self.assertIsInstance(xform, XFormError) self.assertEqual(xform.doc_type, 'XFormError') self.assertIn('IllegalCaseId', xform.problem) self.assertIn('Bad case id', xform.problem)
def testSubmitToDeletedCase(self): # submitting to a deleted case should succeed and affect the case case_id = uuid.uuid4().hex xform, [case] = post_case_blocks([ CaseBlock(create=True, case_id=case_id, user_id='whatever', update={ 'foo': 'bar' }).as_xml() ]) case.soft_delete() self.assertEqual('bar', case.dynamic_case_properties()['foo']) self.assertTrue(case.is_deleted) xform, [case] = post_case_blocks([ CaseBlock(create=False, case_id=case_id, user_id='whatever', update={ 'foo': 'not_bar' }).as_xml() ]) self.assertEqual('not_bar', case.dynamic_case_properties()['foo']) self.assertTrue(case.is_deleted)
def test_submission_with_bad_log_default(self): with self.assertRaises(ResourceNotFound): post_case_blocks( [CaseBlock(create=True, case_id='bad-log-default', version=V2).as_xml()], form_extras={"last_sync_token": 'not-a-valid-synclog-id'}, domain='some-domain-without-toggle', )
def setUp(self): delete_all_xforms() delete_all_cases() post_case_blocks([ CaseBlock( create=True, case_id='mother_case_id', case_type='mother-case', version=V2, ).as_xml() ], {'domain': TEST_DOMAIN}) self.case_id = 'test_case_1' self.date_modified = datetime.utcnow() - timedelta(hours=1) self.date_modified = self.date_modified.replace(microsecond=0) post_case_blocks([ CaseBlock( create=True, case_id=self.case_id, owner_id="owner", user_id='user', case_type='c_type', case_name=('a' * TEST_NAME_LEN) + '123456789', external_id='external_id', date_modified=self.date_modified, version=V2, update={'foo': 'bar'}, index={'mom': ('mother-case', 'mother_case_id')} ).as_xml() ], {'domain': TEST_DOMAIN}) instance = CommCareCase.get(self.case_id) self.casedata = CaseData.create_or_update_from_instance(instance)
def testCacheNonInvalidation(self): original_payload = RestoreConfig( self.user, version=V2, caching_enabled=True, restore_id=self.sync_log._id, ).get_payload() self.sync_log = SyncLog.get(self.sync_log._id) self.assertTrue(self.sync_log.has_cached_payload(V2)) # posting a case associated with this sync token should invalidate the cache # submitting a case not with the token will not touch the cache for that token case_id = "cache_noninvalidation" post_case_blocks([CaseBlock( create=True, case_id=case_id, user_id=self.user.user_id, owner_id=self.user.user_id, case_type=PARENT_TYPE, version=V2, ).as_xml()]) next_payload = RestoreConfig( self.user, version=V2, caching_enabled=True, restore_id=self.sync_log._id, ).get_payload() self.assertEqual(original_payload, next_payload) self.assertFalse(case_id in next_payload)
def testSubmitToDeletedCase(self): # submitting to a deleted case should succeed and affect the case case_id = 'immagetdeleted' deleted_doc_type = 'CommCareCase-Deleted' post_case_blocks([ CaseBlock(create=True, case_id=case_id, user_id='whatever', version=V2, update={ 'foo': 'bar' }).as_xml() ]) case = CommCareCase.get(case_id) self.assertEqual('bar', case.foo) # hack copy how we delete things case.doc_type = deleted_doc_type case.save() self.assertEqual(deleted_doc_type, case.doc_type) post_case_blocks([ CaseBlock(create=False, case_id=case_id, user_id='whatever', version=V2, update={ 'foo': 'not_bar' }).as_xml() ]) case = CommCareCase.get(case_id) self.assertEqual('not_bar', case.foo) self.assertEqual(deleted_doc_type, case.doc_type)
def _new_case(self, properties): id = uuid.uuid4().hex case_block = CaseBlock( create=True, case_id=id, case_type=self.case_type, version=V2, update=properties ).as_xml() post_case_blocks([case_block], {"domain": self.domain}) return CommCareCase.get(id)
def test_submit_to_deleted_case(self): """submitting to a deleted case should succeed and affect the case""" case_id = uuid.uuid4().hex xform, [case] = post_case_blocks([ CaseBlock(create=True, case_id=case_id, user_id='whatever', update={ 'foo': 'bar' }).as_xml() ], domain="test-domain") CommCareCase.objects.soft_delete_cases("test-domain", [case_id]) case = CommCareCase.objects.get_case(case_id, "test-domain") self.assertEqual('bar', case.dynamic_case_properties()['foo']) self.assertTrue(case.is_deleted) xform, [case] = post_case_blocks([ CaseBlock(create=False, case_id=case_id, user_id='whatever', update={ 'foo': 'not_bar' }).as_xml() ]) self.assertEqual('not_bar', case.dynamic_case_properties()['foo']) self.assertTrue(case.is_deleted)
def testMismatch(self): self.assertEqual(CaseStateHash(EMPTY_HASH), self.sync_log.get_state_hash()) c1 = CaseBlock(case_id="abc123", create=True, owner_id=self.user.user_id).as_xml() c2 = CaseBlock(case_id="123abc", create=True, owner_id=self.user.user_id).as_xml() post_case_blocks([c1, c2], form_extras={"last_sync_token": self.sync_log.get_id}) self.sync_log = get_properly_wrapped_sync_log(self.sync_log.get_id) real_hash = CaseStateHash("409c5c597fa2c2a693b769f0d2ad432b") bad_hash = CaseStateHash("thisisntright") self.assertEqual(real_hash, self.sync_log.get_state_hash()) generate_restore_payload( self.project, self.user, self.sync_log.get_id, version=V2, state_hash=str(real_hash) ) try: generate_restore_payload(self.project, self.user, self.sync_log.get_id, version=V2, state_hash=str(bad_hash)) self.fail("Call to generate a payload with a bad hash should fail!") except BadStateException, e: self.assertEqual(real_hash, e.server_hash) self.assertEqual(bad_hash, e.phone_hash) self.assertEqual(2, len(e.case_ids)) self.assertTrue("abc123" in e.case_ids) self.assertTrue("123abc" in e.case_ids)
def update_and_test(case_id, owner=None, should_have=None, should_not_have=None): case_block = self.get_update_block( case_id=case_id, update={'greeting': "Hello!"}, owner_id=owner.get_id if owner else None, ) post_case_blocks([case_block], {'domain': self.domain}) check_has_block(case_block, should_have, should_not_have, line_by_line=False)
def _update_episode_case(domain, case_id, updated_properties): post_case_blocks( [CaseBlock( case_id=case_id, update=updated_properties ).as_xml()], {'domain': domain} )
def testBadIndexReference(self): block = CaseBlock(create=True, case_id=self.CASE_ID, user_id=USER_ID, version=V2, index={'bad': ('bad-case', 'not-an-existing-id')}) try: post_case_blocks([block.as_xml()]) self.fail("Submitting against a bad case in an index should fail!") except IllegalCaseId: pass
def create_and_test(case_id, user, owner, should_have, should_not_have, version): case_block = self.get_create_block( case_id=case_id, type="case", user_id=user.user_id, owner_id=owner.get_id, version=version ) post_case_blocks([case_block], {"domain": self.domain}) CommCareCase.get(case_id) check_has_block(case_block, should_have, should_not_have, version=version)
def update_case(domain, case_id, updated_properties, external_id=None): kwargs = { 'case_id': case_id, 'update': updated_properties, } if external_id is not None: kwargs.update({'external_id': external_id}) post_case_blocks([CaseBlock(**kwargs).as_xml()], {'domain': domain})
def create_case(self): case_block = CaseBlock( create=True, case_id=self.host_case_id, case_name=self.host_case_name, case_type=self.host_case_type, owner_id="not the user", ).as_xml() post_case_blocks([case_block], {'domain': DOMAIN})
def update_case_owner(self, case, owner): case_block = CaseBlock( create=False, case_id=case.case_id, case_type='participant', owner_id=owner.get_id, user_id=owner.get_id, ).as_xml() post_case_blocks([case_block], {'domain': self.domain})
def create_case(self): case_block = CaseBlock.deprecated_init( create=True, case_id=self.host_case_id, case_name=self.host_case_name, case_type=self.host_case_type, owner_id='in_soviet_russia_the_case_owns_you', ).as_xml() post_case_blocks([case_block], {'domain': DOMAIN})
def create_and_test(case_id, user, owner, should_have, should_not_have): case_block = self.get_create_block( case_id=case_id, type="case", user_id=user.user_id, owner_id=owner.get_id, ) post_case_blocks([case_block], {'domain': self.domain}) check_has_block(case_block, should_have, should_not_have)
def add_parent_access(self, user, case): case_block = CaseBlock( create=True, case_id=uuid.uuid4().hex, case_type='magic_map', owner_id=user.get_id, index={'parent': ('participant', case.case_id)} ).as_xml() post_case_blocks([case_block], {'domain': self.domain})
def add_parent_access(self, user, case): case_block = CaseBlock(create=True, case_id=uuid.uuid4().hex, case_type='magic_map', owner_id=user.get_id, index={ 'parent': ('participant', case.case_id) }).as_xml() post_case_blocks([case_block], {'domain': self.domain})
def create_case(self): case_block = CaseBlock( create=True, case_id=self.host_case_id, case_name=self.host_case_name, case_type=self.host_case_type, owner_id='in_soviet_russia_the_case_owns_you', ).as_xml() post_case_blocks([case_block], {'domain': DOMAIN})
def add_parent_access(self, user, case): case_block = CaseBlock( create=True, case_id=uuid.uuid4().hex, case_type='magic_map', owner_id=user._id, version=V2, index={'parent': ('participant', case._id)} ).as_xml(format_datetime=json_format_datetime) post_case_blocks([case_block], {'domain': self.domain})
def update_and_test(case_id, owner=None, should_have=None, should_not_have=None, version=V1): case_block = self.get_update_block( case_id='case-a-1', update={'greeting': "Hello!"}, owner_id=owner.get_id if owner else None, version=version ) post_case_blocks([case_block]) check_has_block(case_block, should_have, should_not_have, line_by_line=False, version=version)
def update_case_owner(self, case, owner): case_block = CaseBlock( create=False, case_id=case._id, case_type='participant', owner_id=owner._id, user_id=owner._id, version=V2 ).as_xml(format_datetime=json_format_datetime) post_case_blocks([case_block], {'domain': self.domain})
def update_and_test(case_id, owner=None, should_have=None, should_not_have=None, version=V1): case_block = self.get_update_block( case_id="case-a-1", update={"greeting": "Hello!"}, owner_id=owner.get_id if owner else None, version=version, ) post_case_blocks([case_block], {"domain": self.domain}) check_has_block(case_block, should_have, should_not_have, line_by_line=False, version=version)
def _new_case(self, properties): id = uuid.uuid4().hex case_block = CaseBlock( create=True, case_id=id, case_type=self.case_type, update=properties, ).as_xml() post_case_blocks([case_block], {'domain': self.domain}) return CommCareCase.get(id)
def _new_case(cls, properties): id = uuid.uuid4().hex case_block = CaseBlock( create=True, case_id=id, case_type=cls.case_type, update=properties, ).as_xml() post_case_blocks([case_block], {'domain': cls.domain}) return CommCareCase.get(id)
def _create_case(cls, parent_id): case_id = uuid.uuid4().hex caseblock = CaseBlock(case_id=case_id, case_type=cls.case_type, date_opened=cls.case_date_opened, case_name=cls.case_name, update=cls._get_case_property_values(), index={'parent': (cls.case_type, parent_id)}) post_case_blocks([caseblock.as_xml()], domain=cls.domain) return case_id
def _new_case(cls, properties): id = uuid.uuid4().hex case_block = CaseBlock( create=True, case_id=id, case_type=cls.case_type, update=properties, ).as_xml() with drop_connected_signals(case_post_save): post_case_blocks([case_block], {'domain': cls.domain}) return CommCareCase.get(id)
def _new_case(cls, properties): id = uuid.uuid4().hex case_block = CaseBlock( create=True, case_id=id, case_type=cls.case_type, version=V2, update=properties, ).as_xml() post_case_blocks([case_block], {'domain': cls.domain}) return CommCareCase.get(id)
def _make_some_cases(howmany, domain='dbcache-test'): ids = [uuid.uuid4().hex for i in range(howmany)] post_case_blocks([ CaseBlock(create=True, case_id=ids[i], user_id='some-user', update={ 'my_index': i, }).as_xml() for i in range(howmany) ], {'domain': domain}) return ids
def testRelationshipGetsSet(self): create_index = CaseBlock( create=True, case_id=self.CASE_ID, user_id=self.user.user_id, owner_id=self.user.user_id, index={'mom': ('mother-case', self.MOTHER_CASE_ID, 'extension')}, ).as_xml() post_case_blocks([create_index], domain=self.project.name) check_user_has_case(self, self.user, create_index)
def _new_case(self, properties): id = uuid.uuid4().hex case_block = CaseBlock( create=True, case_id=id, case_type=self.case_type, update=properties, ).as_xml() post_case_blocks([case_block], {'domain': self.domain}) case = CommCareCase.get(id) self.addCleanup(case.delete) return case
def _new_case(self, properties): id = uuid.uuid4().hex case_block = CaseBlock.deprecated_init( create=True, case_id=id, case_type=self.case_type, update=properties, ).as_xml() post_case_blocks([case_block], {'domain': self.domain}) case = CommCareCase.get(id) self.addCleanup(case.delete) return case
def _create_closed_case(cls): case_id = uuid.uuid4().hex caseblock = CaseBlock( case_id=case_id, case_type=cls.case_type, date_opened=cls.closed_case_date_opened, date_modified=cls.closed_case_date_closed, case_name=cls.case_name, close=True, ) post_case_blocks([caseblock.as_xml()], domain=cls.domain) return case_id
def _create_parent_case(cls, case_name): parent_id = uuid.uuid4().hex post_case_blocks([ CaseBlock.deprecated_init( create=True, case_id=parent_id, case_name=case_name, case_type=cls.parent_case_type, ).as_xml() ], domain=cls.domain) return parent_id
def testBadIndexReference(self): CASE_ID = 'test-bad-index-case' block = CaseBlock(create=True, case_id=CASE_ID, user_id=USER_ID, version=V2, index={'bad': ('bad-case', 'not-an-existing-id')}) try: post_case_blocks([block.as_xml()]) self.fail("Submitting against a bad case in an index should fail!") except IllegalCaseId: pass
def testRelationshipGetsSet(self): user = User(user_id=USER_ID, username="", password="", date_joined="") create_index = CaseBlock( create=True, case_id=self.CASE_ID, user_id=USER_ID, owner_id=USER_ID, index={'mom': ('mother-case', self.MOTHER_CASE_ID, 'extension')}, ).as_xml() post_case_blocks([create_index]) check_user_has_case(self, user, create_index)
def create_and_test(case_id, user, owner, should_have, should_not_have, version): case_block = self.get_create_block( case_id=case_id, type="case", user_id=user.user_id, owner_id=owner.get_id, version=version ) post_case_blocks([case_block], {'domain': self.domain}) CommCareCase.get(case_id) check_has_block(case_block, should_have, should_not_have, version=version)
def _make_case(self, user_id, owner_id, **kwargs): id = uuid.uuid4().hex case_block = CaseBlock(create=True, case_id=id, case_name='Some Name', case_type='rectest', user_id=user_id, owner_id=owner_id, version=V2, **kwargs).as_xml() post_case_blocks([case_block], {'domain': self.domain}) return CommCareCase.get(id)
def testParseWithIndices(self): self._test_parse_create() user_id = "bar-user-id" for prereq in ["some_referenced_id", "some_other_referenced_id"]: post_case_blocks([ CaseBlock(create=True, case_id=prereq, user_id=user_id).as_xml() ]) file_path = os.path.join(os.path.dirname(__file__), "data", "v2", "index_update.xml") with open(file_path, "rb") as f: xml_data = f.read() case = submit_form_locally(xml_data, 'test-domain').case self.assertEqual(2, len(case.indices)) self.assertTrue(case.has_index("foo_ref")) self.assertTrue(case.has_index("baz_ref")) self.assertEqual("bar", case.get_index("foo_ref").referenced_type) self.assertEqual("some_referenced_id", case.get_index("foo_ref").referenced_id) self.assertEqual("bop", case.get_index("baz_ref").referenced_type) self.assertEqual("some_other_referenced_id", case.get_index("baz_ref").referenced_id) if not getattr(settings, 'TESTS_SHOULD_USE_SQL_BACKEND', False): # check the action self.assertEqual(2, len(case.actions)) [_, index_action] = case.actions self.assertEqual(const.CASE_ACTION_INDEX, index_action.action_type) self.assertEqual(2, len(index_action.indices)) # quick test for ota restore v2response = xml.get_case_xml( case, [const.CASE_ACTION_CREATE, const.CASE_ACTION_UPDATE], V2) expected_v2_response = """ <case case_id="foo-case-id" date_modified="2011-12-07T13:42:50.000000Z" user_id="bar-user-id" xmlns="http://commcarehq.org/case/transaction/v2"> <create> <case_type>v2_case_type</case_type> <case_name>test case name</case_name> <owner_id>bar-user-id</owner_id> </create> <update> <date_opened>2011-12-06</date_opened> </update> <index> <baz_ref case_type="bop">some_other_referenced_id</baz_ref> <foo_ref case_type="bar">some_referenced_id</foo_ref> </index> </case>""" check_xml_line_by_line(self, expected_v2_response, v2response)
def _create_parent_case(cls, case_name): parent_id = uuid.uuid4().hex post_case_blocks( [ CaseBlock( create=True, case_id=parent_id, case_name=case_name, case_type=cls.parent_case_type, ).as_xml() ], domain=cls.domain ) return parent_id
def _new_case(self, index=None): index = index or {} id = uuid.uuid4().hex case_block = CaseBlock( create=True, case_id=id, case_type='person', owner_id=self.original_owner._id, version=V2, index=index, ).as_xml(format_datetime=json_format_datetime) post_case_blocks([case_block], {'domain': self.domain}) return CommCareCase.get(id)
def _make_case(self, user_id, owner_id, **kwargs): id = uuid.uuid4().hex case_block = CaseBlock( create=True, case_id=id, case_name='Some Name', case_type='rectest', user_id=user_id, owner_id=owner_id, **kwargs ).as_xml() post_case_blocks([case_block], {'domain': self.domain}) return CommCareCase.get(id)
def _submit_case(domain): case_id = uuid.uuid4().hex case_block = CaseBlock( create=True, case_id=case_id, case_name='donald', case_type='duck', user_id=user._id, owner_id=user._id, version=V2, ).as_xml(format_datetime=json_format_datetime) post_case_blocks([case_block], {'domain': domain}) return CommCareCase.get(case_id)
def _make_some_cases(howmany, domain='dbcache-test'): ids = [uuid.uuid4().hex for i in range(howmany)] post_case_blocks([ CaseBlock( create=True, case_id=ids[i], user_id='some-user', update={ 'my_index': i, } ).as_xml() for i in range(howmany) ], {'domain': domain}) return ids