/home/liman/liman-backend/accounting/ Current File: /home/liman/liman-backend/accounting/views.py
import json

from django.db.models import Sum, Count, Q
from django.db.models.functions import ExtractWeekDay, ExtractHour, ExtractMonth, ExtractDay, ExtractYear
from django.http import JsonResponse
from rest_framework import viewsets
from rest_framework.decorators import api_view
from rest_framework.permissions import IsAuthenticated

from limanAuth.models import User, Customer
from limanAuth.serializers import UserBankAccountSerializer, UserBankAccountPKField
from permissions.permissions import PermissionLevel
from utility.table_engine.src.table_engine import TableEngine
from .serializers import *
from .models import *
from rest_framework.decorators import permission_classes as permissionclasses
from limanAuth.views import calc_ranking
from rest_framework.response import Response


# -------------- Bank Account -----------------

class AdminUserBankAccountView(viewsets.ModelViewSet):
    serializer_class = UserBankAccountSerializer
    queryset = UserBankAccount.objects.all()
    access_level = 100
    permission_classes = [PermissionLevel]
    http_method_names = ['get', 'post', 'patch', 'update', 'delete']

    @staticmethod
    @api_view(['POST'])
    @permissionclasses([PermissionLevel])
    def table(request):
        table_engine = TableEngine(
            UserBankAccount.objects.all(),
            request.bodyDict).init_cols(
            ["id", "owner"]).execute()
        return JsonResponse(table_engine)


class UserBankAccountView(viewsets.ModelViewSet):
    serializer_class = UserBankAccountPKField
    queryset = UserBankAccount.objects.all()
    http_method_names = ['get', 'post', 'patch', 'update', 'delete']

    def create(self, request):
        try:
            _inp = request.bodyDict
            _inp['user'] = request.user.pk
            new_bank_account = UserBankAccountSerializer(data=_inp)
            if new_bank_account.is_valid():
                new_bank_account.save()
                return Response(new_bank_account.data)
            else:
                return Response(new_bank_account.errors, status=422)
        except Exception as e:
            return Response(str(e), 422)

    def get_queryset(self):
        user = self.request.user
        return UserBankAccount.objects.filter(user=user)

    @staticmethod
    @api_view(['POST'])
    @permissionclasses([IsAuthenticated])
    def table(request):
        table_engine = TableEngine(
            UserBankAccount.objects.filter(user=request.user),
            request.bodyDict).init_cols(
            ["id", "owner"]).execute()
        return JsonResponse(table_engine)


# ---------------- Brand -----------------
class AdminBrandView(viewsets.ModelViewSet):
    serializer_class = BrandSerializer
    queryset = Brand.objects.all()
    access_level = 100
    permission_classes = [PermissionLevel]
    http_method_names = ['get', 'post', 'patch', 'update', 'delete']

    @staticmethod
    @api_view(['POST'])
    @permissionclasses([PermissionLevel])
    def table(request):
        table_engine = TableEngine(
            Brand.objects.all(),
            request.bodyDict).init_cols(
            ["id", "name", "slug"]).execute()
        return JsonResponse(table_engine)


class BrandView(viewsets.ModelViewSet):
    serializer_class = BrandSerializer
    queryset = Brand.objects.all()
    permission_classes = [IsAuthenticated]
    http_method_names = ['get']

    @staticmethod
    @api_view(['POST'])
    @permissionclasses([IsAuthenticated])
    def table(request):
        table_engine = TableEngine(
            Brand.objects.all(),
            request.bodyDict).init_cols(
            ["id", "name", "slug"]).execute()
        return JsonResponse(table_engine)


# ---------------- Category ---------------

class AdminCategoryView(viewsets.ModelViewSet):
    serializer_class = CategorySerializer
    queryset = Category.objects.all()
    access_level = 100
    permission_classes = [PermissionLevel]
    http_method_names = ['get', 'post', 'patch', 'update', 'delete']

    @staticmethod
    @api_view(['POST'])
    @permissionclasses([PermissionLevel])
    def table(request):
        table_engine = TableEngine(
            Category.objects.all(),
            request.bodyDict).init_cols(
            ["id", "name", "slug"]).execute()
        return JsonResponse(table_engine)


class CategoryView(viewsets.ModelViewSet):
    serializer_class = CategorySerializer
    queryset = Category.objects.all()
    permission_classes = [IsAuthenticated]
    http_method_names = ['get']

    @staticmethod
    @api_view(['POST'])
    @permissionclasses([IsAuthenticated])
    def table(request):
        with_product = 'with_product' in request.bodyDict and request.bodyDict['with_product']
        table_engine = TableEngine(
            Category.objects.all(),
            request.bodyDict).init_cols(
            ["id", "name", "slug"]).execute()
        if with_product:
            for item in table_engine['rows'][0]:
                item['products'] = ProductSerializer(
                    instance=Product.objects.filter(category_id=item['id']).order_by('-id').all()[:10:1],
                    many=True).data
        return JsonResponse(table_engine)


