def create(self, request):
"""Creating a task for a user"""
print ">>> User:"******">>> Token:", request.auth, request.current_user
serializer = TodoSerializer(data=request.data)
serializer.initial_data["author"] = request.user
if serializer.is_valid():
post = Todo()
post.description = serializer.data["description"]
post.author = serializer.data["author"]
if "due_at" in serializer.data and serializer.data["due_at"]:
post.due_at = convert_time(serializer.data["due_at"])
else:
today = datetime.datetime.now()
_date = (today - datetime.timedelta(days=settings.DEFAULT_DAYS))
post.due_at = _date
post.save()
serializer = TodoSerializer(post)
return Response(serializer.data, status=status.HTTP_201_CREATED)
else:
msg = {
"error": 400,
"message": serializer.errors
}
return Response(msg, status=status.HTTP_400_BAD_REQUEST)
def get_patient_todos_info(request, patient_id):
resp = {}
todos = ToDo.objects.filter(patient_id=patient_id).order_by("order")
pending_todos = [todo for todo in todos if todo.accomplished is False]
accomplished_todos = [todo for todo in todos if todo.accomplished is True]
resp['pending_todos'] = TodoSerializer(pending_todos, many=True).data
resp['accomplished_todos'] = TodoSerializer(accomplished_todos,
many=True).data
resp['problem_todos'] = TodoSerializer(todos, many=True).data
return ajax_response(resp)
def post(self, request):
"""
add new todo-note
"""
serializer = TodoSerializer(data=request.data)
if not serializer.is_valid():
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
data = serializer.data
todo_obj = Todo(description=data['description'], is_done=False)
todo_obj.save()
request.data['id'] = todo_obj.id
return Response(request.data, status=status.HTTP_201_CREATED)
def put(self, request, todo_id):
"""
update already saved todo note
"""
serializer = TodoSerializer(data=request.data)
if not serializer.is_valid():
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
data = serializer.data
desc = data['description']
is_done = data['is_done']
todo_obj = Todo(id=todo_id, description=desc, is_done=is_done, updated=datetime.now())
todo_obj.save()
return Response(status=status.HTTP_200_OK)
def add_order(request, patient_id):
"""
:param patient_id:
:param request:
:return:
"""
resp = {'success': False}
json_body = json.loads(request.body)
todo = json_body.get('todo')
due_date = json_body.get('due_date')
problem_id = json_body.get('problem_id')
user_profile = UserProfile.objects.filter(id=patient_id).get()
todo = ToDo(todo=todo, user=request.user,
patient=user_profile.user,
problem_id=problem_id,
created_at=1,
accomplished=False)
if due_date is not None:
todo.due_date = datetime.strptime(due_date, '%Y-%m-%d').date()
todo.save()
resp['order'] = TodoSerializer(todo).data
resp['success'] = True
return ajax_response(resp)
def get_most_recent_encounter(request, patient_id):
"""
:param request:
:param patient_id:
:return:
"""
resp = {'success': False}
# Retrieve most recent encounter information
encounter = Encounter.objects.filter(
patient_id=patient_id).order_by("-starttime").first()
most_recent_encounter_summaries = []
most_recent_encounter_documents_holder = []
related_problem_holder = []
if encounter:
# Encounter's event summaries
most_recent_encounter_events = EncounterEvent.objects.filter(
encounter__patient_id=patient_id, encounter=encounter)
for event in most_recent_encounter_events:
if not "Started encounter by" in event.summary and not "Stopped encounter by" in event.summary:
most_recent_encounter_summaries.append(event.summary)
# Encounter's document
documents = ObservationValue.objects.filter(created_on__range=(
encounter.starttime.replace(
hour=0, minute=0, second=0, microsecond=0),
datetime.datetime.now())).filter(
component__observation__subject=encounter.patient)
for document in documents:
most_recent_encounter_documents_holder.append({
'name':
document.component.__str__(),
'value':
'%g' % float(document.value_quantity),
'effective':
document.effective_datetime.isoformat()
})
# Encounter's related problems
related_problem_records = EncounterProblemRecord.objects.filter(
encounter=encounter)
related_problem_ids = [x.problem.id for x in related_problem_records]
related_problems = Problem.objects.filter(id__in=related_problem_ids)
related_problem_holder = ProblemSerializer(related_problems,
many=True).data
# Load all pending todo
todo = ToDo.objects.filter(patient_id=patient_id, accomplished=False)
resp['success'] = True
resp['todo'] = TodoSerializer(todo, many=True).data
resp['most_recent_encounter_summaries'] = most_recent_encounter_summaries
resp['most_recent_encounter_related_problems'] = related_problem_holder
resp[
'most_recent_encounter_documents'] = most_recent_encounter_documents_holder
return ajax_response(resp)
def get(self, request):
"""
get all created todo-notes
"""
all_to_noted = Todo.objects.all()
serializer = TodoSerializer(all_to_noted, many=True)
return Response(serializer.data)
class ColonCancerScreeningSerializer(serializers.ModelSerializer):
colon_studies = ColonCancerStudySerializer(many=True, read_only=True)
colon_risk_factors = RiskFactorSerializer(many=True, read_only=True)
colon_cancer_todos = TodoSerializer(many=True, read_only=True)
colon_notes = ColonCancerTextNoteSerializer(many=True, read_only=True)
problem = ProblemSerializer()
patient = UserSerializer()
last_risk_updated_user = SafeUserSerializer()
class Meta:
model = ColonCancerScreening
fields = (
'id',
'patient',
'problem',
'created_on',
'patient_refused',
'not_appropriate',
'colon_studies',
'risk',
'colon_risk_factors',
'last_risk_updated_date',
'last_risk_updated_user',
'todo_past_five_years',
'colon_cancer_todos',
'patient_refused_on',
'not_appropriate_on',
'colon_notes',
)
class DocumentTodoSerializer(serializers.ModelSerializer):
document = DocumentSerializer()
todo = TodoSerializer()
author = SafeUserSerializer()
class Meta:
model = DocumentTodo
fields = (
'document',
'todo',
'author',
)
def create(self, request):
"""Creating a task for a user"""
print ">>> User:"******">>> Token:", request.auth, request.current_user
serializer = TodoSerializer(data=request.data)
serializer.initial_data["author"] = request.user
if serializer.is_valid():
post = Todo()
post.description = serializer.data["description"]
post.author = serializer.data["author"]
if "due_at" in serializer.data and serializer.data["due_at"]:
post.due_at = convert_time(serializer.data["due_at"])
else:
today = datetime.datetime.now()
_date = (today -
datetime.timedelta(days=settings.DEFAULT_DAYS))
post.due_at = _date
post.save()
serializer = TodoSerializer(post)
return Response(serializer.data, status=status.HTTP_201_CREATED)
else:
msg = {"error": 400, "message": serializer.errors}
return Response(msg, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, *args, **kwargs):
data = request.data
data["user"] = self.request.user
serializer = TodoSerializer(data=data)
serializer.is_valid(raise_exception=True)
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
def get_orders(request, patient_id, problem_id):
"""
Get all orders(aka todo) which is generated in this widget
:param problem_id:
:param patient_id:
:param request:
:return:
"""
resp = {'success': False}
orders = ToDo.objects.filter(patient_id=patient_id).filter(problem_id=problem_id).filter(accomplished=False).filter(
created_at=1)
resp['orders'] = TodoSerializer(orders, many=True).data
resp['success'] = True
return ajax_response(resp)
class AOneCSerializer(serializers.ModelSerializer):
problem = ProblemSerializer()
observation = ObservationSerializer()
a1c_todos = TodoSerializer(many=True, read_only=True)
a1c_notes = AOneCTextNoteSerializer(many=True, read_only=True)
class Meta:
model = AOneC
fields = (
'id',
'problem',
'observation',
'todo_past_six_months',
'patient_refused_A1C',
'a1c_todos',
'a1c_notes',
)
def update(self, request, pk=None):
"""Updating a task"""
print ">>> User:"******">>> Token:", request.auth
serializer = TodoUpdateSerializer(data=request.data)
if serializer.is_valid():
post = Todo.objects.get(id=pk)
if post:
check_permission(request, post, 'update')
if "due_at" in serializer.data and serializer.data["due_at"]:
post.due_at = convert_time(serializer.data["due_at"])
if "description" in serializer.data and serializer.data[
"description"]:
post.description = serializer.data["description"]
if "completed" in serializer.data and serializer.data[
"completed"]:
post.completed = serializer.data["completed"]
post.save()
print post.due_at, type(post.due_at), post.created_at
serializer = TodoSerializer(post)
print '\nPUT ===>' + str(serializer.data)
return Response(serializer.data,
status=status.HTTP_202_ACCEPTED)
else:
msg = {"error": 404, "message": "Todo task could not be found"}
return Response(msg, status=status.HTTP_404_NOT_FOUND)
else:
msg = {"error": 400, "message": serializer.errors}
return Response(msg, status=status.HTTP_400_BAD_REQUEST)
def retrieve(self, request, pk=None):
"""
Retrieving a task
"""
print ">>> User", request.user
print ">>> Token", request.auth
author = request.current_user["username"]
print "current user:"******"error": 404, "message": "Todo task could not be found"}
return Response(msg, status=status.HTTP_404_NOT_FOUND)
def get_user_todo(request, patient_id):
"""
API for querying patient todo
:param request:
:param patient_id:
:return:
"""
resp = {'success': False}
is_accomplished = request.GET.get('accomplished') == 'true'
page = int(request.GET.get('page', 1))
load_all = request.GET.get('all', 'false') == 'true'
per_page = 5 # Default
# Filter todo type and pagination
todo = ToDo.objects.filter(patient_id=patient_id,
accomplished=is_accomplished).order_by("order")
if not load_all:
todo = todo[per_page * (page - 1):per_page * page]
resp['success'] = True
resp['data'] = TodoSerializer(todo, many=True).data
return ajax_response(resp)
def get_todos_physicians(request, user_id):
resp = {}
team_members = PhysicianTeam.objects.filter(member_id=user_id)
physician_ids = [x.physician.id for x in team_members]
patient_controllers = PatientController.objects.filter(
physician__id__in=physician_ids)
patient_ids = [x.patient.id for x in patient_controllers]
todos = ToDo.objects.filter(
accomplished=False,
patient__id__in=patient_ids,
created_on__gte=datetime.datetime.now() -
datetime.timedelta(hours=24)).order_by('created_on')
resp['new_generated_todos_list'] = TodoSerializer(todos, many=True).data
physicians_list = []
for team in team_members:
user_dict = UserProfileSerializer(team.physician.profile).data
physicians_list.append(user_dict)
resp['new_generated_physicians_list'] = physicians_list
return ajax_response(resp)
def auto_generate_note_todo(actor_profile, patient, problem, request, resp):
if 'patient' == actor_profile.role or 'nurse' == actor_profile.role or 'secretary' == actor_profile.role:
# Create todo and Pin to problem
note_auto_generated_todo = ToDo(patient=patient,
problem=problem,
todo="A note was added")
order = ToDo.objects.all().aggregate(Max('order'))
if not order['order__max']:
order = 1
else:
order = order['order__max'] + 1
note_auto_generated_todo.order = order
note_auto_generated_todo.save()
summary = '''Added <u>todo</u> <a href="#/todo/{}"><b>{}</b></a> for <u>problem</u> <b>{}</b>'''.format(
note_auto_generated_todo.id, "A note was added",
problem.problem_name)
op_add_todo_event(request.user, patient, summary,
note_auto_generated_todo)
add_todo_activity(note_auto_generated_todo, request.user,
"Added this todo.")
# Tag associated physician
# Find all associated physician(s) with this patient
patient_controller = PatientController.objects.filter(
patient=patient).all()
for doctor in patient_controller:
TaggedToDoOrder.objects.create(todo=note_auto_generated_todo,
user=doctor.physician)
log = "<b>{0} {1} - {2}</b> joined this todo.".format(
doctor.physician.first_name, doctor.physician.last_name,
doctor.physician.profile.role)
add_todo_activity(note_auto_generated_todo, request.user, log)
resp['todo'] = TodoSerializer(note_auto_generated_todo).data
class DocumentSerializer(serializers.ModelSerializer):
author = SafeUserSerializer()
patient = SafeUserSerializer()
labels = serializers.SerializerMethodField()
todos = TodoSerializer(many=True)
problems = ProblemSerializer(many=True)
class Meta:
model = Document
fields = (
'id',
'author',
'patient',
'document',
'labels',
'todos',
'problems',
'document_name',
'file_mime_type',
'created_on'
)
def get_labels(self, obj):
return LabelSerializer(fetch_document_label_set(obj), many=True).data
def list(self, request):
""">>>Listing all tasks for the logged user"""
queryset = Todo.objects.filter(author=request.user)
serializer = TodoSerializer(queryset, many=True)
return Response(serializer.data)
def add_problem_todo(request, problem_id):
resp = {'success': False}
problem = Problem.objects.get(id=problem_id)
actor_profile = UserProfile.objects.get(user=request.user)
problem.authenticated = actor_profile.role in ['physician', 'admin']
problem.save()
patient = problem.patient
todo = request.POST.get('name')
due_date = request.POST.get('due_date', None)
if due_date:
due_date = parser.parse(due_date, dayfirst=False).date()
# due_date = datetime.strptime(due_date, '%m/%d/%Y').date()
new_todo = ToDo(patient=patient,
problem=problem,
todo=todo,
due_date=due_date)
a1c_id = request.POST.get('a1c_id', None)
if a1c_id:
a1c = AOneC.objects.get(id=int(a1c_id))
new_todo.a1c = a1c
order = ToDo.objects.all().aggregate(Max('order'))
if not order['order__max']:
order = 1
else:
order = order['order__max'] + 1
new_todo.order = order
new_todo.save()
colon_cancer_id = request.POST.get('colon_cancer_id', None)
if colon_cancer_id:
colon = ColonCancerScreening.objects.get(id=int(colon_cancer_id))
if not Label.objects.filter(name="screening",
css_class="todo-label-yellow",
is_all=True).exists():
label = Label(name="screening",
css_class="todo-label-yellow",
is_all=True)
label.save()
else:
label = Label.objects.get(name="screening",
css_class="todo-label-yellow",
is_all=True)
new_todo.colon_cancer = colon
new_todo.save()
new_todo.labels.add(label)
physician = request.user
summary = '''Added <u>todo</u> : <a href="#/todo/%s"><b>%s</b></a> to <u>problem</u> : <b>%s</b>''' % (
new_todo.id, todo, problem.problem_name)
op_add_event(physician, patient, summary, problem)
activity = summary
add_problem_activity(problem, request.user, activity, 'output')
summary = '''Added <u>todo</u> <a href="#/todo/%s"><b>%s</b></a> for <u>problem</u> <b>%s</b>''' % (
new_todo.id, new_todo.todo, problem.problem_name)
op_add_todo_event(physician, patient, summary, new_todo, True)
# todo activity
activity = '''
Added this todo.
'''
add_todo_activity(new_todo, request.user, activity)
resp['success'] = True
resp['todo'] = TodoSerializer(new_todo).data
return ajax_response(resp)
