コード例 #1
0
    def setUp(self):
        now = datetime.utcnow()
        owner_id = str(uuid4())
        self.parent_case_id = str(uuid4())
        self.parent_case = CommCareCase(
            case_id=self.parent_case_id,
            domain=DOMAIN,
            type='person',
            name='Beth',
            owner_id=owner_id,
            modified_on=now,
            server_modified_on=now,
        )
        self.parent_case.save()

        self.child_case_id = str(uuid4())
        self.child_case = CommCareCase(
            case_id=self.child_case_id,
            domain=DOMAIN,
            type='vitals',
            case_json={'temperature': 36.1},
            owner_id=owner_id,
            modified_on=now,
            server_modified_on=now,
        )
        self.child_case.save()
        add_case_index(
            self.child_case,
            identifier='parent',
            referenced_type='person',
            referenced_id=self.parent_case_id,
        )
コード例 #2
0
ファイル: test_indexes.py プロジェクト: soitun/commcare-hq
class IndexSimpleTest(SimpleTestCase):
    def setUp(self):
        i1 = {
            'identifier': 'i1',
            'referenced_type': 't1',
            'referenced_id': 'id1',
        }
        i2 = {
            'identifier': 'i2',
            'referenced_type': 't2',
            'referenced_id': 'id2',
        }
        self.i1 = CommCareCaseIndex(**i1)
        self.i2 = CommCareCaseIndex(**i2)
        self.case = CommCareCase(indices=[i1, i2])

    def testHasIndex(self):
        self.assertEqual(True, self.case.has_index('i1'))
        self.assertEqual(True, self.case.has_index('i2'))
        self.assertEqual(False, self.case.has_index('i3'))

    def testGetIndex(self):
        self.assertEqual(self.i1, self.case.get_index('i1'))
        self.assertEqual(self.i2, self.case.get_index('i2'))
        self.assertEqual(None, self.case.get_index('i3'))
        self.assertEqual(None, self.case.get_index('id1'))
コード例 #3
0
def _test_refer_case_payload_generator(initial_case_properties,
                                       expected_referral_props):
    domain = "source_domain"
    repeater = ReferCaseRepeater(domain=domain)
    generator = ReferCasePayloadGenerator(repeater)
    generator.submission_user_id = Mock(return_value='user1')
    generator.submission_username = Mock(return_value='user1')
    transfer_case = CommCareCase(type="transfer",
                                 case_json={
                                     "cases_to_forward": "case1",
                                     "new_owner": "owner1",
                                     "case_types": "patient",
                                     "patient_whitelist": "copy_this"
                                 })
    copy_value = uuid.uuid4().hex
    properties = {"copy_this": copy_value}
    properties.update(initial_case_properties or {})
    target_case = CommCareCase(case_id="1",
                               type="patient",
                               case_json=properties)
    with patch.object(CommCareCase.objects,
                      "get_cases",
                      return_value=[target_case]):
        form = generator.get_payload(None, transfer_case)
        formxml = ElementTree.fromstring(form)
        case = CaseBlock.from_xml(formxml.find("{%s}case" % V2_NAMESPACE))
        expected_update = {
            "cchq_referral_source_domain": domain,
            "cchq_referral_source_case_id": "1",
            "copy_this": copy_value
        }
        expected_update.update(expected_referral_props)
        eq(case.update, expected_update)
コード例 #4
0
    def setUp(self):
        now = datetime.utcnow()
        case_kwargs = {
            'owner_id': uuid4().hex,
            'modified_on': now,
            'server_modified_on': now,
        }
        self.host_case_id = uuid4().hex
        case = CommCareCase(
            case_id=self.host_case_id,
            domain=self.domain,
            type='person',
            name='Ted',
            **case_kwargs,
        )
        self.host_case = create_case(case)

        case = CommCareCase(
            case_id=uuid4().hex,
            domain=self.domain,
            type='person_name',
            name='Theodore',
            case_json={
                'given_names': 'Theodore John',
                'family_name': 'Kaczynski',
            },
            **case_kwargs,
        )
        index = CommCareCaseIndex(
            domain=self.domain,
            identifier='host',
            referenced_type='person',
            referenced_id=self.host_case_id,
            relationship_id=CommCareCaseIndex.EXTENSION,
        )
        self.ext_case_1 = create_case_with_index(case, index)

        case = CommCareCase(
            case_id=uuid4().hex,
            domain=self.domain,
            type='person_name',
            name='Unabomber',
            case_json={
                'given_names': 'Unabomber',
            },
            **case_kwargs,
        )
        index = CommCareCaseIndex(
            domain=self.domain,
            identifier='host',
            referenced_type='person',
            referenced_id=self.host_case_id,
            relationship_id=CommCareCaseIndex.EXTENSION,
        )
        self.ext_case_2 = create_case_with_index(case, index)
