def get(self, request, pk=None):
try:
if pk is None:
queryset = Semester.objects.all()
serializer = SemesterSerializer(queryset, many=True)
if queryset.count() == 0:
raise EmptyResultSet("No semesters to display")
else:
queryset = Semester.objects.get(pk=pk)
serializer = SemesterSerializer(queryset)
response = success.APIResponse(200, serializer.data).respond()
# return Response(response, status=200)
except EmptyResultSet as empty_error:
response = error.APIErrorResponse(404, str(empty_error)).respond()
# return Response(response, status=404)
except Semester.DoesNotExist as not_found_error:
error_message = f"Semester with given id {pk} does not exist"
response = error.APIErrorResponse(404, str(not_found_error),
error_message).respond()
# return Response(response, status=404)
except Exception as e:
response = error.APIErrorResponse(400, str(e)).respond()
# return Response(response, status=400)
finally:
return Response(response)
def put(self, request, pk):
try:
att = StudentAttendance.objects.get(pk=pk)
print(att)
print(len(att.attendance))
if len(att.attendance) is 0 or att.attendance == []:
stat = {request.data['sid']: request.data['status']}
proto = AttendencePrototype(request.data['date'], stat).get()
print(proto)
att.attendance.append(proto)
else:
for a in att.attendance:
print(a)
if a['date'].strip() == request.data['date'].strip():
print('date same')
proto = AttendencePrototype(a['date'], a['status'])
proto.update(request.data['sid'], request.data['status'])
print(proto.get())
else:
stat = {request.data['sid']: request.data['status']}
proto = AttendencePrototype(request.data['date'], stat).get()
att.attendance.append(proto)
saved = att.save()
msg = "Attendance updated successfully"
response = success.APIResponse(200, msg).respond()
return Response(response)
except StudentAttendance.DoesNotExist as not_found_error:
msg = "Attendance of given id does not exists"
response = error.APIErrorResponse(404, str(not_found_error), msg).respond()
return Response(response)
except Exception as unkown_exception:
response = error.APIErrorResponse(400,str(unkown_exception)).respond()
return Response(response)
def get_week_attenence(request, sub_id, class_id):
try:
studs = []
students = Student.objects.filter(class_data=class_id)
for student in students:
data = {}
attendence = StudentAttendance.objects.get(
student=student.studentId)
data['student'] = student.fname
subs_data = {}
for attend in attendence.attendance:
subs_data['date'] = attend['date']
sub_list = attend['status']
if str(sub_id) in sub_list:
subs_data['data'] = {str(sub_id): sub_list[str(sub_id)]}
data['data'] = subs_data
studs.append(data)
response = success.APIResponse(200, studs).respond()
except EmptyResultSet as empty_error:
response = error.APIErrorResponse(404, str(empty_error)).respond()
except StudentAttendance.DoesNotExist as not_found_error:
error_message = "Attendence of given id is Not available"
response = error.APIErrorResponse(404, str(not_found_error),
error_message).respond()
except ValidationError as validation_error:
err = validation_error.__dict__
response = error.APIErrorResponse(409, err['detail']).respond()
except Exception as err:
response = success.APIResponse(400, err).respond()
finally:
return (Response(response))
def get_class(request, prof_id):
try:
subjects = []
classes = []
queryset = Professor.objects.get(pk=prof_id)
serialized = SubjectSerializer(queryset)
for subject in serialized.data['subject']:
subjects.append(subject)
studenclass = StudentClass.objects.all()
serialized = SubjectSerializer(studenclass, many=True)
for subject in serialized.data:
data = dict(subject.items())
class_temp = {}
subs = []
class_temp['classId'] = data['classId']
for prof_subject in subjects:
if prof_subject in data['subject']:
subs.append(prof_subject)
if len(subs) > 0:
class_temp['subjects'] = subs
classes.append(class_temp)
response = success.APIResponse(200, classes).respond()
except EmptyResultSet as empty_error:
response = error.APIErrorResponse(404, str(empty_error)).respond()
except Professor.DoesNotExist as not_found_error:
error_message = "Professor of id {} is Not available".format(prof_id)
response = error.APIErrorResponse(404, str(not_found_error),
error_message).respond()
except ValidationError as validation_error:
err = validation_error.__dict__
response = error.APIErrorResponse(409, err['detail']).respond()
except Exception as err:
response = success.APIResponse(400, err).respond()
finally:
return (Response(response))
def get(self, request, pk=None):
try:
if pk is None:
queryset = Patient.objects.all()
serializer = PatientSerializer(queryset, many=True)
if queryset.count() == 0:
raise TableEmptyError("No Patients to display")
else:
queryset = Patient.objects.get(pk=pk)
serializer = PatientSerializer(queryset)
print(request.data)
response = success.APIResponse(200, serializer.data).respond()
except TableEmptyError as empty_error:
response = error.APIErrorResponse(404, str(empty_error)).respond()
except Patient.DoesNotExist as not_found_error:
error_message = f"Patient with given id {pk} does not exist"
response = error.APIErrorResponse(404, str(not_found_error),
error_message).respond()
except Exception as e:
response = error.APIErrorResponse(400, str(e)).respond()
finally:
return Response(response)
def delete(self, request, pk):
try:
class_instance = Patient.objects.get(pk=pk)
class_instance.delete()
success_message = f"Patient with id {pk} deleted successfully"
response = success.APIResponse(202, success_message).respond()
# return Response(response, status=202)
except IntegrityError:
error_message = "Database integrity error occured"
response = error.APIErrorResponse(409, str(IntegrityError),
error_message).respond()
# return Response(response, status=409)
except Patient.DoesNotExist as not_found_error:
error_message = f"Patient with given {pk} does not exist"
response = error.APIErrorResponse(404, str(not_found_error),
error_message).respond()
# return Response(response, status=404)
except Exception as e:
error_message = "unexpected error occured"
response = error.APIErrorResponse(400, str(e),
error_message).respond()
# return Response(response, status=400)
finally:
return Response(response)
def put(self, request, pk):
try:
data = request.data
instance = Year.objects.get(pk=pk)
serialized = YearSerializer(instance=instance,
data=data,
partial=True)
if serialized.is_valid(raise_exception=True):
saved = serialized.save()
success_message = "Year {} updated successfully".format(saved)
response = success.APIResponse(201, success_message).respond()
return Response(response, status=201)
except ValidationError as validation_error:
error_message = "Year {} already exists".format(
data.get('yearName'))
response = error.APIErrorResponse(409, str(validation_error),
error_message).respond()
return Response(response, status=409)
except IntegrityError as integrity_error:
error_message = "Integrity Error Occurred"
response = error.APIErrorResponse(409, str(integrity_error),
error_message).respond()
return Response(response, status=409)
except Year.DoesNotExist as not_found_error:
error_message = "Year with id {} is Not available".format(pk)
response = error.APIErrorResponse(404, str(not_found_error),
error_message).respond()
return Response(response, status=404)
except Exception as unkown_exception:
response = error.APIErrorResponse(400,
str(unkown_exception)).respond()
return Response(response, status=400)
def post(self, request):
try:
serializer = PatientSerializer(data=request.data)
if serializer.is_valid(raise_exception=True):
saved_object = serializer.save()
success_message = f"Patient {saved_object} added successfully"
response = success.APIResponse(201, success_message).respond()
except ValidationError as validation_error:
err = validation_error.__dict__
response = error.APIErrorResponse(409, err['detail']).respond()
except IntegrityError:
error_message = "Database integrity error occured"
response = error.APIErrorResponse(409, str(IntegrityError),
error_message).respond()
except Exception as e:
error_message = "unexpected error occured"
response = error.APIErrorResponse(400, str(e),
error_message).respond()
finally:
return Response(response)
def delete(self, request, pk=None):
try:
if pk is None:
Year.objects.all().delete()
success_message = "All Years are deleted Successfully"
response = success.APIResponse(202, success_message).respond()
return Response(response, status=202)
else:
data = Year.objects.get(pk=pk)
data.delete()
success_message = "Year with id {} is deleted".format(pk)
response = success.APIResponse(202, success_message).respond()
return Response(response, status=202)
except Year.DoesNotExist as not_found_error:
error_message = "Year with given id {} is Not available".format(pk)
response = error.APIErrorResponse(404, str(not_found_error),
error_message).respond()
return Response(response, status=404)
except IntegrityError as integrity_error:
error_message = "Integrity Error Occurred"
response = error.APIErrorResponse(409, str(integrity_error),
error_message).respond()
return Response(response, status=409)
except Exception as unknown_exception:
response = error.APIErrorResponse(
400, str(unknown_exception)).respond()
return Response(response, status=400)
def delete(self, request, pk=None):
try:
if pk is None:
Department.objects.all().delete()
success_message = "All Departments are deleted Successfully"
response = success.APIResponse(202, success_message).respond()
return Response(response)
else:
Department.objects.get(pk=pk).delete()
success_message = f"Department with id {pk} is deleted"
response = success.APIResponse(202, success_message).respond()
return Response(response)
except Department.DoesNotExist as not_found_error:
error_message = f"Department with given id {pk} is Not available"
response = error.APIErrorResponse(404, str(not_found_error),
error_message).respond()
return Response(response)
except IntegrityError as integrity_error:
error_message = "Integrity Error Occurred"
response = error.APIErrorResponse(409, str(integrity_error),
error_message).respond()
return Response(response)
except Exception as unknown_exception:
response = error.APIErrorResponse(
400, str(unknown_exception)).respond()
return Response(response, status=400)
def delete(self, request, pk=None):
try:
if pk is None:
StudentAttendance.objects.all().delete()
success_message = "All Sections are deleted Successfully"
response=success.APIResponse(202,success_message).respond()
return Response(response)
else:
data = StudentAttendance.objects.get(pk = pk)
data.delete()
success_message = f"Attendance with id {pk} is deleted"
response = success.APIResponse(202,success_message).respond()
return Response(response)
except StudentAttendance.DoesNotExist as not_found_error:
error_message = f"Attendance with given id {pk} does not exist"
response = error.APIErrorResponse(404,str(not_found_error),error_message).respond()
return Response(response)
except IntegrityError as integrity_error:
error_message = "Integrity Error Occurred"
response = error.APIErrorResponse(409,str(integrity_error),error_message).respond()
return Response(response)
except Exception as unknown_exception:
response = error.APIErrorResponse(400,str(unknown_exception)).respond()
return Response(response)
def put(self, request, pk):
try:
data = request.data
instance = Professor.objects.get(pk=pk)
serialized = ProfessorSerializer(data=data,
instance=instance,
partial=True)
if (serialized.is_valid(raise_exception=True)):
saved = serialized.save()
response = success.APIResponse(
201, "updated {}".format(saved)).respond()
except ValidationError as validation_error:
response = error.APIErrorResponse(409,
str(validation_error)).respond()
except IntegrityError as integrity_error:
error_message = "Integrity Error Occurred"
response = error.APIErrorResponse(409, str(integrity_error),
error_message).respond()
except Professor.DoesNotExist as not_found_error:
error_message = "Professor with id {} is Not available".format(pk)
response = error.APIErrorResponse(404, str(not_found_error),
error_message).respond()
except Exception as unkown_exception:
response = error.APIErrorResponse(400,
str(unkown_exception)).respond()
finally:
return Response(response, status=400)
def get_date_attenence(request, sub_id, class_id):
try:
date = request.data.get('date')
studs = {}
students = Student.objects.filter(class_data=class_id)
for student in students:
attendence = StudentAttendance.objects.get(
student=student.studentId)
for attend in attendence.attendance:
print(attend)
if date == attend['date']:
if str(sub_id) in attend['status']:
print(attend['status'][str(sub_id)])
studs[student.fname] = attend['status'][str(sub_id)]
response = success.APIResponse(200, studs).respond()
except EmptyResultSet as empty_error:
response = error.APIErrorResponse(404, str(empty_error)).respond()
except StudentAttendance.DoesNotExist as not_found_error:
error_message = "Attendence of given id is Not available"
response = error.APIErrorResponse(404, str(not_found_error),
error_message).respond()
except ValidationError as validation_error:
err = validation_error.__dict__
response = error.APIErrorResponse(409, err['detail']).respond()
except Exception as err:
response = success.APIResponse(400, err).respond()
finally:
return (Response(response))
def put(self, request, pk):
try:
data = request.data
instance = Section.objects.get(pk=pk)
serialized = SectionSerializer(instance, data, partial=True)
if serialized.is_valid(raise_exception=True):
saved = serialized.save()
success_message = f"Section {saved} updated successfully"
response = success.APIResponse(201, success_message).respond()
return Response(response)
except ValidationError as validation_error:
err = validation_error.__dict__
response = error.APIErrorResponse(409, err['detail']).respond()
return Response(response)
except IntegrityError as integrity_error:
error_message = "Integrity Error Occurred"
response = error.APIErrorResponse(409, str(integrity_error),
error_message).respond()
return Response(response)
except Section.DoesNotExist as not_found_error:
error_message = f"Section with id {pk} is Not available"
response = error.APIErrorResponse(404, str(not_found_error),
error_message).respond()
return Response(response, status=404)
except Exception as unkown_exception:
response = error.APIErrorResponse(400,
str(unkown_exception)).respond()
return Response(response)
def get(self, request, pk=None):
try:
if pk is None:
queryset = Section.objects.all()
serialized = SectionSerializer(queryset, many=True)
if queryset.count() is 0:
raise EmptyResultSet("No Sections")
else:
queryset = Section.objects.get(pk=pk)
serialized = SectionSerializer(queryset)
response = success.APIResponse(200, serialized.data).respond()
return Response(response)
except EmptyResultSet as empty_error:
response = error.APIErrorResponse(404, str(empty_error)).respond()
return Response(response)
except Section.DoesNotExist as not_found_error:
msg = "Section of given id does not exists"
response = error.APIErrorResponse(404, str(not_found_error),
msg).respond()
return Response(response)
except Exception as unkown_exception:
response = error.APIErrorResponse(400,
str(unkown_exception)).respond()
return Response(response)
def post(self, request):
try:
data = request.data
serialized = SectionSerializer(data=data)
if (serialized.is_valid(raise_exception=True)):
saved = serialized.save()
success_message = f"Section {saved} added Successfully"
response = success.APIResponse(201, success_message).respond()
return Response(response)
except ValidationError as validation_error:
err = validation_error.__dict__
response = error.APIErrorResponse(409, err['detail']).respond()
return Response(response)
except IntegrityError as integrity_error:
error_message = "Integrity Error Occurred"
response = error.APIErrorResponse(409, str(integrity_error),
error_message).respond()
return Response(response)
except Exception as unkown_exception:
response = error.APIErrorResponse(400,
str(unkown_exception)).respond()
return Response(response)
def get(self,request,token):
try:
data=jwt.decode(token,self.key,'utf-8',self.algorithm)
success_message=data
response=success.APIResponse(202,success_message).respond()
return Response(response)
except jwt.InvalidTokenError as err:
return Response(error.APIErrorResponse(400,str(err)).respond())
except Exception as err:
return Response(error.APIErrorResponse(400,str(err)).respond())
def loginUser(request):
username = request.data['username']
password = request.data['password']
user = authenticate(username=username, password=password)
if user is not None:
try:
profile = get_object_or_404(DoctorModel, email=username)
serializer = DoctorSerializer(profile)
return Response(
success.APIResponse(200, serializer.data).respond())
except Exception as e:
return Response(error.APIErrorResponse(401, (str(e))).respond())
else:
return Response(
error.APIErrorResponse(500, "Unexpected Error Occurred").respond())
def getScans(request, pk):
try:
queryset = ImageModel.objects.filter(patient=pk)
serializer = ImageSerializer(queryset, many=True)
return Response(success.APIResponse(200, serializer.data).respond())
except Exception as e:
return Response(error.APIErrorResponse(404, str(e)))
def getPatient(request, pk):
try:
queryset = PatientModel.objects.get(pk=pk)
serializer = PatientSerializer(queryset)
return Response(success.APIResponse(200, serializer.data).respond())
except Exception as e:
return Response(error.APIErrorResponse(404, str(e)))
def get_students_class(request, class_id):
try:
queryset = Student.objects.filter(class_data=class_id)
serialized = StudentSerializer(queryset, many=True)
response = success.APIResponse(200, serialized.data).respond()
except Student.DoesNotExist as not_found_error:
error_message = "Student with given class {} is Not available".format(
class_id)
response = error.APIErrorResponse(404, str(not_found_error),
error_message).respond()
except ValidationError as validation_error:
err = validation_error.__dict__
response = error.APIErrorResponse(409, err['detail']).respond()
except Exception as err:
response = error.APIErrorResponse(400, err).respond()
finally:
return (Response(response))
def put(self, request, pk):
try:
data = request.data
instance = Department.objects.get(pk=pk)
serialized = DepartmentInsertSerializer(instance,
data,
partial=True)
if serialized.is_valid(raise_exception=True):
saved = serialized.save()
success_message = f"Department {saved} updated successfully"
response = success.APIResponse(201, success_message).respond()
return Response(response)
except ValidationError as validation_error:
err = json.loads(json.dumps(validation_error.__dict__))
try:
e = err['detail']['hod']
error_message = "This HOD already have department"
response = error.APIErrorResponse(409, str(validation_error),
error_message).respond()
return Response(response)
except:
error_message = f"Department {data['departmentName']} already exists"
response = error.APIErrorResponse(409, str(validation_error),
error_message).respond()
return Response(response)
except IntegrityError as integrity_error:
error_message = "Integrity Error Occurred"
response = error.APIErrorResponse(409, str(integrity_error),
error_message).respond()
return Response(response)
except Department.DoesNotExist as not_found_error:
error_message = f"Department with id {pk} is Not available"
response = error.APIErrorResponse(404, str(not_found_error),
error_message).respond()
return Response(response, status=404)
except Exception as unkown_exception:
response = error.APIErrorResponse(400,
str(unkown_exception)).respond()
return Response(response)
def get(self, request):
try:
queryset = MedicineModel.objects.all()
serialized = MedicineSerializer(queryset, many=True)
response = success.APIResponse(200, serialized.data).respond()
return Response(response)
except Exception as unkown_exception:
response = error.APIErrorResponse(400,
str(unkown_exception)).respond()
return Response(response)
def get_students_professor(request, prof_id):
try:
queryset = Professor.objects.get(professorId=prof_id)
stud = []
serialized = SubjectSerializer(queryset)
subjects = dict(serialized.data)['subject']
queryset = StudentClass.objects.all()
serialized = SubjectSerializer(queryset, many=True)
for studentclass in serialized.data:
class_student = {}
class_subjects = dict(studentclass)['subject']
class_student['class'] = dict(studentclass)['classId']
subs = []
for prof_subject in subjects:
subject_student = {}
if prof_subject in class_subjects:
subject_student['subject'] = prof_subject
queryset = Student.objects.filter(
class_data=class_student['class'])
serialized_student = StudentSerializer(queryset, many=True)
subject_student['data'] = serialized_student.data
subs.append(subject_student)
class_student['data'] = subs
if 'data' in class_student:
stud.append(class_student)
response = success.APIResponse(200, stud).respond()
except EmptyResultSet as empty_error:
response = error.APIErrorResponse(404, str(empty_error)).respond()
except Professor.DoesNotExist as not_found_error:
error_message = "Professor with given id {} is Not available".format(
prof_id)
response = error.APIErrorResponse(404, str(not_found_error),
error_message).respond()
except ValidationError as validation_error:
err = validation_error.__dict__
response = error.APIErrorResponse(409, err['detail']).respond()
except Exception as err:
response = success.APIResponse(400, err).respond()
finally:
return (Response(response))
def get(self, request, pk):
try:
queryset = PatientModel.objects.filter(doctor=pk)
page = self.paginate_queryset(queryset)
if page is not None:
serializer = self.get_paginated_response(
self.serializer_class(page, many=True).data)
else:
serializer = self.serializer_class(queryset, many=True)
return Response(
success.APIResponse(200, serializer.data).respond())
except Exception as e:
return Response(error.APIErrorResponse(404, str(e)))
def post(self, request):
try:
serialized = StudentAttendanceSerializer(data=request.data)
if serialized.is_valid(raise_exception=True):
saved = serialized.save()
msg = f"Attendence {saved} successfully"
response = success.APIResponse(200, msg).respond()
return Response(response)
except ValidationError as validation_error:
err = validation_error.__dict__
response = error.APIErrorResponse(409, err['detail']).respond()
return Response(response)
except IntegrityError as integrity_error:
error_message = "Integrity Error Occurred"
response = error.APIErrorResponse(409,str(integrity_error),error_message).respond()
return Response(response)
except Exception as unkown_exception:
response = error.APIErrorResponse(400,str(unkown_exception)).respond()
return Response(response)
def get(self, request, pk=None):
try:
if pk is None:
queryset = Professor.objects.all()
serialized = ProfessorSerializer(queryset, many=True)
response = success.APIResponse(200, serialized.data).respond()
else:
queryset = Professor.objects.get(pk=pk)
serialized = ProfessorSerializer(queryset)
response = success.APIResponse(200, serialized.data).respond()
except EmptyResultSet as empty_result:
response = error.APIErrorResponse(404, str(empty_result)).respond()
except Professor.DoesNotExist as not_found_error:
error_message = "Professor with id {} is not found".format(pk)
response = error.APIErrorResponse(404, str(not_found_error),
error_message).respond()
except EmptyResultSet as empty_error:
response = error.APIErrorResponse(404, str(empty_error)).respond()
except Exception as unkown_exception:
response = error.APIErrorResponse(400,
str(unkown_exception)).respond()
finally:
return Response(response)
def post(self, request, *args, **kwargs):
try:
response = super(CustomObtainAuthToken,
self).post(request, *args, **kwargs)
token = Token.objects.get(key=response.data['token'])
response_message = success.APIResponse(200, {
'token': token.key
}).respond()
except Exception as e:
response_message = error.APIErrorResponse(404, {
'error': str(e)
}).respond()
finally:
return Response(response_message)
def put(self, request, pk):
try:
class_instance = StudentClass.objects.get(pk=pk)
serializer = StudentClassSerializer(instance=class_instance,
data=request.data,
partial=True)
if serializer.is_valid(raise_exception=True):
saved_object = serializer.save()
success_message = f"StudentClass {saved_object} updated successfully"
response = success.APIResponse(201, success_message).respond()
# return Response(response, status=201)
except ValidationError as validation_error:
err = validation_error.__dict__
response = error.APIErrorResponse(409, err['detail']).respond()
# return Response(response, status=409)
except IntegrityError:
error_message = "Database integrity error occured"
response = error.APIErrorResponse(409, str(IntegrityError),
error_message).respond()
# return Response(response, status=409)
except StudentClass.DoesNotExist as not_found_error:
error_message = f"StudentClass with given id {pk} does not exist"
response = error.APIErrorResponse(404, str(not_found_error),
error_message).respond()
# return Response(response, status=404)
except Exception as e:
error_message = "unexpected error occured"
response = error.APIErrorResponse(400, str(e),
error_message).respond()
# return Response(response, status=400)
finally:
return Response(response)
def get(self, request, pk=None):
try:
if pk is None:
queryset = Year.objects.all()
serialized = YearSerializer(queryset, many=True)
if queryset.count() is 0:
raise TableEmptyError("No Years in Table to Display")
else:
queryset = Year.objects.get(pk=pk)
serialized = YearSerializer(queryset)
response = success.APIResponse(200, serialized.data).respond()
return Response(response)
except Year.DoesNotExist as not_found_error:
error_message = "Yearect with given Id is not found"
response = error.APIErrorResponse(404, str(not_found_error),
error_message).respond()
return Response(response)
except TableEmptyError as empty_error:
response = error.APIErrorResponse(404, str(empty_error)).respond()
return Response(response, )
except Exception as unkown_exception:
response = error.APIErrorResponse(400,
str(unkown_exception)).respond()
return Response(response)