# ---------------- Document ----------------

class AdminDocumentView(viewsets.ModelViewSet):
    serializer_class = DocumentSerializer
    queryset = Document.objects.all()
    access_level = 100
    permission_classes = [PermissionLevel]
    http_method_names = ['get', 'post', 'patch', 'update', 'delete']

    def create(self, request):
        try:
            _inp = request.dict
            document = DocumentSerializer(data=_inp)
            if document.is_valid():
                document.save()
                for item in _inp['items']:
                    item['document'] = document.instance.pk
                    total = 0
                    if 'unit_price' in item and item['unit_price']:
                        amount = item['amount'] if ('amount' in item and item['amount']) else 1
                        total += int(item['unit_price']) * int(amount)
                    if 'product' in item and item['product']:
                        total += Product.objects.get(pk=item['product']).price
                    item['total']=total
                    item = DocumentItemSerializer(data=item)
                    if item.is_valid():
                        item.save()
                    else:
                        document.instance.delete()
                        return Response(data=item.errors, status=422)
                return Response(data=document.data, status=200)
            else:
                return Response(data=document.errors, status=422)
        except Exception as e:
            return Response(str(e), status=500)

    def partial_update(self, request, pk):

        res = super().partial_update(request, pk)
        if 'accepted' in request.dict:
            _doc = Document.objects.get(pk=pk)
            calc_ranking(id, ('customer' if _doc.creator.user_type == 2 else 'porter'))
        return res

    @staticmethod
    @api_view(['POST'])
    @permissionclasses([PermissionLevel])
    def table(request):
        table_engine = TableEngine(
            Document.objects.all(),
            request.bodyDict).init_cols(
            ["id", "c_no", "no", "type"]).execute()
        return JsonResponse(table_engine)


class BuiltDocumentView(viewsets.ModelViewSet):
    serializer_class = BuiltDocument
    queryset = Document.objects.all()
    permission_classes = [IsAuthenticated]
    http_method_names = ['get', 'post', 'patch', 'update', 'delete']

    def create(self, request):
        try:
            _inp = request.dict
            _inp['creator'] = request.user.pk
            user = User.objects.filter(pk=_inp['user']).first()
            if user.customer not in request.user.porter.customers.all():
                return Response(data="مشتری مورد نظر یافت نشد.", status=404)
            document = DocumentSerializer(data=_inp)
            if document.is_valid():
                document.save()
                for item in _inp['items']:
                    item['document'] = document.instance.pk
                    total = 0
                    if 'unit_price' in item and item['unit_price']:
                        amount = item['amount'] if ('amount' in item and item['amount']) else 1
                        total += int(item['unit_price']) * int(amount)
                    if 'product' in item and item['product']:
                        total += Product.objects.get(pk=item['product']).price
                    item['total']=total
                    item = DocumentItemSerializer(data=item)
                    if item.is_valid():
                        item.save()
                    else:
                        document.instance.delete()
                        return Response(data=item.errors, status=422)
                return Response(data=document.data, status=200)
            else:
                return Response(data=document.errors, status=422)
        except Exception as e:
            return Response(str(e), status=500)

    @staticmethod
    @api_view(['POST'])
    @permissionclasses([PermissionLevel])
    def table(request):
        table_engine = TableEngine(
            Document.objects.filter(creator=request.user),
            request.bodyDict).init_cols(
            ["id", "c_no", "no", "type"]).execute()
        for item in table_engine['rows'][0]:
            item['items'] = DocumentItemSerializer(
                instance=DocumentItem.objects.filter(document_id=item['id']).all(),
                many=True).data
        return JsonResponse(table_engine)

    def get_queryset(self):
        user = self.request.user
        return Document.objects.filter(creator=user)


class MyDocumentView(viewsets.ModelViewSet):
    serializer_class = MyDocument
    queryset = Document.objects.all()
    permission_classes = [IsAuthenticated]
    http_method_names = ['get']

    @staticmethod
    @api_view(['POST'])
    @permissionclasses([IsAuthenticated])
    def table(request):
        table_engine = TableEngine(
            Document.objects.filter(user=request.user),
            request.bodyDict).init_cols(
            ["id", "c_no", "no", "type"]).execute()
        for item in table_engine['rows'][0]:
            item['items'] = DocumentItemSerializer(
                instance=DocumentItem.objects.filter(document_id=item['id']).all(),
                many=True).data
        return JsonResponse(table_engine)

    def get_queryset(self):
        user = self.request.user
        return Document.objects.filter(user=user)


# ---------------- Document-Item ----------------

