Example #1
0
 def change_form_unique_id(form, map):
     unique_id = form['unique_id']
     new_unique_id = map.get(form['xmlns'], random_hex())
     form['unique_id'] = new_unique_id
     if ("%s.xml" % unique_id) in app_source['_attachments']:
         app_source['_attachments']["%s.xml" % new_unique_id] = app_source['_attachments'].pop("%s.xml" % unique_id)
     return new_unique_id
Example #2
0
def delete_all_data(request, domain, template="cleanup/delete_all_data.html"):
    if request.method == 'GET':
        return render(request, template, {
            'domain': domain
        })
    key = make_form_couch_key(domain)
    xforms = XFormInstance.view('reports_forms/all_forms',
        startkey=key,
        endkey=key+[{}],
        include_docs=True,
        reduce=False
    )
    cases = CommCareCase.view('case/by_date_modified',
        startkey=[domain, {}, {}],
        endkey=[domain, {}, {}, {}],
        include_docs=True,
        reduce=False
    )
    suffix = DELETED_SUFFIX
    deletion_id = random_hex()
    for thing_list in (xforms, cases):
        for thing in thing_list:
            thing.doc_type += suffix
            thing['-deletion_id'] = deletion_id
            thing.save()
    return HttpResponseRedirect(reverse('homepage'))
    def test_aggregate_ucr_delete(self):
        for domain_name in [self.domain.name, self.domain2.name]:
            aggregate_table_definition = AggregateTableDefinition.objects.create(
                domain=domain_name,
                primary_data_source_id=uuid.uuid4(),
                table_id=random_hex(),
            )
            secondary_table_definition = SecondaryTableDefinition.objects.create(
                table_definition=aggregate_table_definition,
                data_source_id=uuid.uuid4(),
            )
            PrimaryColumn.objects.create(table_definition=aggregate_table_definition)
            SecondaryColumn.objects.create(table_definition=secondary_table_definition)
            self._assert_aggregate_ucr_count(domain_name, 1)

        self.domain.delete()

        self._assert_aggregate_ucr_count(self.domain.name, 0)
        self._assert_aggregate_ucr_count(self.domain2.name, 1)

        self.assertEqual(SecondaryTableDefinition.objects.count(), 1)
        self.assertEqual(
            SecondaryTableDefinition.objects.filter(table_definition__domain=self.domain2.name).count(),
            1
        )
        self.assertEqual(PrimaryColumn.objects.count(), 1)
        self.assertEqual(PrimaryColumn.objects.filter(table_definition__domain=self.domain2.name).count(), 1)
        self.assertEqual(SecondaryColumn.objects.count(), 1)
        self.assertEqual(
            SecondaryColumn.objects.filter(table_definition__table_definition__domain=self.domain2.name).count(),
            1
        )
Example #4
0
def update_unique_ids(app_source):
    from corehq.apps.app_manager.models import form_id_references, jsonpath_update

    app_source = deepcopy(app_source)

    def change_form_unique_id(form):
        unique_id = form['unique_id']
        new_unique_id = random_hex()
        form['unique_id'] = new_unique_id
        if ("%s.xml" % unique_id) in app_source['_attachments']:
            app_source['_attachments']["%s.xml" % new_unique_id] = app_source['_attachments'].pop("%s.xml" % unique_id)
        return new_unique_id

    change_form_unique_id(app_source['user_registration'])
    id_changes = {}
    for m, module in enumerate(app_source['modules']):
        for f, form in enumerate(module['forms']):
            old_id = form['unique_id']
            new_id = change_form_unique_id(app_source['modules'][m]['forms'][f])
            id_changes[old_id] = new_id

    for reference_path in form_id_references:
        for reference in reference_path.find(app_source):
            if reference.value in id_changes:
                jsonpath_update(reference, id_changes[reference.value])

    for module in app_source['modules']:
        if module['module_type'] == 'report':
            for report_config in module['report_configs']:
                report_config['uuid'] = random_hex()

    return app_source
