diff --git a/core/views/sso_login.py b/core/views/sso_login.py
index e78e87a03da099fbe164b8b4e6c82a04808c8fa3..55d6a00f66ebb7a787b48bdfd10d3aa73de2999a 100755
--- a/core/views/sso_login.py
+++ b/core/views/sso_login.py
@@ -1,50 +1,43 @@
import requests
from django.conf import settings
+import views_constants
def get_access_token(username, password):
try:
- url = "https://akun.cs.ui.ac.id/oauth/token/"
+ url = views_constants.URL_AKUN_CS_UI
- payload = "username=" + username + "&password=" + password + "&grant_type=password"
+ payload = views_constants.PARAM_USERNAME + username + "&" + views_constants.PARAM_PASSWORD + password + "&" + \
+ views_constants.PARAM_GRANT_TYPE + views_constants.PASSWORD
headers = {
- 'authorization': "Basic WDN6TmtGbWVwa2RBNDdBU05NRFpSWDNaOWdxU1UxTHd5d3U1V2VwRzpCRVFXQW43RDl6a2k3NEZ0bkNpWVhIRk50Ymg3eXlNWmFuNnlvMU1uaUdSVWNGWnhkQnBobUU5TUxuVHZiTTEzM1dsUnBwTHJoTXBkYktqTjBxcU9OaHlTNGl2Z0doczB0OVhlQ3M0Ym1JeUJLMldwbnZYTXE4VU5yTEFEMDNZeA==",
- 'cache-control': "no-cache",
- 'content-type': "application/x-www-form-urlencoded"
+ 'authorization': views_constants.HEADER_AUTH,
+ 'cache-control': views_constants.HEADER_NO_CACHE,
+ 'content-type': views_constants.HEADER_CONTENT_TYPE
}
- response = requests.request("POST", url, data=payload, headers=headers)
+ response = requests.request(views_constants.METHOD_POST, url, data=payload, headers=headers)
- return response.json()["access_token"]
+ return response.json()[views_constants.ACCESS_TOKEN]
except Exception as e:
return None
def get_client_id():
- client_id = 'X3zNkFmepkdA47ASNMDZRX3Z9gqSU1Lwywu5WepG'
- return client_id
+ return views_constants.CLIENT_ID_VALUE
def verify_user(access_token):
- print ("#get identity number")
- parameters = {"access_token": access_token, "client_id": get_client_id()}
+ parameters = {views_constants.ACCESS_TOKEN: access_token, views_constants.CLIENT_ID: get_client_id()}
response = requests.get(settings.API_VERIFY_USER, params=parameters)
- print ("response => ", response.json())
return response.json()
def get_summary_user(access_token, npm):
- print ("#get summary user => ", npm)
- parameters = {"access_token": access_token, "client_id": get_client_id()}
+ parameters = {views_constants.ACCESS_TOKEN: access_token, views_constants.CLIENT_ID: get_client_id()}
response = requests.get(settings.API_MAHASISWA + str(npm), params=parameters)
- print ("response => ", response.text)
- print ("response => ", response.json())
return response.json()
def get_riwayat_user(access_token, npm):
- print ("#get riwayat user => ", npm)
- parameters = {"access_token": access_token, "client_id": get_client_id()}
+ parameters = {views_constants.ACCESS_TOKEN: access_token, views_constants.CLIENT_ID: get_client_id()}
response = requests.get(settings.API_RIWAYAT_MAHASISWA.format(npm=npm), params=parameters)
- print ("response => ", response.text)
- print ("response => ", response.json())
return response.json()
diff --git a/core/views/vacancies.py b/core/views/vacancies.py
index bbbbe958ad3f35ec855385ebcb8669122622a013..d71124449ade8feea4bad79502e3f18a9b867c03 100644
--- a/core/views/vacancies.py
+++ b/core/views/vacancies.py
@@ -9,6 +9,7 @@ from rest_framework.generics import get_object_or_404
from rest_framework.pagination import PageNumberPagination
from rest_framework.permissions import IsAuthenticated
from rest_framework.response import Response
+import views_constants
from core.lib.mixins import MultiSerializerViewSetMixin
from core.lib.permissions import IsAdminOrStudent, IsAdminOrCompany, IsAdminOrVacancyOwner, AsAdminOrSupervisor, \
@@ -23,16 +24,19 @@ from core.views.accounts import StudentViewSet
def date_validator(open_time, close_time):
if open_time < str(datetime.today()):
- return {'is_valid': False, 'error': 'Waktu buka lowongan harus lebih dari hari ini!',
- 'status': status.HTTP_400_BAD_REQUEST}
+ return {views_constants.IS_VALID: False,
+ views_constants.ERROR: views_constants.ERROR_OPEN_TIME_GREATER_THAN_CURRENT_TIME,
+ views_constants.STATUS: status.HTTP_400_BAD_REQUEST}
elif close_time < open_time:
- return {'is_valid': False, 'error': 'Waktu tutup lowongan harus lebih dari waktu buka lowongan!',
- 'status': status.HTTP_400_BAD_REQUEST}
+ return {views_constants.IS_VALID: False,
+ views_constants.ERROR: views_constants.ERROR_OPEN_TIME_GREATER_THAN_CLOSE_TIME,
+ views_constants.STATUS: status.HTTP_400_BAD_REQUEST}
elif close_time == open_time:
- return {'is_valid': False, 'error': 'Waktu tutup dan buka lowongan tidak boleh sama!',
- 'status': status.HTTP_400_BAD_REQUEST}
+ return {views_constants.IS_VALID: False,
+ views_constants.ERROR: views_constants.ERROR_OPEN_TIME_EQUALS_CLOSE_TIME,
+ views_constants.STATUS: status.HTTP_400_BAD_REQUEST}
else:
- return {'is_valid': True, 'error': '', 'status': status.HTTP_200_OK}
+ return {views_constants.IS_VALID: True, views_constants.ERROR: '', views_constants.STATUS: status.HTTP_200_OK}
class VacancyViewSet(MultiSerializerViewSetMixin, viewsets.ModelViewSet):
@@ -42,19 +46,21 @@ class VacancyViewSet(MultiSerializerViewSetMixin, viewsets.ModelViewSet):
pagination_class = PageNumberPagination
def get_permissions(self):
- if self.action in ["retrieve", "list"]:
+ if self.action in [views_constants.ACTION_RETRIEVE, views_constants.ACTION_LIST]:
return [IsAuthenticated()]
return super(VacancyViewSet, self).get_permissions()
def list(self, request, *args, **kwargs):
- search = request.query_params['search'] if 'search' in request.query_params else None
- verified = request.query_params['verified'] if 'verified' in request.query_params else "True"
- order_by = request.GET.get('sort', None)
- order = request.GET.get('order', 'ascending')
+ search = request.query_params[views_constants.SEARCH] \
+ if views_constants.SEARCH in request.query_params else None
+ verified = request.query_params[views_constants.VERIFIED] \
+ if views_constants.VERIFIED in request.query_params else "True"
+ order_by = request.GET.get(views_constants.SORT, None)
+ order = request.GET.get(views_constants.ORDERING, views_constants.ORDER_ASCENDING)
- opened_only = str(request.query_params['opened_only']) \
- if 'opened_only' in request.query_params else "False"
- companies = [int(x) for x in request.query_params.getlist('company', [])]
+ opened_only = str(request.query_params[views_constants.OPENED_ONLY]) \
+ if views_constants.OPENED_ONLY in request.query_params else "False"
+ companies = [int(x) for x in request.query_params.getlist(views_constants.COMPANY, [])]
if search is not None:
vacancies = Vacancy.objects.filter(Q(name__icontains=search) | Q(company__user__username__icontains=search))
@@ -71,9 +77,10 @@ class VacancyViewSet(MultiSerializerViewSetMixin, viewsets.ModelViewSet):
print(vacancies)
print(request)
if page is not None:
- return self.get_paginated_response(VacancySerializer(page, many=True, context={'request': request}).data)
+ return self.get_paginated_response(
+ VacancySerializer(page, many=True, context={views_constants.REQUEST: request}).data)
vacancies = Vacancy.objects.all()
- return Response(VacancySerializer(vacancies, many=True, context={'request': request}).data)
+ return Response(VacancySerializer(vacancies, many=True, context={views_constants.REQUEST: request}).data)
def verifiedFilter(self, vacancies, flag):
if flag.lower() in ("yes", "true", "t", "1"):
@@ -94,9 +101,10 @@ class VacancyViewSet(MultiSerializerViewSetMixin, viewsets.ModelViewSet):
return vacancies
def sort(self, order_by, vacancies, order):
- if (order_by is not None) and (order_by in ['name', 'salary']) and (order in ['ascending', 'descending']):
+ if (order_by is not None) and (order_by in [views_constants.NAME, views_constants.SALARY]) and (
+ order in [views_constants.ORDER_ASCENDING, views_constants.ORDER_DESCENDING]):
order_query = ""
- if order == 'descending':
+ if order == views_constants.ORDER_DESCENDING:
order_query = "-"
return vacancies.order_by('{}{}'.format(order_query, order_by))
return vacancies
@@ -104,86 +112,84 @@ class VacancyViewSet(MultiSerializerViewSetMixin, viewsets.ModelViewSet):
def name_position_validator(self, names):
for name in names.split(" "):
if not name.isalpha():
- raise ValidationError("Name must alphabets only")
+ raise ValidationError(views_constants.ERROR_NAME_MUST_ALPHABET)
return name
def salary_validator(self, salary):
try:
int(salary)
except:
- raise ValidationError("Salary must number only")
+ raise ValidationError(views_constants.ERROR_SALARY_MUST_NUMBER)
def amount_validator(self, amount):
try:
int(amount)
except:
- raise ValidationError("Amount must number only")
+ raise ValidationError(views_constants.ERROR_AMOUNT_MUST_NUMBER)
def responsibilities_validator(self, responsibilities):
if not isinstance(responsibilities, basestring):
- raise ValidationError("Responsibilities must be string")
+ raise ValidationError(views_constants.ERROR_RESPONSIBILITIES_MUST_STRING)
def recruiter_activity_validator(self, recruiter_activity):
enum_recruiter_activity = ['Selalu', 'Sering', 'Kadang', 'Jarang', 'Tidak Pernah']
if (not isinstance(recruiter_activity, basestring)) or (recruiter_activity not in enum_recruiter_activity):
- raise ValidationError('Tingkat Respons Perekrut harus salah '
- 'satu dari Selalu, Sering, Kadang, '
- 'Jarang, dan Tidak Pernah!')
+ raise ValidationError(views_constants.ERROR_INVALID_RECRUITER_RESPONSE)
def date_range_validator(self, open_time, close_time):
validity = date_validator(open_time, close_time)
- if not validity['is_valid']:
- raise ValidationError(validity['error'])
+ if not validity[views_constants.IS_VALID]:
+ raise ValidationError(validity[views_constants.ERROR])
def __get_company(self, company_id):
company_set = Company.objects.filter(id=company_id)
if len(company_set) == 0:
- raise ValidationError('No company exists with that ID')
+ raise ValidationError(views_constants.ERROR_COMPANY_DOES_NOT_EXIST)
return company_set[0]
def __parse_vacancy_data(self, raw_data):
data = {
- "open_time": raw_data['open_time'],
- "close_time": raw_data['close_time'],
- "name": raw_data['name'],
- "salary": raw_data.get('salary', 0),
- "tag": raw_data.get('tag', ''),
- "requirements": raw_data.get('requirements', ''),
- "responsibilities": raw_data.get('responsibilities', ''),
- "benefits": raw_data.get('benefits', ''),
- "amount": raw_data.get('amount', 0),
- "recruiter_activity": raw_data.get('recruiter_activity', ''),
- "description": raw_data['description'],
- "working_period": raw_data['working_period'],
- "max_accepted_applicants": raw_data['max_accepted_applicants']
+ views_constants.OPEN_TIME: raw_data[views_constants.OPEN_TIME],
+ views_constants.CLOSE_TIME: raw_data[views_constants.CLOSE_TIME],
+ views_constants.NAME: raw_data[views_constants.NAME],
+ views_constants.SALARY: raw_data.get(views_constants.SALARY, 0),
+ views_constants.TAG: raw_data.get(views_constants.TAG, ''),
+ views_constants.REQUIREMENTS: raw_data.get(views_constants.REQUIREMENTS, ''),
+ views_constants.RESPONSIBILITIES: raw_data.get(views_constants.RESPONSIBILITIES, ''),
+ views_constants.BENEFITS: raw_data.get(views_constants.BENEFITS, ''),
+ views_constants.AMOUNT: raw_data.get(views_constants.AMOUNT, 0),
+ views_constants.RECRUITER_ACTIVITY: raw_data.get(views_constants.RECRUITER_ACTIVITY, ''),
+ views_constants.DESCRIPTION: raw_data[views_constants.DESCRIPTION],
+ views_constants.WORKING_PERIOD: raw_data[views_constants.WORKING_PERIOD],
+ views_constants.MAX_ACCEPTED_APPLICANTS: raw_data[views_constants.MAX_ACCEPTED_APPLICANTS]
}
return data
def __validate_vacancy_data(self, data):
- self.date_range_validator(data['open_time'], data['close_time'])
- self.name_position_validator(data['name'])
- self.salary_validator(data['salary'])
- if data.get('amount'):
- self.amount_validator(data['amount'])
- if data.get('responsibilities'):
- self.responsibilities_validator(data['responsibilities'])
- if data.get('recruiter_activity'):
- self.recruiter_activity_validator(data['recruiter_activity'])
+ self.date_range_validator(data[views_constants.OPEN_TIME], data[views_constants.CLOSE_TIME])
+ self.name_position_validator(data[views_constants.NAME])
+ self.salary_validator(data[views_constants.SALARY])
+ if data.get(views_constants.AMOUNT):
+ self.amount_validator(data[views_constants.AMOUNT])
+ if data.get(views_constants.RESPONSIBILITIES):
+ self.responsibilities_validator(data[views_constants.RESPONSIBILITIES])
+ if data.get(views_constants.RECRUITER_ACTIVITY):
+ self.recruiter_activity_validator(data[views_constants.RECRUITER_ACTIVITY])
def create(self, request):
print("[LOG] data: " + str(request.data))
try:
data = self.__parse_vacancy_data(request.data)
- data['company'] = self.__get_company(request.data['company'])
+ data[views_constants.COMPANY] = self.__get_company(request.data[views_constants.COMPANY])
self.__validate_vacancy_data(data)
vacancy = Vacancy(**data)
vacancy.save()
except ValidationError as e:
print("[LOG] error: " + str(e))
- return Response({"error": str(e.detail[0])}, status=status.HTTP_400_BAD_REQUEST)
+ return Response({views_constants.ERROR: str(e.detail[0])}, status=status.HTTP_400_BAD_REQUEST)
except ValueError as e:
print("[LOG] error: " + str(e))
- return Response({"error": str(e)}, status=status.HTTP_400_BAD_REQUEST)
+ return Response({views_constants.ERROR: str(e)}, status=status.HTTP_400_BAD_REQUEST)
return Response(status=status.HTTP_200_OK)
def partial_update(self, request, pk):
@@ -197,7 +203,7 @@ class VacancyViewSet(MultiSerializerViewSetMixin, viewsets.ModelViewSet):
vacancy.save()
except ValidationError as e:
print("[LOG] error: " + str(e))
- return Response({"error": str(e.detail[0])}, status=status.HTTP_400_BAD_REQUEST)
+ return Response({views_constants.ERROR: str(e.detail[0])}, status=status.HTTP_400_BAD_REQUEST)
return Response(status=status.HTTP_200_OK)
@detail_route(permission_classes=[IsAdminOrCompany])
@@ -205,9 +211,9 @@ class VacancyViewSet(MultiSerializerViewSetMixin, viewsets.ModelViewSet):
vacancy = self.get_object()
count = Application.objects.filter(vacancy=vacancy).count()
count_new = Application.objects.filter(vacancy=vacancy, status=Application.NEW).count()
- return Response({"count": count, "count_new": count_new}, status=status.HTTP_200_OK)
+ return Response({views_constants.COUNT: count, views_constants.COUNT_NEW: count_new}, status=status.HTTP_200_OK)
- @detail_route(methods=['patch'], permission_classes=[VacancyApprovalPermission],
+ @detail_route(methods=[views_constants.METHOD_PATCH], permission_classes=[VacancyApprovalPermission],
serializer_class=VacancyVerifiedSerializer)
def verify(self, request, pk=None):
vacancy = self.get_object()
@@ -215,49 +221,49 @@ class VacancyViewSet(MultiSerializerViewSetMixin, viewsets.ModelViewSet):
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_200_OK)
- return Response({"error": "bad request"}, status=status.HTTP_400_BAD_REQUEST)
+ return Response({views_constants.ERROR: views_constants.ERROR_BAD_REQUEST}, status=status.HTTP_400_BAD_REQUEST)
class ApplicationViewSet(MultiSerializerViewSetMixin, viewsets.GenericViewSet):
queryset = Application.objects.all()
serializer_class = ApplicationSerializer
serializer_action_classes = {
- 'update': ApplicationStatusSerializer,
- 'partial_update': ApplicationStatusSerializer,
- 'list': SupervisorStudentApplicationSerializer
+ views_constants.ACTION_UPDATE: ApplicationStatusSerializer,
+ views_constants.ACTION_PARTIAL_UPDATE: ApplicationStatusSerializer,
+ views_constants.ACTION_LIST: SupervisorStudentApplicationSerializer
}
permission_classes = [IsAdminOrVacancyOwner]
pagination_class = PageNumberPagination
def list(self, request):
- applications = Application.objects.order_by('student')
+ applications = Application.objects.order_by(views_constants.ORDER_STUDENT)
page = self.paginate_queryset(applications)
serializer = self.get_serializer_class()
if page is not None:
return self.get_paginated_response(
- serializer(applications, many=True, context={'request': request}).data)
- return Response(serializer(applications, many=True, context={'request': request}).data)
+ serializer(applications, many=True, context={views_constants.REQUEST: request}).data)
+ return Response(serializer(applications, many=True, context={views_constants.REQUEST: request}).data)
- @detail_route(methods=['get'], permission_classes=[IsAdminOrStudent])
+ @detail_route(methods=[views_constants.METHOD_GET], permission_classes=[IsAdminOrStudent])
def count(self, request, pk=None):
count = Application.objects.filter(vacancy_id=pk).count()
- return Response({"count": count}, status=status.HTTP_200_OK)
+ return Response({views_constants.COUNT: count}, status=status.HTTP_200_OK)
def partial_update(self, request, pk=None):
application = self.get_object()
serializer = self.get_serializer_class()(application, data=request.data, partial=True)
if serializer.is_valid():
serializer.save()
- if request.data['status'] == 3:
- if request.data['reason'] == "" or request.data['reason'] == " ":
+ if request.data[views_constants.STATUS] == 3:
+ if request.data[views_constants.REASON] == "" or request.data[views_constants.REASON] == " ":
ReasonRejected.objects.create(application=application)
else:
- ReasonRejected.objects.create(application=application, reason=request.data['reason'])
+ ReasonRejected.objects.create(application=application, reason=request.data[views_constants.REASON])
return Response(serializer.data, status=status.HTTP_202_ACCEPTED)
else:
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
- @detail_route(methods=['get'], permission_classes=[IsAdminOrVacancyOwner])
+ @detail_route(methods=[views_constants.METHOD_GET], permission_classes=[IsAdminOrVacancyOwner])
def transcript(self, request, pk):
"""
Get student's academic transcript on application {application_id}
@@ -267,7 +273,7 @@ class ApplicationViewSet(MultiSerializerViewSetMixin, viewsets.GenericViewSet):
return StudentViewSet.transcript(StudentViewSet(), request, application.student.pk)
def get_permissions(self):
- if self.action == "list":
+ if self.action == views_constants.ACTION_LIST:
return [AsAdminOrSupervisor()]
return super(ApplicationViewSet, self).get_permissions()
@@ -283,8 +289,8 @@ class StudentApplicationViewSet(viewsets.GenericViewSet):
---
"""
student = get_object_or_404(Student.objects.all(), pk=student_id)
- vacancy_ids = Application.objects.filter(student=student).values('vacancy')
- search = request.query_params['search'] if 'search' in request.query_params else None
+ vacancy_ids = Application.objects.filter(student=student).values(views_constants.VACANCY)
+ search = request.query_params[views_constants.SEARCH] if views_constants.SEARCH in request.query_params else None
if search is not None:
vacancies = Vacancy.objects.filter(
Q(id__in=vacancy_ids) & (Q(name__icontains=search) | Q(company__user__username__icontains=search)))
@@ -292,8 +298,8 @@ class StudentApplicationViewSet(viewsets.GenericViewSet):
vacancies = Vacancy.objects.filter(id__in=vacancy_ids)
page = self.paginate_queryset(vacancies)
if page is not None:
- return self.get_paginated_response(VacancySerializer(page, many=True, context={'request': request}).data)
- return Response(VacancySerializer(vacancies, many=True, context={'request': request}).data)
+ return self.get_paginated_response(VacancySerializer(page, many=True, context={views_constants.REQUEST: request}).data)
+ return Response(VacancySerializer(vacancies, many=True, context={views_constants.REQUEST: request}).data)
def create(self, request, student_id):
"""
@@ -306,17 +312,17 @@ class StudentApplicationViewSet(viewsets.GenericViewSet):
type: string
paramType: body
"""
- cover_letter = request.data.get('cover_letter')
- vacancy = get_object_or_404(Vacancy.objects.all(), pk=request.data.get('vacancy_id'))
+ cover_letter = request.data.get(views_constants.COVER_LETTER)
+ vacancy = get_object_or_404(Vacancy.objects.all(), pk=request.data.get(views_constants.VACANCY_ID))
if vacancy.close_time < timezone.now():
- return Response({"error": "vacancy is closed"}, \
+ return Response({views_constants.ERROR: views_constants.ERROR_VACANCY_CLOSED},
status=status.HTTP_400_BAD_REQUEST)
student = get_object_or_404(Student.objects.all(), pk=student_id)
if Application.objects.filter(vacancy=vacancy, student=student).exists():
- raise ValidationError("You have already applied for the vacancy")
+ raise ValidationError(views_constants.ERROR_VACANCY_ALREADY_APPLIED)
application = Application(vacancy=vacancy, student=student, cover_letter=cover_letter)
application.save()
- return Response(ApplicationSerializer(application, context={'request': request}).data)
+ return Response(ApplicationSerializer(application, context={views_constants.REQUEST: request}).data)
def destroy(self, request, student_id, pk):
"""
@@ -327,9 +333,9 @@ class StudentApplicationViewSet(viewsets.GenericViewSet):
student = get_object_or_404(Student.objects.all(), pk=student_id)
application = get_object_or_404(Application.objects.all(), student=student, vacancy=vacancy)
application.delete()
- return Response(ApplicationSerializer(application, context={'request': request}).data)
+ return Response(ApplicationSerializer(application, context={views_constants.REQUEST: request}).data)
- @detail_route(methods=['get'], permission_classes=[IsAdminOrStudent])
+ @detail_route(methods=[views_constants.METHOD_GET], permission_classes=[IsAdminOrStudent])
def reason(self, request, student_id, pk):
"""
Get the reason for rejection of application {id} for student {student_id}
@@ -340,7 +346,7 @@ class StudentApplicationViewSet(viewsets.GenericViewSet):
application = get_object_or_404(Application.objects.all(), student=student, vacancy=vacancy)
reason_rejected = get_object_or_404(ReasonRejected.objects.all(), application=application)
print(reason_rejected.reason)
- return Response({"reason": reason_rejected.reason}, status=status.HTTP_200_OK)
+ return Response({views_constants.REASON: reason_rejected.reason}, status=status.HTTP_200_OK)
class StatusError(Exception):
@@ -368,12 +374,12 @@ class CompanyApplicationViewSet(viewsets.GenericViewSet):
applications = self.__filter_application_list_by_status(request, applications)
return self.__get_paginated_application_list(request, applications)
except UnauthorizeError:
- return Response({"error": "forbidden"}, status=status.HTTP_403_FORBIDDEN)
+ return Response({views_constants.ERROR: views_constants.ERROR_FORBIDDEN}, status=status.HTTP_403_FORBIDDEN)
except (StatusError, ValueError):
- return Response({"error": "status must be an integer between 0 and 4"}, \
+ return Response({views_constants.ERROR: views_constants.ERROR_INVALID_STATUS_CODE},
status=status.HTTP_400_BAD_REQUEST)
- @detail_route(methods=["get"])
+ @detail_route(methods=[views_constants.METHOD_GET])
def by_vacancy(self, request, company_id, pk=None):
"""
Get list of company {company_id}'s applications by vacancy {id}
@@ -388,13 +394,13 @@ class CompanyApplicationViewSet(viewsets.GenericViewSet):
applications = self.__filter_application_list_by_status(request, applications)
return self.__get_paginated_application_list(request, applications)
except UnauthorizeError:
- return Response({"error": "forbidden"}, status=status.HTTP_403_FORBIDDEN)
+ return Response({views_constants.ERROR: views_constants.ERROR_FORBIDDEN}, status=status.HTTP_403_FORBIDDEN)
except (StatusError, ValueError):
- return Response({"error": "status must be an integer between 0 and 4"}, \
+ return Response({views_constants.ERROR: views_constants.ERROR_INVALID_STATUS_CODE},
status=status.HTTP_400_BAD_REQUEST)
def __get_company_list_by_company_id(self, request, company_id):
- company = get_object_or_404(Company.objects.all().order_by('-updated'), pk=company_id)
+ company = get_object_or_404(Company.objects.all().order_by(views_constants.ORDER_UPDATED), pk=company_id)
if not self.__validating_user(request, company):
raise UnauthorizeError
return company
@@ -421,7 +427,7 @@ class CompanyApplicationViewSet(viewsets.GenericViewSet):
return Application.objects.filter(vacancy=vacancy)
def __get_status_from_request_param(self, request):
- return request.query_params.get('status', None)
+ return request.query_params.get(views_constants.STATUS, None)
def __validating_application_status(self, status):
list_status = {0: "NEW", 1: "READ", 2: "BOOKMARKED", 3: "REJECTED", 4: "ACCEPTED", 6: "FINISHED"}
@@ -441,8 +447,8 @@ class CompanyApplicationViewSet(viewsets.GenericViewSet):
page = self.paginate_queryset(applications)
if page is not None:
return self.get_paginated_response(
- ApplicationSerializer(page, many=True, context={'request': request}).data)
- return Response(ApplicationSerializer(applications, many=True, context={'request': request}).data)
+ ApplicationSerializer(page, many=True, context={views_constants.REQUEST: request}).data)
+ return Response(ApplicationSerializer(applications, many=True, context={views_constants.REQUEST: request}).data)
class CompanyVacanciesViewSet(viewsets.GenericViewSet):
@@ -455,14 +461,14 @@ class CompanyVacanciesViewSet(viewsets.GenericViewSet):
Get list of company {company_id}'s vacancies
---
"""
- company = get_object_or_404(Company.objects.all().order_by('-updated'), pk=company_id)
+ company = get_object_or_404(Company.objects.all().order_by(views_constants.ORDER_UPDATED), pk=company_id)
if not request.user.is_superuser and request.user != company.user:
- return Response({"error": "forbidden"}, status=status.HTTP_403_FORBIDDEN)
+ return Response({views_constants.ERROR: views_constants.ERROR_FORBIDDEN}, status=status.HTTP_403_FORBIDDEN)
vacancies = Vacancy.objects.filter(company=company)
page = self.paginate_queryset(vacancies)
if page is not None:
- return self.get_paginated_response(VacancySerializer(page, many=True, context={'request': request}).data)
- return Response(VacancySerializer(vacancies, many=True, context={'request': request}).data)
+ return self.get_paginated_response(VacancySerializer(page, many=True, context={views_constants.REQUEST: request}).data)
+ return Response(VacancySerializer(vacancies, many=True, context={views_constants.REQUEST: request}).data)
class BookmarkedVacancyByStudentViewSet(viewsets.GenericViewSet):
@@ -475,7 +481,7 @@ class BookmarkedVacancyByStudentViewSet(viewsets.GenericViewSet):
---
"""
student = get_object_or_404(Student.objects.all(), pk=student_id)
- search = request.query_params['search'] if 'search' in request.query_params else None
+ search = request.query_params[views_constants.SEARCH] if views_constants.SEARCH in request.query_params else None
if search is not None:
vacancies = student.bookmarked_vacancies.filter(
Q(name__icontains=search) | Q(company__user__username__icontains=search))
@@ -483,8 +489,8 @@ class BookmarkedVacancyByStudentViewSet(viewsets.GenericViewSet):
vacancies = student.bookmarked_vacancies.all()
page = self.paginate_queryset(vacancies)
if page is not None:
- return self.get_paginated_response(VacancySerializer(page, many=True, context={'request': request}).data)
- return Response(VacancySerializer(vacancies, many=True, context={'request': request}).data)
+ return self.get_paginated_response(VacancySerializer(page, many=True, context={views_constants.REQUEST: request}).data)
+ return Response(VacancySerializer(vacancies, many=True, context={views_constants.REQUEST: request}).data)
def create(self, request, student_id):
"""
@@ -497,11 +503,11 @@ class BookmarkedVacancyByStudentViewSet(viewsets.GenericViewSet):
type: string
paramType: body
"""
- vacancy = get_object_or_404(Vacancy.objects.all(), pk=request.data['vacancy_id'])
+ vacancy = get_object_or_404(Vacancy.objects.all(), pk=request.data[views_constants.VACANCY_ID])
student = get_object_or_404(Student.objects.all(), pk=student_id)
student.bookmarked_vacancies.add(vacancy)
return Response(
- self.serializer_class(student.bookmarked_vacancies, many=True, context={'request': request}).data)
+ self.serializer_class(student.bookmarked_vacancies, many=True, context={views_constants.REQUEST: request}).data)
def destroy(self, request, student_id, pk):
"""
@@ -512,7 +518,7 @@ class BookmarkedVacancyByStudentViewSet(viewsets.GenericViewSet):
student = get_object_or_404(Student.objects.all(), pk=student_id)
student.bookmarked_vacancies.remove(vacancy)
return Response(
- self.serializer_class(student.bookmarked_vacancies, many=True, context={'request': request}).data)
+ self.serializer_class(student.bookmarked_vacancies, many=True, context={views_constants.REQUEST: request}).data)
class VacancyMilestoneViewSet(viewsets.GenericViewSet):
@@ -529,8 +535,8 @@ class VacancyMilestoneViewSet(viewsets.GenericViewSet):
page = self.paginate_queryset(milestones)
if page is not None:
return self.get_paginated_response(
- self.serializer_class(page, many=True, context={'request': request}).data)
- return Response(self.serializer_class(milestones, many=True, context={'request': request}).data)
+ self.serializer_class(page, many=True, context={views_constants.REQUEST: request}).data)
+ return Response(self.serializer_class(milestones, many=True, context={views_constants.REQUEST: request}).data)
def create(self, request, vacancy_id):
"""
@@ -548,7 +554,7 @@ class VacancyMilestoneViewSet(viewsets.GenericViewSet):
milestone_serializer = self.serializer_class(data=request.data)
if milestone_serializer.is_valid():
milestone = milestone_serializer.save(vacancy=vacancy)
- return Response(self.serializer_class(milestone, context={'request': request}).data,
+ return Response(self.serializer_class(milestone, context={views_constants.REQUEST: request}).data,
status=status.HTTP_200_OK)
return Response(milestone_serializer.errors, status=status.HTTP_400_BAD_REQUEST)
@@ -569,7 +575,7 @@ class VacancyMilestoneViewSet(viewsets.GenericViewSet):
milestone_serializer = self.serializer_class(old_milestone, data=request.data)
if milestone_serializer.is_valid():
milestone = milestone_serializer.save(vacancy=vacancy)
- return Response(self.serializer_class(milestone, context={'request': request}).data,
+ return Response(self.serializer_class(milestone, context={views_constants.REQUEST: request}).data,
status=status.HTTP_200_OK)
return Response(milestone_serializer.errors, status=status.HTTP_400_BAD_REQUEST)
@@ -582,7 +588,7 @@ class VacancyMilestoneViewSet(viewsets.GenericViewSet):
milestone = get_object_or_404(vacancy.milestones.all(), pk=pk)
milestone.delete()
return Response(
- self.serializer_class(vacancy.milestones.all(), many=True, context={'request': request}).data)
+ self.serializer_class(vacancy.milestones.all(), many=True, context={views_constants.REQUEST: request}).data)
class AcceptOfferByStudentViewSet(MultiSerializerViewSetMixin, viewsets.GenericViewSet):
@@ -594,13 +600,13 @@ class AcceptOfferByStudentViewSet(MultiSerializerViewSetMixin, viewsets.GenericV
Get list of a student {student_id}'s cancel offered vacancies
---
"""
- student = get_object_or_404(Student.objects.all().order_by('-updated'), pk=student_id)
+ student = get_object_or_404(Student.objects.all().order_by(views_constants.ORDER_UPDATED), pk=student_id)
apps = Application.objects.filter(student=student)
for a in apps:
if a.vacancy_id != int(pk):
- serializer = ApplicationStatusSerializer(a, data={'status': 5}, partial=True)
+ serializer = ApplicationStatusSerializer(a, data={views_constants.STATUS: 5}, partial=True)
if serializer.is_valid():
serializer.save()
- return Response(SupervisorStudentApplicationSerializer(apps, many=True, context={'request': request}).data)
+ return Response(SupervisorStudentApplicationSerializer(apps, many=True, context={views_constants.REQUEST: request}).data)
diff --git a/core/views/views_constants.py b/core/views/views_constants.py
new file mode 100644
index 0000000000000000000000000000000000000000..9874200b5426410987a17e4443f8321480d9ae11
--- /dev/null
+++ b/core/views/views_constants.py
@@ -0,0 +1,74 @@
+ERROR_OPEN_TIME_GREATER_THAN_CURRENT_TIME = 'Waktu buka lowongan harus lebih dari hari ini!'
+ERROR_OPEN_TIME_GREATER_THAN_CLOSE_TIME = 'Waktu tutup lowongan harus lebih dari waktu buka lowongan!'
+ERROR_OPEN_TIME_EQUALS_CLOSE_TIME = 'Waktu tutup dan buka lowongan tidak boleh sama!'
+ERROR_NAME_MUST_ALPHABET = 'Name must alphabets only'
+ERROR_SALARY_MUST_NUMBER = 'Salary must number only'
+ERROR_AMOUNT_MUST_NUMBER = 'Amount must number only'
+ERROR_RESPONSIBILITIES_MUST_STRING = 'Responsibilities must be string'
+ERROR_INVALID_RECRUITER_RESPONSE = 'Tingkat Respons Perekrut harus salah satu dari Selalu, Sering, Kadang, Jarang, ' \
+ 'dan Tidak Pernah!'
+ERROR_VACANCY_ALREADY_APPLIED = 'You have already applied for the vacancy'
+ERROR_COMPANY_DOES_NOT_EXIST = 'No company exists with that ID'
+ERROR_VACANCY_CLOSED = 'vacancy is closed'
+ERROR_INVALID_STATUS_CODE = 'status must be an integer between 0 and 4'
+ERROR_FORBIDDEN = 'forbidden'
+ERROR_BAD_REQUEST = 'bad request'
+
+ACTION_LIST = 'list'
+ACTION_PARTIAL_UPDATE = 'partial_update'
+ACTION_RETRIEVE = 'retrieve'
+ACTION_UPDATE = 'update'
+
+HEADER_AUTH = 'Basic WDN6TmtGbWVwa2RBNDdBU05NRFpSWDNaOWdxU1UxTHd5d3U1V2VwRzpCRVFXQW43RDl6a2k3NEZ0bkNpWVhIRk50Ymg3eXlNWmFuNnlvMU1uaUdSVWNGWnhkQnBobUU5TUxuVHZiTTEzM1dsUnBwTHJoTXBkYktqTjBxcU9OaHlTNGl2Z0doczB0OVhlQ3M0Ym1JeUJLMldwbnZYTXE4VU5yTEFEMDNZeA=='
+HEADER_CONTENT_TYPE = 'application/x-www-form-urlencoded'
+HEADER_NO_CACHE = 'no-cache'
+
+CLIENT_ID_VALUE = 'X3zNkFmepkdA47ASNMDZRX3Z9gqSU1Lwywu5WepG'
+URL_AKUN_CS_UI = 'https://akun.cs.ui.ac.id/oauth/token/'
+
+METHOD_GET = 'get'
+METHOD_PATCH = 'patch'
+METHOD_POST = 'POST'
+
+ORDER_ASCENDING = 'ascending'
+ORDER_DESCENDING = 'descending'
+ORDER_STUDENT = 'student'
+ORDER_UPDATED = '-updated'
+
+PARAM_GRANT_TYPE = 'grant_type='
+PARAM_PASSWORD = 'password='
+PARAM_USERNAME = 'username='
+
+
+ACCESS_TOKEN = 'access_token'
+AMOUNT = 'amount'
+BENEFITS = 'benefits'
+CLIENT_ID = 'client_id'
+CLOSE_TIME = 'close_time'
+COMPANY = 'company'
+COUNT = 'count'
+COUNT_NEW = 'count_new'
+COVER_LETTER = 'cover_letter'
+DESCRIPTION = 'description'
+ERROR = 'error'
+IS_VALID = 'is_valid'
+MAX_ACCEPTED_APPLICANTS = 'max_accepted_applicants'
+NAME = 'name'
+OPEN_TIME = 'open_time'
+OPENED_ONLY = 'opened_only'
+ORDERING = 'order'
+PASSWORD = 'password'
+REASON = 'reason'
+RECRUITER_ACTIVITY = 'recruiter_activity'
+REQUEST = 'request'
+REQUIREMENTS = 'requirements'
+RESPONSIBILITIES = 'responsibilities'
+SALARY = 'salary'
+SEARCH = 'search'
+SORT = 'sort'
+STATUS = 'status'
+TAG = 'tag'
+VACANCY = 'vacancy'
+VACANCY_ID = 'vacancy_id'
+VERIFIED = 'verified'
+WORKING_PERIOD = 'working_period'