vacancies.py

from datetime import datetime, time

from django.db.models import Q
from django.utils import timezone
from rest_framework import viewsets, status
from rest_framework.decorators import action
from rest_framework.exceptions import ValidationError
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
from core.views import views_constants

from core.lib.mixins import MultiSerializerViewSetMixin
from core.lib.permissions import IsAdminOrStudent, IsAdminOrCompany, IsAdminOrVacancyOwner, AsAdminOrSupervisor, \
    VacancyApprovalPermission, IsAdminOrVacancyOwnerOrAuthenticatedReadOnly
from core.models import Student, Company
from core.models.vacancies import Vacancy, Application, ReasonRejected
from core.serializers.vacancies import VacancySerializer, ApplicationSerializer, ApplicationStatusSerializer, \
    VacancyVerifiedSerializer, SupervisorStudentApplicationSerializer, \
    VacancyMilestoneSerializer
from core.views.accounts import StudentViewSet


def date_validator(open_time, close_time):
    if open_time < str(datetime.today()):
        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 {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 {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 {views_constants.IS_VALID: True, views_constants.ERROR: '', views_constants.STATUS: status.HTTP_200_OK}


class VacancyViewSet(MultiSerializerViewSetMixin, viewsets.ModelViewSet):
    queryset = Vacancy.objects.all()
    serializer_class = VacancySerializer
    permission_classes = [IsAdminOrCompany]
    pagination_class = PageNumberPagination

    def get_permissions(self):
        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[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[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))
        else:
            vacancies = Vacancy.objects.all()

        # Filter vacancies here
        vacancies = self.verifiedFilter(vacancies, verified)
        vacancies = self.openedJobFilter(vacancies, opened_only)
        vacancies = self.companyFilter(vacancies, companies)
        vacancies = self.sort(order_by, vacancies, order)

        page = self.paginate_queryset(vacancies)
        print(vacancies)
        print(request)
        if page is not None:
            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={views_constants.REQUEST: request}).data)

    def verifiedFilter(self, vacancies, flag):
        if flag.lower() in ("yes", "true", "t", "1"):
            vacancies = vacancies.filter(verified=True)
        if flag.lower() in {"no", "false", "f", "0"}:
            vacancies = vacancies.filter(verified=False)
        return vacancies

    def openedJobFilter(self, vacancies, flag):
        if flag.lower() in ("yes", "true", "t", "1"):
            today = datetime.combine(datetime.now().date(), time())
            vacancies = vacancies.filter(close_time__gte=today)
        return vacancies

    def companyFilter(self, vacancies, companies):
        if len(companies) > 0:
            vacancies = vacancies.filter(company__id__in=companies)
        return vacancies

    def sort(self, order_by, vacancies, order):
        if (order_by is not None) and (order_by in [views_constants.NAME, views_constants.SALARY, views_constants.MOST_RECENT, views_constants.CLOSE_TIME, views_constants.OPEN_TIME]) and (
                order in [views_constants.ORDER_ASCENDING, views_constants.ORDER_DESCENDING]):
            if order_by == views_constants.MOST_RECENT:
                return vacancies.order_by('-created')
            order_query = ""
            if order == views_constants.ORDER_DESCENDING:
                order_query = "-"
            return vacancies.order_by('{}{}'.format(order_query, order_by))
        return vacancies

    def name_position_validator(self, names):
        for name in names.split(" "):
            if not name.isalpha():
                raise ValidationError(views_constants.ERROR_NAME_MUST_ALPHABET)
        return name

    def salary_validator(self, salary):
        try:
            int(salary)
        except:
            raise ValidationError(views_constants.ERROR_SALARY_MUST_NUMBER)

    def amount_validator(self, amount):
        try:
            int(amount)
        except:
            raise ValidationError(views_constants.ERROR_AMOUNT_MUST_NUMBER)

    def office_address_validator(self, office_address):
        print(office_address)
        print(type(office_address))
        if not isinstance(office_address, str):
            print('DEBUG ERROR')
            raise ValidationError(views_constants.ERROR_INVALID_OFFICE_ADDRESS)

    def responsibilities_validator(self, responsibilities):
        if not isinstance(responsibilities, str):
            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, str)) or (recruiter_activity not in enum_recruiter_activity):
            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[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(views_constants.ERROR_COMPANY_DOES_NOT_EXIST)
        return company_set[0]

    def __parse_vacancy_data(self, raw_data):
        data = {
            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.OFFICE_ADDRESS: raw_data.get(views_constants.OFFICE_ADDRESS, ''),
            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[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])
        if data.get(views_constants.OFFICE_ADDRESS):
            self.office_address_validator(data[views_constants.OFFICE_ADDRESS])

    def create(self, request):
        print("[LOG] data: " + str(request.data))
        try:
            data = self.__parse_vacancy_data(request.data)
            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({views_constants.ERROR: str(e.detail[0])}, status=status.HTTP_400_BAD_REQUEST)
        except ValueError as e:
            print("[LOG] error: " + str(e))
            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):
        print("[LOG] data: " + str(request.data))
        try:
            data = self.__parse_vacancy_data(request.data)
            self.__validate_vacancy_data(data)
            vacancy = Vacancy.objects.get(pk=pk)
            for (key, value) in data.items():
                setattr(vacancy, key, value)
            vacancy.save()
        except ValidationError as e:
            print("[LOG] error: " + str(e))
            return Response({views_constants.ERROR: str(e.detail[0])}, status=status.HTTP_400_BAD_REQUEST)
        return Response(status=status.HTTP_200_OK)

    @action(detail=True, permission_classes=[IsAdminOrCompany])
    def count(self, request, pk=None):
        vacancy = self.get_object()
        count = Application.objects.filter(vacancy=vacancy).count()
        count_new = Application.objects.filter(vacancy=vacancy, status=Application.NEW).count()
        return Response({views_constants.COUNT: count, views_constants.COUNT_NEW: count_new}, status=status.HTTP_200_OK)

    @action(detail=True, methods=[views_constants.METHOD_PATCH], permission_classes=[VacancyApprovalPermission],
            serializer_class=VacancyVerifiedSerializer)
    def verify(self, request, pk=None):
        vacancy = self.get_object()
        serializer = self.get_serializer_class()(vacancy, data=request.data, partial=True)
        if serializer.is_valid():
            serializer.save()
            return Response(serializer.data, status=status.HTTP_200_OK)
        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 = {
        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(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={views_constants.REQUEST: request}).data)
        return Response(serializer(applications, many=True, context={views_constants.REQUEST: request}).data)

    @action(detail=True, methods=[views_constants.METHOD_GET], permission_classes=[IsAdminOrStudent])
    def count(self, request, pk=None):
        count = Application.objects.filter(vacancy_id=pk).count()
        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[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[views_constants.REASON])
            return Response(serializer.data, status=status.HTTP_202_ACCEPTED)
        else:
            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

    @action(detail=True, methods=[views_constants.METHOD_GET], permission_classes=[IsAdminOrVacancyOwner])
    def transcript(self, request, pk):
        """
        Get student's academic transcript on application {application_id}
        ---
        """
        application = self.get_object()
        return StudentViewSet.transcript(StudentViewSet(), request, application.student.pk)

    def get_permissions(self):
        if self.action == views_constants.ACTION_LIST:
            return [AsAdminOrSupervisor()]
        return super(ApplicationViewSet, self).get_permissions()