Example #5
0
 def change_form_unique_id(form):
     unique_id = form['unique_id']
     new_unique_id = random_hex()
     form['unique_id'] = new_unique_id
     if ("%s.xml" % unique_id) in app_source['_attachments']:
         app_source['_attachments']["%s.xml" % new_unique_id] = app_source['_attachments'].pop("%s.xml" % unique_id)
     return new_unique_id
    def test_aggregate_ucr_delete(self):
        for domain_name in [self.domain.name, self.domain2.name]:
            aggregate_table_definition = AggregateTableDefinition.objects.create(
                domain=domain_name,
                primary_data_source_id=uuid.uuid4(),
                table_id=random_hex(),
            )
            secondary_table_definition = SecondaryTableDefinition.objects.create(
                table_definition=aggregate_table_definition,
                data_source_id=uuid.uuid4(),
            )
            PrimaryColumn.objects.create(
                table_definition=aggregate_table_definition)
            SecondaryColumn.objects.create(
                table_definition=secondary_table_definition)
            self._assert_aggregate_ucr_count(domain_name, 1)

        self.domain.delete()

        self._assert_aggregate_ucr_count(self.domain.name, 0)
        self._assert_aggregate_ucr_count(self.domain2.name, 1)

        self.assertEqual(SecondaryTableDefinition.objects.count(), 1)
        self.assertEqual(
            SecondaryTableDefinition.objects.filter(
                table_definition__domain=self.domain2.name).count(), 1)
        self.assertEqual(PrimaryColumn.objects.count(), 1)
        self.assertEqual(
            PrimaryColumn.objects.filter(
                table_definition__domain=self.domain2.name).count(), 1)
        self.assertEqual(SecondaryColumn.objects.count(), 1)
        self.assertEqual(
            SecondaryColumn.objects.filter(
                table_definition__table_definition__domain=self.domain2.name).
            count(), 1)
Example #7
0
    def from_log_record(cls, record):
        type = exc = tb = traceback_string = None
        if record.exc_info:
            type, exc, tb = record.exc_info
            traceback_string = "".join(traceback.format_tb(tb))
        # ['args', 'created', 'exc_info', 'exc_text', 'filename', 'funcName',
        # 'getMessage', 'levelname', 'levelno', 'lineno', 'module', 'msecs',
        # 'msg', 'name', 'pathname', 'process', 'processName',
        # 'relativeCreated', 'thread', 'threadName']

        # to fix a problem with gunicorn
        # in which things get logged after fork
        # but before calling random.seed(), we
        # call it here
        random.seed()
        c_record = ExceptionRecord(
            function=record.funcName,
            line_number=record.lineno,
            level=record.levelname,
            logger_name=record.name,
            pathname=record.pathname,
            message=record.getMessage(),
            type=str(type),
            stack_trace=traceback_string,
            date=datetime.utcnow(),
            url="",
            query_params={},
        )
        # couchdbkit's uuid generation is not fork-safe
        # so we generate a random id
        c_record._id = random_hex()
        c_record.save()
        # fire signal
        signals.couchlog_created.send(sender="couchlog", record=c_record)
        return c_record
    def test_data_interfaces(self):
        for domain_name in [self.domain.name, self.domain2.name]:
            automatic_update_rule = AutomaticUpdateRule.objects.create(domain=domain_name)
            AutomaticUpdateAction.objects.create(rule=automatic_update_rule)
            AutomaticUpdateRuleCriteria.objects.create(rule=automatic_update_rule)
            CaseRuleAction.objects.create(rule=automatic_update_rule)
            CaseRuleCriteria.objects.create(rule=automatic_update_rule)
            CaseRuleSubmission.objects.create(
                created_on=datetime.utcnow(),
                domain=domain_name,
                form_id=random_hex(),
                rule=automatic_update_rule,
            )
            DomainCaseRuleRun.objects.create(domain=domain_name, started_on=datetime.utcnow())
            self._assert_data_interfaces(domain_name, 1)

        self.domain.delete()

        self._assert_data_interfaces(self.domain.name, 0)
        self._assert_data_interfaces(self.domain2.name, 1)

        self.assertEqual(AutomaticUpdateAction.objects.count(), 1)
        self.assertEqual(AutomaticUpdateAction.objects.filter(rule__domain=self.domain2.name).count(), 1)
        self.assertEqual(AutomaticUpdateRuleCriteria.objects.count(), 1)
        self.assertEqual(AutomaticUpdateRuleCriteria.objects.filter(rule__domain=self.domain2.name).count(), 1)
        self.assertEqual(CaseRuleAction.objects.count(), 1)
        self.assertEqual(CaseRuleAction.objects.filter(rule__domain=self.domain2.name).count(), 1)
        self.assertEqual(CaseRuleCriteria.objects.count(), 1)
        self.assertEqual(CaseRuleCriteria.objects.filter(rule__domain=self.domain2.name).count(), 1)
