Python CaseAccessorSQL.save_case方法代码示例

# 需要导入模块: from corehq.form_processor.backends.sql.dbaccessors import CaseAccessorSQL [as 别名]
# 或者: from corehq.form_processor.backends.sql.dbaccessors.CaseAccessorSQL import save_case [as 别名]
    def test_reconcile_transactions_within_fudge_factor(self, soft_assert_mock):
        """ tests a transanction with an early client date and late server date """
        with freeze_time("2018-10-10"):
            case = self._create_case()

        with freeze_time("2018-10-11 06:00"):
            new_old_xform = self._create_form()
        with freeze_time("2018-10-10 18:00"):
            new_old_trans = self._create_case_transaction(case, new_old_xform)
        with freeze_time("2018-10-11 06:00"):
            case.track_create(new_old_trans)
            FormProcessorSQL.save_processed_models(ProcessedForms(new_old_xform, []), [case])

        with freeze_time("2018-10-11"):
            new_old_xform = self._create_form()
            new_old_trans = self._create_case_transaction(case, new_old_xform)
            case.track_create(new_old_trans)
            FormProcessorSQL.save_processed_models(ProcessedForms(new_old_xform, []), [case])

        case = CaseAccessorSQL.get_case(case.case_id)
        update_strategy = SqlCaseUpdateStrategy(case)
        self.assertTrue(update_strategy.reconcile_transactions_if_necessary())
        self._check_for_reconciliation_error_soft_assert(soft_assert_mock)

        CaseAccessorSQL.save_case(case)

        case = CaseAccessorSQL.get_case(case.case_id)
        update_strategy = SqlCaseUpdateStrategy(case)
        self.assertFalse(update_strategy.reconcile_transactions_if_necessary())
        self._check_for_reconciliation_error_soft_assert(soft_assert_mock)

# 需要导入模块: from corehq.form_processor.backends.sql.dbaccessors import CaseAccessorSQL [as 别名]
# 或者: from corehq.form_processor.backends.sql.dbaccessors.CaseAccessorSQL import save_case [as 别名]
    def test_save_case_update_index(self):
        case = _create_case()

        original_index = CommCareCaseIndexSQL(
            case=case,
            identifier='parent',
            referenced_type='mother',
            referenced_id=uuid.uuid4().hex,
            relationship_id=CommCareCaseIndexSQL.CHILD
        )
        case.track_create(original_index)
        CaseAccessorSQL.save_case(case)

        [index] = CaseAccessorSQL.get_indices(case.domain, case.case_id)
        index.identifier = 'new_identifier'  # shouldn't get saved
        index.referenced_type = 'new_type'
        index.referenced_id = uuid.uuid4().hex
        index.relationship_id = CommCareCaseIndexSQL.EXTENSION
        case.track_update(index)
        CaseAccessorSQL.save_case(case)

        [updated_index] = CaseAccessorSQL.get_indices(case.domain, case.case_id)
        self.assertEqual(updated_index.id, index.id)
        self.assertEqual(updated_index.identifier, original_index.identifier)
        self.assertEqual(updated_index.referenced_type, index.referenced_type)
        self.assertEqual(updated_index.referenced_id, index.referenced_id)
        self.assertEqual(updated_index.relationship_id, index.relationship_id)

# 需要导入模块: from corehq.form_processor.backends.sql.dbaccessors import CaseAccessorSQL [as 别名]
# 或者: from corehq.form_processor.backends.sql.dbaccessors.CaseAccessorSQL import save_case [as 别名]
def _create_case_transactions(case):
    case.track_create(CaseTransaction(
        case=case,
        form_id=uuid.uuid4().hex,
        server_date=datetime.utcnow(),
        type=CaseTransaction.TYPE_FORM,
        revoked=False
    ))
    # exclude revoked
    case.track_create(CaseTransaction(
        case=case,
        form_id=uuid.uuid4().hex,
        server_date=datetime.utcnow(),
        type=CaseTransaction.TYPE_FORM,
        revoked=True
    ))
    # exclude based on type
    case.track_create(CaseTransaction(
        case=case,
        form_id=uuid.uuid4().hex,
        server_date=datetime.utcnow(),
        type=CaseTransaction.TYPE_REBUILD_FORM_ARCHIVED,
        revoked=False
    ))
    form_ids = [t.form_id for t in case.get_tracked_models_to_create(CaseTransaction)]
    CaseAccessorSQL.save_case(case)
    return form_ids

