Exemplo n.º 1
0
def _rebuild_action():
    now = datetime.datetime.utcnow()
    return CommCareCaseAction(
        action_type=const.CASE_ACTION_REBUILD,
        date=now,
        server_date=now,
    )
    def _send_case_to_es(self,
                         domain=None,
                         owner_id=None,
                         user_id=None,
                         case_type=None,
                         opened_on=None,
                         closed_on=None):

        actions = [
            CommCareCaseAction(
                action_type=CASE_ACTION_CREATE,
                date=opened_on,
            )
        ]

        case = CommCareCase(
            _id=uuid.uuid4().hex,
            domain=domain or self.domain,
            owner_id=owner_id or self.owner_id,
            user_id=user_id or self.user_id,
            type=case_type or self.case_type,
            opened_on=opened_on or datetime.now(),
            opened_by=user_id or self.user_id,
            closed_on=closed_on,
            closed_by=user_id or self.user_id,
            actions=actions,
        )
        send_to_elasticsearch('cases', case.to_json())
        self.es.indices.refresh(CASE_INDEX_INFO.index)
        return case
    def test_update_dependent_case_owner_still_present(self):
        sync_log = SimplifiedSyncLog(
            domain="domain",
            case_ids_on_phone={'c1', 'd1'},
            dependent_case_ids_on_phone={'d1'},
            index_tree=IndexTree(indices={'c1': {
                'd1-id': 'd1'
            }}),
            user_id="user",
            owner_ids_on_phone={'user1'})

        dependent_case_state = CaseState(case_id="d1", indices=[])
        xform_id = uuid.uuid4().hex
        xform = XFormInstance(_id=xform_id)
        form_actions = [
            CommCareCaseAction(action_type=CASE_ACTION_UPDATE,
                               updated_known_properties={'owner_id': 'user2'})
        ]
        with patch.object(CommCareCase,
                          'get_actions_for_form',
                          return_value=form_actions):
            parent_case = CommCareCase(_id='d1')
            # before this test was added, the following call raised a ValueError on legacy logs.
            sync_log.update_phone_lists(xform, [parent_case])
            self.assertIn(dependent_case_state,
                          sync_log.test_only_get_dependent_cases_on_phone())
 def test_update_dependent_case_owner_still_present(self):
     dependent_case_state = CaseState(case_id="d1", indices=[])
     sync_log = SyncLog(cases_on_phone=[
         CaseState(case_id="c1",
                   indices=[
                       CommCareCaseIndex(identifier="d1-id",
                                         referenced_id="d1")
                   ])
     ],
                        dependent_cases_on_phone=[dependent_case_state],
                        owner_ids_on_phone=['user1'])
     xform_id = uuid.uuid4().hex
     xform = XFormInstance(_id=xform_id)
     form_actions = [
         CommCareCaseAction(action_type=CASE_ACTION_UPDATE,
                            updated_known_properties={'owner_id': 'user2'})
     ]
     with patch.object(CommCareCase,
                       'get_actions_for_form',
                       return_value=form_actions):
         parent_case = CommCareCase(_id='d1')
         # before this test was added, the following call raised a ValueError on legacy logs.
         for log in [
                 sync_log,
                 SimplifiedSyncLog.from_other_format(sync_log)
         ]:
             log.update_phone_lists(xform, [parent_case])
             self.assertIn(dependent_case_state,
                           log.test_only_get_dependent_cases_on_phone())
 def test_update_dependent_case(self):
     sync_log = SyncLog(
         cases_on_phone=[
             CaseState(
                 case_id='bran',
                 indices=[
                     CommCareCaseIndex(identifier='legs',
                                       referenced_id='hodor')
                 ],
             ),
         ],
         dependent_cases_on_phone=[CaseState(case_id='hodor')])
     xform_id = uuid.uuid4().hex
     xform = XFormInstance(_id=xform_id)
     form_actions = [CommCareCaseAction(action_type=CASE_ACTION_UPDATE, )]
     with patch.object(CommCareCase,
                       'get_actions_for_form',
                       return_value=form_actions):
         parent_case = CommCareCase(_id='hodor')
         # before this test was added, the following call raised a SyncLogAssertionError on legacy logs.
         # this test just ensures it doesn't still do that.
         for log in [
                 sync_log,
                 SimplifiedSyncLog.from_other_format(sync_log)
         ]:
             log.update_phone_lists(xform, [parent_case])
Exemplo n.º 6
0
def _make_action(server_date,
                 phone_date=EMPTY_DATE,
                 action_type=const.CASE_ACTION_UPDATE,
                 user_id='someuserid'):
    if phone_date == EMPTY_DATE:
        phone_date = server_date
    return CommCareCaseAction(action_type=action_type,
                              server_date=server_date,
                              date=phone_date,
                              user_id=user_id)