class StudentApplicationViewSet(viewsets.GenericViewSet):
    serializer_class = ApplicationSerializer
    permission_classes = [IsAdminOrStudent]
    pagination_class = PageNumberPagination

    def list(self, request, student_id):
        """
        Get list of a student {student_id}'s applied vacancies
        ---
        """
        student = get_object_or_404(Student.objects.all(), pk=student_id)
        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)))
        else:
            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={views_constants.REQUEST: request}).data)
        return Response(VacancySerializer(vacancies, many=True, context={views_constants.REQUEST: request}).data)

    def create(self, request, student_id):
        """
        Create a new application for student {student_id}
        ---
        parameters:
            - name: body
              description: JSON object containing an integer 'vacancy_id' and a string 'cover_letter'
              required: true
              type: string
              paramType: body
        """
        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({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(views_constants.ERROR_VACANCY_ALREADY_APPLIED)
        application = Application(vacancy=vacancy, student=student, cover_letter=cover_letter)
        application.save()
        return Response(ApplicationSerializer(application, context={views_constants.REQUEST: request}).data)

    def destroy(self, request, student_id, pk):
        """
        Remove a application {id} for student {student_id}
        ---
        """
        vacancy = get_object_or_404(Vacancy.objects.all(), pk=pk)
        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={views_constants.REQUEST: request}).data)

    @action(detail=True, 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}
        ---
        """
        vacancy = get_object_or_404(Vacancy.objects.all(), pk=pk)
        student = get_object_or_404(Student.objects.all(), pk=student_id)
        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({views_constants.REASON: reason_rejected.reason}, status=status.HTTP_200_OK)


class StatusError(Exception):
    pass


class UnauthorizeError(Exception):
    pass


class CompanyApplicationViewSet(viewsets.GenericViewSet):
    queryset = Application.objects.all()
    permission_classes = [IsAdminOrCompany]
    pagination_class = PageNumberPagination

    def list(self, request, company_id):
        """
        Get list of company {company_id}'s applications
        ---
        """
        try:
            company = self.__get_company_list_by_company_id(request, company_id)
            vacancies = self.__get_vacancy_list_filter_by_company(company)
            applications = self.__get_application_list_filter_by_vacancies(vacancies)
            applications = self.__filter_application_list_by_status(request, applications)
            return self.__get_paginated_application_list(request, applications)
        except UnauthorizeError:
            return Response({views_constants.ERROR: views_constants.ERROR_FORBIDDEN}, status=status.HTTP_403_FORBIDDEN)
        except (StatusError, ValueError):
            return Response({views_constants.ERROR: views_constants.ERROR_INVALID_STATUS_CODE},
                            status=status.HTTP_400_BAD_REQUEST)

    @action(detail=True, 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}
        ---
        """
        try:
            if pk is None:
                return list(self, request, company_id)
            company = self.__get_company_list_by_company_id(request, company_id)
            vacancy = self.__get_vacancy_list_by_pk(pk, company)
            applications = self.__get_application_by_vacancy(vacancy)
            applications = self.__filter_application_list_by_status(request, applications)
            return self.__get_paginated_application_list(request, applications)
        except UnauthorizeError:
            return Response({views_constants.ERROR: views_constants.ERROR_FORBIDDEN}, status=status.HTTP_403_FORBIDDEN)
        except (StatusError, ValueError):
            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(views_constants.ORDER_UPDATED), pk=company_id)
        if not self.__validating_user(request, company):
            raise UnauthorizeError
        return company

    def __validating_user(self, request, company):
        return request.user.is_superuser or request.user == company.user

    def __get_vacancy_list_by_pk(self, pk, company):
        vacancy = get_object_or_404(Vacancy.objects.all(), pk=pk)
        if not self.__validating_vacancy(vacancy, company):
            raise UnauthorizeError
        return vacancy

    def __validating_vacancy(self, vacancy, company):
        return vacancy.company == company

    def __get_vacancy_list_filter_by_company(self, company):
        return Vacancy.objects.filter(company=company)

    def __get_application_list_filter_by_vacancies(self, vacancies):
        return Application.objects.filter(vacancy__in=vacancies)

    def __get_application_by_vacancy(self, vacancy):
        return Application.objects.filter(vacancy=vacancy)

    def __get_status_from_request_param(self, request):
        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"}
        if status not in list_status:
            raise StatusError
        return True

    def __filter_application_list_by_status(self, request, applications):
        status = self.__get_status_from_request_param(request)
        if status is not None:
            status = int(status)
            self.__validating_application_status(status)
            return applications.filter(status=status)
        return applications

    def __get_paginated_application_list(self, request, applications):
        page = self.paginate_queryset(applications)
        if page is not None:
            return self.get_paginated_response(
                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):
    queryset = Vacancy.objects.all()
    pagination_class = PageNumberPagination
    permission_classes = [IsAdminOrCompany]

    def list(self, request, company_id):
        """
        Get list of company {company_id}'s vacancies
        ---
        """
        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({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={views_constants.REQUEST: request}).data)
        return Response(VacancySerializer(vacancies, many=True, context={views_constants.REQUEST: request}).data)