# 需要导入模块: from corehq.form_processor.backends.sql.dbaccessors import CaseAccessorSQL [as 别名]
# 或者: from corehq.form_processor.backends.sql.dbaccessors.CaseAccessorSQL import save_case [as 别名]
    def test_get_attachment_by_name(self):
        case = _create_case()

        case.track_create(CaseAttachmentSQL(
            case=case,
            attachment_id=uuid.uuid4().hex,
            name='pic.jpg',
            content_type='image/jpeg',
            blob_id='123',
            identifier='pic1',
            md5='123'
        ))
        case.track_create(CaseAttachmentSQL(
            case=case,
            attachment_id=uuid.uuid4().hex,
            name='my_doc',
            content_type='text/xml',
            blob_id='124',
            identifier='doc1',
            md5='123'
        ))
        CaseAccessorSQL.save_case(case)

        with self.assertRaises(AttachmentNotFound):
            CaseAccessorSQL.get_attachment_by_identifier(case.case_id, 'missing')

        with self.assertNumQueries(1, using=db_for_read_write(CaseAttachmentSQL)):
            attachment_meta = CaseAccessorSQL.get_attachment_by_identifier(case.case_id, 'pic1')

        self.assertEqual(case.case_id, attachment_meta.case_id)
        self.assertEqual('pic.jpg', attachment_meta.name)
        self.assertEqual('image/jpeg', attachment_meta.content_type)

# 需要导入模块: from corehq.form_processor.backends.sql.dbaccessors import CaseAccessorSQL [as 别名]
# 或者: from corehq.form_processor.backends.sql.dbaccessors.CaseAccessorSQL import save_case [as 别名]
    def test_get_attachments(self):
        case = _create_case()

        case.track_create(CaseAttachmentSQL(
            case=case,
            attachment_id=uuid.uuid4().hex,
            name='pic.jpg',
            content_type='image/jpeg'
        ))
        case.track_create(CaseAttachmentSQL(
            case=case,
            attachment_id=uuid.uuid4().hex,
            name='doc',
            content_type='text/xml'
        ))
        CaseAccessorSQL.save_case(case)

        with self.assertRaises(AttachmentNotFound):
            CaseAccessorSQL.get_attachment_by_name(case.case_id, 'missing')

        with self.assertNumQueries(1, using=db_for_read_write(CaseAttachmentSQL)):
            attachments = CaseAccessorSQL.get_attachments(case.case_id)

        self.assertEqual(2, len(attachments))
        sorted_attachments = sorted(attachments, key=lambda x: x.name)
        for att in attachments:
            self.assertEqual(case.case_id, att.case_id)
        self.assertEqual('doc', sorted_attachments[0].name)
        self.assertEqual('pic.jpg', sorted_attachments[1].name)

# 需要导入模块: from corehq.form_processor.backends.sql.dbaccessors import CaseAccessorSQL [as 别名]
# 或者: from corehq.form_processor.backends.sql.dbaccessors.CaseAccessorSQL import save_case [as 别名]
    def test_get_extension_case_ids(self):
        # Create case and index
        referenced_id = uuid.uuid4().hex
        case = _create_case()
        extension_index = CommCareCaseIndexSQL(
            case=case,
            identifier="task",
            referenced_type="task",
            referenced_id=referenced_id,
            relationship_id=CommCareCaseIndexSQL.EXTENSION
        )
        case.track_create(extension_index)
        CaseAccessorSQL.save_case(case)

        # Create irrelevant case
        other_case = _create_case()
        child_index = CommCareCaseIndexSQL(
            case=other_case,
            identifier='parent',
            referenced_type='mother',
            referenced_id=referenced_id,
            relationship_id=CommCareCaseIndexSQL.CHILD
        )
        case.track_create(child_index)
        CaseAccessorSQL.save_case(other_case)

        self.assertEqual(
            CaseAccessorSQL.get_extension_case_ids(DOMAIN, [referenced_id]),
            [case.case_id]
        )