コード例 #5
0
    def setUp(self):
        now = datetime.utcnow()
        yesterday = now - timedelta(days=1)
        owner_id = uuid4().hex
        self.parent_case_id = uuid4().hex
        case = CommCareCase(
            case_id=self.parent_case_id,
            domain=self.domain,
            type='person',
            name='Joe',
            owner_id=owner_id,
            modified_on=yesterday,
            server_modified_on=yesterday,
        )
        self.parent_case = create_case(case)

        case = CommCareCase(
            case_id=uuid4().hex,
            domain=self.domain,
            type='temperature',
            case_json={
                'value': '36.2',
            },
            owner_id=owner_id,
            modified_on=yesterday,
            server_modified_on=yesterday,
        )
        index = CommCareCaseIndex(
            domain=self.domain,
            identifier='parent',
            referenced_type='person',
            referenced_id=self.parent_case_id,
            relationship_id=CommCareCaseIndex.CHILD,
        )
        self.child_case_1 = create_case_with_index(case, index)

        case = CommCareCase(
            case_id=uuid4().hex,
            domain=self.domain,
            type='temperature',
            case_json={
                'value': '36.6',
            },
            owner_id=owner_id,
            modified_on=now,
            server_modified_on=now,
        )
        index = CommCareCaseIndex(
            domain=self.domain,
            identifier='parent',
            referenced_type='person',
            referenced_id=self.parent_case_id,
            relationship_id=CommCareCaseIndex.CHILD,
        )
        self.child_case_2 = create_case_with_index(case, index)
コード例 #6
0
def test_get_expanded_case_results(get_cases_mock):
    cases = [
        CommCareCase(case_json={}),
        CommCareCase(case_json={"potential_duplicate_id": "123"}),
        CommCareCase(case_json={"potential_duplicate_id": "456"}),
        CommCareCase(case_json={"potential_duplicate_id": ""}),
        CommCareCase(case_json={"potential_duplicate_id": None}),
    ]
    helper = None
    get_expanded_case_results(helper, "potential_duplicate_id", cases)
    get_cases_mock.assert_called_with(helper, {"123", "456"})
コード例 #7
0
 def setUp(self):
     self.case = CommCareCase(
         domain=DOMAIN,
         case_id="123456",
         type="person",
         name="Eric Idle",
         external_id="94d60c79-59b5-4a2c-90a5-325d6e32b3db",
         modified_on=datetime.utcnow(),
         server_modified_on=datetime.utcnow(),
     )
     self.case.save()
コード例 #8
0
 def setUp(self):
     now = datetime.utcnow()
     self.case_id = str(uuid4())
     self.case = CommCareCase(
         case_id=self.case_id,
         domain=DOMAIN,
         type='person',
         name='Ted',
         owner_id=str(uuid4()),
         modified_on=now,
         server_modified_on=now,
     )
     self.case.save()
コード例 #9
0
def create_commcare_case(data):
    cccsql = CommCareCase(
        case_id=data['case_id'],
        domain=data['domain'],
        type=data['type'],
        name=data['name'],
        owner_id=data['owner_id'],
        modified_by=data['modified_by'],
        modified_on=datetime.utcnow(),
        server_modified_on=datetime.utcnow(),
    )
    cccsql.save()
    return cccsql
コード例 #10
0
ファイル: test_indexes.py プロジェクト: soitun/commcare-hq
 def setUp(self):
     i1 = {
         'identifier': 'i1',
         'referenced_type': 't1',
         'referenced_id': 'id1',
     }
     i2 = {
         'identifier': 'i2',
         'referenced_type': 't2',
         'referenced_id': 'id2',
     }
     self.i1 = CommCareCaseIndex(**i1)
     self.i2 = CommCareCaseIndex(**i2)
     self.case = CommCareCase(indices=[i1, i2])