Example #9
0
 def _create_form(app_id, xmlns, with_attachment):
     xml = FORM_XML.format(doc_id=random_hex(), xmlns=xmlns)
     attachments = {}
     if with_attachment:
         attachment = open('./corehq/ex-submodules/casexml/apps/case/tests/data/attachments/fruity.jpg', 'rb')
         attachments = {
             'pic.jpg': UploadedFile(attachment, 'pic.jpg')
         }
     submit_form_locally(xml, domain=DOMAIN, app_id=app_id, attachments=attachments)
 def _create_form(app_id, xmlns, with_attachment):
     xml = FORM_XML.format(doc_id=random_hex(), xmlns=xmlns)
     attachments = {}
     if with_attachment:
         attachment = open(
             './corehq/ex-submodules/casexml/apps/case/tests/data/attachments/fruity.jpg',
             'rb')
         attachments = {'pic.jpg': UploadedFile(attachment, 'pic.jpg')}
     submit_form_locally(xml,
                         domain=DOMAIN,
                         app_id=app_id,
                         attachments=attachments)
    def test_userreports_delete(self):
        for domain_name in [self.domain.name, self.domain2.name]:
            AsyncIndicator.objects.create(
                domain=domain_name,
                doc_id=random_hex(),
                doc_type='doc_type',
                indicator_config_ids=[],
            )
            self._assert_userreports_counts(domain_name, 1)

        self.domain.delete()

        self._assert_userreports_counts(self.domain.name, 0)
        self._assert_userreports_counts(self.domain2.name, 1)
Example #12
0
    def test_userreports_delete(self):
        for domain_name in [self.domain.name, self.domain2.name]:
            AsyncIndicator.objects.create(
                domain=domain_name,
                doc_id=random_hex(),
                doc_type='doc_type',
                indicator_config_ids=[],
            )
            self._assert_userreports_counts(domain_name, 1)

        self.domain.delete()

        self._assert_userreports_counts(self.domain.name, 0)
        self._assert_userreports_counts(self.domain2.name, 1)
def check_elasticsearch():
    cluster_health = check_es_cluster_health()
    if cluster_health == 'red':
        return ServiceStatus(False, "Cluster health at %s" % cluster_health)

    doc = {'_id': 'elasticsearch-service-check-{}'.format(random_hex()[:7]),
           'date': datetime.datetime.now().isoformat()}
    try:
        send_to_elasticsearch('groups', doc)
        refresh_elasticsearch_index('groups')
        hits = GroupES().remove_default_filters().doc_id(doc['_id']).run().hits
        if doc in hits:
            return ServiceStatus(True, "Successfully sent a doc to ES and read it back")
        else:
            return ServiceStatus(False, "Something went wrong sending a doc to ES")
    finally:
        send_to_elasticsearch('groups', doc, delete=True)  # clean up
Example #14
0
def check_elasticsearch():
    cluster_health = check_es_cluster_health()
    if cluster_health != 'green':
        return ServiceStatus(False, "Cluster health at %s" % cluster_health)

    doc = {'_id': 'elasticsearch-service-check-{}'.format(random_hex()[:7]),
           'date': datetime.datetime.now().isoformat()}
    try:
        send_to_elasticsearch('groups', doc)
        refresh_elasticsearch_index('groups')
        hits = GroupES().remove_default_filters().doc_id(doc['_id']).run().hits
        if doc in hits:
            return ServiceStatus(True, "Successfully sent a doc to ES and read it back")
        else:
            return ServiceStatus(False, "Something went wrong sending a doc to ES")
    finally:
        send_to_elasticsearch('groups', doc, delete=True)  # clean up
    def test_case_importer(self):
        for domain_name in [self.domain.name, self.domain2.name]:
            case_upload_record = CaseUploadRecord.objects.create(
                domain=domain_name,
                task_id=uuid.uuid4().hex,
                upload_id=uuid.uuid4().hex,
            )
            CaseUploadFormRecord.objects.create(
                case_upload_record=case_upload_record,
                form_id=random_hex(),
            )
            self._assert_case_importer_counts(domain_name, 1)

        self.domain.delete()

        self._assert_case_importer_counts(self.domain.name, 0)
        self._assert_case_importer_counts(self.domain2.name, 1)

        self.assertEqual(CaseUploadFormRecord.objects.count(), 1)
        self.assertEqual(
            CaseUploadFormRecord.objects.filter(
                case_upload_record__domain=self.domain2.name).count(), 1)
