class SnippetList(generics.ListCreateAPIView):
"""SnippetList classdoc"""
queryset = Snippet.objects.all()
serializer_class = SnippetSerializer
parser_classes = (FormParser, CamelCaseJSONParser, FileUploadParser)
renderer_classes = (CamelCaseJSONRenderer, )
swagger_schema = CamelCaseOperationIDAutoSchema
def perform_create(self, serializer):
serializer.save(owner=self.request.user)
def post(self, request, *args, **kwargs):
"""post method docstring"""
return super(SnippetList, self).post(request, *args, **kwargs)
@swagger_auto_schema(
operation_id="snippets_delete_bulk",
request_body=openapi.Schema(
type=openapi.TYPE_OBJECT,
properties={
"body":
openapi.Schema(
type=openapi.TYPE_STRING,
description=
"this should not crash (request body on DELETE method)",
)
},
),
)
def delete(self, *args, **kwargs):
"""summary from docstring
class JoinDepartment(views.APIView):
authentication_classes = (authentication.TokenAuthentication,)
permission_classes = (permissions.IsAuthenticated,)
serializer_class = serializers.DepartmentSerializer
@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),
}
),
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", 0)
organization = kwargs.get("organization")
if not organization.accepting_req:
errors = [
'This organization is not accepting requests currently.'
]
return Response({'details': errors}, status.HTTP_400_BAD_REQUEST)
department = kwargs.get("department")
if not department.organization == organization:
errors = [
'Invalid dept_id'
]
return Response({'details': errors}, status.HTTP_400_BAD_REQUEST)
if request.user in department.requesting_users.all() or request.user == department.user:
errors = [
'Request already sent'
]
return Response({'details': errors}, status.HTTP_400_BAD_REQUEST)
department.requesting_users.add(request.user.id)
department.save()
msgs = [
'Join request sent'
]
return Response({'details': msgs}, status.HTTP_200_OK)
class FCMDeviceViewSet(viewsets.ModelViewSet):
queryset = FCMDevice.objects.all().order_by('-id')
serializer_class = serializers.FCMDeviceSerializer
permission_classes = []
@swagger_auto_schema(request_body=openapi.Schema(
type=openapi.TYPE_OBJECT,
properties={
'fcm_registration_token':
openapi.Schema(type=openapi.TYPE_STRING, description='string'),
'employee_id':
openapi.Schema(type=openapi.TYPE_INTEGER, description='integer'),
'device_type':
openapi.Schema(type=openapi.TYPE_STRING, description='string'),
}))
def create(self, request):
fcm_registration_token = request.data.get('fcm_registration_token',
None)
device_type = request.data.get('device_type', None)
employee_id = request.data.get('employee_id', None)
if not fcm_registration_token:
raise ValidationError(
{"message": "fcm_registration_token is required field"})
if not device_type:
raise ValidationError({"message": "device_type is required field"})
if device_type not in ['web', 'android', 'ios']:
raise ValidationError(
{"message": "Invalid device_type is required field"})
if not employee_id:
raise ValidationError({"message": "employee_id is required field"})
if employee_id:
employee = Employee.objects.filter(id=employee_id,
deleted_at=None).first()
if not employee:
raise ValidationError({"message": "Employee Does Not Exists."})
fcm_obj = FCMDevice.objects.filter(user=employee.user).first()
if fcm_obj:
fcm_obj.registration_id = fcm_registration_token
fcm_obj.device_type = device_type
fcm_obj.active = True
fcm_obj.save()
return JsonResponse({"status": "True"})
device_data = {
"registration_id": fcm_registration_token,
"user": employee.user.id,
"type": device_type,
"active": True
}
serializer = serializers.FCMDeviceSerializer(data=device_data)
if serializer.is_valid():
serializer.save()
return JsonResponse(serializer.data)
raise ValidationError({"message": "Invalid arguments"})
class SubmittedAssignmentFile(views.APIView):
authentication_classes = (authentication.TokenAuthentication, )
permission_classes = (permissions.IsAuthenticated, )
@swagger_auto_schema(
request_body=openapi.Schema(
title="Add Submitted Assignment files",
type=openapi.TYPE_OBJECT,
properties={
'org_id': openapi.Schema(type=openapi.TYPE_STRING),
'submitted_assignment':
openapi.Schema(type=openapi.TYPE_INTEGER),
'file': openapi.Schema(type=openapi.TYPE_FILE),
}),
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_student
@validate_submitted_assignment
def post(self, request, *args, **kwargs):
data = request.data
file = data.get("file", None)
submitted_assignment = kwargs.get("submitted_assignment")
if not file:
return Response({'details': ['file is required']},
status.HTTP_400_BAD_REQUEST)
data_dict = {"submission": submitted_assignment.id, "file": file}
serializer = events_serializer.SubmittedAssignmentFileSerializer(
data=data_dict)
if not serializer.is_valid():
return Response({'details': [str(serializer.errors)]},
status.HTTP_400_BAD_REQUEST)
serializer.save()
msgs = ['successfully saved assignment file']
return Response({'details': msgs}, status.HTTP_200_OK)
class CompleteOrderViewSet(views.APIView):
authentication_classes = (authentication.TokenAuthentication, )
permission_classes = (permissions.IsAuthenticated, )
@swagger_auto_schema(
request_body=openapi.Schema(
title="Complete Order",
type=openapi.TYPE_OBJECT,
properties={
'order_uuid': 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_order_with_uuid
def post(self, request, *args, **kwargs):
order = kwargs.get("order")
order.ordered = True
order.ordered_at = datetime.datetime.now()
order.save()
if order.discount_code:
discount = order.discount_code
discount.copies -= 1
if discount.copies < 1:
discount.is_available = False
discount.save()
serializer = orders_serializers.OrderSerializer(order)
return response.Response(serializer.data, status.HTTP_200_OK)
details = {
"message": "Order completed successfully",
"order": serializer.data
}
return response.Response(details, status.HTTP_201_CREATED)
class RefreshTokenView(views.APIView):
"""
API endpoint that allows users to get access token from refresh token.
"""
response_schema_dict = {
"200":
openapi.Response(description="Success",
examples={"application/json": {
"access": "string",
}}),
"400":
openapi.Response(description="Failed",
examples={
"application/json": {
"message": "Token is invalid or expired."
}
}),
"400: Bad":
openapi.Response(
description="Failed",
examples={"application/json": {
"message": "Token is required."
}}),
}
@swagger_auto_schema(method='post',
request_body=openapi.Schema(
type=openapi.TYPE_OBJECT,
properties={
'refresh':
openapi.Schema(type=openapi.TYPE_STRING,
description='string')
}),
responses=response_schema_dict)
@action(detail=False, methods=['POST'])
def post(self, request, *args, **kwargs):
refresh = request.data.get('refresh', None)
if refresh:
try:
refresh_token = RefreshToken(refresh)
except:
raise ValidationError(
{"message": "Refresh Token is invalid or expired."})
return JsonResponse({
"refresh": str(refresh_token),
"access": str(refresh_token.access_token),
"x-karza-key": str(settings.CORE_X_KARZA_KEY)
})
raise ValidationError({"message": "Refresh Token is required."})
def test_optional_return_type(py_type, expected_type):
class OptionalMethodSerializer(serializers.Serializer):
x = serializers.SerializerMethodField()
def get_x(self, instance):
pass
# Add the type annotation here in order to avoid a SyntaxError in py27
get_x.__annotations__["return"] = typing.Optional[py_type]
class OptionalMethodViewSet(viewsets.ViewSet):
@swagger_auto_schema(
responses={200: openapi.Response("OK", OptionalMethodSerializer)})
def retrieve(self, request, pk=None):
return Response({"optional": None})
router = routers.DefaultRouter()
router.register(r"optional", OptionalMethodViewSet,
**_basename_or_base_name("optional"))
generator = OpenAPISchemaGenerator(
info=openapi.Info(title="Test optional parameter",
default_version="v1"),
patterns=router.urls,
)
swagger = generator.get_schema(None, True)
property_schema = swagger["definitions"]["OptionalMethod"]["properties"][
"x"]
assert property_schema == openapi.Schema(title="X",
type=expected_type,
readOnly=True)
def test_choice_field(choices, expected_type):
class DetailSerializer(serializers.Serializer):
detail = serializers.ChoiceField(choices)
class DetailViewSet(viewsets.ViewSet):
@swagger_auto_schema(
responses={200: openapi.Response("OK", DetailSerializer)})
def retrieve(self, request, pk=None):
return Response({"detail": None})
router = routers.DefaultRouter()
router.register(r"details", DetailViewSet,
**_basename_or_base_name("details"))
generator = OpenAPISchemaGenerator(
info=openapi.Info(title="Test generator", default_version="v1"),
patterns=router.urls,
)
swagger = generator.get_schema(None, True)
property_schema = swagger["definitions"]["Detail"]["properties"]["detail"]
assert property_schema == openapi.Schema(title="Detail",
type=expected_type,
enum=choices)
class ZeroPaymentViewSet(views.APIView):
authentication_classes = (authentication.TokenAuthentication, )
permission_classes = (permissions.IsAuthenticated, )
@swagger_auto_schema(
request_body=openapi.Schema(
title="Complete Zero Order",
type=openapi.TYPE_OBJECT,
properties={
'uuid': openapi.Schema(type=openapi.TYPE_STRING),
}),
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."
)
})
@validate_order
def post(self, request, *args, **kwargs):
order = kwargs.get("order")
if not order.user == request.user or int(order.total_amount) != 0:
errors = {
'message': 'Invalid request',
}
return response.Response(errors, status.HTTP_400_BAD_REQUEST)
order.ordered_at = datetime.datetime.now()
order.ordered = True
order.save()
if order.discount_code:
discount_code = order.discount_code
discount_code.copies -= 1
discount_code.save()
details = {"message": "Order completed successfully"}
return response.Response(details, status.HTTP_200_OK)
class UserProfileViewSet(viewsets.ModelViewSet):
serializer_class = serializers.UserProfileSerializer
queryset = models.UserProfile.objects.all()
permission_classes = [permissions.IsAuthenticatedOrReadOnly]
@swagger_auto_schema(
request_body=openapi.Schema(
type=openapi.TYPE_OBJECT,
required=['username', 'password'],
properties={
'username':
openapi.Schema(type=openapi.TYPE_STRING,
description='用户名(或手机号)'),
'password':
openapi.Schema(type=openapi.TYPE_STRING),
}),
responses={'201': openapi.Schema(type=openapi.TYPE_OBJECT)},
operation_summary='登录或注册')
@action(detail=False,
methods=['POST'],
permission_classes=[permissions.AllowAny])
def sign_up(self, request):
"""登录或注册功能, 如果用户名和密码存在则登录, 反之则创建新用户, 两种操作都会返回一个token"""
username = request.data.get('username')
password = request.data.get('password')
if User.objects.filter(username=username).exists():
# user_obj: User = User.objects.get(username=username)
user_obj: User = authenticate(request,
username=username,
password=password)
if user_obj is None:
return Response({
'successful': False,
'detail': '登录失败，用户名或密码错误'
})
else:
user_obj: User = User.objects.create_user(username=username,
password=password)
token, created = Token.objects.get_or_create(user=user_obj)
return Response({'successful': True, 'token': token.key})
class EssayQuestion(views.APIView):
serializer_class = serializers.EssayQuestionSerializer
# authentication_classes = (authentication.TokenAuthentication,)
permission_classes = (permissions.AllowAny, )
@swagger_auto_schema(
request_body=openapi.Schema(
title="Essay question",
type=openapi.TYPE_OBJECT,
properties={
'content': openapi.Schema(type=openapi.TYPE_STRING),
'explanation': openapi.Schema(type=openapi.TYPE_STRING),
'category': openapi.Schema(type=openapi.TYPE_INTEGER),
'sub-category': openapi.Schema(type=openapi.TYPE_INTEGER),
'quiz': 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
quiz = data.get('quiz')
category = data.get('category')
sub_category = data.get('sub_category', "")
content = data.get('content', "")
explanation = data.get('explanation', "")
data_dict = {
"content": content,
"quiz": [quiz],
"category": category,
"sub_category": sub_category,
"explanation": explanation,
}
serializer = self.serializer_class(data=data_dict)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status.HTTP_201_CREATED)
return Response({'details': serializer.errors},
status.HTTP_400_BAD_REQUEST)
class UserList(APIView):
"""UserList cbv classdoc"""
@swagger_auto_schema(
query_serializer=UserListQuerySerializer,
responses={200: UserSerializerrr(many=True)},
tags=["Users"],
)
def get(self, request):
queryset = User.objects.all()
serializer = UserSerializerrr(queryset, many=True)
return Response(serializer.data)
@swagger_auto_schema(
operation_description="apiview post description override",
request_body=openapi.Schema(
type=openapi.TYPE_OBJECT,
required=["username"],
properties={"username": openapi.Schema(type=openapi.TYPE_STRING)},
),
security=[],
tags=["Users"],
)
def post(self, request):
serializer = UserSerializerrr(request.data)
serializer.is_valid(raise_exception=True)
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
@swagger_auto_schema(
operation_id="users_dummy",
operation_description="dummy operation",
tags=["Users"],
)
def patch(self, request):
pass
def test_json_field():
class TestJSONFieldSerializer(serializers.Serializer):
json = serializers.JSONField()
class JSONViewSet(viewsets.ModelViewSet):
serializer_class = TestJSONFieldSerializer
router = routers.DefaultRouter()
router.register(r"jsons", JSONViewSet, **_basename_or_base_name("jsons"))
generator = OpenAPISchemaGenerator(
info=openapi.Info(title="Test json field generator",
default_version="v1"),
patterns=router.urls,
)
swagger = generator.get_schema(None, True)
property_schema = swagger["definitions"]["TestJSONField"]["properties"][
"json"]
assert property_schema == openapi.Schema(title="Json",
type=openapi.TYPE_OBJECT)
def test_nested_choice_in_array_field(choices, field, expected_type):
# Create a model class on the fly to avoid warnings about using the several
# model class name several times
model_class = type(
"%sModel" % field.__name__,
(fake_models.FakeModel, ),
{
"array":
postgres_fields.ArrayField(
field(choices=((i, "choice %s" % i) for i in choices))),
"__module__":
"test_models",
},
)
class ArraySerializer(serializers.ModelSerializer):
class Meta:
model = model_class
fields = ("array", )
class ArrayViewSet(viewsets.ModelViewSet):
serializer_class = ArraySerializer
router = routers.DefaultRouter()
router.register(r"arrays", ArrayViewSet,
**_basename_or_base_name("arrays"))
generator = OpenAPISchemaGenerator(
info=openapi.Info(title="Test array model generator",
default_version="v1"),
patterns=router.urls,
)
swagger = generator.get_schema(None, True)
property_schema = swagger["definitions"]["Array"]["properties"]["array"][
"items"]
assert property_schema == openapi.Schema(title="Array",
type=expected_type,
enum=choices)
class SmsOtpView(views.APIView):
"""
API endpoint that allows users to send sms
"""
permission_classes = []
response_schema_dict = {
"200":
openapi.Response(
description="Success",
examples={
"application/json": {
"body":
"Hello! Your OTP for login is 154622. And this OTP is valid for 2 minutes only.",
"sender":
"NSQURD",
"type":
"OTP",
"source":
"API",
"id":
"83fd53e3-e183-401e-8411-9a3d2e409c02",
"createdDateTime":
"2020-12-12 12:22:11+00:00",
"totalCount":
1,
"data": [{
"message_id": "83fd53e3-e183-401e-8411-9a3d2e409c02:1",
"recipient": "917007501490"
}],
"error": {},
"otp":
"154622"
}
}),
}
@swagger_auto_schema(method='post',
request_body=openapi.Schema(
type=openapi.TYPE_OBJECT,
properties={
'phone':
openapi.Schema(type=openapi.TYPE_STRING,
description='string'),
'template':
openapi.Schema(type=openapi.TYPE_STRING,
description='string'),
}),
responses=response_schema_dict)
@action(detail=False, methods=['POST'])
def post(self, request, *args, **kwargs):
phone = request.data.get('phone', None)
template = request.data.get('template', None)
if not phone:
raise ValidationError({"message": "Phone is Required."})
if not template:
raise ValidationError({"message": "Template is Required."})
user = User.objects.filter(username=phone).first()
# get otp and send to the user
otp = utilities.generate_random_number(6)
data = call(phone, template, otp)
data['otp'] = str(otp) if otp else ""
if user:
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(data)
class Event(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="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
event_id = query_params.get('event', None)
subject_id = query_params.get('subject', None)
qs = events_models.Event.objects.filter(is_active=True)
if event_id:
qs = qs.filter(id=event_id)
if subject_id:
qs = qs.filter(subject__id=int(subject_id))
serializer = events_serializer.EventSerializer(qs, many=True)
return Response(serializer.data, status.HTTP_200_OK)
@swagger_auto_schema(
request_body=openapi.Schema(
title="Create event",
type=openapi.TYPE_OBJECT,
properties={
'org_id': openapi.Schema(type=openapi.TYPE_STRING),
'type': openapi.Schema(type=openapi.TYPE_STRING),
'data': openapi.Schema(type=openapi.TYPE_OBJECT),
'subject_id': openapi.Schema(type=openapi.TYPE_NUMBER),
'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
def post(self, request, *args, **kwargs):
data = json.loads(json.dumps(request.data))
event_type = data.get("type", "")
event_data = data.get("data", "")
subject_id = data.get("subject_id", "")
date = data.get("date", "")
if not event_data or not event_type or not subject_id or not data:
errors = [
'event_data, event_type, subject_id and data are required'
]
return Response({'details': errors}, status.HTTP_400_BAD_REQUEST)
subjects = subject_models.Subject.objects.filter(is_active=True,
id=subject_id)
if not len(subjects):
errors = ['Invalid subjects_id']
return Response({'details': errors}, status.HTTP_400_BAD_REQUEST)
subject = subjects[0]
EVENT_TYPES_keys = [i[0] for i in events_models.EVENT_TYPES]
if not str(event_type) in EVENT_TYPES_keys:
errors = [f"invalid type, options are {EVENT_TYPES_keys}"]
return Response({'details': errors}, status.HTTP_400_BAD_REQUEST)
events_models.Event.objects.create(data=str(event_data),
subject=subject,
date=date,
type=str(event_type))
msgs = ['successfully created daily class']
return Response({'details': msgs}, status.HTTP_200_OK)
class SubmittedAssignment(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="assignment",
in_="query",
type=openapi.TYPE_INTEGER),
openapi.Parameter(name="submitted_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),
])
@validate_org
@is_teacher
def get(self, request, *args, **kwargs):
query_params = self.request.query_params
submitted_assignment_id = query_params.get('assignment', None)
assignment_id = query_params.get('assignment', None)
event_id = query_params.get('event', None)
subject_id = query_params.get('subject', None)
qs = events_models.SubmittedAssignment.objects.filter(is_active=True)
if submitted_assignment_id:
qs = qs.filter(id=int(submitted_assignment_id))
if assignment_id:
qs = qs.filter(assignment__id=int(assignment_id))
if event_id:
qs = qs.filter(assignment__event__id=int(event_id))
if subject_id:
qs = qs.filter(assignment__event__subject__id=int(subject_id))
serializer = events_serializer.SubmittedAssignmentSerializer(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),
'assignment': openapi.Schema(type=openapi.TYPE_INTEGER),
'is_completed': 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
@validate_assignment
@is_student
def post(self, request, *args, **kwargs):
data = request.data
student = kwargs.get("student")
assignment = kwargs.get("assignment")
is_completed = data.get('is_completed', False)
data_dict = {
"assignment": assignment.id,
"student": student.id,
"is_completed": True if is_completed else False
}
if is_completed:
data_dict.update({"submitted_at": datetime.datetime.now()})
serializer = events_serializer.SubmittedAssignmentSerializer(
data=data_dict)
if not serializer.is_valid():
return Response({'details': [str(serializer.errors)]},
status.HTTP_400_BAD_REQUEST)
serializer.save()
msgs = ['successfully submitted assignment']
return Response({'details': msgs}, 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),
'submitted_assignment':
openapi.Schema(type=openapi.TYPE_INTEGER),
'assignment': openapi.Schema(type=openapi.TYPE_INTEGER),
'is_completed': 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
@validate_submitted_assignment
@is_student
def put(self, request, *args, **kwargs):
data = request.data
student = kwargs.get("student")
submitted_assignment = kwargs.get("submitted_assignment")
is_completed = data.get('is_completed', False)
data_dict = {"is_completed": True if is_completed else False}
if is_completed:
data_dict.update({"submitted_at": datetime.datetime.now()})
submitted_assignment = kwargs.get("submitted_assignment")
if not submitted_assignment.student == student:
return Response({'details': ["Invalid request"]},
status.HTTP_400_BAD_REQUEST)
serializer = events_serializer.SubmittedAssignmentSerializer(
submitted_assignment, data=data_dict, 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)
class CompanyViewSet(viewsets.ModelViewSet):
"""
API endpoint that allows users to be viewed or edited.
"""
queryset = Company.objects.all().order_by('-id')
serializer_class = CompanySerializer
permission_classes = []
response_schema_dict = {
"200":
openapi.Response(description="source=app and fieldset=autocomplete",
examples={
"application/json": {
"count": 1,
"next": "",
"previous": "",
"results": [{
"id": 1,
"name": "string"
}]
}
}),
"200:ok":
openapi.Response(
description="source == 'web' and fieldset == 'principal'",
examples={
"application/json": {
"count":
1,
"next":
"",
"previous":
"",
"results": [{
"id": 1,
"name": "string",
"rid": "53973782-0198-4511-9d5e-ab11b50f780e"
}]
}
}),
}
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)
domain_param = openapi.Parameter('domain',
openapi.IN_QUERY,
description="Enter domain 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)
name_param = openapi.Parameter('name',
openapi.IN_QUERY,
description="Enter company name",
type=openapi.TYPE_STRING)
qr_id_param = openapi.Parameter('qr_id',
openapi.IN_QUERY,
description="Enter company qr_id",
type=openapi.TYPE_STRING)
@swagger_auto_schema(manual_parameters=[
source_param, fieldset_param, domain_param, longitude_param,
latitude_param, name_param, qr_id_param
],
responses=response_schema_dict)
def list(self, request, *args, **kwargs):
queryset = Company.objects.all().order_by('-id')
name = self.request.query_params.get('name', None)
qr_id = self.request.query_params.get('qr_id', None)
source = self.request.query_params.get('source', None)
fieldset = self.request.query_params.get('fieldset', None)
domain = self.request.query_params.get('domain', None)
if source == 'app' and fieldset == 'autocomplete':
page = self.paginate_queryset(queryset)
serializer = CompanyAutoCompleteListSerializer(page, many=True)
response = self.get_paginated_response(serializer.data)
return response
if source == 'web' and fieldset == 'principal':
queryset = queryset.filter(category=1)
page = self.paginate_queryset(queryset)
serializer = PrincipalCompanyListSerializer(page, many=True)
response = self.get_paginated_response(serializer.data)
return response
if source == 'web' and fieldset == 'name':
queryset = queryset.filter(name=name)
page = self.paginate_queryset(queryset)
serializer = CompanySerializer(page, many=True)
response = self.get_paginated_response(serializer.data)
return response
if source == 'app' and fieldset == 'domain':
if not domain:
raise ValidationError({"message": "Domain Param is required"})
queryset = queryset.filter(domain=domain)
page = self.paginate_queryset(queryset)
serializer = CompanyDomainListSerializer(page, many=True)
response = self.get_paginated_response(serializer.data)
return response
if name is not None:
queryset = queryset.filter(name__icontains=name)
if qr_id:
queryset = queryset.filter(qr_id=qr_id)
page = self.paginate_queryset(queryset)
serializer = CompanySerializer(page, many=True)
response = self.get_paginated_response(serializer.data)
return response
@swagger_auto_schema(request_body=openapi.Schema(
type=openapi.TYPE_OBJECT,
properties={
'employer_set':
openapi.Schema(type=openapi.TYPE_ARRAY,
items=openapi.TYPE_OBJECT,
description='string'),
'name':
openapi.Schema(type=openapi.TYPE_STRING, description='string'),
'office_address':
openapi.Schema(type=openapi.TYPE_STRING, description='string'),
'pincode':
openapi.Schema(type=openapi.TYPE_STRING, description='string'),
'gstin':
openapi.Schema(type=openapi.TYPE_STRING, description='string'),
'average_monthly_salary_payout':
openapi.Schema(type=openapi.TYPE_INTEGER, description='integer'),
'monthly_salary_day':
openapi.Schema(type=openapi.TYPE_INTEGER, description='integer'),
'industry':
openapi.Schema(type=openapi.TYPE_INTEGER, description='integer'),
'employee_range':
openapi.Schema(type=openapi.TYPE_INTEGER, description='integer'),
'city':
openapi.Schema(type=openapi.TYPE_INTEGER, description='integer'),
'state':
openapi.Schema(type=openapi.TYPE_INTEGER, description='integer'),
}))
def create(self, request):
company_data = request.data
employers_data = company_data.get('employer_set')
# employers_data data validation
for employer in employers_data:
username = employer.get('username', None)
if username:
user_object = User.objects.filter(username=username).first()
if user_object:
raise ValidationError(
{"message": "User already exists with this username."})
department = employer.get('department', None)
if department:
try:
Department.objects.get(id=department)
except:
raise ValidationError(
{"message": "department does not exist."})
designation = employer.get('designation', None)
if designation:
try:
Designation.objects.get(id=designation)
except:
raise ValidationError(
{"message": "designation does not exist."})
# company data validation
company_name = company_data.get('name', None)
industry = company_data.get('industry', None)
employee_range = company_data.get('employee_range', None)
office_address = company_data.get('office_address', None)
city = company_data.get('city', None)
state = company_data.get('state', None)
pincode = company_data.get('pincode', None)
gstin = company_data.get('gstin', None)
if not company_name:
raise ValidationError({"message": "company_name is required."})
if not industry:
raise ValidationError({"message": "industry is required."})
if not employee_range:
raise ValidationError({"message": "employee_range is required."})
if not office_address:
raise ValidationError({"message": "office_address is required."})
if not city:
raise ValidationError({"message": "city is required."})
if not state:
raise ValidationError({"message": "state is required."})
if not pincode:
raise ValidationError({"message": "pincode is required."})
if not gstin:
raise ValidationError({"message": "gstin is required."})
if company_name:
company = Company.objects.filter(name=company_name)
if len(company) > 0:
raise ValidationError(
{"message": "company exists with the same name"})
if industry:
try:
Industry.objects.get(id=industry)
except:
raise ValidationError({"message": "Industry does not exist."})
if employee_range:
try:
EmployeeRange.objects.get(id=employee_range)
except:
raise ValidationError(
{"message": "employee_range does not exist."})
if city:
try:
City.objects.get(id=city)
except:
raise ValidationError({"message": "city does not exist."})
if state:
try:
State.objects.get(id=state)
except:
raise ValidationError({"message": "state does not exist."})
serializer = CompanySerializer(data=company_data)
if serializer.is_valid():
serializer.save()
return JsonResponse(serializer.data)
raise ValidationError({"message": "Invalid company arguments"})
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 AssignTeacher(views.APIView):
authentication_classes = (authentication.TokenAuthentication, )
permission_classes = (permissions.IsAuthenticated, )
@swagger_auto_schema(
request_body=openapi.Schema(
title="Assign class teacher to section",
type=openapi.TYPE_OBJECT,
properties={
'teacher': openapi.Schema(type=openapi.TYPE_INTEGER),
'section': 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
teacher = data.get('teacher', None)
section = data.get('section', None)
if not teacher or not section:
errors = ["teacher and sction ID's are required"]
return Response({'details': errors}, status.HTTP_400_BAD_REQUEST)
sections = models.Section.objects.filter(
Q(id=int(section)) & Q(is_active=True))
if not len(sections):
errors = ["Invalid sction id"]
return Response({'details': errors}, status.HTTP_400_BAD_REQUEST)
section = sections[0]
teachers = teachers_models.Teacher.objects.filter(
Q(id=int(teacher)) & Q(is_active=True))
if not len(teachers):
errors = ["Invalid teacher id"]
return Response({'details': errors}, status.HTTP_400_BAD_REQUEST)
teacher = teachers[0]
if section.class_teacher == teacher:
errors = ["teacher is already assigned to this section"]
return Response({'details': errors}, status.HTTP_400_BAD_REQUEST)
section.class_teacher = teacher
section.save()
msgs = ['successfully assigned class teacher']
return Response({'details': msgs}, status.HTTP_200_OK)
class EmployerViewSet(viewsets.ModelViewSet):
"""
API endpoint that allows users to list, create,retrieve, update, delete.
"""
queryset = Employer.objects.all().order_by('-id')
serializer_class = EmployerSerializer
permission_classes = []
response_schema_dict = {
"200": openapi.Response(
description="source == 'web' and fieldset == 'principal'",
examples={
"application/json": {
"count": 1,
"next": "",
"previous": "",
"results": [
{
"id": 22,
"user": {
"id": 44,
"username": "******"
},
"rid": "string",
"name": "string",
"phone": "string",
"email": "string",
"company": 1,
"department": 1,
"designation": 1,
"principal_companies": [
1
]
},
]
}
}
),
}
name_param = openapi.Parameter(
'name', openapi.IN_QUERY, description="Enter employer's name",
type=openapi.TYPE_STRING)
email_param = openapi.Parameter(
'email', openapi.IN_QUERY, description="Enter employer's email",
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
)
@swagger_auto_schema(manual_parameters=[
name_param, email_param, source_param, fieldset_param],
responses=response_schema_dict)
def list(self, request, *args, **kwargs):
queryset = Employer.objects.all().order_by('-id')
name = self.request.query_params.get('name', None)
email = self.request.query_params.get('email', None)
source = self.request.query_params.get('source', None)
fieldset = self.request.query_params.get('fieldset', None)
if name:
queryset = queryset.filter(name__icontains=name)
if email:
queryset = queryset.filter(email=email)
if email and source == 'web' and fieldset == 'principal':
employer = queryset.first()
principal_companies = employer.principal_companies.all()
page = self.paginate_queryset(principal_companies)
serializer = PrincipalCompanyListSerializer(page, many=True)
response = self.get_paginated_response(serializer.data)
return response
page = self.paginate_queryset(queryset)
serializer = EmployerSerializer(page, many=True)
response = self.get_paginated_response(serializer.data)
return response
@swagger_auto_schema(request_body=openapi.Schema(
type=openapi.TYPE_OBJECT,
properties={
'user': openapi.Schema(
type=openapi.TYPE_OBJECT,
description='object'),
'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'),
'department': openapi.Schema(
type=openapi.TYPE_INTEGER, description='integer'),
'designation': openapi.Schema(
type=openapi.TYPE_INTEGER, description='integer'),
'company': openapi.Schema(
type=openapi.TYPE_INTEGER, description='integer'),
}
))
def create(self, request):
employer_data = request.data
# user data validation
username = employer_data['user'].get('username', None)
if not username:
raise ValidationError({"message": "username is required field"})
if username:
user = User.objects.filter(username=username).first()
if user:
raise ValidationError({
"message": "User already exists with this username."})
# employer_data validation
name = employer_data.get('name', None)
phone = employer_data.get('phone', None)
email = employer_data.get('email', None)
photo = employer_data.get('photo', None)
department = employer_data.get('department', None)
designation = employer_data.get('designation', None)
company = employer_data.get('company', None)
if not email:
raise ValidationError({"message": "email is required."})
if not name:
raise ValidationError({"message": "name is required."})
if not phone:
raise ValidationError({"message": "phone is required."})
if email:
employer = Employer.objects.filter(email=email).first()
if employer:
raise ValidationError({
"message": "employer already exists with this email."})
if department:
try:
Department.objects.get(id=department)
except:
raise ValidationError({"message": "department does not exist."})
if designation:
try:
Designation.objects.get(id=designation)
except:
raise ValidationError({"message": "designation does not exist."})
if company:
try:
Company.objects.get(id=company)
except:
raise ValidationError({"message": "company does not exist."})
serializer = EmployerSerializer(data=employer_data)
if serializer.is_valid():
serializer.save()
return JsonResponse(serializer.data)
raise ValidationError({"message": "Invalid arguments"})
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 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 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)
class QuizViewApi(views.APIView):
serializer_class = serializers.QuizSerializer
# authentication_classes = (authentication.TokenAuthentication,)
permission_classes = (permissions.AllowAny, )
@swagger_auto_schema(
request_body=openapi.Schema(
title="Quiz",
type=openapi.TYPE_OBJECT,
properties={
'title': openapi.Schema(type=openapi.TYPE_STRING),
'description': openapi.Schema(type=openapi.TYPE_STRING),
'url': openapi.Schema(type=openapi.TYPE_STRING),
'category': openapi.Schema(type=openapi.TYPE_INTEGER),
'random_order': openapi.Schema(type=openapi.TYPE_BOOLEAN),
'max_questions': openapi.Schema(type=openapi.TYPE_INTEGER),
'answers_at_end': openapi.Schema(type=openapi.TYPE_BOOLEAN),
'exam_paper': openapi.Schema(type=openapi.TYPE_BOOLEAN),
'single_attempt': openapi.Schema(type=openapi.TYPE_BOOLEAN),
'pass_mark': openapi.Schema(type=openapi.TYPE_INTEGER),
'success_text': openapi.Schema(type=openapi.TYPE_STRING),
'fail_text': openapi.Schema(type=openapi.TYPE_STRING),
'draft': 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."
)
})
def post(self, request):
data = request.data
title = data.get('title', "")
description = data.get('description')
url = data.get('url')
category = data.get('category')
random_order = data.get('random_order')
max_questions = data.get('max_questions')
answer_at_end = data.get('answers_at_end')
exam_paper = data.get('exam_paper')
single_attempt = data.get('single_attempt')
pass_mark = data.get('pass_mark')
success_text = data.get('success_text')
fail_text = data.get('fail_text')
draft = data.get('draft')
data_dict = {
"title": title,
"description": description,
"url": url,
"category": category,
"random_order": random_order,
"max_questions": max_questions,
"answers_at_end": answer_at_end,
"exam_paper": exam_paper,
"single_attempt": single_attempt,
"pass_mark": pass_mark,
"success_text": success_text,
"fail_text": fail_text,
"draft": draft,
}
serializer = self.serializer_class(data=data_dict)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status.HTTP_201_CREATED)
return Response({'details': serializer.errors},
status.HTTP_400_BAD_REQUEST)
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 CreateSection(views.APIView):
serializer_class = serializers.SectionSerializer
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),
])
def get(self, request):
query_params = self.request.query_params
id = query_params.get('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.Section.objects.filter(is_active=True)
if id:
qs = qs.filter(id=int(id))
if class_id:
qs = qs.filter(of_class__id=int(class_id))
if dept_id:
qs = qs.filter(of_class__department__department_id=dept_id)
if org_id:
qs = qs.filter(of_class__department__organization__org_id=org_id)
serializer = serializers.SectionSerializer(qs, many=True)
return Response(serializer.data, status.HTTP_200_OK)
@swagger_auto_schema(
request_body=openapi.Schema(
title="Create Section",
type=openapi.TYPE_OBJECT,
properties={
'title': openapi.Schema(type=openapi.TYPE_STRING),
'of_class_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
title = data.get('title', "")
of_class_id = data.get('of_class_id', 0)
if not title:
errors = ['title is not passed']
return Response({'details': errors}, status.HTTP_400_BAD_REQUEST)
if not of_class_id:
errors = ['of_class_id is not passed']
return Response({'details': errors}, status.HTTP_400_BAD_REQUEST)
qr_class = class_models.Class.objects.filter(id=int(of_class_id),
is_active=True)
if not len(qr_class):
errors = ['Invalid of_class_id']
return Response({'details': errors}, status.HTTP_400_BAD_REQUEST)
of_class_id = qr_class[0]
if models.Section.objects.filter(title=title,
of_class=of_class_id).exists():
errors = ['Section already exists']
return Response({'details': errors}, status.HTTP_400_BAD_REQUEST)
models.Section.objects.create(title=title, of_class=of_class_id)
msgs = ['successfully created section']
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 VerifierViewSet(viewsets.ModelViewSet):
queryset = Verifier.objects.all().order_by('-id')
serializer_class = serializers.VerifierSerializer
permission_classes = []
email_param = openapi.Parameter(
'email', openapi.IN_QUERY,
description="Enter Email",
type=openapi.TYPE_STRING
)
@swagger_auto_schema(manual_parameters=[email_param])
def list(self, request, *args, **kwargs):
queryset = Verifier.objects.all().order_by('-id')
email = self.request.query_params.get('email', None)
if email is not None:
queryset = queryset.filter(email__icontains=email)
page = self.paginate_queryset(queryset)
serializer = serializers.VerifierSerializer(page, many=True)
response = self.get_paginated_response(serializer.data)
return response
@swagger_auto_schema(request_body=openapi.Schema(
type=openapi.TYPE_OBJECT,
properties={
'employee_id': openapi.Schema(
type=openapi.TYPE_STRING, description='string'),
'verifiers': openapi.Schema(
type=openapi.TYPE_STRING, description='array of string')
}
))
def create(self, request, *args, **kwargs):
employee_id = request.data.get('employee_id', None)
verifiers = request.data.get('verifiers', None) # Array of string
if not employee_id:
raise ValidationError({
"status": "False",
"message": "EmployeeId is required"})
if employee_id:
employee = Employee.objects.filter(id=employee_id, deleted_at=None).first()
if not employee:
raise ValidationError({
"status": "False",
"message": "Employee does not exists"
})
if not verifiers:
raise ValidationError({
"status": "False",
"message": "Verifiers list is required"})
if verifiers:
if len(verifiers) < 1:
raise ValidationError({
"status": "False",
"message": "No Verifiers in list."})
for verifier_email in verifiers:
if verifier_email.split('@')[1] == str(employee.email).split('@')[1]:
verifier_obj = Verifier.objects.create(
email=verifier_email
)
verifier_obj.employee.add(employee)
verifier_obj.save()
return JsonResponse({
"status": "True",
"message": "Verifiers created successfully"
})
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)
