def openmrs_raw_api(request, domain, repeater_id, rest_uri):
get_params = dict(request.GET)
no_links = get_params.pop('links', None) is None
repeater = OpenmrsRepeater.get(repeater_id)
assert repeater.domain == domain
requests = Requests(repeater.url, repeater.username, repeater.password)
raw_json = requests.get('/ws/rest/v1' + rest_uri, get_params).json()
if no_links:
return JsonResponse(_filter_out_links(raw_json))
return JsonResponse(raw_json)
def fire_for_record(self, repeat_record):
form_json = json.loads(self.get_payload(repeat_record))
trigger_case_infos = get_relevant_case_updates_from_form_json(
self.domain, form_json, case_types=self.white_listed_case_types,
extra_fields=[id_matcher.case_property
for id_matcher in self.openmrs_config.case_config.id_matchers])
send_openmrs_data(Requests(self.url, self.username, self.password), form_json,
trigger_case_infos, self.openmrs_config)
return repeat_record.handle_success(None)
def send_request(self, repeat_record, payload, verify=None):
case_trigger_infos = get_relevant_case_updates_from_form_json(
self.domain,
payload,
case_types=self.white_listed_case_types,
extra_fields=[
id_matcher.case_property
for id_matcher in self.openmrs_config.case_config.id_matchers
])
form_question_values = get_form_question_values(payload)
return send_openmrs_data(
Requests(self.url, self.username, self.password), payload,
self.openmrs_config, case_trigger_infos, form_question_values)
def requests(self):
return Requests(self.repeater.url, self.repeater.username,
self.repeater.password)
def import_patients_to_domain(domain_name, force=False):
"""
Iterates OpenmrsImporters of a domain, and imports patients
Who owns the imported cases?
If `importer.owner_id` is set, then the server will be queried
once. All patients, regardless of their location, will be assigned
to the mobile worker whose ID is `importer.owner_id`.
If `importer.location_type_name` is set, then check whether the
OpenmrsImporter's location is set with `importer.location_id`.
If `importer.location_id` is given, then the server will be queried
for each location among its descendants whose type is
`importer.location_type_name`. The request's query parameters will
include that descendant location's OpenMRS UUID. Imported cases
will be owned by the first mobile worker in that location.
If `importer.location_id` is given, then the server will be queried
for each location in the project space whose type is
`importer.location_type_name`. As when `importer.location_id` is
specified, the request's query parameters will include that
location's OpenMRS UUID, and imported cases will be owned by the
first mobile worker in that location.
..NOTE:: As you can see from the description above, if
`importer.owner_id` is set then `importer.location_id` is
not used.
:param domain_name: The name of the domain
:param force: Import regardless of the configured import frequency / today's date
"""
today = datetime.today()
for importer in get_openmrs_importers_by_domain(domain_name):
if not force and importer.import_frequency == IMPORT_FREQUENCY_WEEKLY and today.weekday(
) != 1:
continue # Import on Tuesdays
if not force and importer.import_frequency == IMPORT_FREQUENCY_MONTHLY and today.day != 1:
continue # Import on the first of the month
# TODO: ^^^ Make those configurable
password = b64_aes_decrypt(importer.password)
requests = Requests(importer.server_url, importer.username, password)
if importer.location_type_name:
try:
location_type = LocationType.objects.get(
domain=domain_name, name=importer.location_type_name)
except LocationType.DoesNotExist:
logger.error(
'No organization level named "{location_type}" found in project space "{domain}".'
.format(location_type=importer.location_type_name,
domain=domain_name))
continue
if importer.location_id:
location = SQLLocation.objects.filter(domain=domain_name).get(
importer.location_id)
locations = location.get_descendants.filter(
location_type=location_type)
else:
locations = SQLLocation.objects.filter(
domain=domain_name, location_type=location_type)
for location in locations:
# Assign cases to the first user in the location, not to the location itself
try:
owner = next(
get_commcare_users_by_location(domain_name,
location.location_id))
except StopIteration:
logger.error(
'Project space "{domain}" at location "{location}" has no user to own cases imported from '
'OpenMRS Importer "{importer}"'.format(
domain=domain_name,
location=location.name,
importer=importer))
continue
import_patients_of_owner(requests, importer, domain_name,
owner, location)
elif importer.owner_id:
try:
owner = CommCareUser.get(importer.owner_id)
except ResourceNotFound:
logger.error(
'Project space "{domain}" has no user to own cases imported from OpenMRS Importer '
'"{importer}"'.format(domain=domain_name,
importer=importer))
continue
import_patients_of_owner(requests, importer, domain_name, owner)
else:
logger.error(
'Error importing patients for project space "{domain}" from OpenMRS Importer "{importer}": Unable '
'to determine the owner of imported cases without either owner_id or location_type_name'
.format(domain=domain_name, importer=importer))
continue