Example #16
0
    def retire(self):
        suffix = DELETED_SUFFIX
        deletion_id = random_hex()
        # doc_type remains the same, since the views use base_doc instead
        if not self.base_doc.endswith(suffix):
            self.base_doc += suffix
            self['-deletion_id'] = deletion_id
        for form in self.get_forms():
            form.doc_type += suffix
            form['-deletion_id'] = deletion_id
            form.save()
        for case in self.get_cases():
            case.doc_type += suffix
            case['-deletion_id'] = deletion_id
            case.save()

        try:
            django_user = self.get_django_user()
        except User.DoesNotExist:
            pass
        else:
            django_user.delete()
        self.save()
Example #17
0
    def test_data_interfaces(self):
        for domain_name in [self.domain.name, self.domain2.name]:
            automatic_update_rule = AutomaticUpdateRule.objects.create(domain=domain_name)
            CaseRuleAction.objects.create(rule=automatic_update_rule)
            CaseRuleCriteria.objects.create(rule=automatic_update_rule)
            CaseRuleSubmission.objects.create(
                created_on=datetime.utcnow(),
                domain=domain_name,
                form_id=random_hex(),
                rule=automatic_update_rule,
            )
            DomainCaseRuleRun.objects.create(domain=domain_name, started_on=datetime.utcnow())
            self._assert_data_interfaces(domain_name, 1)

        self.domain.delete()

        self._assert_data_interfaces(self.domain.name, 0)
        self._assert_data_interfaces(self.domain2.name, 1)

        self.assertEqual(CaseRuleAction.objects.count(), 1)
        self.assertEqual(CaseRuleAction.objects.filter(rule__domain=self.domain2.name).count(), 1)
        self.assertEqual(CaseRuleCriteria.objects.count(), 1)
        self.assertEqual(CaseRuleCriteria.objects.filter(rule__domain=self.domain2.name).count(), 1)
Example #18
0
    def test_case_importer(self):
        for domain_name in [self.domain.name, self.domain2.name]:
            case_upload_record = CaseUploadRecord.objects.create(
                domain=domain_name,
                task_id=uuid.uuid4().hex,
                upload_id=uuid.uuid4().hex,
            )
            CaseUploadFormRecord.objects.create(
                case_upload_record=case_upload_record,
                form_id=random_hex(),
            )
            self._assert_case_importer_counts(domain_name, 1)

        self.domain.delete()

        self._assert_case_importer_counts(self.domain.name, 0)
        self._assert_case_importer_counts(self.domain2.name, 1)

        self.assertEqual(CaseUploadFormRecord.objects.count(), 1)
        self.assertEqual(
            CaseUploadFormRecord.objects.filter(case_upload_record__domain=self.domain2.name).count(),
            1
        )
Example #19
0
def toggle_js_user_cachebuster(username):
    return random_hex()[:3]
Example #20
0
def toggle_js_domain_cachebuster(domain):
    # to get fresh cachebusters on the next deploy
    # change the date below (output from *nix `date` command)
    #   Mon Oct 31 10:30:09 EDT 2016
    return random_hex()[:3]
Example #21
0
def toggle_js_domain_cachebuster(domain):
    # to get fresh cachebusters on the next deploy
    # change the date below (output from *nix `date` command)
    #   Wed Apr 25 14:12:12 EDT 2018
    return random_hex()[:3]
Example #22
0
def toggle_js_domain_cachebuster(domain):
    # to get fresh cachebusters on the next deploy
    # change the date below (output from *nix `date` command)
    #   Thu Mar  3 16:21:30 EST 2016
    return random_hex()[:3]
Example #23
0
def toggle_js_user_cachebuster(username):
    return random_hex()[:3]
Example #24
0
def toggle_js_domain_cachebuster(domain):
    # to get fresh cachebusters on the next deploy
    # change the date below (output from *nix `date` command)
    #   Mon Oct 31 10:30:09 EDT 2016
    return random_hex()[:3]
Example #25
0
def toggle_js_domain_cachebuster(domain):
    # to get fresh cachebusters on the next deploy
    # change the date below (output from *nix `date` command)
    #   Thu Mar  3 16:21:30 EST 2016
    return random_hex()[:3]