Python dbaccessors.CaseAccessorSQL类代码示例

    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)

    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)

    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)

 def tearDownClass(cls):
     CaseAccessorSQL.hard_delete_cases(
         cls.domain,
         cls.created_case_ids
     )
     cls.domain_obj.delete()
     super(BaseICDSTest, cls).tearDownClass()

    def test_edit_form_that_removes_ledgers(self):
        from corehq.apps.commtrack.tests.util import get_single_balance_block
        form_id = uuid.uuid4().hex
        submit_case_blocks([
            get_single_balance_block(self.case.case_id, self.product_a._id, 100)],
            DOMAIN,
            form_id=form_id
        )

        self._assert_ledger_state(100)

        transactions = CaseAccessorSQL.get_transactions(self.case.case_id)
        self.assertEqual(2, len(transactions))
        self.assertTrue(transactions[0].is_form_transaction)
        self.assertTrue(transactions[1].is_form_transaction)
        self.assertTrue(transactions[1].is_ledger_transaction)

        submit_case_blocks([
            CaseBlock(case_id=self.case.case_id).as_string().decode('utf-8')],
            DOMAIN,
            form_id=form_id
        )

        self._assert_ledger_state(0)

        transactions = CaseAccessorSQL.get_transactions(self.case.case_id)
        self.assertEqual(3, len(transactions))
        self.assertTrue(transactions[0].is_form_transaction)
        # ordering not guaranteed since they have the same date
        self.assertTrue(transactions[1].is_form_transaction)
        self.assertFalse(transactions[1].is_ledger_transaction)  # no longer a ledger transaction
        self.assertTrue(transactions[2].is_case_rebuild)

        self._assert_transactions([])

    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)

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

    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)

    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]
        )

    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)

    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])

 def test_case_has_transactions_since_sync(self):
     case1 = _create_case()
     _create_case_transactions(case1)
     self.assertTrue(
         CaseAccessorSQL.case_has_transactions_since_sync(case1.case_id, "foo", datetime(1992, 01, 30))
     )
     self.assertFalse(
         CaseAccessorSQL.case_has_transactions_since_sync(case1.case_id, "foo", datetime.utcnow())
     )

    def test_get_deleted_case_ids_by_owner(self):
        user_id = uuid.uuid4().hex
        case1 = _create_case(user_id=user_id)
        case2 = _create_case(user_id=user_id)
        case3 = _create_case(user_id=user_id)

        CaseAccessorSQL.soft_delete_cases(DOMAIN, [case1.case_id, case2.case_id])

        case_ids = CaseAccessorSQL.get_deleted_case_ids_by_owner(DOMAIN, user_id)
        self.assertEqual(set(case_ids), {case1.case_id, case2.case_id})

    def test_get_transaction_by_form_id(self):
        form_id = uuid.uuid4().hex
        case = _create_case(form_id=form_id)

        transaction = CaseAccessorSQL.get_transaction_by_form_id(case.case_id, form_id)
        self.assertEqual(form_id, transaction.form_id)
        self.assertEqual(case.case_id, transaction.case_id)

        transaction = CaseAccessorSQL.get_transaction_by_form_id(case.case_id, 'wrong')
        self.assertIsNone(transaction)

def create_case(domain, case_type, **kwargs):
    case = CaseFactory(domain).create_case(case_type=case_type, **kwargs)

    try:
        yield case
    finally:
        if should_use_sql_backend(domain):
            CaseAccessorSQL.hard_delete_cases(domain, [case.case_id])
        else:
            case.delete()