class AdminDocumentItemView(viewsets.ModelViewSet):
    serializer_class = DocumentItemSerializer
    queryset = DocumentItem.objects.all()
    access_level = 100
    permission_classes = [PermissionLevel]
    http_method_names = ['get', 'post', 'patch', 'update', 'delete']

    @staticmethod
    @api_view(['POST'])
    @permissionclasses([PermissionLevel])
    def table(request):
        table_engine = TableEngine(
            DocumentItem.objects.all(),
            request.bodyDict).init_cols(
            ["id", "document__id"]).execute()
        return JsonResponse(table_engine)


class BuiltDocumentItemView(viewsets.ModelViewSet):
    serializer_class = BuiltDocumentItem
    queryset = DocumentItem.objects.all()
    permission_classes = [IsAuthenticated]
    http_method_names = ['get', 'post', 'patch', 'update', 'delete']

    @staticmethod
    @api_view(['POST'])
    @permissionclasses([IsAuthenticated])
    def table(request):
        table_engine = TableEngine(
            DocumentItem.objects.filter(document__creator=request.user),
            request.bodyDict).init_cols(
            ["id", "document__id"]).execute()
        return JsonResponse(table_engine)

    def get_queryset(self):
        return DocumentItem.objects.filter(document__creator=self.request.user)


# ---------------- Product -----------------
class AdminProductView(viewsets.ModelViewSet):
    serializer_class = ProductSerializer
    queryset = Product.objects.all()
    access_level = 100
    permission_classes = [PermissionLevel]
    http_method_names = ['get', 'post', 'patch', 'update', 'delete']

    @staticmethod
    @api_view(['POST'])
    @permissionclasses([PermissionLevel])
    def table(request):
        table_engine = TableEngine(
            Product.objects.all(),
            request.bodyDict).init_cols(
            ["id", "name", "category", "brand"]).execute()
        return JsonResponse(table_engine)


class ProductView(viewsets.ModelViewSet):
    serializer_class = ProductSerializer
    queryset = Product.objects.all()
    permission_classes = [IsAuthenticated]
    http_method_names = ['get']

    @staticmethod
    @api_view(['POST'])
    @permissionclasses([IsAuthenticated])
    def table(request):
        table_engine = TableEngine(
            Product.objects.all(),
            request.bodyDict).init_cols(
            ["id", "name", "category", "brand"]).execute()
        return JsonResponse(table_engine)


# ---------------- Negotiable -----------------
class AdminNegotiableView(viewsets.ModelViewSet):
    serializer_class = NegotiableSerializer
    queryset = Negotiable.objects.all()
    access_level = 100
    permission_classes = [PermissionLevel]
    http_method_names = ['get', 'post', 'patch', 'update', 'delete']

    @staticmethod
    @api_view(['POST'])
    @permissionclasses([PermissionLevel])
    def table(request):
        table_engine = TableEngine(
            Negotiable.objects.all(),
            request.bodyDict).init_cols(
            ["id", "name", "slug"]).execute()
        return JsonResponse(table_engine)


class NegotiableView(viewsets.ModelViewSet):
    serializer_class = NegotiableSerializer
    queryset = Negotiable.objects.all()
    permission_classes = [IsAuthenticated]
    http_method_names = ['get']

    @staticmethod
    @api_view(['POST'])
    @permissionclasses([IsAuthenticated])
    def table(request):
        table_engine = TableEngine(
            Negotiable.objects.all(),
            request.bodyDict).init_cols(
            ["id", "name", "Slug"]).execute()
        return JsonResponse(table_engine)


# ---------------- Negotiable Type-----------------
class AdminNegotiableTypeView(viewsets.ModelViewSet):
    serializer_class = NegotiableTypeSerializer
    queryset = NegotiableType.objects.all()
    access_level = 100
    permission_classes = [PermissionLevel]
    http_method_names = ['get', 'post', 'patch', 'update', 'delete']

    @staticmethod
    @api_view(['POST'])
    @permissionclasses([PermissionLevel])
    def table(request):
        table_engine = TableEngine(
            NegotiableType.objects.all(),
            request.bodyDict).init_cols(
            ["id", "name", "slug"]).execute()
        return JsonResponse(table_engine)


class NegotiableTypeView(viewsets.ModelViewSet):
    serializer_class = NegotiableTypeSerializer
    queryset = NegotiableType.objects.all()
    permission_classes = [IsAuthenticated]
    http_method_names = ['get']

    @staticmethod
    @api_view(['POST'])
    @permissionclasses([IsAuthenticated])
    def table(request):
        table_engine = TableEngine(
            NegotiableType.objects.all(),
            request.bodyDict).init_cols(
            ["id", "name", "Slug"]).execute()
        return JsonResponse(table_engine)


# ------------------------------------------------

