def simple_search_view(request):
page_number = int(request.GET.get("page_number", 1))
all_criteria = _extract_basic_search_parameters(request)
if not all_criteria:
return _build_json_response({'error': "No search terms"}, 400)
query = queries.SearchBackend(request.user, all_criteria)
eps = query.get_patient_summaries()
return _build_json_response(_add_pagination(eps, page_number))
def patient_search_view(request):
hospital_number = request.GET.get("hospital_number")
if hospital_number is None:
return _build_json_response({'error': "No search terms"}, 400)
criteria = [{
"queryType": "Equals",
"query": hospital_number,
"field": "Hospital Number",
'combine': 'and',
'column': u'demographics',
}]
query = queries.SearchBackend(request.user, criteria)
return _build_json_response(query.patients_as_json())
def get(self, *args, **kwargs):
pathway_cls = Pathway.get(kwargs['name'])
pathway = pathway_cls(
patient_id=kwargs.get("patient_id"),
episode_id=kwargs.get("episode_id")
)
serialised = _build_json_response(
pathway.to_dict()
)
return serialised
def get(self, *args, **kwargs):
"""
Tell the client about the state of the extract
"""
from celery.result import AsyncResult
import taskrunner
task_id = kwargs['task_id']
result = AsyncResult(id=task_id, app=taskrunner.celery.app)
print result.state
return _build_json_response({'state': result.state})
def episode_detail_view(request, pk):
try:
episode = models.Episode.objects.get(pk=pk)
except models.Episode.DoesNotExist:
return HttpResponseNotFound()
if request.method == 'GET':
serialized = episode.to_dict(request.user)
return _build_json_response(serialized)
data = _get_request_data(request)
try:
pre = episode.to_dict(request.user)
episode.update_from_dict(data, request.user)
post = episode.to_dict(request.user)
glossolalia.change(pre, post)
return _build_json_response(episode.to_dict(request.user, shallow=True))
except exceptions.ConsistencyError:
return _build_json_response({'error': 'Item has changed'}, 409)
def get(self, request, *args, **kwargs):
w = WardRound.get(kwargs['name'])
if not w:
raise Http404("wardround not found")
wardround = w(request)
episode_ids = request.GET.getlist("e")
response = wardround.find_patient_table(episode_ids)
return _build_json_response(response)
def get(self, request, *args, **kwargs):
w = WardRound.get(kwargs['name'])
if not w:
raise Http404("wardround not found")
wardround = w(request)
serialised = _build_json_response(
wardround.list_view_table()
)
return serialised
def get(self, *args, **kwargs):
tag, subtag = kwargs.get('tag', None), kwargs.get('subtag', None)
filter_kwargs = {"tagging__archived": False}
if subtag:
filter_kwargs['tagging__team__name'] = subtag
elif tag:
filter_kwargs['tagging__team__name'] = tag
# Probably the wrong place to do this, but mine needs specialcasing.
if tag == 'mine':
filter_kwargs['tagging__user'] = self.request.user
serialised = models.Episode.objects.serialised_active(
self.request.user, **filter_kwargs)
return _build_json_response(serialised)
def post(self, *args, **kwargs):
request_data = _get_request_data(self.request)
page_number = 1
if "page_number" in request_data[0]:
page_number = request_data[0].pop("page_number", 1)
query = queries.SearchBackend(
self.request.user,
request_data,
)
eps = query.get_patient_summaries()
return _build_json_response(_add_pagination(eps, page_number))
def post(self, *args, **kwargs):
"""
Expects PATIENT, EPISODE, TARGET
"""
from opal.models import Episode
data = _get_request_data(self.request)
episode = Episode.objects.get(pk=data['episode'])
current_tags = episode.get_tag_names(None)
if not data['target'] in current_tags:
current_tags.append(data['target'])
episode.set_tag_names(current_tags, None)
resp = {'ok': 'Got your referral just fine - thanks!'}
return _build_json_response(resp)
def episode_list_and_create_view(request):
if request.method == 'GET':
serialised = models.Episode.objects.serialised_active(request.user)
return _build_json_response(serialised)
elif request.method == 'POST':
data = _get_request_data(request)
hospital_number = data['demographics'].get('hospital_number')
if hospital_number:
patient, _ = models.Patient.objects.get_or_create(
demographics__hospital_number=hospital_number)
else:
patient = models.Patient.objects.create()
patient.update_from_demographics_dict(data['demographics'], request.user)
try:
episode = patient.create_episode()
episode_fields = models.Episode._get_fieldnames_to_serialize()
episode_data = {}
for fname in episode_fields:
if fname in data:
episode_data[fname] = data[fname]
episode.update_from_dict(episode_data, request.user)
except exceptions.APIError:
return _build_json_response(
{'error': 'Patient already has active episode'}, 400)
location = episode.location_set.get()
location.update_from_dict(data['location'], request.user)
if 'tagging' in data:
tag_names = [n for n, v in data['tagging'][0].items() if v]
episode.set_tag_names(tag_names, request.user)
serialised = episode.to_dict(request.user)
glossolalia.admit(serialised)
return _build_json_response(serialised, 201)
def post(self, args, pk=None, category=None, **kwargs):
old = models.Episode.objects.get(pk=pk)
new = models.Episode(patient=old.patient,
category=category,
date_of_admission=old.date_of_admission)
new.save()
for sub in episode_subrecords():
if sub._is_singleton:
continue
for item in sub.objects.filter(episode=old):
item.id = None
item.episode = new
item.save()
serialised = new.to_dict(self.request.user)
glossolalia.admit(serialised)
return _build_json_response(serialised)
def post(self, *args, **kwargs):
if getattr(settings, 'EXTRACT_ASYNC', None):
criteria = _get_request_data(self.request)['criteria']
extract_id = async_extract(
self.request.user,
json.loads(criteria)
)
return _build_json_response({'extract_id': extract_id})
query = queries.SearchBackend(
self.request.user, json.loads(self.request.POST['criteria'])
)
episodes = query.get_episodes()
fname = zip_archive(episodes, query.description(), self.request.user)
resp = HttpResponse(open(fname, 'rb').read())
disp = 'attachment; filename="{0}extract{1}.zip"'.format(
settings.OPAL_BRAND_NAME, datetime.datetime.now().isoformat())
resp['Content-Disposition'] = disp
return resp
def delete(self, *args, **kwargs):
self.filter.delete()
return _build_json_response('')
def put(self, *args, **kwargs):
data = _get_request_data(self.request)
self.filter.update_from_dict(data)
return _build_json_response(self.filter.to_dict())
def get(self, *args, **kwargs):
return _build_json_response(self.filter)
def post(self, *args, **kwargs):
data = _get_request_data(self.request)
self.filter = models.Filter(user=self.request.user)
self.filter.update_from_dict(data)
return _build_json_response(self.filter.to_dict())
def get(self, *args, **kwargs):
filters = models.Filter.objects.filter(user=self.request.user)
return _build_json_response([f.to_dict() for f in filters])
def post(self, *args, **kwargs):
data = _get_request_data(self.request)
self.filter = models.Filter(user=self.request.user)
self.filter.update_from_dict(data)
return _build_json_response(self.filter.to_dict())
def post(self, *args, **kwargs):
data = _get_request_data(self.request)
resp = {'ok': 'Got your admission just fine - thanks!'}
return _build_json_response(resp)
def list(self, request):
return _build_json_response(all_drugs)
def get(self, *args, **kwargs):
filters = models.Filter.objects.filter(user=self.request.user)
return _build_json_response([f.to_dict() for f in filters])