# 需要导入模块: from corehq.form_processor.backends.sql.dbaccessors import CaseAccessorSQL [as 别名]
# 或者: from corehq.form_processor.backends.sql.dbaccessors.CaseAccessorSQL import save_case [as 别名]
    def hard_rebuild_case(domain, case_id, detail, lock=True):
        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 = CommCareCaseSQL(case_id=case_id, domain=domain)
            if lock:
                lock_obj = CommCareCaseSQL.get_obj_lock_by_id(case_id)
                acquire_lock(lock_obj, degrade_gracefully=False)

        try:
            assert case.domain == domain, (case.domain, domain)
            case, rebuild_transaction = FormProcessorSQL._rebuild_case_from_transactions(case, detail)
            if case.is_deleted and not case.is_saved():
                return None

            case.server_modified_on = rebuild_transaction.server_date
            CaseAccessorSQL.save_case(case)
            publish_case_saved(case)
            return case
        finally:
            release_lock(lock_obj, degrade_gracefully=True)

# 需要导入模块: from corehq.form_processor.backends.sql.dbaccessors import CaseAccessorSQL [as 别名]
# 或者: from corehq.form_processor.backends.sql.dbaccessors.CaseAccessorSQL import save_case [as 别名]
    def test_get_attachments(self):
        case = _create_case()

        case.track_create(CaseAttachmentSQL(
            case=case,
            attachment_id=uuid.uuid4().hex,
            name='pic.jpg',
            content_type='image/jpeg',
            blob_id='125',
            identifier='pic1',
            md5='123',
        ))
        case.track_create(CaseAttachmentSQL(
            case=case,
            attachment_id=uuid.uuid4().hex,
            name='doc',
            content_type='text/xml',
            blob_id='126',
            identifier='doc1',
            md5='123',
        ))
        CaseAccessorSQL.save_case(case)

        with self.assertNumQueries(1, using=db_for_read_write(CaseAttachmentSQL)):
            attachments = CaseAccessorSQL.get_attachments(case.case_id)

        self.assertEqual(2, len(attachments))
        sorted_attachments = sorted(attachments, key=lambda x: x.name)
        for att in attachments:
            self.assertEqual(case.case_id, att.case_id)
        self.assertEqual('doc', sorted_attachments[0].name)
        self.assertEqual('pic.jpg', sorted_attachments[1].name)

# 需要导入模块: from corehq.form_processor.backends.sql.dbaccessors import CaseAccessorSQL [as 别名]
# 或者: from corehq.form_processor.backends.sql.dbaccessors.CaseAccessorSQL import save_case [as 别名]
    def test_hard_delete_case(self):
        case1 = _create_case()
        case2 = _create_case(domain='other_domain')
        self.addCleanup(lambda: CaseAccessorSQL.hard_delete_cases('other_domain', [case2.case_id]))

        case1.track_create(CommCareCaseIndexSQL(
            case=case1,
            identifier='parent',
            referenced_type='mother',
            referenced_id=uuid.uuid4().hex,
            relationship_id=CommCareCaseIndexSQL.CHILD
        ))
        case1.track_create(CaseAttachmentSQL(
            case=case1,
            attachment_id=uuid.uuid4().hex,
            name='pic.jpg',
            content_type='image/jpeg',
            blob_id='122',
            md5='123',
            identifier='pic.jpg',
        ))
        CaseAccessorSQL.save_case(case1)

        num_deleted = CaseAccessorSQL.hard_delete_cases(DOMAIN, [case1.case_id, case2.case_id])
        self.assertEqual(1, num_deleted)
        with self.assertRaises(CaseNotFound):
            CaseAccessorSQL.get_case(case1.case_id)

        self.assertEqual([], CaseAccessorSQL.get_indices(case1.domain, case1.case_id))
        self.assertEqual([], CaseAccessorSQL.get_attachments(case1.case_id))
        self.assertEqual([], CaseAccessorSQL.get_transactions(case1.case_id))

# 需要导入模块: from corehq.form_processor.backends.sql.dbaccessors import CaseAccessorSQL [as 别名]
# 或者: from corehq.form_processor.backends.sql.dbaccessors.CaseAccessorSQL import save_case [as 别名]
    def test_get_case_by_location(self):
        case = _create_case(case_type=SupplyPointCaseMixin.CASE_TYPE)
        location_id = uuid.uuid4().hex
        case.location_id = location_id
        CaseAccessorSQL.save_case(case)

        fetched_case = CaseAccessorSQL.get_case_by_location(DOMAIN, location_id)
        self.assertEqual(case.id, fetched_case.id)

# 需要导入模块: from corehq.form_processor.backends.sql.dbaccessors import CaseAccessorSQL [as 别名]
# 或者: from corehq.form_processor.backends.sql.dbaccessors.CaseAccessorSQL import save_case [as 别名]
    def test_get_closed_case_ids(self):
        case1 = _create_case(user_id="user1")
        case2 = _create_case(user_id="user1")
        case3 = _create_case(user_id="user2")
        case2.closed = True
        CaseAccessorSQL.save_case(case2)

        self.assertEqual(CaseAccessorSQL.get_closed_case_ids_for_owner(DOMAIN, "user1"), [case2.case_id])