Exemplo n.º 7
0
def _make_action(server_date,
                 phone_date=EMPTY_DATE,
                 action_type=const.CASE_ACTION_UPDATE,
                 user_id='someuserid',
                 form_id=None):
    if phone_date == EMPTY_DATE:
        phone_date = server_date
    form_id = form_id or uuid.uuid4().hex
    return CommCareCaseAction(action_type=action_type,
                              server_date=server_date,
                              date=phone_date,
                              user_id=user_id,
                              xform_id=form_id)
 def test_update_dependent_case(self):
     sync_log = SimplifiedSyncLog(
         case_ids_on_phone={'bran', 'hodor'},
         dependent_case_ids_on_phone={'hodor'},
         index_tree=IndexTree(indices={'bran': {
             'legs': 'hodor'
         }}),
         user_id="someuser")
     xform_id = uuid.uuid4().hex
     xform = XFormInstance(_id=xform_id)
     form_actions = [CommCareCaseAction(action_type=CASE_ACTION_UPDATE, )]
     with patch.object(CommCareCase,
                       'get_actions_for_form',
                       return_value=form_actions):
         parent_case = CommCareCase(_id='hodor')
         # before this test was added, the following call raised a SyncLogAssertionError on legacy logs.
         # this test just ensures it doesn't still do that.
         sync_log.update_phone_lists(xform, [parent_case])
    def _copy_unprocessed_case(self, change):
        couch_case = CommCareCase.wrap(change.get_document())
        log.debug('Processing doc: {}({})'.format(couch_case['doc_type'], change.id))
        try:
            first_action = couch_case.actions[0]
        except IndexError:
            first_action = CommCareCaseAction()

        sql_case = CommCareCaseSQL(
            case_id=couch_case.case_id,
            domain=self.domain,
            type=couch_case.type or '',
            name=couch_case.name,
            owner_id=couch_case.owner_id or couch_case.user_id or '',
            opened_on=couch_case.opened_on or first_action.date,
            opened_by=couch_case.opened_by or first_action.user_id,
            modified_on=couch_case.modified_on,
            modified_by=couch_case.modified_by or couch_case.user_id or '',
            server_modified_on=couch_case.server_modified_on,
            closed=couch_case.closed,
            closed_on=couch_case.closed_on,
            closed_by=couch_case.closed_by,
            deleted=True,
            deletion_id=couch_case.deletion_id,
            deleted_on=couch_case.deletion_date,
            external_id=couch_case.external_id,
            case_json=couch_case.dynamic_case_properties()
        )
        _migrate_case_actions(couch_case, sql_case)
        _migrate_case_indices(couch_case, sql_case)
        _migrate_case_attachments(couch_case, sql_case)
        try:
            CaseAccessorSQL.save_case(sql_case)
        except IntegrityError:
            # case re-created by form processing so just mark the case as deleted
            CaseAccessorSQL.soft_delete_cases(
                self.domain,
                [sql_case.case_id],
                sql_case.deleted_on,
                sql_case.deletion_id
            )

        self.processed_docs += 1
        self._log_unprocessed_cases_processed_count(throttled=True)
Exemplo n.º 10
0
    def _copy_unprocessed_case(self, doc):
        couch_case = CommCareCase.wrap(doc)
        log.debug('Processing doc: %(doc_type)s(%(_id)s)', doc)
        try:
            first_action = couch_case.actions[0]
        except IndexError:
            first_action = CommCareCaseAction()

        opened_on = couch_case.opened_on or first_action.date
        sql_case = CommCareCaseSQL(
            case_id=couch_case.case_id,
            domain=self.domain,
            type=couch_case.type or '',
            name=couch_case.name,
            owner_id=couch_case.owner_id or couch_case.user_id or '',
            opened_on=opened_on,
            opened_by=couch_case.opened_by or first_action.user_id,
            modified_on=couch_case.modified_on or opened_on,
            modified_by=couch_case.modified_by or couch_case.user_id or '',
            server_modified_on=couch_case.server_modified_on,
            closed=couch_case.closed,
            closed_on=couch_case.closed_on,
            closed_by=couch_case.closed_by,
            deleted=True,
            deletion_id=couch_case.deletion_id,
            deleted_on=couch_case.deletion_date,
            external_id=couch_case.external_id,
            case_json=couch_case.dynamic_case_properties())
        _migrate_case_actions(couch_case, sql_case)
        _migrate_case_indices(couch_case, sql_case)
        _migrate_case_attachments(couch_case, sql_case)
        try:
            CaseAccessorSQL.save_case(sql_case)
        except IntegrityError:
            # case re-created by form processing so just mark the case as deleted
            CaseAccessorSQL.soft_delete_cases(self.domain, [sql_case.case_id],
                                              sql_case.deleted_on,
                                              sql_case.deletion_id)
        finally:
            self.case_diff_queue.enqueue(couch_case.case_id)
