RasadDam_Backend/apps/pos_device/web/api/v1/viewsets/device.py

from datetime import timedelta

from apps.pos_device.web.api.v1.serilaizers import device as device_serializer
from apps.authorization.api.v1.serializers import UserRelationSerializer
from apps.authentication.api.v1.api import UserViewSet
from apps.authorization.models import UserRelations
from rest_framework.exceptions import APIException
from apps.pos_device import models as pos_models
from rest_framework.response import Response
from rest_framework.decorators import action
from common.tools import CustomOperations
from common.helpers import generate_code
from django.utils.timezone import now
from rest_framework import viewsets
from django.db import transaction
from rest_framework import status


class ProviderCompanyViewSet(viewsets.ModelViewSet):  # noqa
    queryset = pos_models.ProviderCompany.objects.all()
    serializer_class = device_serializer.ProviderCompanySerializer

    def list(self, request, *args, **kwargs):
        """ list of provider companies """

        # paginate devices
        page = self.paginate_queryset(self.queryset.order_by('-create_date'))
        if page is not None:
            serializer = self.get_serializer(page, many=True)
            return self.get_paginated_response(serializer.data)

    @action(
        methods=['get'],
        detail=False,
        url_path='psp_users',
        url_name='psp_users',
        name='psp_users'
    )
    def users_with_psp_org(self):
        """ list of psp users """

        users = UserRelations.objects.filter(
            organization__type__key='PSP'
        )

        # paginate devices
        page = self.paginate_queryset(users)
        if page is not None:
            serializer = UserRelationSerializer(page, many=True)
            return self.get_paginated_response(serializer.data)


class DeviceViewSet(viewsets.ModelViewSet):
    queryset = pos_models.Device.objects.all()
    serializer_class = device_serializer.DeviceSerializer

    def create(self, request, *args, **kwargs):
        """ Custom create of pos devices """

        if 'company' not in request.data.keys():
            company = pos_models.ProviderCompany.objects.get(
                user_relation__user=request.user
            )
            request.data.update({'company': company.id})

        # create device
        serializer = self.serializer_class(data=request.data)
        if serializer.is_valid():
            serializer.save()

            return Response(serializer.data, status=status.HTTP_201_CREATED)
        return Response(serializer.errors, status=status.HTTP_403_FORBIDDEN)

    @action(
        methods=['get'],
        detail=False,
        url_name='my_devices',
        url_path='my_devices',
        name='my_devices'
    )
    @transaction.atomic
    def my_devices(self, request):
        """ list of company devices """

        devices = self.queryset.filter(
            company__user_relation__user=request.user
        )

        # paginate devices
        page = self.paginate_queryset(devices)
        if page is not None:
            serializer = self.get_serializer(page, many=True)
            return self.get_paginated_response(serializer.data)

    def activate_device(self, request):
        """ activations of pos by a temporary code """

        device = self.queryset.filter(serial=request.data['serial']).first()
        if not device or not device.is_activated:
            code = generate_code()
            pos_models.DeviceActivationCode.objects.create(
                code=code,
                expires_at=now() + timedelta(hours=2)
            )
            return Response({'code': code, 'detail': 'enter code in panel'}, status=status.HTTP_202_ACCEPTED)
        elif device.is_activated:
            raise APIException('device is activated', code=403)


class DeviceVersionViewSet(viewsets.ModelViewSet):
    queryset = pos_models.DeviceVersion.objects.all()
    serializer_class = device_serializer.DeviceVersionSerializer


class SessionViewSet(viewsets.ModelViewSet):  # noqa
    queryset = pos_models.Sessions.objects.all()
    serializer_class = device_serializer.SessionSerializer


class DeviceAssignmentViewSet(viewsets.ModelViewSet):
    queryset = pos_models.DeviceAssignment.objects.all()
    serializer_class = device_serializer.DeviceAssignmentSerializer

    @action(
        methods=['post'],
        detail=False,
        url_path='assignment',
        url_name='assignment',
        name='assignment',
    )
    @transaction.atomic
    def device_assignment(self, request):
        """ assign pos device to client by company """

        if 'company' not in request.data.keys():
            company = pos_models.ProviderCompany.objects.get(
                user_relation__user=request.user
            )
            request.data.update({'company': company.id})

        # create assignment
        serializer = self.serializer_class(data=request.data)
        if serializer.is_valid():
            assignment = serializer.save()

            # set organization having pos status
            assignment.company.user_relation.organization.has_pos = True
            assignment.company.user_relation.organization.save()

            return Response(serializer.data, status=status.HTTP_201_CREATED)
        return Response(serializer.errors, status=status.HTTP_403_FORBIDDEN)

    @action(
        methods=['get'],
        detail=False,
        url_name='my_assignments',
        url_path='my_assignments',
        name='my_assignments'
    )
    def my_assignment(self, request):
        """ list of company device assignment to clients """

        try:
            company = pos_models.ProviderCompany.objects.get(
                user_relation__user=request.user
            )

            # get device assignment
            assignments = self.queryset.filter(company=company)

            serializer = self.serializer_class(assignments, many=True)
            return Response(serializer.data, status=status.HTTP_200_OK)
        except Exception as e:
            raise APIException('Non Object Error', code=403)


class StakeHoldersViewSet(viewsets.ModelViewSet):
    queryset = pos_models.StakeHolders.objects.all()
    serializer_class = device_serializer.StakeHoldersSerializer