async def get_patients_by_filter(filter: dict, Authorize: AuthJWT = Depends()):
"""
Get patients list by attributes for search engine.
:param filter: dict (column:"value") of attributes to search for.
:return: list of patients.
"""
Authorize.jwt_required()
current_role = Repository.get_user_role_by_email(Authorize.get_jwt_subject())
if current_role == 'doctor':
patients = Repository.get_patient_by_dict(filter)
return {'data': patients, 'result': True}
return {'description': 'You need to be a doctor', 'result': False}
async def delete_history(history_id: str, Authorize: AuthJWT = Depends()):
"""
Delete history with id - history_id
:param history_id: id of history in the database
:return:
"""
Authorize.jwt_required()
current_role = Repository.get_user_role_by_email(
Authorize.get_jwt_subject())
if current_role == 'doctor':
result, status = Repository.delete_history(history_id)
return {'description': result, 'result': status}
return {'description': 'You need to be a doctor', 'result': False}
async def upload_file(history_id: str,
extension: str,
request: Request,
Authorize: AuthJWT = Depends()):
"""
upload file to google cloud storage
:param history_id: id of history in the database
:param extension: name of file
:param file_bytes: file to uploading
:return:
"""
Authorize.jwt_required()
current_role = Repository.get_user_role_by_email(
Authorize.get_jwt_subject())
if current_role == 'doctor':
if history_id in HistoriesCollection.get_ids():
if not Repository.get_history_by_id(history_id).get('file_name'):
# with open(file.filename, "wb") as buffer:
# shutil.copyfileobj(file.file, buffer)
#
new_filename = str(uuid.uuid4()) + '.' + extension
body = b''
async for chunk in request.stream():
body += chunk
f = open(new_filename, "wb")
f.write(body)
f.close()
# os.renames(file.filename, new_filename)
shutil.move(new_filename, "app/disease_storage/")
file_uploader = FileUploader()
file_uploader.upload_file(
'app/disease_storage/' + new_filename, new_filename)
Repository.update_history(history_id,
{'file_name': new_filename})
return {'description': 'Success add file', 'result': True}
else:
return {'description': 'File already added', 'result': False}
return {
'description': 'Can\'n found history by this id',
'result': False
}
return {'description': 'You need to be a doctor', 'result': False}
async def add_history(history: DiseaseHistoryScheme,
Authorize: AuthJWT = Depends()):
"""
Add to database new disease history for user
:param history: dict of data to add to database
:return:
"""
Authorize.jwt_required()
current_role = Repository.get_user_role_by_email(
Authorize.get_jwt_subject())
if current_role == 'doctor':
Repository.add_history(history)
return {'description': 'Success add', 'result': True}
return {'description': 'You need to be a doctor', 'result': False}
def add_new_relative(relative: RelationshipScheme,
Authorize: AuthJWT = Depends()):
"""
Add relative to patient
:param relative: object of
:return: Json of result about operation
"""
Authorize.jwt_required()
current_role = Repository.get_user_role_by_email(
Authorize.get_jwt_subject())
if current_role == 'doctor':
Repository.add_relative(relative)
return {'description': 'Success add', 'result': True}
return {'description': 'You need to be a doctor', 'result': False}
async def delete_file(history_id: str):
filename = Repository.get_history_by_id(history_id).get('file_name')
if filename:
file_uploader = FileUploader()
if filename in file_uploader.list_blobs():
file_uploader.delete_file(filename)
else:
Repository.update_history(history_id, {'file_name': None})
return {"description": "File not found", 'result': False}
Repository.update_history(history_id, {'file_name': None})
return {"description": "File was successful deleted", 'result': True}
return {"description": "File not found", 'result': False}
async def update_history(history_id: str,
history: DiseaseHistoryScheme,
Authorize: AuthJWT = Depends()):
"""
Update history with id - history_id
:param history_id: id of history in the database
:param history: dict of data to add to database
:return:
"""
Authorize.jwt_required()
current_role = Repository.get_user_role_by_email(
Authorize.get_jwt_subject())
if current_role == 'doctor':
result, status = Repository.update_history(history_id, history)
return {'description': result, 'result': status}
return {'description': 'You need to be a doctor', 'result': False}
async def get_all_hospitals(Authorize: AuthJWT = Depends()):
"""
Get all hospitals from database
:return: list of hospitals
"""
Authorize.jwt_required()
list_hospitals = Repository.get_all_hospitals()
return {'data': list_hospitals, 'result': bool(list_hospitals)}
async def get_hospital_profile(hospital_id: str,
Authorize: AuthJWT = Depends()):
"""
Get data for hospital profile
"""
Authorize.jwt_required()
hospital_profile = Repository.get_hospital_by_id(hospital_id)
return {'data': hospital_profile, 'result': bool(hospital_profile)}
async def get_schedule(doctor_id: str, Authorize: AuthJWT = Depends()):
"""
Get doctor's all schedules by id
:param doctor_id:
:return: schedule_data
"""
Authorize.jwt_required()
result = Repository.get_schedule(doctor_id)
return result
async def get_all_doctors(Authorize: AuthJWT = Depends()):
"""
Get all doctors from database
:return: list of doctors
"""
Authorize.jwt_required()
list_doctors = Repository.get_all_doctors()
return {'data': list_doctors, 'result': bool(list_doctors)}
async def get_history(history_id: str, Authorize: AuthJWT = Depends()):
"""
Get history of some patient with some id of history
:param history_id: id of history in the database
:return: histories with history_id
"""
Authorize.jwt_required()
history = Repository.get_history_by_id(history_id)
return {'data': history, 'result': bool(history)}
def get_relatives_of_patient(user_id: str, Authorize: AuthJWT = Depends()):
"""
Get all relatives of patient
:param user_id: user_id of patient, whose relatives we're looking
:return:
"""
Authorize.jwt_required()
relatives = Repository.get_relatives(user_id)
return {'data': relatives, 'result': bool(relatives)}
async def get_all_patient(Authorize: AuthJWT = Depends()):
"""
Get all patients from database
:return: list of patients
"""
Authorize.jwt_required()
list_patients = Repository.get_all_patients()
return {'data': list_patients, 'result': bool(list_patients)}
async def add_appointment(appointment: AppointmentScheme,
Authorize: AuthJWT = Depends()):
"""
Adds an appointment of patient with a doctor
:param appointment: dictionary containing appointment details
:return: status
"""
Authorize.jwt_required()
status = Repository.add_appointment(appointment)
return status
async def get_appointments_by_doctor(doctor_id: str,
Authorize: AuthJWT = Depends()):
"""
Returns a list of appointments given doctor_id
:param doctor_id: doctor id
:return: list of appointments
"""
Authorize.jwt_required()
appointments = Repository.get_appointments_by_doctor(doctor_id)
return appointments
async def get_patient_profile(user_id: str, Authorize: AuthJWT = Depends()):
"""
Get data for patients profile
:param user_id: Id of user in database
:return: patient data
"""
Authorize.jwt_required()
patient_profile = Repository.get_patient_by_id(user_id)
return {'data': patient_profile, 'result': bool(patient_profile)}
async def get_doctors_by_filter(filter: dict, Authorize: AuthJWT = Depends()):
"""
Get doctors list by features for search engine.
:param filter: dict (column:"value") of features to search for.
:return: list of found doctors.
"""
Authorize.jwt_required()
list_doctors = Repository.get_doctor_by_dict(filter)
return list_doctors
async def get_disease_histories(patient_id: str,
Authorize: AuthJWT = Depends()):
"""
Get list of disease histories of some user
:param patient_id:
:return: list of histtories
"""
Authorize.jwt_required()
histories_patient = Repository.get_histories_by_patient_id(patient_id)
return {'data': histories_patient, 'result': bool(histories_patient)}
def within_working_hours(cls, v, values):
schedule = Repository.get_schedule(values['doctor_id'])['data']
workingHours = [(s['startTime'], s['finishTime']) for s in schedule
if s['weekDay'] == v.strftime('%A')
] # get working hours on the appointment day
v = v.replace(tzinfo=None)
for start, finish in workingHours:
if start.time() <= v.time() <= finish.time():
return v
raise ValueError(
f'Out of schedule! Doctor is working today at {workingHours}')
async def get_appointments_by_filter(filter: dict,
Authorize: AuthJWT = Depends()):
"""
Returns a list of appointments given filter
:param filter: dictionary of what to search for
:return: appointments list
"""
Authorize.jwt_required()
appointments = Repository.get_appointments_by_filter(filter)
return appointments
async def delete_appointment(appointment_id: str,
Authorize: AuthJWT = Depends()):
"""
Deletes an appointment with given id
:param id: _id of the appointment
:return: status
"""
Authorize.jwt_required()
status = Repository.delete_appointment(appointment_id)
return status
async def get_hospitals_doctors(hospital_id: str,
Authorize: AuthJWT = Depends()):
"""
Get doctors of hospital with hospital_id
:param hospital_id: hospital's id
:return: list of doctors
"""
Authorize.jwt_required()
list_doctors = Repository.get_doctors_by_hospital_id(hospital_id)
return {'data': list_doctors, 'result': bool(list_doctors)}
async def get_doctor_profile(user_id: str, Authorize: AuthJWT = Depends()):
"""
Get data for doctor's profile
:param user_id: Id of doctor in database
:return: doctor data
"""
Authorize.jwt_required()
doctor_profile = Repository.get_doctor_by_id(user_id)
return {'data': doctor_profile, 'result': bool(doctor_profile)}
async def add_schedule(schedule: ScheduleScheme, Authorize: AuthJWT = Depends()):
"""
Takes schedule, adds it to database.
:param schedule_id:
:return: status
"""
Authorize.jwt_required()
current_role = Repository.get_user_role_by_email(Authorize.get_jwt_subject())
if current_role == 'doctor':
ScheduleCollection.insert_obj(dict(schedule))
return {'description': 'Addition successful', 'result': True}
return {'description': 'You need to be a doctor', 'result': False}
def is_unoccupied(cls, values):
if 'startDateTime' in values and 'finishDateTime' in values:
values['startDateTime'] = values['startDateTime'].replace(
tzinfo=None)
values['finishDateTime'] = values['finishDateTime'].replace(
tzinfo=None)
doctors_appointments = Repository.get_appointments_by_doctor(
values['doctor_id'])
for a in doctors_appointments:
if a['startDateTime'] <= values['startDateTime'] <= a[
'finishDateTime'] or a['startDateTime'] <= values[
'finishDateTime'] <= a['finishDateTime']:
raise ValueError('Time overlaps with existing appointment')
return values
async def delete_schedule(schedule_id: str, Authorize: AuthJWT = Depends()):
"""
Delete schedule by id
:param schedule_id:
:return: description and status
"""
Authorize.jwt_required()
current_role = Repository.get_user_role_by_email(Authorize.get_jwt_subject())
if current_role == 'doctor':
if schedule_id in ScheduleCollection.get_ids():
ScheduleCollection.delete_obj_by_id(schedule_id)
return {'description': 'Delete successful', 'result': True}
return {'description': 'Can\'t find schedule by this id', 'result': False}
return {'description': 'You need to be a doctor', 'result': False}
async def get_analytics():
"""
Get data for analytics
"""
histories = Repository.get_all_histories()
illness_count = dict()
status_count = dict()
for history in histories:
status_count[history['status']] = status_count.get(history['status'], 0) + 1
illness_count[history['diagnosis']] = illness_count.get(history['diagnosis'], 0) + 1
data = {
'illness_count': illness_count,
'status_count': status_count
}
return {'data': data, 'result': bool(histories)}
async def download_file(history_id: str, Authorize: AuthJWT = Depends()):
Authorize.jwt_required()
if history_id in HistoriesCollection.get_ids():
filename = Repository.get_history_by_id(history_id).get('file_name')
if filename not in os.listdir(CLEARED_DIR):
file_uploader = FileUploader()
if filename in file_uploader.list_blobs():
file_uploader.download_file(filename)
else:
return {'description': "File not found", 'result': True}
shutil.move(filename, "app/disease_storage/")
return FileResponse('app/disease_storage/' + filename,
media_type='application/octet-stream',
filename=filename)
return {'description': 'Can\'n found history by this id', 'result': False}
@router.post('/patients/search/')
<<<<<<< HEAD
async def get_patients_by_filter(filter: dict, Authorize: AuthJWT = Depends()):
||||||| merged common ancestors
async def get_patients_by_dict(filter:dict):
=======
async def get_patients_by_filter(filter:dict):
>>>>>>> 7502b1f49ac5e4efb7074a3866b964592d53af6b
"""
Get patients list by attributes for search engine.
:param filter: dict (column:"value") of attributes to search for.
:return: list of patients.
"""
Authorize.jwt_required()
current_role = Repository.get_user_role_by_email(Authorize.get_jwt_subject())
if current_role == 'doctor':
patients = Repository.get_patient_by_dict(filter)
return {'data': patients, 'result': True}
return {'description': 'You need to be a doctor', 'result': False}
@router.get('/patients/')
async def get_all_patient(Authorize: AuthJWT = Depends()):
"""
Get all patients from database
:return: list of patients
"""
Authorize.jwt_required()