Exemplo n.º 11
0
    def _copy_unprocessed_cases(self):
        doc_types = ['CommCareCase-Deleted']
        changes = _get_case_iterator(self.domain,
                                     doc_types=doc_types).iter_all_changes()
        for change in self._with_progress(doc_types, changes):
            couch_case = CommCareCase.wrap(change.get_document())
            self.log_debug('Processing doc: {}({})'.format(
                couch_case['doc_type'], change.id))
            try:
                first_action = couch_case.actions[0]
            except IndexError:
                first_action = CommCareCaseAction()

            sql_case = CommCareCaseSQL(
                case_id=couch_case.case_id,
                domain=self.domain,
                type=couch_case.type or '',
                name=couch_case.name,
                owner_id=couch_case.owner_id or couch_case.user_id or '',
                opened_on=couch_case.opened_on or first_action.date,
                opened_by=couch_case.opened_by or first_action.user_id,
                modified_on=couch_case.modified_on,
                modified_by=couch_case.modified_by or couch_case.user_id or '',
                server_modified_on=couch_case.server_modified_on,
                closed=couch_case.closed,
                closed_on=couch_case.closed_on,
                closed_by=couch_case.closed_by,
                deleted=True,
                deletion_id=couch_case.deletion_id,
                deleted_on=couch_case.deletion_date,
                external_id=couch_case.external_id,
                case_json=couch_case.dynamic_case_properties())
            _migrate_case_actions(couch_case, sql_case)
            _migrate_case_indices(couch_case, sql_case)
            _migrate_case_attachments(couch_case, sql_case)
            try:
                CaseAccessorSQL.save_case(sql_case)
            except IntegrityError as e:
                self.log_error("Unable to migrate case:\n{}\n{}".format(
                    couch_case.case_id, e))
Exemplo n.º 12
0
            rebuild_case_from_forms(REBUILD_TEST_DOMAIN, child_case_id, RebuildWithReason(reason='test'))


class TestCheckActionOrder(SimpleTestCase):

    def test_already_sorted(self):
        case = CommCareCase(actions=[
            CommCareCaseAction(server_date=datetime(2001, 1, 1, 0, 0, 0)),
            CommCareCaseAction(server_date=datetime(2001, 1, 2, 0, 0, 0)),
            CommCareCaseAction(server_date=datetime(2001, 1, 3, 0, 0, 0)),
        ])
        self.assertTrue(CouchCaseUpdateStrategy(case).check_action_order())

    def test_out_of_order(self):
        case = CommCareCase(actions=[
            CommCareCaseAction(server_date=datetime(2001, 1, 1, 0, 0, 0)),
            CommCareCaseAction(server_date=datetime(2001, 1, 3, 0, 0, 0)),
            CommCareCaseAction(server_date=datetime(2001, 1, 2, 0, 0, 0)),
        ])
        self.assertFalse(CouchCaseUpdateStrategy(case).check_action_order())

    def test_sorted_with_none(self):
        case = CommCareCase(actions=[
            CommCareCaseAction(server_date=datetime(2001, 1, 1, 0, 0, 0)),
            CommCareCaseAction(server_date=None),
            CommCareCaseAction(server_date=datetime(2001, 1, 2, 0, 0, 0)),
            CommCareCaseAction(server_date=datetime(2001, 1, 3, 0, 0, 0)),
        ])
        self.assertTrue(CouchCaseUpdateStrategy(case).check_action_order())

    def test_out_of_order_with_none(self):
Exemplo n.º 13
0
class TestCheckActionOrder(TestCase):
    def test(self):
        case = CommCareCase(actions=[
            CommCareCaseAction(server_date=datetime(2001, 01, 01, 00, 00, 00)),
            CommCareCaseAction(server_date=datetime(2001, 01, 02, 00, 00, 00)),
            CommCareCaseAction(server_date=datetime(2001, 01, 03, 00, 00, 00)),
        ])
        self.assertTrue(case.check_action_order())
        case = CommCareCase(actions=[
            CommCareCaseAction(server_date=datetime(2001, 01, 01, 00, 00, 00)),
            CommCareCaseAction(server_date=datetime(2001, 01, 03, 00, 00, 00)),
            CommCareCaseAction(server_date=datetime(2001, 01, 02, 00, 00, 00)),
        ])
        self.assertFalse(case.check_action_order())
        case = CommCareCase(actions=[
            CommCareCaseAction(server_date=datetime(2001, 01, 01, 00, 00, 00)),
            CommCareCaseAction(server_date=None),
            CommCareCaseAction(server_date=datetime(2001, 01, 02, 00, 00, 00)),
            CommCareCaseAction(server_date=datetime(2001, 01, 03, 00, 00, 00)),
        ])
        self.assertTrue(case.check_action_order())
        case = CommCareCase(actions=[
            CommCareCaseAction(server_date=datetime(2001, 01, 01, 00, 00, 00)),
            CommCareCaseAction(server_date=datetime(2001, 01, 03, 00, 00, 00)),
            CommCareCaseAction(server_date=None),
            CommCareCaseAction(server_date=datetime(2001, 01, 02, 00, 00, 00)),
        ])
        self.assertFalse(case.check_action_order())
Exemplo n.º 14
0
 def _action(self, datetime_):
     return CommCareCaseAction(server_date=datetime_, date=datetime_, action_type='update')
Exemplo n.º 15
0
 def test_couch_action_not_equals(self):
     orig = CommCareCaseAction()
     copy = CommCareCaseAction.wrap(deepcopy(orig._doc))
     self.assertTrue(orig == copy)
     self.assertFalse(orig != copy)