class BookmarkedVacancyByStudentViewSet(viewsets.GenericViewSet):
    serializer_class = VacancySerializer
    permission_classes = [IsAdminOrStudent]

    def list(self, request, student_id):
        """
        Get list of a student {student_id}'s bookmarked vacancies
        ---
        """
        student = get_object_or_404(Student.objects.all(), pk=student_id)
        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))
        else:
            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={views_constants.REQUEST: request}).data)
        return Response(VacancySerializer(vacancies, many=True, context={views_constants.REQUEST: request}).data)

    def create(self, request, student_id):
        """
        Bookmarks a vacancy for student {student_id}
        ---
        parameters:
            - name: body
              description: JSON object containing only one string: vacancy_id
              required: true
              type: string
              paramType: body
        """
        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={views_constants.REQUEST: request}).data)

    def destroy(self, request, student_id, pk):
        """
        Remove bookmark {id} for student {student_id}
        ---
        """
        vacancy = get_object_or_404(Vacancy.objects.all(), pk=pk)
        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={views_constants.REQUEST: request}).data)


class VacancyMilestoneViewSet(viewsets.GenericViewSet):
    serializer_class = VacancyMilestoneSerializer
    permission_classes = [IsAdminOrVacancyOwnerOrAuthenticatedReadOnly]

    def list(self, request, vacancy_id):
        """
        Get list of a vacancy {vacancy_id}'s milestone plans
        ---
        """
        vacancy = get_object_or_404(Vacancy.objects.all(), pk=vacancy_id)
        milestones = vacancy.milestones.all()
        page = self.paginate_queryset(milestones)
        if page is not None:
            return self.get_paginated_response(
                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):
        """
        Create a new milestone for vacancy {vacancy_id}
        ---
        parameters:
            - name: body
              description: JSON object containing 'name' string, 'detail' string, 'expected_start' date string, and
                           'expected_finish' date string
              required: true
              type: string
              paramType: body
        """
        vacancy = get_object_or_404(Vacancy.objects.all(), pk=vacancy_id)
        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={views_constants.REQUEST: request}).data,
                            status=status.HTTP_200_OK)
        return Response(milestone_serializer.errors, status=status.HTTP_400_BAD_REQUEST)

    def update(self, request, vacancy_id, pk):
        """
        Create existing milestone {pk} for vacancy {vacancy_id}
        ---
        parameters:
            - name: body
              description: JSON object containing 'name' string, 'detail' string, 'expected_start' date string, and
                           'expected_finish' date string
              required: true
              type: string
              paramType: body
        """
        vacancy = get_object_or_404(Vacancy.objects.all(), pk=vacancy_id)
        old_milestone = get_object_or_404(vacancy.milestones.all(), pk=pk)
        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={views_constants.REQUEST: request}).data,
                            status=status.HTTP_200_OK)
        return Response(milestone_serializer.errors, status=status.HTTP_400_BAD_REQUEST)

    def destroy(self, request, vacancy_id, pk):
        """
        Remove existing milestone {pk} from vacancy {vacancy_id}
        ---
        """
        vacancy = get_object_or_404(Vacancy.objects.all(), pk=vacancy_id)
        milestone = get_object_or_404(vacancy.milestones.all(), pk=pk)
        milestone.delete()
        return Response(
            self.serializer_class(vacancy.milestones.all(), many=True, context={views_constants.REQUEST: request}).data)


class AcceptOfferByStudentViewSet(MultiSerializerViewSetMixin, viewsets.GenericViewSet):
    queryset = Application.objects.all()
    permission_classes = [IsAdminOrStudent]

    def partial_update(self, request, student_id, pk=None):
        """
        Get list of a student {student_id}'s cancel offered vacancies
        ---
        """
        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={views_constants.STATUS: 5}, partial=True)
                if serializer.is_valid():
                    serializer.save()

        return Response(SupervisorStudentApplicationSerializer(apps, many=True, context={views_constants.REQUEST: request}).data)