class Report:
    class Client:

        @staticmethod
        @api_view(['POST'])
        @permissionclasses([IsAuthenticated])
        def Sale(request):
            _type = request.bodyDict['type']
            _from = request.bodyDict['from']
            to = request.bodyDict['to']
 
            res = []
            docs = DocumentItem.objects.filter(document__creator_id=request.user.id, document__created_at__lte=to,
                                               document__created_at__gte=_from, total__gt=0)
            if _type == 'day':
                res = docs.annotate(
                    hour=ExtractHour('document__created_at'),
                ).values(
                    'hour',
                ).annotate(
                    total=Sum('total')
                ).values(
                    'hour',
                    'total'
                )
            if _type == 'week':
                res = docs.annotate(
                    weekday=ExtractWeekDay('document__created_at'),
                ).values(
                    'weekday',
                ).annotate(
                    total=Sum('total')
                ).values(
                    'weekday',
                    'total'
                )
            if _type == 'year':
                res = docs.annotate(
                    month=ExtractMonth('document__created_at'),
                ).values(
                    'month',
                ).annotate(
                    total=Sum('total')
                ).values(
                    'month',
                    'total'
                )
            if _type == 'month':
                res = docs.annotate(
                    day=ExtractDay('document__created_at'),
                ).values(
                    'day',
                ).annotate(
                    total=Sum('total')
                ).values(
                    'day',
                    'total'
                )
            return Response(res)

        @staticmethod
        @api_view(['POST'])
        @permissionclasses([IsAuthenticated])
        def getGold(request):
            _type = request.bodyDict['type']
            _from = request.bodyDict['from']
            to = request.bodyDict['to']
            is_customer = request.bodyDict['is_customer'] if 'is_customer' in request.bodyDict else False
            res = []
            if not is_customer:
                docs = DocumentItem.objects.filter(document__creator_id=request.user.id, document__created_at__lte=to,
                                                   document__created_at__gte=_from, weight__gt=0)
            else:
                docs = DocumentItem.objects.filter(document__user_id=request.user.id, document__created_at__lte=to,
                                                   document__created_at__gte=_from, weight__gt=0)
            if _type == 'day':
                res = docs.annotate(
                    hour=ExtractHour('document__created_at'),
                ).values(
                    'hour',
                ).annotate(
                    total=Sum('weight')
                ).values(
                    'hour',
                    'total'
                )
            if _type == 'week':
                res = docs.annotate(
                    weekday=ExtractWeekDay('document__created_at'),
                ).values(
                    'weekday',
                ).annotate(
                    total=Sum('weight')
                ).values(
                    'weekday',
                    'total'
                )
            if _type == 'year':
                res = docs.annotate(
                    month=ExtractMonth('document__created_at'),
                ).values(
                    'month',
                ).annotate(
                    total=Sum('weight')
                ).values(
                    'month',
                    'total'
                )
            if _type == 'month':
                res = docs.annotate(
                    day=ExtractDay('document__created_at'),
                ).values(
                    'day',
                ).annotate(
                    total=Sum('weight')
                ).values(
                    'day',
                    'total'
                )
            return Response(res)

        @staticmethod
        @api_view(['GET'])
        @permissionclasses([IsAuthenticated])
        def topProduct(request):
            res = DocumentItem.objects.filter(~Q(product=None)).values('product_id').annotate(
                total=Count('product_id')).order_by(
                '-total')[:50]
            for item in res:
                if item['product_id']:
                    item['product'] = ProductSerializer(instance=Product.objects.get(pk=item['product_id'])).data
            return Response(res)

    class Admin:
        @staticmethod
        @api_view(['POST'])
        @permissionclasses([IsAuthenticated])
        def Sale(request):
            _type = request.bodyDict['type']
            _from = request.bodyDict['from']
            to = request.bodyDict['to']
            res = []
            docs = DocumentItem.objects.filter(document__created_at__lte=to,
                                               document__created_at__gte=_from, document__type=2, total__gt=0)
            if _type == 'day':
                res = docs.annotate(
                    hour=ExtractHour('document__created_at'),
                ).values(
                    'hour',
                ).annotate(
                    total=Sum('total')
                ).values(
                    'hour',
                    'total'
                )
            if _type == 'week':
                res = docs.annotate(
                    weekday=ExtractWeekDay('document__created_at'),
                ).values(
                    'weekday',
                ).annotate(
                    total=Sum('total')
                ).values(
                    'weekday',
                    'total'
                )
            if _type == 'year':
                res = docs.annotate(
                    month=ExtractMonth('document__created_at'),
                ).values(
                    'month',
                ).annotate(
                    total=Sum('total')
                ).values(
                    'month',
                    'total'
                )
            if _type == 'month':
                res = docs.annotate(
                    day=ExtractDay('document__created_at'),
                ).values(
                    'day',
                ).annotate(
                    total=Sum('total')
                ).values(
                    'day',
                    'total'
                )
            return Response(res)