コード例 #11
0
ファイル: processor.py プロジェクト: soitun/commcare-hq
 def hard_rebuild_case(domain, case_id, detail, lock=True, save=True):
     assert save or not lock, "refusing to lock when not saving"
     if lock:
         # only record metric if locking since otherwise it has been
         # (most likley) recorded elsewhere
         case_load_counter("rebuild_case", domain)()
     case, lock_obj = FormProcessorSQL.get_case_with_lock(case_id,
                                                          lock=lock)
     found = bool(case)
     if not found:
         case = CommCareCase(case_id=case_id, domain=domain)
         if lock:
             lock_obj = CommCareCase.get_obj_lock_by_id(case_id)
             acquire_lock(lock_obj, degrade_gracefully=False)
コード例 #12
0
    def setUpClass(cls):
        super().setUpClass()
        case_type = CaseType.objects.create(domain=DOMAIN, name='mother')
        cls.resource_type = FHIRResourceType.objects.create(
            domain=DOMAIN,
            case_type=case_type,
            name='Patient',
        )
        for name, jsonpath in [
            ('name', '$.name[0].text'),
            ('first_name', '$.name[0].given[0]'),
            ('honorific', '$.name[0].prefix[0]'),
            ('date_of_birth', '$.birthDate'),
        ]:
            prop = CaseProperty.objects.create(case_type=case_type, name=name)
            FHIRResourceProperty.objects.create(
                resource_type=cls.resource_type,
                case_property=prop,
                jsonpath=jsonpath,
            )

        cls.case_id = str(uuid4())
        cls.case = CommCareCase(case_id=cls.case_id,
                                domain=DOMAIN,
                                type='mother',
                                name='Mehter Plethwih',
                                case_json={
                                    'first_name': 'Plethwih',
                                    'honorific': 'Mehter',
                                    'date_of_birth': '1970-01-01',
                                    'children': ['Hewsos', 'the twins'],
                                })
コード例 #13
0
def _create_ledger(domain,
                   entry_id,
                   balance,
                   case_id=None,
                   section_id='stock'):
    user_id = 'user1'
    utcnow = datetime.utcnow()

    case_id = case_id or uuid.uuid4().hex
    case = CommCareCase(
        case_id=case_id,
        domain=domain,
        type='',
        owner_id=user_id,
        opened_on=utcnow,
        modified_on=utcnow,
        modified_by=user_id,
        server_modified_on=utcnow,
    )

    case.save(with_tracked_models=True)

    ledger = LedgerValue(domain=domain,
                         case_id=case_id,
                         section_id=section_id,
                         entry_id=entry_id,
                         balance=balance,
                         last_modified=utcnow)

    LedgerAccessorSQL.save_ledger_values([ledger])
    return ledger
コード例 #14
0
ファイル: test_session.py プロジェクト: soitun/commcare-hq
 def test_load_session_data_for_commconnect_case(self):
     user = CommCareCase(name='A case', case_id=uuid.uuid4().hex)
     data = get_user_contributions_to_touchforms_session(
         'cloudcare-tests', user)
     self.assertEqual('A case', data['username'])
     self.assertEqual(user.case_id, data['user_id'])
     self.assertEqual({}, data['user_data'])
コード例 #15
0
ファイル: tests.py プロジェクト: soitun/commcare-hq
    def test_vaccination_response(self, update_case_mock, payload_doc_mock, repeat_record_repeater_mock):
        case_id = uuid.uuid4().hex
        person_case_id = uuid.uuid4().hex
        case_json = {
            'person_case_id': person_case_id,
            'api': COWIN_API_DATA_VACCINATION_IDENTIFIER,
            'dose': "1"
        }
        case = CommCareCase(domain=self.domain, type='cowin_api_data', case_id=case_id, case_json=case_json,
                            server_modified_on=datetime.datetime.utcnow())
        payload_doc_mock.return_value = case

        response = requests.Response()
        response.status_code = 204

        repeat_record = RepeatRecord(payload_id=case_id)
        repeater = BeneficiaryVaccinationRepeater(domain=self.domain)

        repeat_record_repeater_mock.return_value = repeater
        repeater.handle_response(response, repeat_record)

        update_case_mock.assert_called_with(
            self.domain, person_case_id, case_properties={'dose_1_notified': True},
            device_id='custom.cowin.repeaters.BeneficiaryVaccinationRepeater'
        )
