def testSubmissionError(self): evil_laugh = "mwa ha ha!" def fail(sender, xform, **kwargs): raise Exception(evil_laugh) successful_form_received.connect(fail) try: file = os.path.join(os.path.dirname(__file__), "data", "simple_form.xml") with open(file) as f: res = self.client.post(self.url, {"xml_submission_file": f}) self.assertEqual(201, res.status_code) self.assertIn(evil_laugh, res.content) # make sure we logged it log = SubmissionErrorLog.view( "couchforms/all_submissions_by_domain", reduce=False, include_docs=True, startkey=[self.domain.name, "by_type", "XFormError"], endkey=[self.domain.name, "by_type", "XFormError", {}], ).one() self.assertTrue(log is not None) self.assertIn(evil_laugh, log.problem) with open(file) as f: self.assertEqual(f.read(), log.get_xml()) finally: successful_form_received.disconnect(fail)
def testSubmissionError(self): evil_laugh = "mwa ha ha!" def fail(sender, xform, **kwargs): raise Exception(evil_laugh) successful_form_received.connect(fail) try: file = os.path.join(os.path.dirname(__file__), "data", "simple_form.xml") with open(file) as f: res = self.client.post(self.url, { "xml_submission_file": f }) self.assertEqual(201, res.status_code) self.assertIn(evil_laugh, res.content) # make sure we logged it log = SubmissionErrorLog.view( "couchforms/all_submissions_by_domain", reduce=False, include_docs=True, startkey=[self.domain.name, "by_type", "XFormError"], endkey=[self.domain.name, "by_type", "XFormError", {}], ).one() self.assertIsNotNone(log) self.assertIn(evil_laugh, log.problem) with open(file) as f: self.assertEqual(f.read(), log.get_xml()) finally: successful_form_received.disconnect(fail)
def testSubmissionError(self): evil_laugh = "mwa ha ha!" def fail(sender, xform, **kwargs): raise Exception(evil_laugh) successful_form_received.connect(fail) try: file = os.path.join(os.path.dirname(__file__), "data", "simple_form.xml") with open(file) as f: res = self.client.post(self.url, { "xml_submission_file": f }) self.assertEqual(201, res.status_code) self.assertIn(evil_laugh, res.content) # make sure we logged it [log] = get_forms_by_type(self.domain.name, 'XFormError', limit=1) self.assertIsNotNone(log) self.assertIn(evil_laugh, log.problem) with open(file) as f: self.assertEqual(f.read(), log.get_xml()) finally: successful_form_received.disconnect(fail)
def failing_signal_handler(error_message): def fail(sender, xform, **kwargs): raise Exception(error_message) successful_form_received.connect(fail) try: yield finally: successful_form_received.disconnect(fail)
def failing_signal_handler(error_message): def fail(sender, xform, **kwargs): raise Exception(error_message) successful_form_received.connect(fail) try: yield finally: successful_form_received.disconnect(fail)
def testSubmissionError(self): evil_laugh = "mwa ha ha!" def fail(sender, xform, **kwargs): raise Exception(evil_laugh) successful_form_received.connect(fail) try: file, res = self._submit("simple_form.xml") self.assertEqual(201, res.status_code) self.assertIn(evil_laugh, res.content) # make sure we logged it [log] = FormAccessors(self.domain.name).get_forms_by_type('XFormError', limit=1) self.assertIsNotNone(log) self.assertIn(evil_laugh, log.problem) with open(file) as f: self.assertEqual(f.read(), log.get_xml()) finally: successful_form_received.disconnect(fail)
def testSubmissionError(self): evil_laugh = "mwa ha ha!" def fail(sender, xform, **kwargs): raise Exception(evil_laugh) successful_form_received.connect(fail) try: file, res = self._submit("simple_form.xml") self.assertEqual(201, res.status_code) self.assertIn(evil_laugh, res.content) # make sure we logged it [log] = FormAccessors(self.domain.name).get_forms_by_type( 'XFormError', limit=1) self.assertIsNotNone(log) self.assertIn(evil_laugh, log.problem) with open(file) as f: self.assertEqual(f.read(), log.get_xml()) finally: successful_form_received.disconnect(fail)
def send_request(self, repeat_record, payload): value_sources = chain( six.itervalues(self.openmrs_config.case_config.patient_identifiers), six.itervalues(self.openmrs_config.case_config.person_properties), six.itervalues(self.openmrs_config.case_config.person_preferred_name), six.itervalues(self.openmrs_config.case_config.person_preferred_address), six.itervalues(self.openmrs_config.case_config.person_attributes), ) case_trigger_infos = get_relevant_case_updates_from_form_json( self.domain, payload, case_types=self.white_listed_case_types, extra_fields=[vs.case_property for vs in value_sources if hasattr(vs, 'case_property')] ) form_question_values = get_form_question_values(payload) return send_openmrs_data( self.requests, self.domain, payload, self.openmrs_config, case_trigger_infos, form_question_values ) def create_openmrs_repeat_records(sender, xform, **kwargs): create_repeat_records(OpenmrsRepeater, xform) successful_form_received.connect(create_openmrs_repeat_records)
CreateVisitsEncountersObsTask(requests, domain, info, form_json, openmrs_config, patient['person']['uuid']), ) errors.extend(execute_workflow(workflow)) if errors: requests.notify_error( f'Errors encountered sending OpenMRS data: {errors}') # If the form included multiple patients, some workflows may # have succeeded, but don't say everything was OK if any # workflows failed. (Of course most forms will only involve one # case, so one workflow.) return OpenmrsResponse( 400, 'Bad Request', "Errors: " + pformat_json([str(e) for e in errors])) if warnings: return OpenmrsResponse( 201, "Accepted", "Warnings: " + pformat_json([str(e) for e in warnings])) return OpenmrsResponse(200, "OK") def create_openmrs_repeat_records(sender, xform, **kwargs): create_repeat_records(OpenmrsRepeater, xform) successful_form_received.connect(create_openmrs_repeat_records)
Question: is it possible to receive registration data from the phone after Case 3? If so, we need to check for a user created via Case 3 and link them to this account automatically """ def create_user_from_commcare_registration(sender, xform, **kwargs): """ # this comes in as xml that looks like: # <n0:registration xmlns:n0="openrosa.org/user-registration"> # <username>user</username> # <password>pw</password> # <uuid>MTBZJTDO3SCT2ONXAQ88WM0CH</uuid> # <date>2008-01-07</date> # <registering_phone_id>NRPHIOUSVEA215AJL8FFKGTVR</registering_phone_id> # <user_data> ... some custom stuff </user_data> """ if xform.xmlns not in VALID_USER_REGISTRATION_XMLNSES: return False try: couch_user, created = CommCareUser.create_or_update_from_xform(xform) except Exception, e: #import traceback, sys #exc_type, exc_value, exc_traceback = sys.exc_info() #traceback.print_tb(exc_traceback, limit=1, file=sys.stdout) logging.exception(e) raise return ReceiverResult(xml.get_response(couch_user, created), Certainty.CERTAIN) successful_form_received.connect(create_user_from_commcare_registration)
raise Dhis2Exception(f"Unable to parse DHIS2 version {dhis2_version}.") return api_version def fetch_metadata(requests): """ Fetch metadata about a DHIS2 instance. Currently only used for determining what API version it supports. .. NOTE:: Metadata is large (like a 100MB JSON document), and contains the IDs one would need to compile a human-readable configuration into one that maps to DHIS2 IDs. """ response = requests.get('/api/metadata', raise_for_status=True) return response.json() def create_dhis2_event_repeat_records(sender, xform, **kwargs): create_repeat_records(Dhis2Repeater, xform) def create_dhis2_entity_repeat_records(sender, xform, **kwargs): create_repeat_records(Dhis2EntityRepeater, xform) successful_form_received.connect(create_dhis2_event_repeat_records) successful_form_received.connect(create_dhis2_entity_repeat_records)
'casexml.apps.case.signals.process_cases has been moved to ' 'casexml.apps.case.process_cases ' 'and the unused `sender` and `**kwargs` parameters have been removed.', DeprecationWarning, ) from casexml.apps.case import process_cases process_cases(xform, config) @log_exception() def _process_cases(sender, xform, config=None, **kwargs): from casexml.apps.case import process_cases process_cases(xform, config) successful_form_received.connect(_process_cases) def rebuild_form_cases(sender, xform, *args, **kwargs): from casexml.apps.case.xform import get_case_ids_from_form from casexml.apps.case.cleanup import rebuild_case for case_id in get_case_ids_from_form(xform): rebuild_case(case_id) xform_archived.connect(rebuild_form_cases) xform_unarchived.connect(rebuild_form_cases) # any time a case is saved case_post_save = Signal(providing_args=["case"])
domain_name = application.domain config = CareplanConfig.for_domain(domain_name) if application.doc_type == 'Application-Deleted': if application.has_careplan_module: careplan_removed(domain_name, config, application.get_id) def update_project_careplan_config_release(sender, application, **kwargs): domain_name = application.domain config = CareplanConfig.for_domain(domain_name) parent_app_id = application.copy_of latest_app = application.get_latest_app(released_only=True) if latest_app and latest_app.is_released and latest_app.has_careplan_module: config = config or CareplanConfig(domain=domain_name) update_careplan_config(config, parent_app_id, latest_app) else: careplan_removed(domain_name, config, parent_app_id) successful_form_received.connect(get_custom_response_message) app_post_save = Signal(providing_args=['application']) app_post_save.connect(create_app_structure_repeat_records) app_post_save.connect(update_project_careplan_config) app_post_release = Signal(providing_args=['application']) app_post_release.connect(update_project_careplan_config_release)
def create_form_repeat_records(sender, xform, **kwargs): from corehq.apps.receiverwrapper.models import FormRepeater create_repeat_records(FormRepeater, xform) def create_case_repeat_records(sender, case, **kwargs): from corehq.apps.receiverwrapper.models import CaseRepeater create_repeat_records(CaseRepeater, case) def create_short_form_repeat_records(sender, xform, **kwargs): from corehq.apps.receiverwrapper.models import ShortFormRepeater create_repeat_records(ShortFormRepeater, xform) def create_repeat_records(repeater_cls, payload): domain = payload.domain if domain: repeaters = repeater_cls.by_domain(domain) for repeater in repeaters: if not (getattr(repeater, 'exclude_device_reports', False) and is_device_report(payload)): repeater.register(payload) successful_form_received.connect(create_form_repeat_records) successful_form_received.connect(create_short_form_repeat_records) case_post_save.connect(create_case_repeat_records)
SupplyPointCase.wrap(c._doc) for c in cases if c.type == const.SUPPLY_POINT_CASE_TYPE ] case_updates = get_case_updates(xform) for sp in supply_points: created = any( filter( lambda update: update.id == sp._id and update.creates_case(), case_updates)) supply_point_modified.send(sender=None, supply_point=sp, created=created) def supply_point_processing(sender, xform, cases, **kwargs): if is_supply_point_form(xform): attach_locations(xform, cases) raise_supply_point_events(xform, cases) cases_received.connect(supply_point_processing) def bootstrap_commtrack_settings_if_necessary_signal(sender, **kwargs): bootstrap_commtrack_settings_if_necessary(kwargs['domain']) commcare_domain_post_save.connect( bootstrap_commtrack_settings_if_necessary_signal) successful_form_received.connect(process_stock_signal_catcher)
if requisition_cases and requisition_cases[0].requisition_status == RequisitionStatus.RECEIVED: requisition_receipt.send(sender=None, requisitions=requisition_cases) if requisition_cases and requisition_cases[0].requisition_status == RequisitionStatus.REQUESTED: requisition_modified.send(sender=None, cases=requisition_cases) def raise_supply_point_events(xform, cases): supply_points = [SupplyPointCase.wrap(c._doc) for c in cases if c.type == const.SUPPLY_POINT_CASE_TYPE] case_updates = get_case_updates(xform) for sp in supply_points: created = any(filter(lambda update: update.id == sp._id and update.creates_case(), case_updates)) supply_point_modified.send(sender=None, supply_point=sp, created=created) def supply_point_processing(sender, xform, cases, **kwargs): if is_supply_point_form(xform): attach_locations(xform, cases) raise_supply_point_events(xform, cases) cases_received.connect(supply_point_processing) def bootstrap_commtrack_settings_if_necessary_signal(sender, **kwargs): bootstrap_commtrack_settings_if_necessary(kwargs["domain"]) commcare_domain_post_save.connect(bootstrap_commtrack_settings_if_necessary_signal) successful_form_received.connect(process_stock_signal_catcher)
domain_name = application.domain config = CareplanConfig.for_domain(domain_name) if application.doc_type == 'Application-Deleted': if application.has_careplan_module: careplan_removed(domain_name, config, application.get_id) def update_project_careplan_config_release(sender, application, **kwargs): domain_name = application.domain config = CareplanConfig.for_domain(domain_name) parent_app_id = application.copy_of latest_app = application.get_latest_app(released_only=True) if latest_app and latest_app.is_released and latest_app.has_careplan_module: config = config or CareplanConfig(domain=domain_name) update_careplan_config(config, parent_app_id, latest_app) else: careplan_removed(domain_name, config, parent_app_id) successful_form_received.connect(get_custom_response_message) app_post_save = Signal(providing_args=['application']) app_post_save.connect(create_app_structure_repeat_records) app_post_save.connect(update_project_careplan_config) app_post_release = Signal(providing_args=['application']) app_post_release.connect(update_project_careplan_config_release)
def connect_user_signals(): post_save.connect(django_user_post_save_signal, User, dispatch_uid="django_user_post_save_signal") successful_form_received.connect(create_user_from_commcare_registration, dispatch_uid="create_user_from_commcare_registration") couch_user_post_save.connect(update_user_in_es, dispatch_uid="update_user_in_es")
#placeholder for doing blocking vs. async via celery BLOCKING = True def process_dots_submission(sender, xform, **kwargs): from pact.tasks import recalculate_dots_data, eval_dots_block try: if xform.xmlns != "http://dev.commcarehq.org/pact/dots_form": return #grrr, if we were on celery 3.0, we could do this! # chain = eval_dots_block.s(xform.to_json()) | recalculate_dots_data.s(case_id) # chain() eval_dots_block(xform.to_json()) case_id = get_case_id(xform) # get user from xform user_id = xform.metadata.userID cc_user = CouchUser.get_by_user_id(user_id) last_sync_token = getattr(xform, 'last_sync_token', None) recalculate_dots_data(case_id, cc_user, sync_token=last_sync_token) except Exception as ex: tb = traceback.format_exc() notify_exception(None, message="Error processing PACT DOT submission due to an unknown error: %s\n\tTraceback: %s" % (ex, tb)) #xform_saved.connect(process_dots_submission) successful_form_received.connect(process_dots_submission)
case, resource_type, case_block, form_question_values, )) return case_trigger_info_list, resource_types_by_case_type def _get_cases_by_id(domain, case_blocks): case_ids = [case_block['@case_id'] for case_block in case_blocks] cases = CaseAccessors(domain).get_cases(case_ids, ordered=True) return {c.case_id: c for c in cases} def _get_resource_types_by_case_type(domain, fhir_version, cases): case_type_names = {case.type for case in cases} fhir_resource_types = (FHIRResourceType.objects.select_related( 'case_type').prefetch_related('properties__case_property').filter( domain=domain, fhir_version=fhir_version, case_type__name__in=case_type_names, )) return {rt.case_type.name: rt for rt in fhir_resource_types} def create_fhir_repeat_records(sender, xform, **kwargs): create_repeat_records(FHIRRepeater, xform) successful_form_received.connect(create_fhir_repeat_records)
""" return self.__class__.__name__ @classmethod def available_for_domain(cls, domain): return DHIS2_INTEGRATION.enabled(domain) @classmethod def get_custom_url(cls, domain): return reverse(AddDhis2RepeaterView.urlname, args=[domain]) def get_payload(self, repeat_record): payload = super(Dhis2Repeater, self).get_payload(repeat_record) return json.loads(payload) def send_request(self, repeat_record, payload): for form_config in self.dhis2_config.form_configs: if form_config.xmlns == payload['form']['@xmlns']: return send_data_to_dhis2( Requests(self.domain, self.url, self.username, self.plaintext_password, verify=self.verify), form_config, payload, ) def create_dhis_repeat_records(sender, xform, **kwargs): create_repeat_records(Dhis2Repeater, xform) successful_form_received.connect(create_dhis_repeat_records)