def get_medication(request, patient_id, medication_id):
resp = {'success': False}
history_list = []
if permissions_accessed(request.user, int(patient_id)):
try:
medication = Medication.objects.get(id=medication_id)
reversion_list = reversion.get_for_object(medication)
for item in reversion_list:
history_list.append({
'date':
item.revision.date_created.isoformat(),
'comment':
item.revision.comment
})
notes = MedicationTextNote.objects.filter(
medication_id=medication_id).order_by('-datetime')
except Medication.DoesNotExist:
pass
resp['success'] = True
resp['info'] = MedicationSerializer(medication).data
resp['history'] = history_list
resp['noteHistory'] = MedicationTextNoteSerializer(notes,
many=True).data
return ajax_response(resp)
def get_tab_info(request, tab_id):
resp = {'success': False}
tab_info = MyStoryTab.objects.get(id=tab_id)
if permissions_accessed(request.user, tab_info.patient.id):
resp['success'] = True
resp['info'] = MyStoryTabSerializer(tab_info).data
return ajax_response(resp)
def pin_to_problem(request, patient_id):
resp = {'success': False}
if permissions_accessed(request.user, int(patient_id)):
medication_id = request.POST.get("medication_id", None)
problem_id = request.POST.get("problem_id", None)
try:
pin = MedicationPinToProblem.objects.get(
medication_id=medication_id, problem_id=problem_id)
pin.delete()
except MedicationPinToProblem.DoesNotExist:
pin = MedicationPinToProblem(author=request.user,
medication_id=medication_id,
problem_id=problem_id)
pin.save()
pinned_instance_set, count = count_pinned_have_same_medication_concept_id_and_problem_concept_id(
request.user, pin.medication, pin.problem)
if request.user.profile.role == "physician" and count >= 3:
op_pin_medication_to_problem_for_all_controlled_patient(
request.user, pinned_instance_set, pin.medication,
pin.problem)
resp['pin'] = MedicationPinToProblemSerializer(pin).data
resp['success'] = True
return ajax_response(resp)
def delete_note(request, note_id):
resp = {'success': False}
note = ColonCancerTextNote.objects.get(id=note_id)
if permissions_accessed(request.user, note.author.id):
note.delete()
resp['success'] = True
return ajax_response(resp)
def obseration_pin_to_problem(request, patient_id):
resp = {'success': False}
if permissions_accessed(request.user, int(patient_id)) or True:
observation_id = request.POST.get("data_id", None)
problem_id = request.POST.get("problem_id", None)
observation = Observation.objects.get(id=observation_id)
try:
pin = ObservationPinToProblem.objects.get(
observation_id=observation_id, problem_id=problem_id)
up = UserProfile.objects.get(user_id=request.user.id)
if up.role == 'patient' and pin.author_id != request.user.id:
resp['success'] = "notallow"
return ajax_response(resp)
pin.delete()
problems = Problem.objects.filter(patient_id=patient_id)
optp = ObservationPinToProblem.objects.values_list(
'observation_id', ).filter(problem__in=problems)
optp1 = []
for x in optp:
optp1.append(x[0])
component = ObservationComponent.objects.filter(
observation_id__in=optp1, component_code='6301-6')
if ObservationComponent.objects.filter(
observation=observation,
component_code='6301-6').exists() and len(component) < 1:
inr_objects_filter = Inr.objects.filter(
observation_value__component__observation_id=observation_id
)
if inr_objects_filter.exists():
inr_objects_filter.delete()
resp['remove_inr'] = True
except ObservationPinToProblem.DoesNotExist:
problems = Problem.objects.filter(patient_id=patient_id)
optp = ObservationPinToProblem.objects.values_list(
'observation_id', ).filter(problem__in=problems).distinct()
optp1 = []
for x in optp:
optp1.append(x[0])
component = ObservationComponent.objects.filter(
observation_id__in=optp1, component_code='6301-6')
pin = ObservationPinToProblem(author_id=request.user.id,
observation_id=observation_id,
problem_id=problem_id)
pin.save()
if ObservationComponent.objects.filter(
observation=observation,
component_code='6301-6').exists() and len(component) < 1:
patient_user = User.objects.get(id=patient_id)
inr = Inr(observation_id=observation_id,
problem_id=problem_id,
author=request.user,
patient=patient_user)
inr.save()
resp['inr'] = InrSerializer(inr).data
resp['pin'] = ObservationPinToProblemSerializer(pin).data
resp['success'] = True
return ajax_response(resp)
def save_data_type(request, patient_id, observation_id):
resp = {'success': False}
name = request.POST.get("name", None)
color_code = request.POST.get("color", None)
unit = request.POST.get("unit", None)
if permissions_accessed(request.user, int(patient_id)):
observation = Observation.objects.get(id=observation_id)
if observation.author is not None: # prevent default datas
observation.name = name
observation.color = color_code
observation.save()
# TODO: will be changed later if we have more components in one custom observation
for component in observation.observation_components.all():
component.name = name
component.component_code = request.POST.get("code", None)
component.save()
if unit:
for observation_unit in observation.observation_units.all():
observation_unit.value_unit = unit
observation_unit.save()
resp['observation'] = ObservationSerializer(observation).data
resp['success'] = True
return ajax_response(resp)
def save_text_component_entry(request, patient_id, component_id):
resp = {}
resp['success'] = False
if permissions_accessed(request.user, int(patient_id)):
component = MyStoryTextComponent.objects.get(id=int(component_id))
patient = User.objects.get(id=patient_id)
entry = MyStoryTextComponentEntry()
entry.component = component
entry.text = request.POST.get("text", None)
entry.patient = patient
entry.author = request.user
entry.save()
resp['entry'] = MyStoryTextComponentEntrySerializer(entry).data
actor = request.user
summary = "<b>%s</b> note was updated to %s" % (component.name,
entry.text)
op_add_event(actor, patient, summary)
resp['success'] = True
return ajax_response(resp)
def get_my_story(request, patient_id):
resp = {'success': False}
if permissions_accessed(request.user, int(patient_id)):
# # METHOD 2: NEW WAY
staffIDList = PatientController.objects.filter(
patient_id=int(patient_id)).values_list('physician_id', flat=True)
myStoryTabComponentQuerySet = MyStoryTextComponent.objects.filter(
Q(patient_id=int(patient_id))
| (Q(author_id__in=staffIDList) & Q(is_all=True)))
if request.user.profile.role != 'patient':
myStoryTabComponentQuerySet = myStoryTabComponentQuerySet.filter(
private=False)
# text_component_entries should be filtered by patient only not sharing across any patient
myStoryTabComponentEntriesQuerySet = MyStoryTextComponentEntry.objects.filter(
patient_id=int(patient_id))
myStoryTabQuerySet = MyStoryTab.objects.prefetch_related(
Prefetch('my_story_tab_components',
queryset=myStoryTabComponentQuerySet),
Prefetch('my_story_tab_components__text_component_entries',
queryset=myStoryTabComponentEntriesQuerySet)).filter(
Q(patient_id=int(patient_id))
| (Q(author_id__in=staffIDList) & Q(is_all=True)))
if request.user.profile.role != 'patient':
myStoryTabQuerySet = myStoryTabQuerySet.filter(private=False)
resp['success'] = True
resp['info'] = MyStoryTabSerializer(myStoryTabQuerySet, many=True).data
return ajax_response(resp)
def add_factor(request, colon_id):
resp = {'success': False}
colon = ColonCancerScreening.objects.get(id=colon_id)
if permissions_accessed(request.user, colon.patient.id):
actor_profile = UserProfile.objects.get(user=request.user)
if not RiskFactor.objects.filter(colon=colon, factor=request.POST.get("value", None)).exists():
factor = RiskFactor.objects.create(colon=colon, factor=request.POST.get("value", None))
if factor.factor == 'no known risk':
factors = RiskFactor.objects.filter(colon=colon).exclude(factor='no known risk')
for f in factors:
f.delete()
else:
factors = RiskFactor.objects.filter(colon=colon, factor='no known risk')
for f in factors:
f.delete()
if RiskFactor.objects.filter(colon=colon).count() == 1 and request.POST.get("value",
None) == 'no known risk':
colon.risk = 'normal'
else:
colon.risk = 'high'
colon.last_risk_updated_user = request.user
colon.last_risk_updated_date = datetime.now().date()
colon.todo_past_five_years = False
colon.save()
resp['factor'] = RiskFactorSerializer(factor).data
resp['info'] = ColonCancerScreeningSerializer(colon).data
resp['success'] = True
return ajax_response(resp)
def add_new_data_type(request, patient_id):
resp = {'success': False}
name = request.POST.get("name", None)
color_code = request.POST.get("color", None)
loinc_code = request.POST.get("code", None)
unit = request.POST.get("unit", None)
if permissions_accessed(request.user, int(patient_id)):
# TODO[Observation]
patient = User.objects.get(id=int(patient_id))
observation = Observation.objects.create(subject=patient,
author=request.user,
name=name,
color=color_code,
code=loinc_code)
observation.save()
if unit:
observation_unit = ObservationUnit.objects.create(
observation=observation, value_unit=unit)
observation_unit.is_used = True # will be changed in future when having conversion
observation_unit.save()
observation_component = ObservationComponent()
observation_component.observation = observation
observation_component.component_code = loinc_code
observation_component.name = name
observation_component.save()
resp['observation'] = ObservationSerializer(observation).data
resp['success'] = True
return ajax_response(resp)
def delete_individual_data(request, patient_id, value_id):
resp = {'success': False}
if permissions_accessed(request.user, int(patient_id)):
value = ObservationValue.objects.get(id=value_id)
value.delete()
resp['success'] = True
return ajax_response(resp)
def delete_study(request, study_id):
resp = {'success': False}
study = ColonCancerStudy.objects.get(id=study_id)
if permissions_accessed(request.user, study.author.id):
study.delete()
resp['success'] = True
return ajax_response(resp)
def edit_note(request, note_id):
resp = {'success': False}
note = ColonCancerTextNote.objects.get(id=note_id)
if permissions_accessed(request.user, note.author.id):
note.note = request.POST.get('note')
note.save()
resp['success'] = True
resp['note'] = ColonCancerTextNoteSerializer(note).data
return ajax_response(resp)
def get_individual_data_info(request, patient_id, value_id):
resp = {'success': False}
if permissions_accessed(request.user, int(patient_id)):
value = ObservationValue.objects.get(id=value_id)
# TODO: Figure out why this one is fixed OBSERVATION_TYPES[0]['name'] = 'a1c'
if not value.component.observation.name == 'a1c':
resp['info'] = ObservationValueSerializer(value).data
resp['success'] = True
return ajax_response(resp)
def update_graph(request):
resp = {'success': False}
# If user have access to this data
if permissions_accessed(request.user, int(request.POST.get('patient_id'))):
observation = Observation.objects.get(id=request.POST.get('data_id'))
observation.graph = request.POST.get('graph_type')
observation.save()
resp['success'] = True
return ajax_response(resp)
def add_note(request, colon_id):
resp = {'success': False}
colon = ColonCancerScreening.objects.get(id=colon_id)
if permissions_accessed(request.user, colon.patient.id):
note = request.POST.get("note")
colon_note = ColonCancerTextNote.objects.create(colon_id=colon_id, author=request.user, note=note)
resp['note'] = ColonCancerTextNoteSerializer(colon_note).data
resp['success'] = True
return ajax_response(resp)
def track_colon_click(request, colon_id):
resp = {'success': False}
colon_info = ColonCancerScreening.objects.get(id=colon_id)
if permissions_accessed(request.user, colon_info.patient.id):
actor = request.user
patient = colon_info.problem.patient
summary = "<b>%s</b> accessed colorectal cancer screening" % (actor.username)
op_add_event(actor, patient, summary, colon_info.problem)
resp['success'] = True
return ajax_response(resp)
def delete_study_image(request, study_id, image_id):
resp = {'success': False}
study = ColonCancerStudy.objects.get(id=study_id)
if permissions_accessed(request.user, study.author.id):
actor_profile = UserProfile.objects.get(user=request.user)
study.last_updated_user = request.user
study.save()
ColonCancerStudyImage.objects.get(id=image_id).delete()
resp['success'] = True
return ajax_response(resp)
def track_tab_click(request):
resp = {'success': False}
if request.POST.get("tab_id", None):
tab_info = MyStoryTab.objects.get(id=request.POST.get("tab_id", None))
if permissions_accessed(request.user, tab_info.patient.id):
actor = request.user
patient = tab_info.patient
summary = "<b>%s</b> accessed %s" % (actor.username, tab_info.name)
op_add_event(actor, patient, summary)
resp['success'] = True
return ajax_response(resp)
def delete_text_component(request, patient_id, component_id):
resp = {}
resp['success'] = False
if permissions_accessed(request.user, int(patient_id)):
component = MyStoryTextComponent.objects.get(id=int(component_id))
if request.user.id == component.author.id:
MyStoryTextComponentEntry.objects.filter(
component=component).delete()
component.delete()
resp['success'] = True
return ajax_response(resp)
def save_tab(request, patient_id, tab_id):
resp = {}
resp['success'] = False
if permissions_accessed(request.user, int(patient_id)):
tab = MyStoryTab.objects.get(id=int(tab_id))
if request.user.id == tab.author.id:
tab.name = request.POST.get("name", None)
tab.save()
resp['tab'] = MyStoryTabSerializer(tab).data
resp['success'] = True
return ajax_response(resp)
def delete_tab(request, patient_id, tab_id):
resp = {'success': False}
if permissions_accessed(request.user, int(patient_id)):
tab = MyStoryTab.objects.get(id=int(tab_id))
if request.user.id == tab.author.id:
MyStoryTextComponentEntry.objects.filter(
component__tab=tab).delete()
MyStoryTextComponent.objects.filter(tab=tab).delete()
tab.delete()
resp['success'] = True
return ajax_response(resp)
def edit_study(request, study_id):
resp = {'success': False}
study = ColonCancerStudy.objects.get(id=study_id)
if permissions_accessed(request.user, study.author.id):
actor_profile = UserProfile.objects.get(user=request.user)
study.finding = request.POST.get("finding", None)
study.result = request.POST.get("result", None)
study.note = request.POST.get("note", None)
study.study_date = datetime.strptime(request.POST.get('study_date'), '%m/%d/%Y').date()
study.last_updated_user = request.user
study.save()
resp['success'] = True
return ajax_response(resp)
def not_appropriate(request, colon_id):
resp = {'success': False}
colon = ColonCancerScreening.objects.get(id=colon_id)
if permissions_accessed(request.user, colon.patient.id):
if colon.not_appropriate:
colon.not_appropriate = False
else:
colon.not_appropriate = True
colon.not_appropriate_on = datetime.now()
colon.save()
colon = ColonCancerScreening.objects.get(id=colon_id)
resp['info'] = ColonCancerScreeningSerializer(colon).data
resp['success'] = True
return ajax_response(resp)
def delete_component_values(request, patient_id):
"""
Delete observation component values
:param patient_id:
:param request:
:return:
"""
resp = {'success': False}
json_body = json.loads(request.body)
observation_value_ids = json_body.get('component_values')
if permissions_accessed(request.user, int(patient_id)):
ObservationValue.objects.filter(id__in=observation_value_ids).delete()
resp['success'] = True
return ajax_response(resp)
def get_medications(request, patient_id):
"""
:param request:
:param patient_id: Patient user id
:return:
"""
resp = {'success': False}
if permissions_accessed(request.user, int(patient_id)):
medications = Medication.objects.filter(
patient__id=patient_id).order_by('name')
resp['success'] = True
resp['info'] = MedicationSerializer(medications, many=True).data
return ajax_response(resp)
def save_data(request, patient_id, value_id):
resp = {'success': False}
if permissions_accessed(request.user, int(patient_id)):
value = ObservationValue.objects.get(id=value_id)
effective_datetime = request.POST.get("datetime", None)
if effective_datetime:
effective_datetime = datetime.strptime(effective_datetime,
'%m/%d/%Y %H:%M')
value_quantity = request.POST.get("value_quantity", None)
value.effective_datetime = effective_datetime
value.value_quantity = value_quantity
value.save()
resp['info'] = ObservationValueSerializer(value).data
resp['success'] = True
return ajax_response(resp)
def get_colon_info(request, colon_id):
resp = {'success': False}
colon_info = ColonCancerScreening.objects.get(id=colon_id)
if permissions_accessed(request.user, colon_info.patient.id):
if Problem.objects.filter(patient=colon_info.patient, id__in=[93761005, 93854002]).exists():
if not RiskFactor.objects.filter(colon=colon_info, factor="personal history of colorectal cancer").exists():
factor = RiskFactor.objects.create(colon=colon_info, factor="personal history of colorectal cancer")
colon_info.risk = 'high'
colon_info.save()
if Problem.objects.filter(patient=colon_info.patient, id__in=[64766004, 34000006]).exists():
if not RiskFactor.objects.filter(colon=colon_info,
factor="personal history of ulcerative colitis or Crohn's disease").exists():
factor = RiskFactor.objects.create(colon=colon_info,
factor="personal history of ulcerative colitis or Crohn's disease")
colon_info.risk = 'high'
colon_info.save()
resp['success'] = True
resp['info'] = ColonCancerScreeningSerializer(colon_info).data
return ajax_response(resp)
def save_text_component(request, patient_id, component_id):
resp = {}
resp['success'] = False
if permissions_accessed(request.user, int(patient_id)):
component = MyStoryTextComponent.objects.get(id=int(component_id))
if request.user.id == component.author.id:
component.name = request.POST.get("name", None)
component.concept_id = request.POST.get("concept_id", None)
component.save()
resp['component'] = MyStoryTextComponentSerializer(component).data
entries = MyStoryTextComponentEntry.objects.filter(
component_id=component.id, patient_id=int(patient_id))
resp['component'][
"text_component_entries"] = MyStoryTextComponentEntrySerializer(
entries, many=True).data
resp['success'] = True
return ajax_response(resp)
def delete_data(request, patient_id, observation_id):
resp = {'success': False}
if permissions_accessed(request.user, int(patient_id)):
observation = Observation.objects.get(id=observation_id)
if not observation.author is None: # prevent default datas
pins = ObservationPinToProblem.objects.filter(
observation_id=observation_id)
for pin in pins:
pin.delete()
for component in observation.observation_components.all():
for value in component.observation_component_values.all():
value.delete()
component.delete()
observation.delete()
resp['success'] = True
return ajax_response(resp)