コード例 #16
0
ファイル: tests.py プロジェクト: soitun/commcare-hq
    def test_registration_response(self, json_response_mock, update_case_mock, payload_doc_mock,
                                   repeat_record_repeater_mock):
        case_id = uuid.uuid4().hex
        person_case_id = uuid.uuid4().hex
        case_json = {
            'person_case_id': person_case_id,
            'api': COWIN_API_DATA_REGISTRATION_IDENTIFIER
        }
        case = CommCareCase(domain=self.domain, type='cowin_api_data', case_id=case_id, case_json=case_json,
                            server_modified_on=datetime.datetime.utcnow())
        payload_doc_mock.return_value = case

        response_json = {
            "beneficiary_reference_id": "1234567890123",
            "isNewAccount": "Y"
        }

        response = requests.Response()
        response.status_code = 200
        json_response_mock.return_value = response_json

        repeat_record = RepeatRecord(payload_id=case_id)
        repeater = BeneficiaryRegistrationRepeater(domain=self.domain)
        repeat_record_repeater_mock.return_value = repeater

        repeater.handle_response(response, repeat_record)

        update_case_mock.assert_called_with(
            self.domain, person_case_id, case_properties={'cowin_beneficiary_reference_id': "1234567890123"},
            device_id='custom.cowin.repeaters.BeneficiaryRegistrationRepeater'
        )
コード例 #17
0
ファイル: processor.py プロジェクト: soitun/commcare-hq
 def get_case_with_lock(case_id, lock=False, wrap=False):
     try:
         if lock:
             try:
                 return CommCareCase.get_locked_obj(_id=case_id)
             except redis.RedisError:
                 case = CommCareCase.objects.get_case(case_id)
         else:
コード例 #18
0
def mock_get_cases(self, case_ids, domain=None, ordered=False):
    return [{
        '65e55473-e83b-4d78-9dde-eaf949758997': CommCareCase(
            case_id='65e55473-e83b-4d78-9dde-eaf949758997',
            type='paciente',
            name='Elsa',
            case_json={'estado_tarv': '1', 'tb': '0'},
        )
    }[case_id] for case_id in case_ids]
コード例 #19
0
ファイル: test_models.py プロジェクト: soitun/commcare-hq
 def test_sets_index_with_doc_type(self):
     data = {
         'indices': [{
             'doc_type': 'CommCareCaseIndex',
             'referenced_id': 'some_id'
         }]
     }
     case = CommCareCase(**data)
     index = case.indices[0]
     self.assertEqual(index.referenced_id, 'some_id')
コード例 #20
0
    def get_case(self, case_json=None):
        utcnow = datetime.utcnow()
        case_json = self.props if case_json is None else case_json
        intent_case = CommCareCase(
            domain=SOURCE_DOMAIN,
            type=self.CASE_TYPE,
            case_json=case_json,
            case_id=uuid.uuid4().hex,
            user_id="local_user1",
            opened_on=utcnow,
            modified_on=utcnow,
        )
        intent_case.track_create(CaseTransaction(form_id="form123", type=CaseTransaction.TYPE_FORM))

        def _mock_subcases(*args, **kwargs):
            return self.subcases

        intent_case.get_subcases = _mock_subcases
        return intent_case
コード例 #21
0
ファイル: test_signals.py プロジェクト: soitun/commcare-hq
    def test_casedb_already_has_cases(self):
        casedb_cache = FormProcessorInterface().casedb_cache
        case = CaseFactory().create_case()
        case_db = casedb_cache(initial=[
            CommCareCase(case_id='fake1'),
            CommCareCase(case_id='fake2'),
        ])
        form = XFormInstance.objects.get_form(case.xform_ids[0])
        received = []

        def receive_cases(sender, xform, cases, **kwargs):
            received.extend(cases)

        cases_received.connect(receive_cases)
        try:
            process_cases_with_casedb([form], case_db)
            self.assertEqual(len(received), 1)
        finally:
            cases_received.disconnect(receive_cases)
