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)