Python CaseAccessorSQL.get_case方法代码示例

# 需要导入模块: from corehq.form_processor.backends.sql.dbaccessors import CaseAccessorSQL [as 别名]
# 或者: from corehq.form_processor.backends.sql.dbaccessors.CaseAccessorSQL import get_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 get_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 get_case [as 别名]
    def get_case_with_lock(case_id, lock=False, strip_history=False, wrap=False):
        try:
            if lock:
                try:
                    return CommCareCaseSQL.get_locked_obj(_id=case_id)
                except redis.RedisError:
                    case = CaseAccessorSQL.get_case(case_id)
            else:
                case = CaseAccessorSQL.get_case(case_id)
        except CaseNotFound:
            return None, None

        return case, None

# 需要导入模块: from corehq.form_processor.backends.sql.dbaccessors import CaseAccessorSQL [as 别名]
# 或者: from corehq.form_processor.backends.sql.dbaccessors.CaseAccessorSQL import get_case [as 别名]
    def _get_case(self, case_id):
        try:
            if self.lock:
                try:
                    case, lock = CommCareCaseSQL.get_locked_obj(_id=case_id)
                except redis.RedisError:
                    case = CaseAccessorSQL.get_case(case_id)
                else:
                    self.locks.append(lock)
            else:
                case = CaseAccessorSQL.get_case(case_id)
        except CaseNotFound:
            return None

        return case

# 需要导入模块: from corehq.form_processor.backends.sql.dbaccessors import CaseAccessorSQL [as 别名]
# 或者: from corehq.form_processor.backends.sql.dbaccessors.CaseAccessorSQL import get_case [as 别名]
 def test_get_case_by_id(self):
     case = _create_case()
     with self.assertNumQueries(1, using=db_for_read_write(CommCareCaseSQL)):
         case = CaseAccessorSQL.get_case(case.case_id)
     self.assertIsNotNone(case)
     self.assertIsInstance(case, CommCareCaseSQL)
     self.assertEqual(DOMAIN, case.domain)
     self.assertEqual('user1', case.owner_id)

# 需要导入模块: from corehq.form_processor.backends.sql.dbaccessors import CaseAccessorSQL [as 别名]
# 或者: from corehq.form_processor.backends.sql.dbaccessors.CaseAccessorSQL import get_case [as 别名]
    def referenced_case(self):
        """
        For a 'forward' index this is the case that the the index points to.
        For a 'reverse' index this is the case that owns the index.
        See ``CaseAccessorSQL.get_reverse_indices``

        :return: referenced case
        """
        from corehq.form_processor.backends.sql.dbaccessors import CaseAccessorSQL
        return CaseAccessorSQL.get_case(self.referenced_id)

# 需要导入模块: from corehq.form_processor.backends.sql.dbaccessors import CaseAccessorSQL [as 别名]
# 或者: from corehq.form_processor.backends.sql.dbaccessors.CaseAccessorSQL import get_case [as 别名]
    def get_case(self, case_id):
        try:
            return CaseAccessorSQL.get_case(case_id)
        except CaseNotFound:
            pass

        try:
            return CaseAccessorCouch.get_case(case_id)
        except ResourceNotFound:
            pass

        return None

# 需要导入模块: from corehq.form_processor.backends.sql.dbaccessors import CaseAccessorSQL [as 别名]
# 或者: from corehq.form_processor.backends.sql.dbaccessors.CaseAccessorSQL import get_case [as 别名]
    def test_reconcile_not_necessary(self):
        with freeze_time("2018-10-10"):
            case = self._create_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.assertFalse(update_strategy.reconcile_transactions_if_necessary())

# 需要导入模块: from corehq.form_processor.backends.sql.dbaccessors import CaseAccessorSQL [as 别名]
# 或者: from corehq.form_processor.backends.sql.dbaccessors.CaseAccessorSQL import get_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)

# 需要导入模块: from corehq.form_processor.backends.sql.dbaccessors import CaseAccessorSQL [as 别名]
# 或者: from corehq.form_processor.backends.sql.dbaccessors.CaseAccessorSQL import get_case [as 别名]
    def test_first_transaction_not_create(self):
        with freeze_time("2018-10-10"):
            case = self._create_case()

        with freeze_time("2018-10-08"):
            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])

        self.assertTrue(case.check_transaction_order())

        case = CaseAccessorSQL.get_case(case.case_id)
        update_strategy = SqlCaseUpdateStrategy(case)
        self.assertRaises(ReconciliationError, update_strategy.reconcile_transactions)