コード例 #22
0
ファイル: test_models.py プロジェクト: soitun/commcare-hq
def test_case_to_json():
    case_id = str(uuid4())
    case = CommCareCase(
        case_id=case_id,
        domain=DOMAIN,
        type='case',
        name='Justin Case',
        case_json={
            'given_name': 'Justin',
            'family_name': 'Case',
            'actions': 'eating sleeping typing',
            'indices': 'Dow_Jones_Industrial_Average S&P_500',
        },
    )
    case_dict = case.to_json()
    assert_equal(
        case_dict,
        {
            '_id': case_id,
            'actions': [],  # Not replaced by case_json
            'backend_id': 'sql',
            'case_attachments': {},
            'case_id': case_id,
            'case_json': {
                'actions': 'eating sleeping typing',
                'family_name': 'Case',
                'given_name': 'Justin',
                'indices': 'Dow_Jones_Industrial_Average S&P_500',
            },
            'closed': False,
            'closed_by': None,
            'closed_on': None,
            'deleted': False,
            'doc_type': 'CommCareCase',
            'domain': DOMAIN,
            'external_id': None,
            'family_name': 'Case',
            'given_name': 'Justin',
            'indices': [],  # Not replaced by case_json
            'location_id': None,
            'modified_by': '',
            'modified_on': None,
            'name': 'Justin Case',
            'opened_by': None,
            'opened_on': None,
            'owner_id': '',
            'server_modified_on': None,
            'type': 'case',
            'user_id': '',
            'xform_ids': [],
        })
コード例 #23
0
ファイル: case_resources.py プロジェクト: soitun/commcare-hq
    def _setup_case(self, cases=None):

        modify_date = datetime.utcnow()

        cases = cases or [(None, None)]
        for owner_id, case_id in cases:
            kwargs = {}
            if owner_id:
                kwargs['owner_id'] = owner_id
            backend_case = CommCareCase(
                case_id=case_id if case_id else uuid.uuid4().hex,
                domain=self.domain.name,
                modified_on=modify_date,
                server_modified_on=modify_date,
                **kwargs)
            backend_case.save()

            translated_doc = transform_case_for_elasticsearch(
                backend_case.to_json())

            send_to_elasticsearch('cases', translated_doc)
        self.es.indices.refresh(CASE_INDEX_INFO.index)
        return backend_case
コード例 #24
0
ファイル: test_utils.py プロジェクト: soitun/commcare-hq
    def _create_change(self):
        now = datetime.utcnow()
        case = CommCareCase(
            case_id=uuid4().hex,
            domain=self.domain,
            modified_on=now,
            server_modified_on=now,
        )
        case.save()

        change = Change(case.case_id,
                        'seq',
                        document_store=CaseDocumentStore(self.domain))
        return change, case
コード例 #25
0
ファイル: util.py プロジェクト: soitun/commcare-hq
def new_case(domain=DOMAIN,
             user_id=DEFAULT_USER,
             owner_id=DEFAULT_USER,
             type=DEFAULT_CASE_TYPE,
             name=DEFAULT_CASE_NAME,
             closed=False,
             **kwargs):
    kwargs.setdefault("case_id", uuid.uuid4().hex)
    kwargs.setdefault("modified_on", datetime.utcnow())
    kwargs.setdefault("server_modified_on", datetime.utcnow())
    return CommCareCase(domain=domain,
                        user_id=user_id,
                        owner_id=owner_id,
                        type=type,
                        name=name,
                        closed=closed,
                        **kwargs)
コード例 #26
0
    def test_get_case_types_caching(self):
        self._send_case_to_es(case_type='t1')

        self.assertEqual({'t1'}, get_case_types_for_domain_es(self.domain))

        self._send_case_to_es(case_type='t2')
        # cached response
        self.assertEqual({'t1'}, get_case_types_for_domain_es(self.domain))

        # simulate a save
        from corehq.form_processor.signals import sql_case_post_save
        sql_case_post_save.send(self,
                                case=CommCareCase(domain=self.domain,
                                                  type='t2'))

        self.assertEqual({'t1', 't2'},
                         get_case_types_for_domain_es(self.domain))
コード例 #27
0
ファイル: case_search.py プロジェクト: soitun/commcare-hq
def wrap_case_search_hit(hit, include_score=False, is_related_case=False):
    """Convert case search index hit to CommCareCase

    Nearly the opposite of
    `corehq.pillows.case_search.transform_case_for_elasticsearch`.

    The "case_properties" list of key/value pairs is converted to a dict
    and assigned to `case_json`. 'Secial' case properties are excluded
    from `case_json`, even if they were present in the original case's
    dynamic properties.

    All fields excluding "case_properties" and its contents are assigned
    as attributes on the case object if `CommCareCase` has a field
    with a matching name. Fields like "doc_type" and "@indexed_on" are
    ignored.

    Warning: `include_score=True` or `is_related_case=True` may cause
    the relevant user-defined properties to be overwritten.

    :returns: A `CommCareCase` instance.
    """
    from corehq.form_processor.models import CommCareCase
    data = hit.get("_source", hit)
    _SPECIAL_PROPERTIES = SPECIAL_CASE_PROPERTIES_MAP
    _VALUE = VALUE
    case = CommCareCase(
        case_id=data.get("_id", None),
        case_json={
            prop["key"]: prop[_VALUE]
            for prop in data.get(CASE_PROPERTIES_PATH, {})
            if prop["key"] not in _SPECIAL_PROPERTIES
        },
        indices=data.get("indices", []),
    )
    _CONVERSIONS = CONVERSIONS
    _setattr = setattr
    case_fields = _case_fields()
    for key, value in data.items():
        if key in case_fields:
            if value is not None and key in _CONVERSIONS:
                value = _CONVERSIONS[key](value)
            _setattr(case, key, value)
    if include_score:
        case.case_json[RELEVANCE_SCORE] = hit['_score']
