def test_get_get_subrecord_from_api_name(self):
hatwearer_api_name = tmodels.HatWearer.get_api_name()
famous_api_name = tmodels.FamousLastWords.get_api_name()
self.assertEqual(
tmodels.HatWearer,
subrecords.get_subrecord_from_api_name(hatwearer_api_name))
self.assertEqual(
tmodels.FamousLastWords,
subrecords.get_subrecord_from_api_name(famous_api_name))
def test_get_get_subrecord_from_api_name(self):
hatwearer_api_name = tmodels.HatWearer.get_api_name()
famous_api_name = tmodels.FamousLastWords.get_api_name()
self.assertEqual(
tmodels.HatWearer,
subrecords.get_subrecord_from_api_name(hatwearer_api_name)
)
self.assertEqual(
tmodels.FamousLastWords,
subrecords.get_subrecord_from_api_name(famous_api_name)
)
def get_graph_data(self, episode_queryset):
subrecord = subrecords.get_subrecord_from_api_name(
self.subrecord_api_name)
qs = get_subrecord_qs_from_episode_qs(subrecord, episode_queryset)
total = qs.count()
count = 0
if total == 0:
amount = 0
else:
count = qs.filter(**{
self.fk_field: None
}).exclude(**{
self.ft_field: ''
}).count()
amount = round(float(count) / total, 3) * 100
result = {}
result["total"] = total
result["count"] = count
aggregate = [['None', amount]]
links = {"None": self.to_link("None")}
result["graph_vals"] = json.dumps(
dict(aggregate=aggregate,
links=links,
field=self.field_name,
subrecord=self.subrecord_api_name))
return result
def iframe_api(request):
# This has to be here because Django wants to make sure it's the first
# thing to import models and gets distinctly snippish if you beat it.
from iframeapi.models import ApiKey
hospital_number = request.GET.get("hospitalNumber")
record_name = request.GET.get("record")
latest = bool(request.GET.get("latest"))
try:
api_key = ApiKey.objects.get(key=request.GET.get("key"))
except ApiKey.DoesNotExist:
return bad_request(request)
api_key.used()
if record_name and hospital_number:
try:
model = get_subrecord_from_api_name(record_name)
except ValueError:
raise Http404("record {} does not exist".format(record_name))
result_set = None
if issubclass(model, opal_models.PatientSubrecord):
result_set = model.objects.filter(
patient__demographics__hospital_number=hospital_number
)
if issubclass(model, opal_models.EpisodeSubrecord):
result_set = model.objects.filter(
episode__patient__demographics__hospital_number=hospital_number
)
if latest:
order_by = getattr(model, "_sort", None)
if order_by is not None:
result = result_set.order_by(model._sort).last()
else:
# if not order fall back to the standard object ordering
result = result_set.last()
context = {
"latest": latest,
"object": result
}
else:
context = dict(object_list=result_set)
response_kwargs = {
"request": request,
"context": context
}
response_kwargs.update(get_template_name(model))
return TemplateResponse(**response_kwargs)
return bad_request(request)
def get_aggregate(self, episode_queryset):
subrecord = subrecords.get_subrecord_from_api_name(
self.subrecord_api_name)
result = OrderedDict()
age_groups = [[0, 20], [20, 40], [40, 60], [60, 80], [80]]
qs = get_subrecord_qs_from_episode_qs(subrecord, episode_queryset)
today = datetime.date.today()
for age_group in age_groups:
if len(age_group) == 1:
label = "{} +".format(age_group[0])
else:
label = "{0} - {1}".format(*age_group)
start_dt = today - relativedelta(years=age_group[0])
age_group_qs = qs.filter(date_of_birth__lte=start_dt)
if len(age_group) == 1:
age_counts = age_group_qs.count()
else:
end_dt = today - relativedelta(years=age_group[1])
age_counts = age_group_qs.filter(
date_of_birth__gt=end_dt).count()
result[label] = age_counts
return result
def dispatch(self, *a, **kw):
"""
Set the context for what this modal is for so
it can be accessed by all subsequent methods
"""
self.column = get_subrecord_from_api_name(kw['model'])
self.name = camelcase_to_underscore(self.column.__name__)
return super(FormTemplateView, self).dispatch(*a, **kw)
def dispatch(self, *a, **kw):
"""
Set the context for what this modal is for so
it can be accessed by all subsequent methods
"""
self.column = get_subrecord_from_api_name(kw['model'])
self.name = camelcase_to_underscore(self.column.__name__)
return super(FormTemplateView, self).dispatch(*a, **kw)
def bulk_update(self, dict_of_list_of_upgrades, user,
episode=None, force=False):
"""
takes in a dictionary of api name to a list of fields and
creates the required subrecords. If passed an episode
sub record but no episode it will create an episode
and attatch it.
e.g. {"allergies": [
{"drug": "paracetomol"}
{"drug": "aspirin"}
],
"diagnosis":[
{
"condition": "some test",
"details": "some details"
}
]
}
"""
if "demographics" not in dict_of_list_of_upgrades:
if not self.id:
dict_of_list_of_upgrades["demographics"] = [{}]
if not self.id:
self.save()
#
# We never want to be in the position where we don't have an episode.
# If this patient has never had an episode, we create one now.
# If the patient has preexisting episodes, we will either use an
# episode passed in to us as a kwarg, or create a fresh episode for
# this bulk update once we're sure we have episode subrecord data to
# save.
#
if not self.episode_set.exists():
episode = self.create_episode()
for api_name, list_of_upgrades in dict_of_list_of_upgrades.items():
if(api_name == "tagging"):
episode.set_tag_names_from_tagging_dict(
list_of_upgrades[0], user
)
continue
model = get_subrecord_from_api_name(api_name=api_name)
if model in episode_subrecords():
if episode is None:
episode = self.create_episode()
episode.save()
model.bulk_update_from_dicts(episode, list_of_upgrades, user,
force=force)
else:
# it's a patient subrecord
model.bulk_update_from_dicts(self, list_of_upgrades, user,
force=force)
def import_patient_subrecord_data(api_name, data, patient, user=None):
"""
Given the API_NAME of a patient subrecord, some DATA containing n
instances of that subrecord, and a patient, save that data to the
patient.
If required, pass in the user as a kwarg
"""
subrecord = subrecords.get_subrecord_from_api_name(api_name)
return subrecord.bulk_update_from_dicts(patient, data, user)
def iframe_api(request):
# This has to be here because Django wants to make sure it's the first
# thing to import models and gets distinctly snippish if you beat it.
from iframeapi.models import ApiKey
hospital_number = request.GET.get("hospitalNumber")
record_name = request.GET.get("record")
latest = bool(request.GET.get("latest"))
try:
api_key = ApiKey.objects.get(key=request.GET.get("key"))
except ApiKey.DoesNotExist:
return bad_request(request)
api_key.used()
if record_name and hospital_number:
try:
model = get_subrecord_from_api_name(record_name)
except ValueError:
raise Http404("record {} does not exist".format(record_name))
result_set = None
if issubclass(model, opal_models.PatientSubrecord):
result_set = model.objects.filter(
patient__demographics__hospital_number=hospital_number)
if issubclass(model, opal_models.EpisodeSubrecord):
result_set = model.objects.filter(
episode__patient__demographics__hospital_number=hospital_number
)
if latest:
order_by = getattr(model, "_sort", None)
if order_by is not None:
result = result_set.order_by(model._sort).last()
else:
# if not order fall back to the standard object ordering
result = result_set.last()
context = {"latest": latest, "object": result}
else:
context = dict(object_list=result_set)
response_kwargs = {"request": request, "context": context}
response_kwargs.update(get_template_name(model))
return TemplateResponse(**response_kwargs)
return bad_request(request)
def get_external_source(api_name):
model = subrecords.get_subrecord_from_api_name(api_name)
external_system = EXTERNAL_SYSTEM_MAPPING.get(model)
try:
field = model._meta.get_field("external_system")
except FieldDoesNotExist:
field = None
if not field and external_system:
e = "We cannot supply the mapping for {} as it is not an externally sourced model"
raise ValueError(e.format(model.__name__))
else:
return external_system
def get_context_data(self, *args, **kwargs):
ctx = super(OverviewDetailView, self).get_context_data(*args, **kwargs)
episode_qs = self.get_episode_qs()
subrecord = subrecords.get_subrecord_from_api_name(kwargs["api_name"])
ctx["fields"] = []
for field_name in subrecord._get_fieldnames_to_serialize():
if field_name in self.IGNORED_FIELDS:
continue
field = subrecord._get_field(field_name)
if isinstance(field, ForeignKeyOrFreeText):
ctx["fields"].append(
fields.ForeignKeyOrFreeTextField(episode_qs, subrecord,
field_name))
else:
ctx["fields"].append(
fields.DefaultField(episode_qs, subrecord, field_name))
ctx["subrecord"] = subrecord
return ctx
def get_path_and_qs_from(get_param, value, qs):
subrecord = get_subrecord_from_api_name(get_param.split("__")[0])
field = get_param.split("__")[1]
lookup = "{0}__{1}".format(subrecord.__name__.lower(), field)
if subrecord in patient_subrecords():
lookup = "patient__{}".format(lookup)
if isinstance(getattr(subrecord, field), ForeignKeyOrFreeText):
if value == 'None':
value = None
lookup = "{}_fk".format(lookup)
else:
lookup = "{}_fk__name".format(lookup)
path = ("{0}-{1}: {2}".format(subrecord.get_display_name(),
subrecord._get_field_title(field), value))
qs = qs.filter(**{lookup: value})
return path, qs
def get_template_names(self):
model = get_subrecord_from_api_name(self.kwargs["model"])
template_name = model.get_display_template()
return [template_name]
def get_model_from_api_name(column_name):
if column_name == "tagging":
return models.Tagging
else:
return subrecords.get_subrecord_from_api_name(column_name)
def get_template_names(self):
model = get_subrecord_from_api_name(self.kwargs["model"])
template_name = model.get_display_template()
return [template_name]
def test_subrecord_does_not_exist(self):
with self.assertRaises(ValueError):
subrecords.get_subrecord_from_api_name('not_a_model')
def get_model_from_api_name(column_name):
if column_name == "tagging":
return models.Tagging
else:
return subrecords.get_subrecord_from_api_name(column_name)
def test_subrecord_does_not_exist(self):
with self.assertRaises(ValueError):
subrecords.get_subrecord_from_api_name('not_a_model')
def get_context_data(self, **kwargs):
model = get_subrecord_from_api_name(kwargs["model"])
instance = model.objects.get(pk=kwargs["pk"])
context = super(ImgTemplateView, self).get_context_data(**kwargs)
context["title"] = instance.view
return context
def subrecord(self):
return subrecords.get_subrecord_from_api_name(self.subrecord_api_name)
