class CouponViewSet(views.APIView): authentication_classes = (authentication.TokenAuthentication,) permission_classes = (permissions.IsAuthenticated,) @swagger_auto_schema( responses={ 200: openapi.Response("OK- Successful GET Request"), 401: openapi.Response("Unauthorized- Authentication credentials were not provided. || Token Missing or Session Expired"), 500: openapi.Response("Internal Server Error- Error while processing the GET Request Function.") }, manual_parameters=[ openapi.Parameter(name="uuid", in_="query", type=openapi.TYPE_STRING), ] ) def get(self, request, *args, **kwargs): query_params = self.request.query_params uuid = query_params.get('uuid', None) coupons = coupons_models.Coupon.objects.filter(Q(user=request.user) & Q(is_active=True)).order_by("-created_at") if uuid: coupons = coupons.filter(uuid=uuid) serializer = coupons_serializers.CouponSerializer(coupons, many=True) data = { "coupons": serializer.data } return response.Response(data, status.HTTP_200_OK) @swagger_auto_schema( request_body = openapi.Schema( title = "Create Coupon", type=openapi.TYPE_OBJECT, properties={ 'amount': openapi.Schema(type=openapi.TYPE_NUMBER), } ), responses={ 200: openapi.Response("OK- Successful POST Request"), 401: openapi.Response("Unauthorized- Authentication credentials were not provided. || Token Missing or Session Expired"), 422: openapi.Response("Unprocessable Entity- Make sure that all the required field values are passed"), 500: openapi.Response("Internal Server Error- Error while processing the POST Request Function.") } ) @coupons_available def post(self, request, *args, **kwargs): data = request.data amount = data.get("amount", None) if kwargs.get("available_coupons", 0) < 1: errors = { 'message': 'No coupons left', } return response.Response(errors, status.HTTP_400_BAD_REQUEST) if not amount or float(amount) <= 0: errors = { 'message': 'Invalid amount', } return response.Response(errors, status.HTTP_400_BAD_REQUEST) data = { "user": request.user.id, "amount": float(amount) } serializer = coupons_serializers.CouponSerializer(data=data) if serializer.is_valid(): serializer.save() details = { "message": "Coupon Successfully created.", "coupon": serializer.data, } return response.Response(details, status.HTTP_201_CREATED) errors = { 'message': str(serializer.errors), } return response.Response(errors, status.HTTP_400_BAD_REQUEST) @swagger_auto_schema( request_body = openapi.Schema( title = "Update Coupon", type=openapi.TYPE_OBJECT, properties={ 'amount': openapi.Schema(type=openapi.TYPE_NUMBER), 'valid_from': openapi.Schema(type=openapi.FORMAT_DATE), 'valid_till': openapi.Schema(type=openapi.FORMAT_DATE), 'payment_methods': openapi.Schema(type=openapi.TYPE_STRING), 'message': openapi.Schema(type=openapi.TYPE_STRING), 'is_available': openapi.Schema(type=openapi.TYPE_BOOLEAN), 'paid': openapi.Schema(type=openapi.TYPE_BOOLEAN), } ), responses={ 200: openapi.Response("OK- Successful POST Request"), 401: openapi.Response("Unauthorized- Authentication credentials were not provided. || Token Missing or Session Expired"), 422: openapi.Response("Unprocessable Entity- Make sure that all the required field values are passed"), 500: openapi.Response("Internal Server Error- Error while processing the POST Request Function.") }, manual_parameters=[ openapi.Parameter(name="uuid", in_="query", type=openapi.TYPE_STRING), ] ) def put(self, request, *args, **kwargs): query_params = self.request.query_params data = request.data uuid = query_params.get('uuid', "") coupons = coupons_models.Coupon.objects.filter(Q(user=request.user) & Q(uuid=str(uuid)) & Q(is_active=True)) if not len(coupons): errors = { 'message': 'Invalid uuid', } return response.Response(errors, status.HTTP_400_BAD_REQUEST) coupon = coupons[0] serializer = coupons_serializers.CouponSerializer(instance=coupon, data=data, partial=True) if serializer.is_valid(): serializer.save() details = { "message": "Coupon Successfully updated.", } return response.Response(details, status.HTTP_200_OK) errors = { 'message': str(serializer.errors), } return response.Response(errors, status.HTTP_400_BAD_REQUEST) @swagger_auto_schema( responses={ 200: openapi.Response("OK- Successful POST Request"), 401: openapi.Response("Unauthorized- Authentication credentials were not provided. || Token Missing or Session Expired"), 422: openapi.Response("Unprocessable Entity- Make sure that all the required field values are passed"), 500: openapi.Response("Internal Server Error- Error while processing the POST Request Function.") }, manual_parameters=[ openapi.Parameter(name="uuid", in_="query", type=openapi.TYPE_STRING), ] ) def delete(self, request, *args, **kwargs): query_params = self.request.query_params uuid = query_params.get('uuid', "") coupons = coupons_models.Coupon.objects.filter(Q(user=request.user) & Q(uuid=str(uuid)) & Q(is_active=True)) if not len(coupons): errors = { 'message': 'Invalid uuid', } return response.Response(errors, status.HTTP_400_BAD_REQUEST) coupon = coupons[0] coupon.is_active = False coupon.save() details = { "message": "Coupon Successfully deleted.", } return response.Response(details, status.HTTP_200_OK)
class Organization(views.APIView): authentication_classes = (authentication.TokenAuthentication,) permission_classes = (permissions.IsAuthenticated,) serializer_class = serializers.OrganizationSerializer @swagger_auto_schema( responses={ 200: openapi.Response("OK- Successful GET Request"), 401: openapi.Response( "Unauthorized- Authentication credentials were not provided. || Token Missing or Session Expired"), 500: openapi.Response("Internal Server Error- Error while processing the GET Request Function.") }, manual_parameters=[ openapi.Parameter(name="org_id", in_="query", type=openapi.TYPE_STRING), ] ) @is_organization def get(self, request, **kwargs): query_params = self.request.query_params organization = kwargs.get('organization') org_id = organization.id qs = models.Organization.objects.filter(id=org_id, is_active=True) serializer = serializers.OrganizationSerializer(qs, many=True) return Response(serializer.data, status.HTTP_200_OK) @swagger_auto_schema( request_body=openapi.Schema( title="Update Organization", type=openapi.TYPE_OBJECT, properties={ 'org_id': openapi.Schema(type=openapi.TYPE_STRING), 'join_id': openapi.Schema(type=openapi.TYPE_STRING), 'name': openapi.Schema(type=openapi.TYPE_STRING), 'contact_name': openapi.Schema(type=openapi.TYPE_STRING), 'contact_phone': openapi.Schema(type=openapi.TYPE_STRING), 'contact_email': openapi.Schema(type=openapi.TYPE_STRING), 'location': openapi.Schema(type=openapi.TYPE_STRING), 'accepting_req': openapi.Schema(type=openapi.TYPE_BOOLEAN) } ), manual_parameters=[ openapi.Parameter(name="org_id", in_="query", type=openapi.TYPE_STRING), ], responses={ 200: openapi.Response("OK- Successful POST Request"), 401: openapi.Response( "Unauthorized- Authentication credentials were not provided. || Token Missing or Session Expired"), 422: openapi.Response("Unprocessable Entity- Make sure that all the required field values are passed"), 500: openapi.Response("Internal Server Error- Error while processing the POST Request Function.") } ) @is_organization def put(self, request, *args, **kwargs): query_params = self.request.query_params data = request.data data = pop_from_data(["is_active", "user"], data) organization = kwargs.get("organization") serializer = serializers.OrganizationSerializer(organization, data=data, partial=True) if not serializer.is_valid(): return Response({'details': [str(serializer.errors)]}, status.HTTP_400_BAD_REQUEST) serializer.save() msgs = [ 'successfully updated department' ] return Response({'details': msgs}, status.HTTP_200_OK)
class DepartmentViewSet(views.APIView): authentication_classes = (authentication.TokenAuthentication,) permission_classes = (permissions.IsAuthenticated,) serializer_class = serializers.DepartmentSerializer @swagger_auto_schema( responses={ 200: openapi.Response("OK- Successful GET Request"), 401: openapi.Response("Unauthorized- Authentication credentials were not provided. || Token Missing or Session Expired"), 500: openapi.Response("Internal Server Error- Error while processing the GET Request Function.") }, manual_parameters=[ openapi.Parameter(name="id", in_="query", type=openapi.TYPE_INTEGER), openapi.Parameter(name="dept_id", in_="query", type=openapi.TYPE_STRING), openapi.Parameter(name="org_id", in_="query", type=openapi.TYPE_STRING), ] ) def get(self, request): query_params = self.request.query_params id = query_params.get('id', None) dept_id = query_params.get('dept_id', None) org_id = query_params.get('org_id', None) qs = models.Department.objects.filter(is_active=True) if id: qs = qs.filter(id=int(id)) if dept_id: qs = qs.filter(department_id=str(dept_id)) if org_id: qs = qs.filter(organization__org_id=org_id) serializer = serializers.DepartmentSerializer(qs, many=True) return Response(serializer.data, status.HTTP_200_OK) @swagger_auto_schema( request_body = openapi.Schema( title = "Create department", type=openapi.TYPE_OBJECT, properties={ 'org_id': openapi.Schema(type=openapi.TYPE_STRING), 'name': openapi.Schema(type=openapi.TYPE_STRING), } ), responses={ 200: openapi.Response("OK- Successful POST Request"), 401: openapi.Response("Unauthorized- Authentication credentials were not provided. || Token Missing or Session Expired"), 422: openapi.Response("Unprocessable Entity- Make sure that all the required field values are passed"), 500: openapi.Response("Internal Server Error- Error while processing the POST Request Function.") } ) @validate_org def post(self, request, **kwargs): data = json.loads(json.dumps(request.data)) name = data.get("name", None) if not name: return Response({'details': ["name is required"]}, status.HTTP_400_BAD_REQUEST) organization = kwargs.get("organization") data_dict = { "organization" : organization.id, "name": str(name), "requesting_users": [request.user.id], } serializer = self.serializer_class(data=data_dict) if serializer.is_valid(): serializer.save() return Response(serializer.data, status.HTTP_201_CREATED) return Response(serializer.errors, status.HTTP_400_BAD_REQUEST) @swagger_auto_schema( request_body=openapi.Schema( title="Update Department", type=openapi.TYPE_OBJECT, properties={ 'org_id': openapi.Schema(type=openapi.TYPE_STRING), 'dept_id': openapi.Schema(type=openapi.TYPE_STRING), 'name': openapi.Schema(type=openapi.TYPE_STRING), 'contact_name': openapi.Schema(type=openapi.TYPE_STRING), 'contact_phone': openapi.Schema(type=openapi.TYPE_STRING), 'contact_email': openapi.Schema(type=openapi.TYPE_STRING), 'department_id': openapi.Schema(type=openapi.TYPE_STRING) } ), responses={ 200: openapi.Response("OK- Successful POST Request"), 401: openapi.Response( "Unauthorized- Authentication credentials were not provided. || Token Missing or Session Expired"), 422: openapi.Response("Unprocessable Entity- Make sure that all the required field values are passed"), 500: openapi.Response("Internal Server Error- Error while processing the POST Request Function.") } ) @is_org_or_department def put(self, request, *args, **kwargs): data = request.data data = pop_from_data(["is_active", "user", "organization"], data) department = kwargs.get("department") serializer = serializers.DepartmentSerializer(department, data=data, partial=True) if not serializer.is_valid(): return Response({'details': [str(serializer.errors)]}, status.HTTP_400_BAD_REQUEST) serializer.save() msgs = [ 'successfully updated department' ] return Response({'details': msgs}, status.HTTP_200_OK) @swagger_auto_schema( request_body=openapi.Schema( title="Delete Department", type=openapi.TYPE_OBJECT, properties={ 'dept_id': openapi.Schema(type=openapi.TYPE_STRING), 'org_id': openapi.Schema(type=openapi.TYPE_STRING) } ), responses={ 200: openapi.Response("OK- Successful POST Request"), 401: openapi.Response( "Unauthorized- Authentication credentials were not provided. || Token Missing or Session Expired"), 422: openapi.Response("Unprocessable Entity- Make sure that all the required field values are passed"), 500: openapi.Response("Internal Server Error- Error while processing the POST Request Function.") } ) @is_organization def delete(self, request, *args, **kwargs): data = request.data dept_id = data.get('dept_id', None) org_id = data.get('org_id', None) departments = models.Department.objects.filter(Q(department_id=dept_id) & Q(organization__org_id=org_id) & Q(is_active=True)) if not len(departments): errors = [ 'invalid id' ] return Response({'details': errors}, status.HTTP_400_BAD_REQUEST) department = departments[0] department.is_active = False department.save() msgs = [ "Successfully deleted department" ] return Response({'details': msgs}, status.HTTP_200_OK)
class CapabilitiesViewsetMixin: """Mixin that allows a ViewSet to take advantage of the RBAC system """ model = None @classmethod def add_to_router(cls, router): """Will return a nested router if the view model has role fields on it """ if cls.model and hasattr(cls.model, '__implicit_role_fields'): return cls.add_as_nested_router(router) return super().add_to_router(router) @classmethod def add_as_nested_router(cls, parent_router): """Adds the viewset to the parent_router and then returns a router instance to use under the viewset """ router = super().add_as_nested_router(parent_router) # TODO: add the role viewset # if cls.model and hasattr(cls.model, '__implicit_role_fields'): # RoleViewset.add_to_router(router) return router @swagger_auto_schema(method='get', manual_parameters=[ openapi.Parameter( name='action', in_=openapi.IN_QUERY, type=openapi.TYPE_ARRAY, description='Filter to check only certain action(s) on the model\'s accessor.', items=openapi.Items(type=openapi.TYPE_STRING), collection_format='multi' ) ]) @drf_action(detail=True, methods=['GET'], url_path='capabilities') def capabilities(self, request, **kwargs): """ === title: Get Capable Actions for the {verbose_name} Resource --- Returns a list of actions and whether or not the current user has permission to perform those actions against the given resource. """ lookup_kwarg = self.lookup_url_kwarg kwarg_value = kwargs.get(lookup_kwarg, None) if not kwarg_value: raise APIException( f'Could not find URL lookup \'{lookup_kwarg}\' in the URL parameters. Please ' 'note the attempted URL and contact the Babka team to fix this server issue.' ) try: instance = self.get_object(permission_check=False) except ObjectDoesNotExist: raise NotFound( f'A matching {self.model._meta.verbose_name} could not be found. If this is ' 'a recurring issue, please contact the Babka team.' ) method_list = request.GET.getlist('action', []) if not method_list: # If the request does not specify what actions to check, then we try to inspect the # instance's model accessor to get _all possible_ actions to test each of them accessor = access_registry[self.model](request.user, instance=instance) raw_methods = inspect.getmembers(accessor, predicate=inspect.ismethod) method_list = [x.replace('can_', '') for x, _ in raw_methods if x.startswith('can_')] logger.debug('capabilities for "%s" for actions "%s" against "%s"', request.user, method_list, instance) accessor = instance_to_accessor(instance)(request.user, request=request, instance=instance, view=self) capabilities = accessor.get_user_capabilities(method_list=method_list) return Response({'username': request.user.username, 'capabilities': capabilities}) def __getattr__(self, name): """ Allows for the dynamic creation of a serializer class that returns the capabilities of a user for that specific object """ if name == 'capabilities_serializer_class': accessor = access_registry.get(self.model, None) if not accessor: return None if self.model in _capabilities_serializer_classes: return _capabilities_serializer_classes[self.model] raw_methods = inspect.getmembers(accessor(self.request.user, view=self), predicate=inspect.ismethod) method_list = [x.replace('can_', '') for x, _ in raw_methods if x.startswith('can_')] attrs = { method: BooleanField( read_only=True, help_text=( f'Describes whether or not the user can perform "{method}" actions ' f'against the given {self.model.__name__} instance.' ) ) for method in method_list } serializer_class = type(f'{self.model.__name__}CapabilitiesSerializer', (Serializer,), attrs) _capabilities_serializer_classes[self.model] = serializer_class return serializer_class return self.__getattribute__(name)
class JoinRequestsDepartment(views.APIView): authentication_classes = (authentication.TokenAuthentication,) permission_classes = (permissions.IsAuthenticated,) @swagger_auto_schema( responses={ 200: openapi.Response("OK- Successful GET Request"), 401: openapi.Response("Unauthorized- Authentication credentials were not provided. || Token Missing or Session Expired"), 500: openapi.Response("Internal Server Error- Error while processing the GET Request Function.") }, manual_parameters=[ openapi.Parameter(name="org_id", in_="query", type=openapi.TYPE_STRING), ] ) @is_organization def get(self, request, *args, **kwargs): departments = departments_models.Department.objects.filter( Q(organization=kwargs.get("organization")) & Q(is_active=True)) serializer = departments_serializers.DepartmentSerializer(departments, many=True) return Response(serializer.data, status.HTTP_200_OK) @swagger_auto_schema( request_body = openapi.Schema( title = "Join department request", type=openapi.TYPE_OBJECT, properties={ 'org_id': openapi.Schema(type=openapi.TYPE_STRING), 'dept_id': openapi.Schema(type=openapi.TYPE_STRING), 'requesting_user_id': openapi.Schema(type=openapi.TYPE_INTEGER), } ), responses={ 200: openapi.Response("OK- Successful POST Request"), 401: openapi.Response("Unauthorized- Authentication credentials were not provided. || Token Missing or Session Expired"), 422: openapi.Response("Unprocessable Entity- Make sure that all the required field values are passed"), 500: openapi.Response("Internal Server Error- Error while processing the POST Request Function.") } ) @is_organization @validate_dept def post(self, request, *args, **kwargs): data = request.data requesting_user_id = data.get("requesting_user_id", 0) if not requesting_user_id: errors = [ 'requesting_user_id is not passed' ] return Response({'details': errors}, status.HTTP_400_BAD_REQUEST) organization = kwargs.get("organization") department = kwargs.get("department") if not department.organization == organization: errors = [ 'Invalid dept_id' ] return Response({'details': errors}, status.HTTP_400_BAD_REQUEST) request_list = [] for i in department.requesting_users.all(): request_list.append(str(i.id)) if not str(requesting_user_id) in request_list: errors = [ 'Invalid requesting_user_id' ] return Response({'details': errors}, status.HTTP_400_BAD_REQUEST) department.requesting_users.remove(int(requesting_user_id)) department.user = users_models.User.objects.get(id=int(requesting_user_id)) department.save() msgs = [ 'Request accepted successfully' ] return Response({'details': msgs}, status.HTTP_200_OK)
self.permission_classes = [permissions.IsAuthenticated] return super().create(request, *args, **kwargs) def list(self, request, *args, **kwargs): self.queryset = RepositoryTranslatedExample.objects.all() self.filter_class = TranslationsFilter return super().list(request, *args, **kwargs) @method_decorator( name="retrieve", decorator=swagger_auto_schema(manual_parameters=[ openapi.Parameter( "with_translation", openapi.IN_QUERY, description= "Boolean that allows you to download or not all translations", type=openapi.TYPE_BOOLEAN, default=True, ), openapi.Parameter( "of_the_language", openapi.IN_QUERY, description="Choose the language to be translated", type=openapi.TYPE_STRING, required=True, ), openapi.Parameter( "for_the_language", openapi.IN_QUERY, description="Which language will be translated", type=openapi.TYPE_STRING,
class AttendanceViewSet(viewsets.ModelViewSet): queryset = Attendance.objects.filter( employee__deleted_at=None).order_by('-id') serializer_class = AttendanceSerializer permission_classes = [] employee_id_param = openapi.Parameter('employee_id', openapi.IN_QUERY, description="Enter employee ID", type=openapi.TYPE_INTEGER) source_param = openapi.Parameter('source', openapi.IN_QUERY, description="Enter source", type=openapi.TYPE_STRING) date_param = openapi.Parameter('fieldset', openapi.IN_QUERY, description="Enter fieldset", type=openapi.TYPE_STRING) @swagger_auto_schema(manual_parameters=[employee_id_param]) def list(self, request, *args, **kwargs): queryset = Attendance.objects.filter( employee__deleted_at=None).order_by('-id') source = self.request.query_params.get('source', None) fieldset = self.request.query_params.get('fieldset', None) employee_id = self.request.query_params.get('employee_id', None) if source == "app" and fieldset == "statement": if employee_id: queryset = queryset.filter( employee=employee_id, date__month=datetime.datetime.now().month, date__year=datetime.datetime.now().year, ) serializer = AttendanceStatementListSerializer(queryset, many=True) employee_obj = Employee.objects.filter(id=employee_id, deleted_at=None).first() if employee_obj: last_statement = employee_obj.statement_set.all().order_by( 'id').last() statements = Statement.objects.filter( employee=employee_obj, date__month=datetime.datetime.now().month, date__year=datetime.datetime.now().year, ) withdraw = sum([s.withdraw for s in statements if s.withdraw]) return Response({ "total_due": float(withdraw) if withdraw else 0.0, "statements": serializer.data }) raise ValidationError({"message": "Invalid arguments"}) response_schema_dict = { "200": openapi.Response(description="custom 200 description", examples={ "application/json": { "status": True, "message": "Attendance marked successfully", "employee": { "daily_salary": 0.0, "balance": 0.0 } } }), "400": openapi.Response( description="Duplicate attendance error", examples={ "application/json": { "status": False, "message": "Attendance already created for this employee.", "employee": {} } }), "400:bad": openapi.Response(description="custom 400 description", examples={ "application/json": { "status": False, "message": "Invalid arguments", "employee": {} } }), } @swagger_auto_schema(request_body=openapi.Schema( type=openapi.TYPE_OBJECT, properties={ 'status': openapi.Schema(type=openapi.TYPE_STRING, description='string'), 'duration': openapi.Schema(type=openapi.TYPE_STRING, description='string'), 'start_time': openapi.Schema(type=openapi.TYPE_STRING, description='string'), 'end_time': openapi.Schema(type=openapi.TYPE_STRING, description='string'), 'qr_code_scanned': openapi.Schema(type=openapi.TYPE_BOOLEAN, description='boolean'), 'face_detected': openapi.Schema(type=openapi.TYPE_BOOLEAN, description='boolean'), 'location': openapi.Schema(type=openapi.TYPE_STRING, description='string'), 'employee': openapi.Schema(type=openapi.TYPE_INTEGER, description='integer'), 'company': openapi.Schema(type=openapi.TYPE_INTEGER, description='integer'), 'image': openapi.Schema(type=openapi.TYPE_STRING, description='string'), }), responses=response_schema_dict) def create(self, request): today_date = str(datetime.datetime.now().date()) date = request.data.get('date', None) duration = request.data.get('duration', None) start_at = request.data.get('start_time', None) end_at = request.data.get('end_time', None) qr_code_scanned = request.data.get('qr_code_scanned', None) face_detected = request.data.get('face_detected', None) work_location = request.data.get('location', None) employee = request.data.get('employee', None) company = request.data.get('company', None) image = request.data.get('image', None) status = request.data.get('status', None) if not employee: raise ValidationError({ "status": False, "message": "Employee is Required.", "employee": {} }) if not company: raise ValidationError({ "status": False, "message": "Company is Required.", "employee": {} }) if not status: raise ValidationError({ "status": False, "message": "Status is Required.", "employee": {} }) if date: try: datetime.datetime.strptime(date, "%Y-%m-%d") except: raise ValidationError({ "status": False, "message": "Date format should be like %Y-%m-%d.", "employee": {} }) if start_at or end_at: try: time.strptime(start_at, "%I:%M %p") time.strptime(end_at, "%I:%M %p") except: raise ValidationError({ "status": False, "message": "Time format should be like 'HH:MM AM/PM'", "employee": {} }) if status: if status not in ['present', 'absent']: raise ValidationError({ "status": False, "message": "Invalid Status", "employee": {} }) if duration: if duration not in ['full_day', 'half_day']: raise ValidationError({ "status": False, "message": "Invalid Duration", "employee": {} }) if work_location: if work_location not in ['office', 'home', 'other']: raise ValidationError({ "status": False, "message": "Invalid Work Location.", "employee": {} }) employee_obj = Employee.objects.filter(id=employee, deleted_at=None).first() company_obj = Company.objects.get(id=company) # to find working day is_working = find_employee_is_working(employee_obj) # check attendance already exists attendance = Attendance.objects.all().filter( date=date if date else today_date, employee_id=employee, company_id=company) if attendance: raise ValidationError({ "status": False, "message": "Today's allowance has already been added to your wallet", "employee": {}, "company": {}, "working_day": is_working, "attendance_marked": True }) if status == 'absent': attendance_data = { "date": date if date else today_date, "status": status, "employee": employee, "company": company, } serializer = AttendanceSerializer(data=attendance_data) if serializer.is_valid(): serializer.save() response_data = { "status": True, "message": "Attendance marked successfully", "employee": { "id": int(employee_obj.id), "name": str(employee_obj.name), "balance": float(employee_obj.balance) \ if employee_obj.balance else 0.0, "daily_salary": float(employee_obj.daily_salary) \ if employee_obj.daily_salary else 0.0, "bank_account_number": str(employee_obj.bank_account_number) \ if employee_obj.bank_account_number else "", "ifs": { "code": str(employee_obj.ifs.code) if employee_obj.ifs else "", "bank": { "name": str(employee_obj.ifs.bank.name) \ if employee_obj.ifs else "" } } }, "company": { "id": int(employee_obj.company.id) if employee_obj.company else None, "Name": str(employee_obj.company.name) if employee_obj.company else "" }, "working_day": is_working, "attendance_marked": True } return JsonResponse(response_data) raise ValidationError({ "status": False, "message": "Invalid arguments", "employee": {}, "company": {}, "working_day": is_working, "attendance_marked": False }) else: attendance_data = { "date": date if date else today_date, "status": status, "duration": duration, "start_at": start_at, "end_at": end_at, "work_location": work_location, "qr_code_scanned": qr_code_scanned, "face_detected": face_detected, "employee": employee, "company": company, "image": image if image else '', } serializer = AttendanceSerializer(data=attendance_data) if serializer.is_valid(): serializer.save() try: # update 'balance' of employee after attendance created employee_obj.balance = float(employee_obj.balance) + float( employee_obj.daily_salary) employee_obj.save() response_data = { "status": True, "message": "Attendance marked successfully", "employee": { "id": int(employee_obj.id), "name": str(employee_obj.name), "balance": float(employee_obj.balance) \ if employee_obj.balance else 0.0, "daily_salary": float(employee_obj.daily_salary) \ if employee_obj.daily_salary else 0.0, "bank_account_number": str(employee_obj.bank_account_number) \ if employee_obj.bank_account_number else "", "ifs": { "code": str(employee_obj.ifs.code) if employee_obj.ifs else "", "bank": { "name": str(employee_obj.ifs.bank.name) \ if employee_obj.ifs else "" } } }, "company": { "id": int(employee_obj.company.id) if employee_obj.company else None, "Name": str(employee_obj.company.name) if employee_obj.company else "" }, "working_day": is_working, "attendance_marked": True } return JsonResponse(response_data) except: raise ValidationError({ "status": False, "message": "Something Went Wrong", "employee": {}, "company": {}, "working_day": is_working, "attendance_marked": False }) print(str(serializer.errors)) raise ValidationError({ "status": False, "message": "Invalid arguments", "employee": {}, "company": {}, "working_day": is_working, "attendance_marked": False })
class ClassViewSet(views.APIView): authentication_classes = (authentication.TokenAuthentication, ) permission_classes = (permissions.IsAuthenticated, ) @swagger_auto_schema(responses={ 200: openapi.Response("OK- Successful GET Request"), 401: openapi.Response( "Unauthorized- Authentication credentials were not provided. || Token Missing or Session Expired" ), 500: openapi.Response( "Internal Server Error- Error while processing the GET Request Function." ) }, manual_parameters=[ openapi.Parameter(name="org_id", in_="query", type=openapi.TYPE_STRING), openapi.Parameter(name="dept_id", in_="query", type=openapi.TYPE_STRING), ]) @is_organization def get(self, request, **kwargs): query_params = self.request.query_params org_id = kwargs.get('organization', None) dept_id = query_params.get('dept_id', None) qs = models.Class.objects.filter( is_active=True, department__organization__id=org_id.id) if dept_id: qs = qs.filter(department__department_id=dept_id, department__organization__id=org_id.id) serializer = serializers.ClassSerializer(qs, many=True) return Response(serializer.data, status.HTTP_200_OK) @swagger_auto_schema( request_body=openapi.Schema( title="Create Class", type=openapi.TYPE_OBJECT, properties={ 'title': openapi.Schema(type=openapi.TYPE_STRING), 'org_id': openapi.Schema(type=openapi.TYPE_STRING), 'dept_id': openapi.Schema(type=openapi.TYPE_STRING), }), responses={ 200: openapi.Response("OK- Successful POST Request"), 401: openapi.Response( "Unauthorized- Authentication credentials were not provided. || Token Missing or Session Expired" ), 422: openapi.Response( "Unprocessable Entity- Make sure that all the required field values are passed" ), 500: openapi.Response( "Internal Server Error- Error while processing the POST Request Function." ) }) @validate_org @validate_dept def post(self, request, **kwargs): data = request.data title = data.get('title', "") department = kwargs.get("department") organization = kwargs.get("organization") if not title: errors = ['title is not passed'] return Response({'details': errors}, status.HTTP_400_BAD_REQUEST) if models.Class.objects.filter(title=title, department=department).exists(): errors = ['Class already exists'] return Response({'details': errors}, status.HTTP_400_BAD_REQUEST) data_dict = { "title": str(title), "department": department.id, } serializer = serializers.ClassSerializer(data=data_dict) if serializer.is_valid(): serializer.save() msgs = [serializer.data] return Response({'details': msgs}, status.HTTP_200_OK) errors = [str(serializer.errors)] return Response({'details': errors}, status.HTTP_400_BAD_REQUEST) @swagger_auto_schema( request_body=openapi.Schema( title="Delete Class", type=openapi.TYPE_OBJECT, properties={ 'id': openapi.Schema(type=openapi.TYPE_INTEGER), 'org_id': openapi.Schema(type=openapi.TYPE_STRING) }), responses={ 200: openapi.Response("OK- Successful POST Request"), 401: openapi.Response( "Unauthorized- Authentication credentials were not provided. || Token Missing or Session Expired" ), 422: openapi.Response( "Unprocessable Entity- Make sure that all the required field values are passed" ), 500: openapi.Response( "Internal Server Error- Error while processing the POST Request Function." ) }) @is_organization def delete(self, request, *args, **kwargs): data = request.data id = data.get('id', None) org_id = data.get('org_id', None) if not id: errors = ['id is not passed'] return Response({'details': errors}, status.HTTP_400_BAD_REQUEST) classes = models.Class.objects.filter( Q(id=int(id)) & Q(is_active=True) & Q(department__organization__org_id=org_id)) if not len(classes): errors = ['invalid id'] return Response({'details': errors}, status.HTTP_400_BAD_REQUEST) classes = classes[0] classes.is_active = False classes.save() msgs = ["Successfully deleted class"] return Response({'details': msgs}, status.HTTP_200_OK)
class Student(views.APIView): authentication_classes = (authentication.TokenAuthentication, ) permission_classes = (permissions.IsAuthenticated, ) serializer_class = serializers.StudentSerializer @swagger_auto_schema(responses={ 200: openapi.Response("OK- Successful GET Request"), 401: openapi.Response( "Unauthorized- Authentication credentials were not provided. || Token Missing or Session Expired" ), 500: openapi.Response( "Internal Server Error- Error while processing the GET Request Function." ) }, manual_parameters=[ openapi.Parameter(name="section_id", in_="query", type=openapi.TYPE_INTEGER), openapi.Parameter(name="org_id", in_="query", type=openapi.TYPE_STRING), openapi.Parameter(name="dept_id", in_="query", type=openapi.TYPE_STRING), openapi.Parameter(name="class_id", in_="query", type=openapi.TYPE_INTEGER), ]) def get(self, request): query_params = self.request.query_params org_id = query_params.get('org_id', None) section_id = query_params.get('section_id', None) dept_id = query_params.get('dept_id', None) class_id = query_params.get('class_id', None) qs = models.Student.objects.filter(is_active=True) if section_id: qs = qs.filter(section__id=section_id) if org_id: qs = qs.filter( section__of_class__department__organization__org_id=org_id) if dept_id: qs = qs.filter( section__of_class__department__department_id=dept_id) if class_id: qs = qs.filter(section__of_class__id=class_id) serializer = serializers.StudentSerializer(qs, many=True) return Response(serializer.data, status.HTTP_200_OK) @swagger_auto_schema( request_body=openapi.Schema( title="Join teacher request", type=openapi.TYPE_OBJECT, properties={ 'sec_join_id': openapi.Schema(type=openapi.TYPE_STRING), 'name': openapi.Schema(type=openapi.TYPE_STRING), }), responses={ 200: openapi.Response("OK- Successful POST Request"), 401: openapi.Response( "Unauthorized- Authentication credentials were not provided. || Token Missing or Session Expired" ), 422: openapi.Response( "Unprocessable Entity- Make sure that all the required field values are passed" ), 500: openapi.Response( "Internal Server Error- Error while processing the POST Request Function." ) }) def post(self, request): data = json.loads(json.dumps(request.data)) sec_join_id = data.get("sec_join_id") if not sec_join_id: errors = ['Sec_Join_ID is not passed'] return Response({'details': errors}, status.HTTP_400_BAD_REQUEST) sections = section_models.Section.objects.filter(join_id=sec_join_id) if not len(sections): errors = ['Invalid section Join ID'] return Response({'details': errors}, status.HTTP_400_BAD_REQUEST) section = sections[0] if not section.is_active: errors = ['Invalid section Join ID'] return Response({'details': errors}, status.HTTP_400_BAD_REQUEST) if not section.accepting_req: errors = ['This section is currently not accepting requests'] return Response({'details': errors}, status.HTTP_400_BAD_REQUEST) data.update({"user": request.user.id, "requested_section": section.id}) serializer = self.serializer_class(data=data) if serializer.is_valid(): serializer.save() return Response(serializer.data, status.HTTP_201_CREATED) return Response(serializer.errors, status.HTTP_400_BAD_REQUEST) @swagger_auto_schema( request_body=openapi.Schema( title="Update Student", type=openapi.TYPE_OBJECT, properties={ 'org_id': openapi.Schema(type=openapi.TYPE_STRING), 'name': openapi.Schema(type=openapi.TYPE_STRING), 'phone': openapi.Schema(type=openapi.TYPE_INTEGER), 'student_id': openapi.Schema(type=openapi.TYPE_STRING), }), responses={ 200: openapi.Response("OK- Successful POST Request"), 401: openapi.Response( "Unauthorized- Authentication credentials were not provided. || Token Missing or Session Expired" ), 422: openapi.Response( "Unprocessable Entity- Make sure that all the required field values are passed" ), 500: openapi.Response( "Internal Server Error- Error while processing the POST Request Function." ) }) @put_student def put(self, request, *args, **kwargs): data = request.data data = pop_from_data(["is_active", "user", "section"], data) student = kwargs.get("student") serializer = serializers.StudentSerializer(student, data=data, partial=True) if not serializer.is_valid(): return Response({'details': [str(serializer.errors)]}, status.HTTP_400_BAD_REQUEST) serializer.save() msgs = ['successfully updated assignment'] return Response({'details': msgs}, status.HTTP_200_OK) @swagger_auto_schema( request_body=openapi.Schema( title="Delete Student", type=openapi.TYPE_OBJECT, properties={ 'org_id': openapi.Schema(type=openapi.TYPE_STRING), 'sec_id': openapi.Schema(type=openapi.TYPE_STRING), 'student_id': openapi.Schema(type=openapi.TYPE_STRING), }), responses={ 200: openapi.Response("OK- Successful POST Request"), 401: openapi.Response( "Unauthorized- Authentication credentials were not provided. || Token Missing or Session Expired" ), 422: openapi.Response( "Unprocessable Entity- Make sure that all the required field values are passed" ), 500: openapi.Response( "Internal Server Error- Error while processing the POST Request Function." ) }) @is_organization def delete(self, request, *args, **kwargs): data = request.data student_id = data.get('student_id', None) sec_id = data.get('sec_id', None) org = kwargs.get('organization') students = models.Student.objects.filter( Q(student_id=student_id) & Q(section__id=sec_id) & Q(section__of_class__department__organization__org_id=org.org_id) & Q(is_active=True)) if not len(students): errors = ['invalid stduent id'] return Response({'details': errors}, status.HTTP_400_BAD_REQUEST) student = students[0] student.is_active = False student.save() msgs = ["Successfully deleted student"] return Response({'details': msgs}, status.HTTP_200_OK)
EnvironmentPermissionModel, UserEnvironmentPermission, UserPermissionGroupEnvironmentPermission, ) from .serializers import EnvironmentSerializerLight, WebhookSerializer logger = get_logger(__name__) @method_decorator( name="list", decorator=swagger_auto_schema(manual_parameters=[ openapi.Parameter( "project", openapi.IN_QUERY, "ID of the project to filter by.", required=False, type=openapi.TYPE_INTEGER, ) ]), ) class EnvironmentViewSet(viewsets.ModelViewSet): lookup_field = "api_key" permission_classes = [IsAuthenticated, EnvironmentPermissions] def get_serializer_class(self): if self.action == "trait_keys": return TraitKeysSerializer if self.action == "delete_traits": return DeleteAllTraitKeysSerializer return EnvironmentSerializerLight
import coreapi from django.db.models import Q from django.utils.decorators import method_decorator from drf_yasg2 import openapi from drf_yasg2.utils import swagger_auto_schema from rest_framework import mixins, viewsets from audit.models import AuditLog from audit.serializers import AuditLogSerializer project_query_param = openapi.Parameter( "project", openapi.IN_QUERY, description="ID of the project to filter on", type=openapi.TYPE_INTEGER, ) environment_query_param = openapi.Parameter( "environment", openapi.IN_QUERY, description="ID of the environment to filter on " "(Note `id` required, not `api_key`)", type=openapi.TYPE_INTEGER, ) @method_decorator( name="list", decorator=swagger_auto_schema( manual_parameters=[project_query_param, environment_query_param]), ) class AuditLogViewSet(mixins.ListModelMixin, viewsets.GenericViewSet):
class CreateSubject(views.APIView): serializer_class = serializers.SubjectSerializer authentication_classes = (authentication.TokenAuthentication, ) permission_classes = (permissions.IsAuthenticated, ) @swagger_auto_schema(responses={ 200: openapi.Response("OK- Successful GET Request"), 401: openapi.Response( "Unauthorized- Authentication credentials were not provided. || Token Missing or Session Expired" ), 500: openapi.Response( "Internal Server Error- Error while processing the GET Request Function." ) }, manual_parameters=[ openapi.Parameter(name="id", in_="query", type=openapi.TYPE_INTEGER), openapi.Parameter(name="org_id", in_="query", type=openapi.TYPE_STRING), openapi.Parameter(name="dept_id", in_="query", type=openapi.TYPE_STRING), openapi.Parameter(name="class_id", in_="query", type=openapi.TYPE_INTEGER), openapi.Parameter(name="section_id", in_="query", type=openapi.TYPE_INTEGER), ]) def get(self, request): query_params = self.request.query_params id = query_params.get('id', None) section_id = query_params.get('section_id', None) class_id = query_params.get('class_id', None) dept_id = query_params.get('dept_id', None) org_id = query_params.get('org_id', None) qs = models.Subject.objects.filter(is_active=True) if id: qs = qs.filter(id=int(id)) if section_id: qs = qs.filter(section__id=int(section_id)) if class_id: qs = qs.filter(section__of_class__id=int(class_id)) if dept_id: qs = qs.filter( section__of_class__department__department_id=dept_id) if org_id: qs = qs.filter( section__of_class__department__organization__org_id=org_id) serializer = serializers.SubjectSerializer(qs, many=True) return Response(serializer.data, status.HTTP_200_OK) @swagger_auto_schema( request_body=openapi.Schema( title="Create Subject", type=openapi.TYPE_OBJECT, properties={ 'name': openapi.Schema(type=openapi.TYPE_STRING), 'section_id': openapi.Schema(type=openapi.TYPE_INTEGER) }), responses={ 200: openapi.Response("OK- Successful POST Request"), 401: openapi.Response( "Unauthorized- Authentication credentials were not provided. || Token Missing or Session Expired" ), 422: openapi.Response( "Unprocessable Entity- Make sure that all the required field values are passed" ), 500: openapi.Response( "Internal Server Error- Error while processing the POST Request Function." ) }) def post(self, request): data = request.data name = data.get('name', "") section_id = data.get('section_id', 0) if not name: errors = ['name is not passed'] return Response({'details': errors}, status.HTTP_400_BAD_REQUEST) if not section_id: errors = ['section_id is not passed'] return Response({'details': errors}, status.HTTP_400_BAD_REQUEST) qr_section = sections_models.Section.objects.filter(id=int(section_id), is_active=True) if not len(qr_section): errors = ['Invalid section_id'] return Response({'details': errors}, status.HTTP_400_BAD_REQUEST) section_id = qr_section[0] if models.Subject.objects.filter(name=name, section=section_id).exists(): errors = ['Subject already exists'] return Response({'details': errors}, status.HTTP_400_BAD_REQUEST) models.Subject.objects.create(name=name, section=section_id) msgs = ['Successfully created subject'] return Response({'details': msgs}, status.HTTP_200_OK)
from .filters import EvaluatesFilter from .filters import EvaluateResultsFilter from .filters import EvaluateResultFilter from .permissions import RepositoryEvaluatePermission from .permissions import RepositoryEvaluateResultPermission @method_decorator( name="list", decorator=swagger_auto_schema(manual_parameters=[ openapi.Parameter( "repository_uuid", openapi.IN_QUERY, description="Repository UUID, calling " "the parameter through url", type=openapi.TYPE_STRING, required=True, ) ]), ) @method_decorator( name="create", decorator=swagger_auto_schema(manual_parameters=[ openapi.Parameter( "repository_uuid", openapi.IN_QUERY, description="Repository UUID, calling " "the parameter through url", type=openapi.TYPE_STRING, required=True,
@swagger_auto_schema( operation_id="users_dummy", operation_description="dummy operation", tags=["Users"], ) def patch(self, request): pass @swagger_auto_schema(method="put", request_body=UserSerializerrr, tags=["Users"]) @swagger_auto_schema( methods=["get"], manual_parameters=[ openapi.Parameter( "test", openapi.IN_QUERY, "test manual param", type=openapi.TYPE_BOOLEAN ), openapi.Parameter( "test_array", openapi.IN_QUERY, "test query array arg", type=openapi.TYPE_ARRAY, items=openapi.Items(type=openapi.TYPE_STRING), required=True, collection_format="multi", ), ], responses={200: openapi.Response("response description", UserSerializerrr),}, tags=["Users"], ) @api_view(["GET", "PUT"])
class ArticleViewSet(viewsets.ModelViewSet): """ ArticleViewSet class docstring retrieve: retrieve class docstring destroy: destroy class docstring partial_update: partial_update class docstring """ queryset = Article.objects.all() lookup_field = "slug" lookup_value_regex = r"[a-z0-9]+(?:-[a-z0-9]+)" serializer_class = serializers.ArticleSerializer pagination_class = ArticlePagination filter_backends = (DjangoFilterBackend, OrderingFilter) filterset_fields = ("title", ) # django-filter 1.1 compatibility; was renamed to filterset_fields in 2.0 # TODO: remove when dropping support for Django 1.11 filter_fields = filterset_fields ordering_fields = ("date_modified", "date_created") ordering = ("date_created", ) swagger_schema = NoTitleAutoSchema from rest_framework.decorators import action @swagger_auto_schema( auto_schema=NoPagingAutoSchema, filter_inspectors=[DjangoFilterDescriptionInspector], ) @action(detail=False, methods=["get"]) def today(self, request): today_min = datetime.datetime.combine(datetime.date.today(), datetime.time.min) today_max = datetime.datetime.combine(datetime.date.today(), datetime.time.max) articles = (self.get_queryset().filter( date_created__range=(today_min, today_max)).all()) serializer = self.serializer_class(articles, many=True) return Response(serializer.data) @swagger_auto_schema(method="get", operation_description="image GET description override" ) @swagger_auto_schema(method="post", request_body=serializers.ImageUploadSerializer) @swagger_auto_schema( method="delete", manual_parameters=[ openapi.Parameter( name="delete_form_param", in_=openapi.IN_FORM, type=openapi.TYPE_INTEGER, description= "this should not crash (form parameter on DELETE method)", ) ], ) @action( detail=True, methods=["get", "post", "delete"], parser_classes=(MultiPartParser, FileUploadParser), ) def image(self, request, slug=None): """ image method docstring """ @swagger_auto_schema(request_body=no_body, operation_id="no_body_test") def update(self, request, *args, **kwargs): """update method docstring""" return super(ArticleViewSet, self).update(request, *args, **kwargs) @swagger_auto_schema( operation_description="partial_update description override", responses={404: "slug not found"}, operation_summary="partial_update summary", deprecated=True, ) def partial_update(self, request, *args, **kwargs): """partial_update method docstring""" return super(ArticleViewSet, self).partial_update(request, *args, **kwargs) def destroy(self, request, *args, **kwargs): """destroy method docstring""" return super(ArticleViewSet, self).destroy(request, *args, **kwargs)
from drf_yasg2 import openapi from drf_yasg2.utils import swagger_auto_schema from bothub.common.models import QAKnowledgeBase, QAtext from .filters import QAKnowledgeBaseFilter, QAtextFilter from .permissions import QAKnowledgeBasePermission, QAtextPermission from .serializers import QAKnowledgeBaseSerializer, QAtextSerializer @method_decorator( name="list", decorator=swagger_auto_schema(manual_parameters=[ openapi.Parameter( "repository_uuid", openapi.IN_QUERY, description="Repository's UUID", required=True, type=openapi.TYPE_STRING, format="uuid", ), ]), ) class QAKnowledgeBaseViewSet( mixins.ListModelMixin, mixins.CreateModelMixin, mixins.RetrieveModelMixin, mixins.DestroyModelMixin, mixins.UpdateModelMixin, GenericViewSet, ): queryset = QAKnowledgeBase.objects.all() serializer_class = QAKnowledgeBaseSerializer
class BookingViewSet(viewsets.ModelViewSet): queryset = Booking.objects.all().order_by('-id') serializer_class = BookingSerializer permission_classes = [] status_param = openapi.Parameter('status', openapi.IN_QUERY, description="Enter status", type=openapi.TYPE_STRING) @swagger_auto_schema(manual_parameters=[status_param]) def list(self, request, *args, **kwargs): queryset = self.queryset status = self.request.query_params.get('status', None) if status is not None: queryset = queryset.filter(status=status) page = self.paginate_queryset(queryset) serializer = BookingSerializer(page, many=True) response = self.get_paginated_response(serializer.data) return response response_schema_dict = { "200": openapi.Response(description="Success", examples={ "application/json": { "message": "Booking created successfully.", "status": "True" } }), "400": openapi.Response(description="Failed", examples={ "application/json": { "message": "Invalid arguments", "status": "False" } }), "400:Bad": openapi.Response(description="Failed", examples={ "application/json": { "message": "Phone is required.", "status": "False" } }), } @swagger_auto_schema(request_body=openapi.Schema( type=openapi.TYPE_OBJECT, properties={ 'name': openapi.Schema(type=openapi.TYPE_STRING, description='string'), 'phone': openapi.Schema(type=openapi.TYPE_STRING, description='string'), 'email': openapi.Schema(type=openapi.TYPE_STRING, description='string'), 'company': openapi.Schema(type=openapi.TYPE_STRING, description='string'), 'status': openapi.Schema(type=openapi.TYPE_INTEGER, description='integer'), 'category': openapi.Schema(type=openapi.TYPE_INTEGER, description='integer'), }), responses=response_schema_dict) def create(self, request, *args, **kwargs): name = request.data.get('name', None) if not name: raise ValidationError({ "status": 'False', "message": "Name is required." }) phone = request.data.get('phone', None) if not phone: raise ValidationError({ "status": 'False', "message": "Phone is required." }) if phone: if len(phone) != 10: raise ValidationError({ "status": 'False', "message": "Phone length should be 10 digits." }) email = request.data.get('email', None) if not email: raise ValidationError({ "status": 'False', "message": "Email is required" }) if email: regex = '^[\w\.\+\-]+\@[\w]+\.[a-z]{2,3}$' match = re.match(regex, email) if not match: raise ValidationError({ "status": 'False', "message": "Email is Invalid" }) company = request.data.get('company', None) category = request.data.get('category', None) booking_data = { "name": name, "phone": phone, "email": email, "company": company, "category": category, } serializer = BookingSerializer(data=booking_data) if serializer.is_valid(): serializer.save() company_first_name = company.split(' ')[0] # mail to user send_email( "Activate your " + str(company_first_name) + " Employee Wallet", "booking_email", [email], '*****@*****.**', None, name, company_first_name, ) # mail to admin send_email( str(name) + " from " + str(company) + " wants to connect with you", "booking_admin_email", [ '*****@*****.**', '*****@*****.**', '*****@*****.**' ], '*****@*****.**', None, name, company, email, phone, ) return JsonResponse({ "status": 'True', "message": "Booking created successfully." }) raise ValidationError({ "status": 'False', "message": "Invalid arguments" })
def create(self, request, *args, **kwargs): project_id = request.data.get('project') project = Project.objects.get(pk=project_id) if project.organisation not in request.user.organisations.all(): return Response(status=status.HTTP_403_FORBIDDEN) return super().create(request, *args, **kwargs) @method_decorator( name='list', decorator=swagger_auto_schema(manual_parameters=[ openapi.Parameter('feature', openapi.IN_QUERY, 'ID of the feature to filter by.', required=False, type=openapi.TYPE_INTEGER), openapi.Parameter( 'anyIdentity', openapi.IN_QUERY, 'Pass any value to get results that have an identity override. ' 'Do not pass for default behaviour.', required=False, type=openapi.TYPE_STRING) ])) class FeatureStateViewSet(viewsets.ModelViewSet): """ View set to manage feature states. Nested beneath environments and environments + identities to allow for filtering on both. """
query_serializer.is_valid(raise_exception=True) events_list = get_multiple_event_list_for_feature( feature_name=feature.name, **query_serializer.data) serializer = FeatureInfluxDataSerializer( instance={"events_list": events_list}) return Response(serializer.data) @method_decorator( name="list", decorator=swagger_auto_schema(manual_parameters=[ openapi.Parameter( "feature", openapi.IN_QUERY, "ID of the feature to filter by.", required=False, type=openapi.TYPE_INTEGER, ), openapi.Parameter( "anyIdentity", openapi.IN_QUERY, "Pass any value to get results that have an identity override. " "Do not pass for default behaviour.", required=False, type=openapi.TYPE_STRING, ), ]), ) class FeatureStateViewSet(viewsets.ModelViewSet): """
class QrCodeViewSet(viewsets.ModelViewSet): queryset = QrCode.objects.all().order_by('-id') serializer_class = QrCodeSerializer permission_classes = [] response_schema_dict = { "200": openapi.Response(description="Success", examples={ "application/json": { "valid": True, "message": "Valid QR Code" } }), "200:ok": openapi.Response(description="Failed", examples={ "application/json": { "valid": False, "message": "Invalid QR Code" } }), "200:Ok": openapi.Response(description="Failed", examples={ "application/json": { "valid": False, "message": "Invalid Location" } }), "200:OK": openapi.Response(description="Failed", examples={ "application/json": { "valid": False, "message": "You are not registered" } }), "200: OK": openapi.Response(description="Failed", examples={ "application/json": { "valid": False, "message": "You are not verified" } }), "400": openapi.Response(description="Failed", examples={ "application/json": { "valid": False, "message": "Params are missing" } }), "400: Bad": openapi.Response(description="Failed", examples={ "application/json": { "valid": False, "message": "Employee's Company has no QrCode." } }), } qr_id_param = openapi.Parameter('qr_id', openapi.IN_QUERY, description="Enter Company QrCode", type=openapi.TYPE_STRING) source_param = openapi.Parameter('source', openapi.IN_QUERY, description="Enter source param", type=openapi.TYPE_STRING) fieldset_param = openapi.Parameter('fieldset', openapi.IN_QUERY, description="Enter fieldset param", type=openapi.TYPE_STRING) longitude_param = openapi.Parameter('longitude', openapi.IN_QUERY, description="Enter longitude param", type=openapi.TYPE_STRING) latitude_param = openapi.Parameter('latitude', openapi.IN_QUERY, description="Enter latitude param", type=openapi.TYPE_STRING) employee_id_param = openapi.Parameter('employee_id', openapi.IN_QUERY, description="Enter Employee ID", type=openapi.TYPE_INTEGER) @swagger_auto_schema(manual_parameters=[ qr_id_param, source_param, fieldset_param, longitude_param, latitude_param, employee_id_param ], responses=response_schema_dict) def list(self, request, *args, **kwargs): queryset = self.queryset qr_id = self.request.query_params.get('qr_id', None) employee_id = self.request.query_params.get('employee_id', None) source = self.request.query_params.get('source', None) fieldset = self.request.query_params.get('fieldset', None) if source == 'app' and fieldset == 'qr': longitude = self.request.query_params.get('longitude', None) latitude = self.request.query_params.get('latitude', None) if not (employee_id and qr_id and longitude and latitude): return JsonResponse({ "valid": "False", "message": "Params are missing" }) try: qr_code = QrCode.objects.get(qr_id=qr_id) except: raise ValidationError({ "valid": "False", "message": "Invalid QR Code" }) employee_obj = Employee.objects.filter(id=employee_id, deleted_at=None).first() if not employee_obj: raise ValidationError({"message": "Employee Does not Exists"}) if employee_obj.check_location: distance_between_location = distance_between_two_points( longitude1=float(qr_code.longitude), latitude1=float(qr_code.latitude), longitude2=float(longitude), latitude2=float(latitude), ) with open(os.path.join(BASE_DIR, 'locations.log'), 'a') as f: string = str(qr_code.longitude) + "," + str(qr_code.latitude) \ + "," + str(longitude) + "," + str(latitude) + "," + \ str(distance_between_location) f.write(string) f.write("\n") try: distance = Setting.objects.get(key='distance') except: raise ValidationError({ "valid": "False", "message": "Setting Not Found" }) if distance_between_location < float(distance.value): return JsonResponse({ "valid": "True", "message": "Valid QR Code" }) return JsonResponse({ "valid": "False", "message": "Invalid Location." }) else: return JsonResponse({ "valid": "True", "message": "Valid QR Code" }) if qr_id: queryset = queryset.filter(qr_id=qr_id) page = self.paginate_queryset(queryset) serializer = QrCodeSerializer(page, many=True) response = self.get_paginated_response(serializer.data) return response @swagger_auto_schema(request_body=openapi.Schema( type=openapi.TYPE_OBJECT, properties={ 'qr_id': openapi.Schema(type=openapi.TYPE_STRING, description='string'), 'longitude': openapi.Schema(type=openapi.TYPE_NUMBER, description='decimal'), 'latitude': openapi.Schema(type=openapi.TYPE_NUMBER, description='decimal'), })) def create(self, request, *args, **kwargs): qr_id = request.data.get('qr_id', None) longitude = request.data.get('longitude', None) latitude = request.data.get('latitude', None) if not qr_id: raise ValidationError({ 'status': 'False', "message": "Empty QR Code" }) if qr_id: try: company_code = qr_id.split('-')[0] except: raise ValidationError({ 'status': 'False', "message": "Invalid QR Code format" }) try: company = Company.objects.get(code=company_code) except: raise ValidationError({ 'status': 'False', "message": "Company not found" }) if qr_id and longitude and latitude: queryset = QrCode.objects.filter(qr_id=qr_id).first() if queryset: raise ValidationError({ 'status': 'False', "message": "QR Code already registered" }) data = { "qr_id": qr_id, "longitude": longitude, "latitude": latitude, "company": company.id } serializer = QrCodeSerializer(data=data) if serializer.is_valid(): serializer.save() return JsonResponse(serializer.data) raise ValidationError({ 'status': 'False', "message": "Invalid details" })
class EmployeeStatusView(views.APIView): response_schema_dict = { "200": openapi.Response(description="success", examples={ "application/json": { "phone": "string", "registered": "true / false", "confirmed": "true / false", "otp": "string" } }), } phone_param = openapi.Parameter('phone', openapi.IN_QUERY, description="Enter phone number", type=openapi.TYPE_STRING) @swagger_auto_schema(method='get', manual_parameters=[phone_param], responses=response_schema_dict) @action(detail=False, methods=['GET']) def get(self, request): phone = request.GET.get('phone') user = User.objects.filter(username=phone).first() if user: employee = user.employee_set.filter(deleted_at=None) else: employee = [] # get otp and send to the user otp = utilities.generate_random_number(6) template = "login" data = call(phone, template, otp) if user and employee: user.otp = otp expiry_datetime = datetime.datetime.now() + datetime.timedelta( seconds=120) expiry_datetime = get_utc_datetime(expiry_datetime) user.otp_valid_till = expiry_datetime user.save() return JsonResponse({ "phone": str(employee[0].phone), "registered": True, "confirmed": employee[0].confirmed, "otp": str(otp) }) if user and not employee: return JsonResponse({ "phone": phone, "registered": False, "confirmed": False, "otp": str(otp) }) if not user: return JsonResponse({ "phone": phone, "registered": False, "confirmed": False, "otp": str(otp) })
class StatementViewSet(viewsets.ModelViewSet): queryset = Statement.objects.filter( employee__deleted_at=None).order_by('-id') serializer_class = StatementSerializer #permission_classes = [permissions.IsAuthenticated] from_date_param = openapi.Parameter( 'from_date', openapi.IN_QUERY, description="Enter from_date (YYYY-MM-DD)", type=openapi.TYPE_STRING) to_date_param = openapi.Parameter('to_date', openapi.IN_QUERY, description="Enter to_date (YYYY-MM-DD)", type=openapi.TYPE_STRING) employee_param = openapi.Parameter('employee', openapi.IN_QUERY, description="Enter employee Id", type=openapi.TYPE_STRING) source_param = openapi.Parameter('source', openapi.IN_QUERY, description="Enter source", type=openapi.TYPE_STRING) fieldset_param = openapi.Parameter('fieldset', openapi.IN_QUERY, description="Enter fieldset", type=openapi.TYPE_STRING) @swagger_auto_schema(manual_parameters=[ from_date_param, to_date_param, source_param, fieldset_param, employee_param ]) def list(self, request, *args, **kwargs): queryset = Statement.objects.filter( employee__deleted_at=None).order_by('-id') from_date = self.request.query_params.get('from_date', None) to_date = self.request.query_params.get('to_date', None) employee = self.request.query_params.get('employee', None) source = self.request.query_params.get('source', None) fieldset = self.request.query_params.get('fieldset', None) if source == 'app' and fieldset == 'debit': queryset = queryset.filter(debit__gt=0.0) if from_date: try: datetime.datetime.strptime(from_date, "%Y-%m-%d") except: raise ValidationError({"message": "Invalid from_date format."}) queryset = queryset.filter(date__gte=from_date) if to_date: try: datetime.datetime.strptime(to_date, "%Y-%m-%d") except: raise ValidationError({"message": "Invalid to_date format."}) queryset = queryset.filter(date__lte=to_date) if employee: queryset = queryset.filter(employee_id=employee) serializer = StatementSerializer(queryset, many=True) last_statement = Statement.objects.filter(employee=employee).last() if last_statement: response_data = { "total_due": float(last_statement.balance) + float(last_statement.previous_due), "balance": float(last_statement.balance), "current_due": float(last_statement.current_due), "previous_due": float(last_statement.previous_due), "statements": serializer.data, } else: response_data = { "total_due": 0.0, "balance": 0.0, "current_due": 0.0, "previous_due": 0.0, "statements": [] } return Response(response_data) page = self.paginate_queryset(queryset) serializer = StatementListSerializer(queryset, many=True) response = self.get_paginated_response(serializer.data) return response response_schema_dict = { "200": openapi.Response(description="Success", examples={ "application/json": { "message": "Statement created successfully.", "otp": "154622" } }), } @swagger_auto_schema(request_body=openapi.Schema( type=openapi.TYPE_OBJECT, properties={ 'description': openapi.Schema(type=openapi.TYPE_STRING, description='string'), 'credit': openapi.Schema(type=openapi.TYPE_NUMBER, description='decimal'), 'debit': openapi.Schema(type=openapi.TYPE_NUMBER, description='decimal'), 'balance': openapi.Schema(type=openapi.TYPE_NUMBER, description='decimal'), 'status': openapi.Schema(type=openapi.TYPE_STRING, description='string'), 'employee': openapi.Schema(type=openapi.TYPE_INTEGER, description='integer'), 'company': openapi.Schema(type=openapi.TYPE_INTEGER, description='integer'), }), manual_parameters=[source_param, fieldset_param]) def create(self, request, *args, **kwargs): description = request.data.get('description', None) credit = request.data.get('credit', None) debit = request.data.get('debit', None) status = request.data.get('status', None) employee = request.data.get('employee', None) company = request.data.get('company', None) source = self.request.query_params.get('source', None) fieldset = self.request.query_params.get('fieldset', None) device_name = request.data.get('device_name', None) device_id = request.data.get('device_id', None) ip_address = request.data.get('ip_address', None) disbursement_id = request.data.get('disbursement_id', None) loan_id = request.data.get('loan_id', None) if not description: raise ValidationError({"message": "Description is required."}) if not employee: raise ValidationError({"message": "Employee is required field."}) if not company: raise ValidationError({"message": "Company is required field."}) if employee: employee_object = Employee.objects.filter(id=employee, deleted_at=None).first() if not employee_object: raise ValidationError({"message": "Employee does not exists."}) if not employee_object.mail_enabled: raise ValidationError({"message": "Please Verify Your Email."}) if not employee_object.ifs or not employee_object.bank_account_number: raise ValidationError( {"message": "Please Add Your Bank Details."}) if company: try: Company.objects.get(id=company) except: raise ValidationError({"message": "Company does not exists."}) if source == 'app' and fieldset == 'debit': if debit: if float(debit) <= 0: raise ValidationError({ "status": "False", "message": "Invalid Transfer Amount" }) if float(debit) > float( employee_object.get_available_balance()): raise ValidationError({ "status": "False", "message": "Insufficient Balance" }) if float(debit) < 500: raise ValidationError({ "status": "False", "message": "Minimum withdrawal amount: Rs.500" }) digital_time_stamp = None if employee_object.name and device_name and device_id and ip_address: digital_time_stamp = utilities.generate_digital_time_stamp( employee_object.name, device_name, device_id, ip_address) fees, gst = calculate_fees_with_gst(debit) total_debit = debit + fees + gst last_statement = Statement.objects.filter( employee=employee_object).last() if last_statement: balance = last_statement.balance + total_debit current_due = last_statement.current_due previous_due = last_statement.previous_due else: balance = total_debit current_due = 0 previous_due = 0 statement_data = { "description": description, "debit": total_debit, "withdraw": debit, "fees": fees, "gst": gst, "balance": balance, "current_due": current_due, "previous_due": previous_due, "employee": employee, "company": company, "digital_time_stamp": digital_time_stamp } serializer = StatementSerializer(data=statement_data) if serializer.is_valid(): serializer.save() employee_object.balance = float( employee_object.balance) - float(debit) employee_object.debited = float( employee_object.debited) + float(total_debit) employee_object.withdraw = float( employee_object.withdraw) + float(debit) employee_object.fees = float( employee_object.fees) + float(fees) employee_object.gst = float(employee_object.gst) + float(gst) employee_object.save() # send email to Admin for withdraw request if employee_object: send_email( "Withdraw Request", # subject "withdraw_request", # template [ '*****@*****.**', '*****@*****.**', '*****@*****.**' ], # to_emails '*****@*****.**', None, # attachment=None str(employee_object.name), str(debit), str(employee_object.ifs.bank.name), str(employee_object.bank_account_number), str(employee_object.ifs.code), str(employee_object.id), ) return JsonResponse({ "status": "True", "message": "Statement created successfully.", "description": serializer.data.get('description', None), "debit": debit }) raise ValidationError({ "status": "False", "message": "Invalid Arguments." }) raise ValidationError({ "status": "False", "message": "Missing source and fieldset Params." })
from environments.identities.models import Identity from segments.serializers import SegmentSerializer from util.views import SDKAPIView from . import serializers from .permissions import SegmentPermissions logger = logging.getLogger() logger.setLevel(logging.INFO) @method_decorator( name='list', decorator=swagger_auto_schema(manual_parameters=[ openapi.Parameter( 'identity', openapi.IN_QUERY, 'Optionally provide the id of an identity to get only the segments they match', required=False, type=openapi.TYPE_INTEGER) ])) class SegmentViewSet(viewsets.ModelViewSet): serializer_class = serializers.SegmentSerializer permission_classes = [SegmentPermissions] def get_queryset(self): project = get_object_or_404(self.request.user.get_permitted_projects( ['VIEW_PROJECT']), pk=self.kwargs['project_pk']) queryset = project.segments.all() identity_pk = self.request.query_params.get('identity') if identity_pk:
class TraitViewSet(viewsets.ModelViewSet): serializer_class = TraitSerializerFull def get_queryset(self): """ Override queryset to filter based on provided URL parameters. """ environment_api_key = self.kwargs["environment_api_key"] identity_pk = self.kwargs.get("identity_pk") environment = self.request.user.get_permitted_environments( ["VIEW_ENVIRONMENT"] ).get(api_key=environment_api_key) if identity_pk: identity = Identity.objects.get(pk=identity_pk, environment=environment) else: identity = None return Trait.objects.filter(identity=identity) def get_environment_from_request(self): """ Get environment object from URL parameters in request. """ return Environment.objects.get(api_key=self.kwargs["environment_api_key"]) def get_identity_from_request(self, environment): """ Get identity object from URL parameters in request. """ return Identity.objects.get(pk=self.kwargs["identity_pk"]) def create(self, request, *args, **kwargs): """ Override create method to add identity (if present) from URL parameters. TODO: fix this - it doesn't work, the FE uses the SDK endpoint instead """ data = request.data environment = self.get_environment_from_request() if ( environment.project.organisation not in self.request.user.organisations.all() ): return Response(status=status.HTTP_403_FORBIDDEN) identity_pk = self.kwargs.get("identity_pk") # check if identity in data or in request if "identity" not in data and not identity_pk: error = {"detail": "Identity not provided"} return Response(error, status=status.HTTP_400_BAD_REQUEST) # TODO: do we give priority to request identity or data? # Override with request identity if identity_pk: data["identity"] = identity_pk serializer = self.get_serializer(data=data) serializer.is_valid(raise_exception=True) self.perform_create(serializer) headers = self.get_success_headers(serializer.data) return Response( serializer.data, status=status.HTTP_201_CREATED, headers=headers ) def update(self, request, *args, **kwargs): """ Override update method to always assume update request is partial and create / update trait value. """ trait_to_update = self.get_object() trait_data = request.data # Check if trait value was provided with request data. If so, we need to figure out value_type from # the given value and also use correct value field e.g. boolean_value, float_value, integer_value or # string_value, and override request data if "trait_value" in trait_data: trait_data = trait_to_update.generate_trait_value_data( trait_data["trait_value"] ) serializer = TraitSerializerFull(trait_to_update, data=trait_data, partial=True) serializer.is_valid(raise_exception=True) self.perform_update(serializer) return Response(serializer.data) def partial_update(self, request, *args, **kwargs): """ Override partial_update as overridden update method assumes partial True for all requests. """ return self.update(request, *args, **kwargs) @swagger_auto_schema( manual_parameters=[ openapi.Parameter( "deleteAllMatchingTraits", openapi.IN_QUERY, "Deletes all traits in this environment matching the key of the deleted trait", type=openapi.TYPE_BOOLEAN, ) ] ) def destroy(self, request, *args, **kwargs): delete_all_traits = request.query_params.get("deleteAllMatchingTraits") if delete_all_traits and delete_all_traits in ("true", "True"): trait = self.get_object() self._delete_all_traits_matching_key( trait.trait_key, trait.identity.environment ) return Response(status=status.HTTP_204_NO_CONTENT) else: return super(TraitViewSet, self).destroy(request, *args, **kwargs) def _delete_all_traits_matching_key(self, trait_key, environment): Trait.objects.filter( trait_key=trait_key, identity__environment=environment ).delete()
class JoinRequestsTeacher(views.APIView): queryset = models.Organization.objects.filter(is_active=True) serializer_class = teachers_serializers.TeacherSerializer authentication_classes = (authentication.TokenAuthentication,) permission_classes = (permissions.IsAuthenticated,) @swagger_auto_schema( responses={ 200: openapi.Response("OK- Successful GET Request"), 401: openapi.Response("Unauthorized- Authentication credentials were not provided. || Token Missing or Session Expired"), 500: openapi.Response("Internal Server Error- Error while processing the GET Request Function.") }, manual_parameters=[ openapi.Parameter(name="org_id", in_="query", type=openapi.TYPE_STRING), ] ) @is_organization def get(self, request, **kwargs): query_params = self.request.query_params organizations=kwargs.get("organization") teachers = teachers_models.Teacher.objects.filter( Q(requested_organization__id=organizations.id) & Q(is_active=True)) serializer = teachers_serializers.TeacherSerializer(teachers, many=True) return Response(serializer.data, status.HTTP_200_OK) @swagger_auto_schema( request_body = openapi.Schema( title = "Join teacher request", type=openapi.TYPE_OBJECT, properties={ 'org_id': openapi.Schema(type=openapi.TYPE_STRING), 'teachers': openapi.Schema(type=openapi.TYPE_STRING), } ), responses={ 200: openapi.Response("OK- Successful POST Request"), 401: openapi.Response("Unauthorized- Authentication credentials were not provided. || Token Missing or Session Expired"), 422: openapi.Response("Unprocessable Entity- Make sure that all the required field values are passed"), 500: openapi.Response("Internal Server Error- Error while processing the POST Request Function.") } ) def post(self, request): data = request.data org_id = data.get('org_id',"") teachers = str(data.get("teachers", "[]")) if not org_id: errors = [ 'org_id is not passed' ] return Response({'details': errors}, status.HTTP_400_BAD_REQUEST) organizations = self.queryset.filter(Q(user__id=request.user.id) & Q(org_id=org_id)) if not len(organizations): errors = [ 'Invalid org_id' ] return Response({'details': errors}, status.HTTP_400_BAD_REQUEST) if len(teachers) < 3: errors = [ "teachers not passed or teachers format should be like this. [1, 2, 3] where 1, 2 and 3 are teacher ID's" ] return Response({'details': errors}, status.HTTP_400_BAD_REQUEST) try: teachers = teachers.replace(" ", "") teachers = teachers[1:len(teachers) - 1].split(",") teachers = [int(i) for i in teachers] except Exception as e: errors = [ "teachers format should be like this. [1, 2, 3] where 1, 2 and 3 are teacher ID's", str(e) ] return Response({'details': errors}, status.HTTP_400_BAD_REQUEST) teach_qs = teachers_models.Teacher.objects.filter(is_active=True) valid_teachers = [] for i in teachers: temp_teach = teach_qs.filter(id=i) if not len(temp_teach): errors = [ 'Invalid teacher ID' ] return Response({'details': errors}, status.HTTP_400_BAD_REQUEST) temp_teach = temp_teach[0] if not temp_teach.requested_organization or temp_teach.requested_organization.user.id != request.user.id: errors = [ 'already accepted requests' ] return Response({'details': errors}, status.HTTP_400_BAD_REQUEST) valid_teachers.append(temp_teach) for temp_teach in valid_teachers: temp_teach.organization = temp_teach.requested_organization temp_teach.requested_organization = None temp_teach.save() return Response({"details": ["Successfully accepted all provided requests."]}, status.HTTP_200_OK)
class ProjectViewSet(FiltersMixin, viewsets.ModelViewSet): """Project ModelViewSet Filters: is_demo """ queryset = Project.objects.all() serializer_class = ProjectSerializer filter_backends = (filters.OrderingFilter,) filter_mappings = {"is_demo": "is_demo"} @swagger_auto_schema(operation_summary="Keep relabel alive.") @action(detail=True, methods=["post"]) def relabel_keep_alive(self, request, pk=None) -> Response: """relabel_keep_alive.""" queryset = self.get_queryset() instance = drf_get_object_or_404(queryset, pk=pk) instance.relabel_expired_time = timezone.now() + datetime.timedelta( seconds=PROJECT_RELABEL_TIME_THRESHOLD ) instance.save(update_fields=["relabel_expired_time"]) serializer = ProjectSerializer(instance) return Response(serializer.data) @swagger_auto_schema( operation_summary="Get training performace from Custom Vision.", responses={ "200": ProjectPerformanesSerializer, "400": MSStyleErrorResponseSerializer, }, ) @action(detail=True, methods=["get"]) def train_performance(self, request, pk=None) -> Response: """train_performance.""" queryset = self.get_queryset() project_obj = drf_get_object_or_404(queryset, pk=pk) if project_obj.setting is None: raise ProjectWithoutSettingError if not project_obj.setting.is_trainer_valid: raise SettingCustomVisionAccessFailed trainer = project_obj.setting.get_trainer_obj() customvision_project_id = project_obj.customvision_id res_data: dict = {"iterations": []} def _parse(iteration, iteration_name: str): """_parse. Args: iteration: """ iteration_id = iteration.id iteration = iteration.as_dict() iteration_status = iteration["status"] if iteration_status == "Completed": performance = trainer.get_iteration_performance( customvision_project_id, iteration["id"] ).as_dict() precision = performance["precision"] recall = performance["recall"] mAP = performance["average_precision"] else: precision = 0.0 recall = 0.0 mAP = 0.0 return { "iteration_name": iteration_name, "iteration_id": iteration_id, "status": iteration_status, "precision": precision, "recall": recall, "mAP": mAP, } if project_obj.is_demo: iteration_data = { "iteration_name": "demo", "iteration_id": "demo_iteration_id", "status": "ok", "precision": 1, "recall": 0.0, "mAP": 0.0, } iteration_serialzer = IterationPerformanceSerializer(data=iteration_data) if iteration_serialzer.is_valid(raise_exception=True): res_data["iterations"].append(iteration_serialzer.data) project_performance_serializer = ProjectPerformanesSerializer(data=res_data) else: iterations = trainer.get_iterations(customvision_project_id) for i in range(min(2, len(iterations))): iteration_data = _parse( iterations[i], iteration_name=("new" if i == 0 else "previous") ) iteration_serialzer = IterationPerformanceSerializer( data=iteration_data ) if iteration_serialzer.is_valid(raise_exception=True): res_data["iterations"].append(iteration_serialzer.data) project_performance_serializer = ProjectPerformanesSerializer(data=res_data) if project_performance_serializer.is_valid(raise_exception=True): return Response(data=project_performance_serializer.data) @swagger_auto_schema( operation_summary="reset project", manual_parameters=[ openapi.Parameter( "project_name", openapi.IN_QUERY, type=openapi.TYPE_STRING, description="Project name", required=True, ) ], responses={"200": ProjectSerializer, "400": MSStyleErrorResponseSerializer}, ) @action(detail=True, methods=["get"]) def reset_project(self, request, pk=None) -> Response: """reset_project.""" queryset = self.get_queryset() project_obj = drf_get_object_or_404(queryset, pk=pk) project_name = request.query_params.get("project_name") or None try: project_obj.reset(name=project_name) project_obj.save() # Let Signals to handle if we need to delete Part/Image serializer = ProjectSerializer(project_obj) return Response(serializer.data) except CustomVisionErrorException: raise SettingCustomVisionAccessFailed @swagger_auto_schema( operation_summary="Pull a Custom Vision project.", manual_parameters=[ openapi.Parameter( "customvision_project_id", openapi.IN_QUERY, type=openapi.TYPE_STRING, description="Custom Vision Id to Pull", ), openapi.Parameter( "partial", openapi.IN_QUERY, type=openapi.TYPE_BOOLEAN, description="partial download or not", ), ], responses={"200": SimpleOKSerializer, "400": MSStyleErrorResponseSerializer}, ) @action(detail=True, methods=["get"]) def pull_cv_project(self, request, pk=None) -> Response: """pull_cv_project.""" queryset = self.get_queryset() project_obj = drf_get_object_or_404(queryset, pk=pk) # Check Customvision Project id customvision_project_id = request.query_params.get("customvision_project_id") logger.info("Project customvision_id: %s", {customvision_project_id}) # Check Partial try: is_partial = bool(strtobool(request.query_params.get("partial"))) except Exception: is_partial = True # Pull Custom Vision Project pull_cv_project_helper( project_id=project_obj.id, customvision_project_id=customvision_project_id, is_partial=is_partial, ) return Response({"status": "ok"}) @swagger_auto_schema( operation_summary="Train project in background.", responses={"200": SimpleOKSerializer, "400": MSStyleErrorResponseSerializer}, ) @action(detail=True, methods=["get"]) def train(self, request, pk=None) -> Response: """train.""" queryset = self.get_queryset() project_obj = drf_get_object_or_404(queryset, pk=pk) project_obj.is_trainable(raise_exception=True) TRAINING_MANAGER.add(project_id=pk) return Response({"status": "ok"})
class JoinRequestsStudent(views.APIView): serializer_class = student_serializers.StudentSerializer authentication_classes = (authentication.TokenAuthentication,) permission_classes = (permissions.IsAuthenticated,) @swagger_auto_schema( responses={ 200: openapi.Response("OK- Successful GET Request"), 401: openapi.Response("Unauthorized- Authentication credentials were not provided. || Token Missing or Session Expired"), 500: openapi.Response("Internal Server Error- Error while processing the GET Request Function.") }, manual_parameters=[ openapi.Parameter(name="dept_id", in_="query", type=openapi.TYPE_STRING), openapi.Parameter(name="sec_id", in_="query", type=openapi.TYPE_STRING), ] ) def get(self, request): query_params = self.request.query_params dept_id = query_params.get('dept_id', None) sec_id = query_params.get('sec_id',None) if not dept_id: errors = [ 'dept_id is not passed' ] return Response({'details': errors}, status.HTTP_400_BAD_REQUEST) if not sec_id: errors = [ 'sec_id is not passed' ] return Response({'details': errors}, status.HTTP_400_BAD_REQUEST) departments = models.Department.objects.filter(Q(user__id=request.user.id) & Q(department_id=dept_id)) if not len(departments): errors = [ 'Invalid dept_id' ] return Response({'details': errors}, status.HTTP_400_BAD_REQUEST) students = student_models.Student.objects.filter( Q(requested_section__id = sec_id) & Q(is_active=True)& Q(requested_section__of_class__department__department_id=dept_id) ) if not len(students): errors = [ f'no request pending for this section_id: {sec_id}' ] return Response({'details': errors}, status.HTTP_400_BAD_REQUEST) serializer = student_serializers.StudentSerializer(students, many=True) return Response(serializer.data, status.HTTP_200_OK) @swagger_auto_schema( request_body = openapi.Schema( title = "Join Department request", type=openapi.TYPE_OBJECT, properties={ 'dept_id': openapi.Schema(type=openapi.TYPE_STRING), 'org_id': openapi.Schema(type=openapi.TYPE_STRING), 'students': openapi.Schema(type=openapi.TYPE_STRING), } ), responses={ 200: openapi.Response("OK- Successful POST Request"), 401: openapi.Response("Unauthorized- Authentication credentials were not provided. || Token Missing or Session Expired"), 422: openapi.Response("Unprocessable Entity- Make sure that all the required field values are passed"), 500: openapi.Response("Internal Server Error- Error while processing the POST Request Function.") } ) @validate_org @validate_dept def post(self, request, *args, **kwargs): data = request.data dept_id = data.get('dept_id',"") org_id = kwargs.get("org_id") students = str(data.get("students", "[]")) if not dept_id: errors = [ 'dept_id is not passed' ] return Response({'details': errors}, status.HTTP_400_BAD_REQUEST) if len(students) < 3: errors = [ "students not passed or students format should be like this. [1, 2, 3] where 1, 2 and 3 are student ID's" ] return Response({'details': errors}, status.HTTP_400_BAD_REQUEST) departments = models.Department.objects.filter(Q(user__id=request.user.id) & Q(department_id=dept_id)) if not len(departments): errors = [ 'Invalid dept_id' ] return Response({'details': errors}, status.HTTP_400_BAD_REQUEST) try: students = students.replace(" ", "") students = students[1:len(students) - 1].split(",") students = [int(i) for i in students] except Exception as e: errors = [ "students format should be like this. [1, 2, 3] where 1, 2 and 3 are student ID's", str(e) ] return Response({'details': errors}, status.HTTP_400_BAD_REQUEST) stud_qs = student_models.Student.objects.filter(is_active=True) valid_students = [] for i in students: temp_stud = stud_qs.filter(id=i) if not len(temp_stud): errors = [ 'Invalid student ID' ] return Response({'details': errors}, status.HTTP_400_BAD_REQUEST) temp_stud = temp_stud[0] if not temp_stud.requested_section: errors = [ 'no students in waiting list' ] return Response({'details': errors}, status.HTTP_400_BAD_REQUEST) valid_students.append(temp_stud) for temp_stud in valid_students: temp_stud.section = temp_stud.requested_section temp_stud.requested_section = None temp_stud.save() return Response({"details": ["Successfully accepted all provided requests."]}, status.HTTP_200_OK)
class AnnouncenmentViewSet(views.APIView): authentication_classes = (authentication.TokenAuthentication,) permission_classes = (permissions.IsAuthenticated,) @swagger_auto_schema( responses={ 200: openapi.Response("OK- Successful GET Request"), 401: openapi.Response("Unauthorized- Authentication credentials were not provided. || Token Missing or Session Expired"), 500: openapi.Response("Internal Server Error- Error while processing the GET Request Function.") }, manual_parameters = [ openapi.Parameter(name="id", in_="query", type=openapi.TYPE_STRING), openapi.Parameter(name="org_id", in_="query", type=openapi.TYPE_STRING), openapi.Parameter(name="start_date", in_="query", type=openapi.FORMAT_DATE), openapi.Parameter(name="end_date", in_="query", type=openapi.FORMAT_DATE), openapi.Parameter(name="is_public", in_="query", type=openapi.TYPE_BOOLEAN), ] ) def get(self, request,**kwargs): query_params = self.request.query_params id = query_params.get('id', None) org_id = query_params.get('org_id', None) start_date = query_params.get('start_date', None) end_date = query_params.get('end_date', None) is_public = query_params.get('is_public', None) qs = models.Announcement.objects.filter(is_active=True) if id: qs = qs.filter(id=int(id)) if org_id: qs = qs.filter(organization__org_id=org_id) if start_date: qs = qs.filter(date__gte=start_date) if end_date: qs = qs.filter(date__lte=end_date) if is_public: if is_public == "true": qs = qs.filter(is_public=True) if is_public == "false": qs = qs.filter(is_public=False) serializer = serializers.AnnouncementSerializer(qs, many=True) return Response({'details': serializer.data}, status.HTTP_200_OK) @swagger_auto_schema( request_body = openapi.Schema( title = "Create Announcement", type=openapi.TYPE_OBJECT, properties={ 'title': openapi.Schema(type=openapi.TYPE_STRING), 'org_id': openapi.Schema(type=openapi.TYPE_STRING), 'user_type': openapi.Schema(type=openapi.TYPE_STRING), 'from': openapi.Schema(type=openapi.TYPE_INTEGER), } ), responses={ 200: openapi.Response("OK- Successful POST Request"), 401: openapi.Response("Unauthorized- Authentication credentials were not provided. || Token Missing or Session Expired"), 422: openapi.Response("Unprocessable Entity- Make sure that all the required field values are passed"), 500: openapi.Response("Internal Server Error- Error while processing the POST Request Function.") } ) @validate_org def post(self, request, **kwargs): data = request.data title = data.get('title', None) user_type = data.get('user_type', None) From = data.get('from', None) if not title or not user_type: errors = [ 'title and user_type are required' ] return Response({'details': errors}, status.HTTP_400_BAD_REQUEST) organization = kwargs.get("organization") if not validate_user_type(user_type, organization, request.user): errors = [ 'invalid user_type options are org,dept,teacher' ] return Response({'details': errors}, status.HTTP_400_BAD_REQUEST) if user_type == 'dept': from1 = validate_from(user_type,organization,request.user, From) if from1 == False: errors = [ 'Department user is not valid' ] return Response({'details': errors}, status.HTTP_400_BAD_REQUEST) fromDetail = { "class":str(from1.title), "Departemnt":str(from1.department), } data_dict = { "user": request.user.id, "organization": organization.id, "title": str(title), "From":str(fromDetail) } if user_type == 'teacher': from1 = validate_from(user_type,organization,request.user, From) if from1 == False: errors = [ 'Teacher user is not valid' ] return Response({'details': errors}, status.HTTP_400_BAD_REQUEST) fromDetail = { "subject":str(from1), "teacher":str(request.user), } data_dict = { "user": request.user.id, "organization": organization.id, "title": str(title), "From":str(fromDetail) } if user_type == 'org': from1 = validate_from(user_type,organization,request.user, From) if from1 == False: errors = [ 'organization user is not valid' ] return Response({'details': errors}, status.HTTP_400_BAD_REQUEST) fromDetail = { "organization":str(from1), } data_dict = { "user": request.user.id, "organization": organization.id, "title": str(title), "From":str(fromDetail) } serializer = serializers.AnnouncementSerializer(data=data_dict) if serializer.is_valid(): serializer.save() msgs = [ serializer.data ] return Response({'details': msgs}, status.HTTP_200_OK) errors = [ str(serializer.errors) ] return Response({'details': errors}, status.HTTP_400_BAD_REQUEST) @swagger_auto_schema( request_body=openapi.Schema( title="Update Announcement", type=openapi.TYPE_OBJECT, properties={ 'id': openapi.Schema(type=openapi.TYPE_INTEGER), 'org_id': openapi.Schema(type=openapi.TYPE_STRING), 'title': openapi.Schema(type=openapi.TYPE_STRING), 'description': openapi.Schema(type=openapi.TYPE_STRING), 'data': openapi.Schema(type=openapi.TYPE_STRING), 'date': openapi.Schema(type=openapi.FORMAT_DATE), 'visible': openapi.Schema(type=openapi.TYPE_STRING), 'is_public': openapi.Schema(type=openapi.TYPE_BOOLEAN), 'acknowledge': openapi.Schema(type=openapi.TYPE_BOOLEAN), } ), responses={ 200: openapi.Response("OK- Successful POST Request"), 401: openapi.Response( "Unauthorized- Authentication credentials were not provided. || Token Missing or Session Expired"), 422: openapi.Response("Unprocessable Entity- Make sure that all the required field values are passed"), 500: openapi.Response("Internal Server Error- Error while processing the POST Request Function.") } ) @validate_org def put(self, request, *args, **kwargs): data = request.data id = data.get('id', None) if not id: errors = [ 'id is not passed' ] return Response({'details': errors}, status.HTTP_400_BAD_REQUEST) announcements = models.Announcement.objects.filter(Q(id=int(id)) & Q(is_active=True) & Q(user=request.user)) if not len(announcements): errors = [ 'invalid id' ] return Response({'details': errors}, status.HTTP_400_BAD_REQUEST) announcement = announcements[0] serializer = serializers.AnnouncementSerializer(instance=announcement, data=data, partial=True) if serializer.is_valid(): serializer.save() msgs = [ serializer.data ] return Response({'details': msgs}, status.HTTP_200_OK) errors = [ str(serializer.errors) ] return Response({'details': errors}, status.HTTP_400_BAD_REQUEST) @swagger_auto_schema( request_body=openapi.Schema( title="Delete Announcement", type=openapi.TYPE_OBJECT, properties={ 'id': openapi.Schema(type=openapi.TYPE_INTEGER), 'org_id': openapi.Schema(type=openapi.TYPE_STRING) } ), responses={ 200: openapi.Response("OK- Successful POST Request"), 401: openapi.Response( "Unauthorized- Authentication credentials were not provided. || Token Missing or Session Expired"), 422: openapi.Response("Unprocessable Entity- Make sure that all the required field values are passed"), 500: openapi.Response("Internal Server Error- Error while processing the POST Request Function.") } ) @validate_org def delete(self, request, *args, **kwargs): data = request.data id = data.get('id', None) if not id: errors = [ 'id is not passed' ] return Response({'details': errors}, status.HTTP_400_BAD_REQUEST) announcements = models.Announcement.objects.filter(Q(id=int(id)) & Q(is_active=True) & Q(user=request.user)) if not len(announcements): errors = [ 'invalid id' ] return Response({'details': errors}, status.HTTP_400_BAD_REQUEST) announcement = announcements[0] announcement.is_active = False announcement.save() msgs = [ "Successfully deleted announcement" ] return Response({'details': msgs}, status.HTTP_200_OK)
class Assignment(views.APIView): authentication_classes = (authentication.TokenAuthentication, ) permission_classes = (permissions.IsAuthenticated, ) @swagger_auto_schema(responses={ 200: openapi.Response("OK- Successful GET Request"), 401: openapi.Response( "Unauthorized- Authentication credentials were not provided. || Token Missing or Session Expired" ), 500: openapi.Response( "Internal Server Error- Error while processing the GET Request Function." ) }, manual_parameters=[ openapi.Parameter(name="assignment", in_="query", type=openapi.TYPE_INTEGER), openapi.Parameter(name="event", in_="query", type=openapi.TYPE_INTEGER), openapi.Parameter(name="subject", in_="query", type=openapi.TYPE_INTEGER), ]) def get(self, request): query_params = self.request.query_params assignment_id = query_params.get('assignment', None) event_id = query_params.get('event', None) subject_id = query_params.get('subject', None) qs = events_models.Assignment.objects.filter(is_active=True) if assignment_id: qs = qs.filter(id=int(assignment_id)) if event_id: qs = qs.filter(event__id=int(event_id)) if subject_id: qs = qs.filter(event__subject__id=int(subject_id)) serializer = events_serializer.AssignmentSerializer(qs, many=True) return Response(serializer.data, status.HTTP_200_OK) @swagger_auto_schema( request_body=openapi.Schema( title="Create Assignment", type=openapi.TYPE_OBJECT, properties={ 'org_id': openapi.Schema(type=openapi.TYPE_STRING), 'event': openapi.Schema(type=openapi.TYPE_INTEGER), 'title': openapi.Schema(type=openapi.TYPE_STRING), 'description': openapi.Schema(type=openapi.TYPE_STRING), 'due_date': openapi.Schema(type=openapi.FORMAT_DATETIME), }), responses={ 200: openapi.Response("OK- Successful POST Request"), 401: openapi.Response( "Unauthorized- Authentication credentials were not provided. || Token Missing or Session Expired" ), 422: openapi.Response( "Unprocessable Entity- Make sure that all the required field values are passed" ), 500: openapi.Response( "Internal Server Error- Error while processing the POST Request Function." ) }) @is_teacher @validate_event def post(self, request, *args, **kwargs): event = kwargs.get("event") if not event.type == 'AS': errors = ['Invalid event type must be AS (Assignment).'] return Response({'details': errors}, status.HTTP_400_BAD_REQUEST) already = events_models.Assignment.objects.filter(event=event) if len(already): errors = [ 'This event is already assigned to an assignment. Please create a new event.' ] return Response({'details': errors}, status.HTTP_400_BAD_REQUEST) data = json.loads(json.dumps(request.data)) title = data.get("title", "") description = data.get("description", "") due_date = data.get("due_date", "") event = kwargs.get("event") events_models.Assignment.objects.create(title=str(title), event=event, description=str(description), due_date=due_date) msgs = ['successfully created assignment'] return Response({'details': msgs}, status.HTTP_200_OK)
class RedeemCode(views.APIView): permission_classes = (permissions.AllowAny,) @swagger_auto_schema( responses={ 200: openapi.Response("OK- Successful GET Request"), 401: openapi.Response("Unauthorized- Authentication credentials were not provided. || Token Missing or Session Expired"), 500: openapi.Response("Internal Server Error- Error while processing the GET Request Function.") }, manual_parameters=[ openapi.Parameter(name="uuid", in_="query", type=openapi.TYPE_STRING), ] ) @validate_coupon_code_with_uuid def get(self, request, *args, **kwargs): coupons = kwargs.get("coupons") if coupons: serializer = coupons_serializers.CouponSerializer(coupons, many=True) coupons = serializer.data coupon = coupons[0] coupon.pop("winner_name") coupon.pop("winner_phone") coupon.pop("winner_email") coupon.pop("feedback") coupon.update({ "payment_preferences": "[]" }) data = { "coupons": serializer.data, } return response.Response(data, status.HTTP_200_OK) errors = { 'message': 'Code is not available', } return response.Response(errors, status.HTTP_400_BAD_REQUEST) @swagger_auto_schema( request_body = openapi.Schema( title = "Create Coupon", type=openapi.TYPE_OBJECT, properties={ 'winner_name': openapi.Schema(type=openapi.TYPE_STRING), 'winner_phone': openapi.Schema(type=openapi.TYPE_STRING), 'winner_email': openapi.Schema(type=openapi.TYPE_STRING), 'payment_preferences': openapi.Schema(type=openapi.TYPE_STRING), 'feedback': openapi.Schema(type=openapi.TYPE_STRING), } ), responses={ 200: openapi.Response("OK- Successful POST Request"), 401: openapi.Response("Unauthorized- Authentication credentials were not provided. || Token Missing or Session Expired"), 422: openapi.Response("Unprocessable Entity- Make sure that all the required field values are passed"), 500: openapi.Response("Internal Server Error- Error while processing the POST Request Function.") }, manual_parameters=[ openapi.Parameter(name="uuid", in_="query", type=openapi.TYPE_STRING), ] ) def post(self, request, *args, **kwargs): query_params = self.request.query_params uuid = query_params.get('uuid', "") data = request.data winner_name = data.get("winner_name", "") winner_email = data.get("winner_email", "") winner_phone = data.get("winner_phone", "") feedback = data.get("feedback", "") payment_preferences = data.get("payment_preferences", "[]") if not winner_name: errors = { 'message': 'Name is required', } return response.Response(errors, status.HTTP_400_BAD_REQUEST) if not winner_phone: errors = { 'message': 'Mobile number is required', } return response.Response(errors, status.HTTP_400_BAD_REQUEST) if not winner_email: errors = { 'message': 'E-mail is required', } return response.Response(errors, status.HTTP_400_BAD_REQUEST) coupons = coupons_models.Coupon.objects.filter( Q(uuid=uuid) & Q(is_available=True) & Q(is_active=True) ) if not len(coupons): errors = { 'message': 'Invalid code', } return response.Response(errors, status.HTTP_400_BAD_REQUEST) coupon = coupons[0] if coupon.redeemed: already = coupons_models.OtherResponses.objects.filter( Q(coupon__id=coupon.id) & Q(winner_name=winner_name) & Q(winner_phone=winner_phone) & Q(winner_email=winner_email) & Q(coupon__id=coupon.id) ) if not already.exists(): serializer = coupons_serializers.OtherResponsesSerializer(data={ "coupon": coupon.id, "winner_name": winner_name, "winner_phone": winner_phone, "winner_email": winner_email, "payment_preferences": payment_preferences, "feedback": feedback, }) if not serializer.is_valid(): errors = {'message': str(serializer.errors)} return response.Response(errors, status.HTTP_400_BAD_REQUEST) serializer.save() errors = {'message': f'Coupon is already redeemed by {coupon.winner_name}'} return response.Response(errors, status.HTTP_400_BAD_REQUEST) data = { "winner_name": winner_name, "winner_phone": winner_phone, "winner_email": winner_email, "payment_preferences": payment_preferences, "feedback": feedback, "redeemed": True, "redeemed_at": datetime.datetime.now(), } serializer = coupons_serializers.CouponSerializer(instance=coupon, data=data, partial=True) if serializer.is_valid(): serializer.save() details = { "message": "Coupon Successfully redeemed.", } return response.Response(details, status.HTTP_201_CREATED) errors = { 'message': str(serializer.errors), } return response.Response(errors, status.HTTP_400_BAD_REQUEST)