コード例 #28
0
def get_databases():
    """Return an ordered dict of (dbname: database). The order is
    according to search preference, the first DB to contain a document
    should be assumed to be the authoritative one."""
    sql_dbs = [
        _SQLDb(
            XFormInstance._meta.db_table,
            lambda id_: XFormInstance.get_obj_by_id(id_),
            "XFormInstance",
            lambda doc: XFormInstanceRawDocSerializer(doc).data,
        ),
        _SQLDb(
            CommCareCase._meta.db_table,
            lambda id_: CommCareCase.get_obj_by_id(id_),
            "CommCareCase",
            lambda doc: CommCareCaseRawDocSerializer(doc).data,
        ),
        _SQLDb(
            SQLLocation._meta.db_table,
            lambda id_: SQLLocation.objects.get(location_id=id_),
            'Location',
            lambda doc: doc.to_json()
        ),
        _SQLDb(
            SMS._meta.db_table,
            lambda id_: SMS.objects.get(couch_id=id_),
            'SMS',
            lambda doc: doc.to_json()
        ),
        _SQLDb(
            SQLMobileBackend._meta.db_table,
            lambda id_: SQLMobileBackend.objects.get(couch_id=id_),
            'SQLMobileBackend',
            lambda doc: doc.to_json()
        ),
    ]

    all_dbs = OrderedDict()
    for db in sql_dbs:
        all_dbs[db.dbname] = db
    couchdbs_by_name = couch_config.all_dbs_by_db_name
    for dbname in sorted(couchdbs_by_name):
        all_dbs[dbname] = _CouchDb(couchdbs_by_name[dbname])
    return all_dbs
コード例 #29
0
    def setUp(self):
        now = datetime.utcnow()
        self.parent_case_id = str(uuid4())
        self.parent_case = CommCareCase(
            case_id=self.parent_case_id,
            domain=DOMAIN,
            type='person',
            name='Ted',
            owner_id=str(uuid4()),
            modified_on=now,
            server_modified_on=now,
        )
        self.parent_case.save()

        self.child_case_1 = CommCareCase(
            case_id='111111111',
            domain=DOMAIN,
            type='person_name',
            name='Theodore',
            case_json={
                'given_names': 'Theodore John',
                'family_name': 'Kaczynski',
            },
            owner_id=str(uuid4()),
            modified_on=now,
            server_modified_on=now,
        )
        self.child_case_1.save()
        add_case_index(
            self.child_case_1,
            identifier='parent',
            referenced_type='person',
            referenced_id=self.parent_case_id,
        )
        self.child_case_2 = CommCareCase(
            case_id='222222222',
            domain=DOMAIN,
            type='person_name',
            name='Unabomber',
            case_json={'given_names': 'Unabomber'},
            owner_id=str(uuid4()),
            modified_on=now,
            server_modified_on=now,
        )
        self.child_case_2.save()
        add_case_index(
            self.child_case_2,
            identifier='parent',
            referenced_type='person',
            referenced_id=self.parent_case_id,
        )
コード例 #30
0
 def create_case(self):
     return CommCareCase(
         case_id='redwoman',
         domain=self.domain,
         opened_on=datetime.datetime(2016, 5, 31),
         modified_on=datetime.datetime(2016, 5, 31),
         type='priestess',
         closed=False,
         name='melisandre',
         owner_id='lordoflight',
         indices=[{
             'identifier': 'advisor',
             'referenced_type': 'human',
             'referenced_id': 'stannis',
             'relationship': 'extension',
         }],
         case_json={
             'power': 'prophecy',
             'hometown': 'asshai'
         },
     )