# 需要导入模块: from corehq.form_processor.backends.sql.dbaccessors import CaseAccessorSQL [as 别名]
# 或者: from corehq.form_processor.backends.sql.dbaccessors.CaseAccessorSQL import save_case [as 别名]
def _update_case(domain, case_id, server_modified_on, last_visit_date=None):
    accessors = CaseAccessors(domain)
    case = accessors.get_case(case_id)
    case.server_modified_on = server_modified_on
    if last_visit_date:
        set_case_property_directly(case, 'last_visit_date', last_visit_date.strftime('%Y-%m-%d'))
    if should_use_sql_backend(domain):
        CaseAccessorSQL.save_case(case)
    else:
        # can't call case.save() since it overrides the server_modified_on property
        CommCareCase.get_db().save_doc(case.to_json())

# 需要导入模块: from corehq.form_processor.backends.sql.dbaccessors import CaseAccessorSQL [as 别名]
# 或者: from corehq.form_processor.backends.sql.dbaccessors.CaseAccessorSQL import save_case [as 别名]
    def test_get_all_reverse_indices_info(self):
        # Create case and indexes
        case = _create_case()
        referenced_id1 = uuid.uuid4().hex
        referenced_id2 = uuid.uuid4().hex
        extension_index = CommCareCaseIndexSQL(
            case=case,
            identifier="task",
            referenced_type="task",
            referenced_id=referenced_id1,
            relationship_id=CommCareCaseIndexSQL.EXTENSION
        )
        case.track_create(extension_index)
        child_index = CommCareCaseIndexSQL(
            case=case,
            identifier='parent',
            referenced_type='mother',
            referenced_id=referenced_id2,
            relationship_id=CommCareCaseIndexSQL.CHILD
        )
        case.track_create(child_index)
        CaseAccessorSQL.save_case(case)

        # Create irrelevant case and index
        other_case = _create_case()
        other_child_index = CommCareCaseIndexSQL(
            case=other_case,
            identifier='parent',
            referenced_type='mother',
            referenced_id=case.case_id,
            relationship_id=CommCareCaseIndexSQL.CHILD
        )
        other_case.track_create(other_child_index)
        CaseAccessorSQL.save_case(other_case)

        self.assertEqual(
            set(CaseAccessorSQL.get_all_reverse_indices_info(DOMAIN, [referenced_id1, referenced_id2])),
            {
                CaseIndexInfo(
                    case_id=case.case_id,
                    identifier=u'task',
                    referenced_id=referenced_id1,
                    referenced_type=u'task',
                    relationship=CommCareCaseIndexSQL.EXTENSION,
                ),
                CaseIndexInfo(
                    case_id=case.case_id,
                    identifier=u'parent',
                    referenced_id=referenced_id2,
                    referenced_type=u'mother',
                    relationship=CommCareCaseIndexSQL.CHILD
                ),
            }
        )

# 需要导入模块: from corehq.form_processor.backends.sql.dbaccessors import CaseAccessorSQL [as 别名]
# 或者: from corehq.form_processor.backends.sql.dbaccessors.CaseAccessorSQL import save_case [as 别名]
    def test_save_case_update_transaction(self):
        case = _create_case()

        [transaction] = CaseAccessorSQL.get_transactions(case.case_id)
        transaction.revoked = True

        # hack to call the sql function with an already saved transaction
        case.track_create(transaction)

        with self.assertRaises(CaseSaveError):
            CaseAccessorSQL.save_case(case)

# 需要导入模块: from corehq.form_processor.backends.sql.dbaccessors import CaseAccessorSQL [as 别名]
# 或者: from corehq.form_processor.backends.sql.dbaccessors.CaseAccessorSQL import save_case [as 别名]
    def hard_rebuild_case(domain, case_id, detail):
        try:
            case = CaseAccessorSQL.get_case(case_id)
            assert case.domain == domain
            found = True
        except CaseNotFound:
            case = CommCareCaseSQL(case_id=case_id, domain=domain)
            found = False

        case = FormProcessorSQL._rebuild_case_from_transactions(case, detail)
        if case.is_deleted and not found:
            return None
        CaseAccessorSQL.save_case(case)