# 需要导入模块: from corehq.form_processor.backends.sql.dbaccessors import CaseAccessorSQL [as 别名]
# 或者: from corehq.form_processor.backends.sql.dbaccessors.CaseAccessorSQL import get_case [as 别名]
    def _create_case(self, case_type=None, user_id=None, case_id=None):
        case_id = case_id or uuid.uuid4().hex
        user_id = user_id or 'mr_wednesday'
        utcnow = datetime.utcnow()

        case = CommCareCaseSQL(
            case_id=case_id,
            domain=self.DOMAIN,
            type=case_type or '',
            owner_id=user_id,
            opened_on=utcnow,
            modified_on=utcnow,
            modified_by=utcnow,
            server_modified_on=utcnow
        )

        form = self._create_form(user_id, utcnow)
        case.track_create(self._create_case_transaction(case, form, utcnow, action_types=[128]))
        FormProcessorSQL.save_processed_models(ProcessedForms(form, []), [case])

        return CaseAccessorSQL.get_case(case_id)

# 需要导入模块: from corehq.form_processor.backends.sql.dbaccessors import CaseAccessorSQL [as 别名]
# 或者: from corehq.form_processor.backends.sql.dbaccessors.CaseAccessorSQL import get_case [as 别名]
def _create_case(domain=None, form_id=None, case_type=None, user_id=None, closed=False):
    """
    Create the models directly so that these tests aren't dependent on any
    other apps. Not testing form processing here anyway.
    :return: case_id
    """
    domain = domain or DOMAIN
    form_id = form_id or uuid.uuid4().hex
    case_id = uuid.uuid4().hex
    user_id = user_id or 'user1'
    utcnow = datetime.utcnow()

    form = XFormInstanceSQL(
        form_id=form_id,
        xmlns='http://openrosa.org/formdesigner/form-processor',
        received_on=utcnow,
        user_id=user_id,
        domain=domain
    )

    cases = []
    if case_id:
        case = CommCareCaseSQL(
            case_id=case_id,
            domain=domain,
            type=case_type or '',
            owner_id=user_id,
            opened_on=utcnow,
            modified_on=utcnow,
            modified_by=user_id,
            server_modified_on=utcnow,
            closed=closed or False
        )
        case.track_create(CaseTransaction.form_transaction(case, form))
        cases = [case]

    FormProcessorSQL.save_processed_models(ProcessedForms(form, None), cases)
    return CaseAccessorSQL.get_case(case_id)

# 需要导入模块: from corehq.form_processor.backends.sql.dbaccessors import CaseAccessorSQL [as 别名]
# 或者: from corehq.form_processor.backends.sql.dbaccessors.CaseAccessorSQL import get_case [as 别名]
    def test_ignores_before_rebuild_transaction(self):
        with freeze_time("2018-10-10"):
            case = self._create_case()

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

        self.assertFalse(case.check_transaction_order())

        with freeze_time("2018-10-13"):
            new_rebuild_xform = self._create_form()
            rebuild_detail = RebuildWithReason(reason="shadow's golden coin")
            rebuild_transaction = CaseTransaction.rebuild_transaction(case, rebuild_detail)
            case.track_create(rebuild_transaction)
            FormProcessorSQL.save_processed_models(ProcessedForms(new_rebuild_xform, []), [case])

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

# 需要导入模块: from corehq.form_processor.backends.sql.dbaccessors import CaseAccessorSQL [as 别名]
# 或者: from corehq.form_processor.backends.sql.dbaccessors.CaseAccessorSQL import get_case [as 别名]
 def test_get_case_by_id_missing(self):
     with self.assertRaises(CaseNotFound):
         CaseAccessorSQL.get_case('missing_case')

# 需要导入模块: from corehq.form_processor.backends.sql.dbaccessors import CaseAccessorSQL [as 别名]
# 或者: from corehq.form_processor.backends.sql.dbaccessors.CaseAccessorSQL import get_case [as 别名]
 def get_supply_point(supply_point_id):
     return CaseAccessorSQL.get_case(supply_point_id)