def create(request):
try:
data = request.data
# 1. Validations
# 1.1. Only Doctors can create new Prehab Plans
if not Permission.verify(request, ['Admin', 'Doctor']):
raise HttpException(
401, 'Não tem permissões para aceder a este recurso.',
'You don\'t have access to this resource.')
# 1.2. Check schema
SchemaValidator.validate_obj_structure(data, 'prehab/create.json')
# 1.3. Check if patient_id is one of this doctor patients
patient_id = data['patient_id']
patient = Patient.objects.get(pk=patient_id)
doctor = Doctor.objects.get(pk=request.USER_ID)
if request.ROLE_ID == 2 and not DoctorPatient.objects.is_a_match(
request.USER_ID, patient_id):
raise HttpException(
400, 'Paciente não é do médico especificado.',
'Patient {} is not from Doctor {}.'.format(
patient_id, request.USER_ID))
# 1.4. Check if surgery date is greater than init_date
surgery_date = datetime.datetime.strptime(data['surgery_date'],
"%d-%m-%Y")
init_date = datetime.datetime.strptime(data['init_date'],
"%d-%m-%Y")
if surgery_date < init_date:
raise HttpException(
400,
'Data de cirurgia deve ser posterior à data de inicio de prehab,',
'Surgery Date must be after prehab init.')
# 1.5. Check if Task Schedule Id was created by
# this specific doctor or a community Task Schedule (created by an admin)
task_schedule = TaskSchedule.objects.get(
pk=data['task_schedule_id'])
if request.ROLE_ID != 1 and not task_schedule.doctor_can_use(
doctor.user.id):
raise HttpException(
400, 'Você não é o dono deste prehab',
'You are not the owner of this task schedule.')
# 1.6. Check if this patient has some prehab already
if Prehab.objects.filter(patient=patient).filter(
status__lt=4).count() > 0:
raise HttpException(400, 'Este paciente já tem um prehab',
'This patient has a prehab already.')
# 2. Transform General Task Schedule to a Custom Patient Task Schedule
expected_end_date = init_date + datetime.timedelta(
days=7 * task_schedule.number_of_weeks)
# 3. Insert new Prehab
with transaction.atomic():
prehab = Prehab(patient=patient,
init_date=init_date,
expected_end_date=expected_end_date,
actual_end_date=None,
surgery_date=surgery_date,
number_of_weeks=task_schedule.number_of_weeks,
status=Prehab.PENDING,
created_by=doctor)
prehab.save()
# 4. Insert Patient Task Schedule
patient_task_schedule_work_load = DataHelper.patient_task_schedule_work_load(
task_schedule)
patient_tasks = []
for row in patient_task_schedule_work_load:
patient_tasks.append(
PatientTaskSchedule(
prehab=prehab,
week_number=row['week_number'],
day_number=row['day_number'],
task=row['task'],
expected_repetitions=1, # row['repetitions'],
actual_repetitions=None,
status=PatientTaskSchedule.PENDING))
PatientTaskSchedule.objects.bulk_create(patient_tasks)
# 5. Insert Patient Meal Schedule
constraint_types = [
pct.constraint_type
for pct in PatientConstraintType.objects.filter(
patient=patient).all()
]
patient_meal_schedule = DataHelper.patient_meal_schedule(
task_schedule.number_of_weeks, constraint_types)
patient_meals = []
for row in patient_meal_schedule:
patient_meals.append(
PatientMealSchedule(prehab=prehab,
week_number=row['week_number'],
day_number=row['day_number'],
meal_order=row['meal_order'],
meal=row['meal']))
PatientMealSchedule.objects.bulk_create(patient_meals)
except Patient.DoesNotExist as e:
return HTTP.response(
400, 'Patient with id of {} does not exist.'.format(
request.data['patient_id']))
except TaskSchedule.DoesNotExist as e:
return HTTP.response(
400, 'Task Schedule with id of {} does not exist.'.format(
request.data['task_schedule_id']))
except HttpException as e:
return HTTP.response(e.http_code, e.http_custom_message,
e.http_detail)
except Exception as e:
return HTTP.response(400, 'Erro Inesperado',
'Unexpected Error: {}.'.format(str(e)))
# Send Response
data = {'prehab_id': prehab.id}
return HTTP.response(201, '', data)
def list(self, request):
try:
if 'active' in request.GET and request.GET.get('active'):
prehabs = Prehab.objects.filter(status__not_in=4)
else:
prehabs = Prehab.objects.filter(status__lt=4)
# In case it's an Admin -> Retrieve ALL PREHABS info
if request.ROLE_ID == 1:
prehabs = prehabs.all()
# In case it's a Doctor -> Retrieve ALL plans created by him
elif request.ROLE_ID == 2:
prehabs = prehabs.filter(created_by=request.USER_ID).all()
# In case it's a Patient -> Retrieve his plan
elif request.ROLE_ID == 3:
prehabs = prehabs.filter(patient_id=request.USER_ID).all()
else:
raise HttpException(400)
queryset = self.paginate_queryset(prehabs)
data = PrehabSerializer(queryset, many=True).data
for record in data:
# STATISTICS
prehab = Prehab.objects.get(pk=record['id'])
patient_tasks = PatientTaskSchedule.objects.filter(
prehab=prehab).all()
past_patient_tasks = [
t for t in patient_tasks
if t.week_number <= prehab.get_current_week_num()
and t.day_number <= prehab.get_current_day_num()
]
record['info'] = {
'patient_id':
prehab.patient.pk,
'patient_tag':
prehab.patient.patient_tag,
'prehab_week_number':
prehab.number_of_weeks,
'prehab_start_date':
prehab.init_date,
'prehab_expected_end_date':
prehab.expected_end_date,
'surgery_day':
prehab.surgery_date,
'days_until_surgery':
prehab.get_days_to_prehab_end()
if prehab.get_days_to_prehab_end() else None,
'total_activities':
len(patient_tasks),
'total_activities_until_now':
len(past_patient_tasks),
'activities_done':
len([
t for t in past_patient_tasks
if t.status == PatientTaskSchedule.COMPLETED
]),
'activities_with_difficulty':
len([t for t in past_patient_tasks if t.was_difficult]),
'activities_not_done':
len([
t for t in past_patient_tasks
if t.status == PatientTaskSchedule.NOT_COMPLETED
]),
'prehab_status_id':
prehab.status,
'prehab_status':
prehab.get_status_display(),
'number_of_alerts_unseen':
len([
t for t in past_patient_tasks
if (t.status == PatientTaskSchedule.NOT_COMPLETED
or t.was_difficult) and not t.seen_by_doctor
]),
'number_of_alerts':
len([
t for t in past_patient_tasks
if (t.status == PatientTaskSchedule.NOT_COMPLETED
or t.was_difficult)
])
}
except HttpException as e:
return HTTP.response(e.http_code, e.http_custom_message,
e.http_detail)
except Exception as e:
return HTTP.response(
400, 'Ocorreu um erro inesperado',
'Unexpected Error. {}. {}.'.format(type(e).__name__, str(e)))
return HTTP.response(200, '', data=data) # , paginator=self.paginator)
def destroy(request, pk=None):
return HTTP.response(405)
def retrieve(request, pk=None):
try:
prehab = Prehab.objects.get(pk=pk)
if request.ROLE_ID != 1 and request.USER_ID not in (
prehab.created_by.user.id, prehab.patient.user.id):
raise HttpException(
401, 'Você não tem permissões para ver este prehab.',
'You don\'t have permissions to see this Prehab Plan')
# STATISTICS
patient_tasks = PatientTaskSchedule.objects.filter(
prehab=prehab).all()
pass_patient_tasks = [
t for t in patient_tasks
if t.week_number <= prehab.get_current_week_num()
and t.day_number <= prehab.get_current_day_num()
]
prehab_statistics = {
'total_activities':
len(patient_tasks),
'total_activities_until_now':
len(pass_patient_tasks),
'activities_done':
len([
t for t in pass_patient_tasks
if t.status == PatientTaskSchedule.COMPLETED
]),
'activities_with_difficulty':
len([t for t in pass_patient_tasks if t.was_difficult]),
'activities_not_done':
len([
t for t in pass_patient_tasks
if t.status == PatientTaskSchedule.NOT_COMPLETED
]),
'prehab_status_id':
prehab.status,
'prehab_status':
prehab.get_status_display()
}
# DOCTORS
prehab_doctors = []
for doctor_patient in DoctorPatient.objects.filter(
patient=prehab.patient).all():
prehab_doctors.append(
SimpleDoctorSerializer(doctor_patient.doctor,
many=False).data)
except Prehab.DoesNotExist:
return HTTP.response(
404, 'Prehab não encontrado',
'Prehab with id {} does not exist'.format(str(pk)))
except ValueError:
return HTTP.response(404, 'Url com formato inválido.',
'Invalid URL format. {}'.format(str(pk)))
except HttpException as e:
return HTTP.response(e.http_code, e.http_custom_message,
e.http_detail)
except Exception as e:
return HTTP.response(
400, 'Ocorreu um erro inesperado',
'Unexpected Error. {}. {}.'.format(type(e).__name__, str(e)))
data = FullPrehabSerializer(prehab, many=False).data
data['alerts'] = [
{
'patient_task_schedule_id': t['id'],
'task_title': t['title'],
'task_description': t['description'],
'task_type': t['task_type'],
'status': t['status'],
'date': t['patient_task_info']['date'].split('T')[0],
'seen_by_doctor': t['patient_task_info']['seen_by_doctor'],
'doctor_notes': t['patient_task_info']['doctor_notes'],
'was_difficult': t['patient_task_info']['was_difficult'],
} for d, tasks in data['task_schedule'].items() for t in tasks
if t['patient_task_info']['was_difficult']
or t['status_id'] == PatientTaskSchedule.NOT_COMPLETED
]
data['number_of_alerts_unseen'] = len(
[a for a in data['alerts'] if not a['seen_by_doctor']])
data['number_of_alerts'] = len(data['alerts'])
data['statistics'] = prehab_statistics
data['patient'] = PatientWithConstraintsSerializer(prehab.patient,
many=False).data
data['patient']['patient_constraints'] = [
patient_constraint['constraint_type']['title']
for patient_constraint in data['patient']['patient_constraints']
]
data['doctors'] = prehab_doctors
return HTTP.response(200, data=data)
def create(request):
return HTTP.response(405)
def update(request, pk=None):
return HTTP.response(405)
def test_code_message_responses(self):
res = HTTP.response(200)
body = json.loads(res.content)
self.assertEqual(res.status_code, 200)
self.assertEqual(body['code'], 200)
self.assertEqual(body['message'], 'Success')
self.assertEqual(body['custom_message'], '')
self.assertEqual(body['details'], '')
self.assertEqual(body['custom_message'], '')
self.assertEqual(body['data'], {})
res = HTTP.response(201)
body = json.loads(res.content)
self.assertEqual(res.status_code, 201)
self.assertEqual(body['code'], 201)
self.assertEqual(body['message'], 'Created')
self.assertEqual(body['custom_message'], '')
self.assertEqual(body['details'], '')
self.assertEqual(body['data'], {})
res = HTTP.response(202)
body = json.loads(res.content)
self.assertEqual(res.status_code, 202)
self.assertEqual(body['code'], 202)
self.assertEqual(body['message'], 'Accepted')
self.assertEqual(body['custom_message'], '')
self.assertEqual(body['details'], '')
self.assertEqual(body['data'], {})
res = HTTP.response(204)
body = json.loads(res.content)
self.assertEqual(res.status_code, 204)
self.assertEqual(body['code'], 204)
self.assertEqual(body['message'], 'No content')
self.assertEqual(body['custom_message'], '')
self.assertEqual(body['details'], '')
self.assertEqual(body['data'], {})
res = HTTP.response(400)
body = json.loads(res.content)
self.assertEqual(res.status_code, 400)
self.assertEqual(body['code'], 400)
self.assertEqual(body['message'], 'Bad request')
self.assertEqual(body['custom_message'], '')
self.assertEqual(body['details'], '')
self.assertEqual(body['data'], {})
res = HTTP.response(401)
body = json.loads(res.content)
self.assertEqual(res.status_code, 401)
self.assertEqual(body['code'], 401)
self.assertEqual(body['message'], 'Unauthorized')
self.assertEqual(body['custom_message'], '')
self.assertEqual(body['details'], '')
self.assertEqual(body['data'], {})
res = HTTP.response(403)
body = json.loads(res.content)
self.assertEqual(res.status_code, 403)
self.assertEqual(body['code'], 403)
self.assertEqual(body['message'], 'Forbidden')
self.assertEqual(body['custom_message'], '')
self.assertEqual(body['details'], '')
self.assertEqual(body['data'], {})
res = HTTP.response(404)
body = json.loads(res.content)
self.assertEqual(res.status_code, 404)
self.assertEqual(body['code'], 404)
self.assertEqual(body['message'], 'Not found')
self.assertEqual(body['custom_message'], '')
self.assertEqual(body['details'], '')
self.assertEqual(body['data'], {})
res = HTTP.response(405)
body = json.loads(res.content)
self.assertEqual(res.status_code, 405)
self.assertEqual(body['code'], 405)
self.assertEqual(body['message'], 'Method not allowed')
self.assertEqual(body['custom_message'], '')
self.assertEqual(body['details'], '')
self.assertEqual(body['data'], {})
res = HTTP.response(500)
body = json.loads(res.content)
self.assertEqual(res.status_code, 500)
self.assertEqual(body['code'], 500)
self.assertEqual(body['message'], 'Internal error')
self.assertEqual(body['custom_message'], '')
self.assertEqual(body['details'], '')
self.assertEqual(body['data'], {})
res = HTTP.response(501)
body = json.loads(res.content)
self.assertEqual(res.status_code, 501)
self.assertEqual(body['code'], 501)
self.assertEqual(body['message'], 'Not Implemented')
self.assertEqual(body['custom_message'], '')
self.assertEqual(body['details'], '')
self.assertEqual(body['custom_message'], '')
self.assertEqual(body['data'], {})
def create(request):
try:
# 0. Check Permissions
if not Permission.verify(request, ['Admin', 'Doctor']):
raise HttpException(
401, 'Não tem permissões para aceder a este recurso.',
'You don\'t have access to this resource.')
data = request.data
# 1. Check schema
SchemaValidator.validate_obj_structure(
data, 'full_task_schedule/create.json')
with transaction.atomic():
# 2. Create Task Schedule
task_schedule = TaskSchedule(
title=request.data['title'],
number_of_weeks=request.data['number_of_weeks'],
created_by=User.objects.get(pk=request.USER_ID),
is_active=True)
task_schedule.save()
# For Each Week, add them
for week in request.data['weeks']:
week_number = week['week_number']
if 0 > week_number > request.data['number_of_weeks']:
raise HttpException(400,
'Número de semanas não eprmitida',
'Number of week is not allowed.')
for week_task in week['tasks']:
try:
task = Task.objects.get(pk=week_task['task_id'])
except Task.DoesNotExist:
raise HttpException(
404, 'Tarefa não enconbtrada',
'Task with id {} does not exist.'.format(
str(week_task['task_id'])))
schedule_week_task = WeekTaskSchedule(
task_schedule=task_schedule,
week_number=week_number,
task=task,
times_per_week=week_task['times_per_week'],
repetition_number=week_task.get(
'repetition_number', None))
schedule_week_task.save()
except HttpException as e:
return HTTP.response(e.http_code, e.http_custom_message,
e.http_detail)
except Exception as e:
return HTTP.response(
400, 'Ocorreu um erro inesperado',
'Unexpected Error. {}. {}.'.format(type(e).__name__, str(e)))
data = {'task_schedule_id': task_schedule.id}
return HTTP.response(201, 'Task Schedule criado com sucesso.', data)
def list(request):
return HTTP.response(405)
def mark_as_done(request):
try:
data = request.data
# 1. Validations
# 1.1. Only Patients can create new Prehab Plans
if not Permission.verify(request, ['Patient']):
raise HttpException(
401, 'Não tem permissões para aceder a este recurso.',
'You don\'t have access to this resource.')
# 1.2. Check schema
SchemaValidator.validate_obj_structure(
data, 'patient_task_schedule/mark_as_done.json')
# 1.3. Check if Patient Task Schedule is valid
patient_task_schedule = PatientTaskSchedule.objects.get(
pk=data['patient_task_schedule_id'])
if patient_task_schedule.status > 2:
raise HttpException(400,
'Esta atividade já tinha sido realizada.',
'This activity was mark as done already.')
# 1.4. Check if patient is prehab's owner
if patient_task_schedule.prehab.patient.user.id != request.USER_ID:
raise HttpException(400, 'Não pode atualizar este prehab.',
'You can\'t update this Prehab Plan')
# 2. Update This specific Task in PatientTaskSchedule
# 2.1. Task completed with success
if data['completed']:
patient_task_schedule.status = PatientTaskSchedule.COMPLETED
# 2.2. Task not completed
else:
patient_task_schedule.status = PatientTaskSchedule.NOT_COMPLETED
patient_task_schedule.finished_date = datetime.datetime.now()
patient_task_schedule.save()
# 3. Report Difficulties
patient_task_schedule.was_difficult = data['difficulties']
patient_task_schedule.patient_notes = data[
'notes'] if 'notes' in data else ''
# Doctor only need to check activities that the patient had difficult
patient_task_schedule.seen_by_doctor = False if data[
'difficulties'] else True
patient_task_schedule.save()
except PatientTaskSchedule.DoesNotExist as e:
return HTTP.response(404, 'Tarefa do paciente não encontrada.',
'Patient Task Schedule not found.')
except Prehab.DoesNotExist as e:
return HTTP.response(
404, 'Prehab não encontrado',
'Prehab with id {} not found'.format(
request.data['prehab_id']))
except HttpException as e:
return HTTP.response(e.http_code, e.http_custom_message,
e.http_detail)
except Exception as e:
return HTTP.response(400, 'Erro Inesperado',
'Unexpected Error: {}.'.format(str(e)))
return HTTP.response(200, 'Prehab atualizado com sucesso.')
def create(request):
try:
# 0 - Handle Permissions
if not Permission.verify(request, ['Doctor']):
raise HttpException(401, 'Não tem permissões para aceder a este recurso.',
'You don\'t have access to this resource.')
data = request.data
# 1. Check schema
SchemaValidator.validate_obj_structure(data, 'patient/create.json')
# 2. Add new User
new_user = User(
name='Anónimo',
username='',
email=data['email'] if 'email' in data else None,
phone=data['phone'] if 'phone' in data else None,
password=None,
role=Role.objects.patient_role().get(),
activation_code=''.join(random.choice(string.ascii_uppercase + string.digits) for _ in range(8)),
is_active=False,
)
new_user.save()
# 1. Generate Activation Code & Username
patient_tag = "HSJ{}{}".format(datetime.now().year, str(new_user.id).zfill(4))
new_user.username = patient_tag
new_user.save()
doctor = Doctor.objects.get(pk=request.USER_ID)
# 3. Add new Patient
new_patient = Patient(
user=new_user,
patient_tag=patient_tag,
age=data['age'],
height=data['height'],
weight=data['weight'],
sex=data['sex']
)
new_patient.save()
# 4. Create Doctor Patient Association
relation = DoctorPatient(
patient=new_patient,
doctor=doctor
)
relation.save()
# 5. Associate Constraints
for constraint_id in data['constraints']:
constraint_type = ConstraintType.objects.get(pk=constraint_id)
constraint = PatientConstraintType(
patient=new_patient,
constraint_type=constraint_type
)
constraint.save()
except HttpException as e:
return HTTP.response(e.http_code, e.http_custom_message, e.http_detail)
except Exception as e:
return HTTP.response(400, 'Ocorreu um erro inesperado',
'Unexpected Error. {}. {}.'.format(type(e).__name__, str(e)))
# Send Response - access code
data = {
'access_code': new_user.activation_code
}
return HTTP.response(201, 'Paciente criado com sucesso.', data)