Rasadyar_Hamedan/panel/KillHouse/views.py

import random
import string
import threading
from datetime import datetime, timedelta

import jdatetime
import requests
from django.contrib.auth.models import User, Group
from django.db.models import Case, When, Avg
from django.http import JsonResponse, HttpResponse
from django.http import QueryDict
from django.shortcuts import get_object_or_404
from django.utils import timezone
from django.views.decorators.csrf import csrf_exempt
from django_filters.rest_framework import DjangoFilterBackend
from oauth2_provider.contrib.rest_framework import (
    TokenHasReadWriteScope,
)
from rest_framework import status
from rest_framework import viewsets
from rest_framework.decorators import permission_classes, api_view
from rest_framework.generics import GenericAPIView
from rest_framework.pagination import PageNumberPagination
from rest_framework.permissions import AllowAny
from rest_framework.response import Response
from rest_framework.views import APIView

from authentication.arvan_image.arvan_storage import upload_object_resize
from authentication.models import UserProfile, SystemUserProfile, City, Province, SystemAddress
from authentication.serializer.serializer import SystemUserProfileSerializer
from authentication.sms_management import kill_request_province_sms, province_kill_request_to_kill_house_sms, \
    kill_request_delete_province_sms, province_kill_request_accept_sms, document_discrepancy_sms, export_code_sms, \
    car_allocation_vet_farm_sms, delete_car_allocation_vet_farm_sms, send_sms_for_bar_difference_request, \
    confirm_price_poultry_request_direct_buying_sms, send_sms_fro_kill_request_market, send_sms_for_sale_bar
from authentication.views import ARTA_URL_CHANGE_MOBILE_NUMBER
from bot_eata import bot_eitaa_for_each_province_kill_request, bot_eitaa_for_each_delete_province_kill_request, \
    send_single_bar_to_eitaa
from deposit_id import market_code_state
from general_urls import base_url_sms, base_url_for_sms_report
from panel.KillHouse.helpers import kill_house_requests_product_warehousing, kill_house_free_buying_product_warehousing, \
    kill_house_free_sale_product_warehousing, get_finance_info, generate_unique_bar_code, \
    send_ticket_for_bar_difference_request, market_poultry_request_remain_quantity, market_kill_request_share_quantity, \
    calculate_governmental_quota, check_kill_house_remain_limitation_weight
from panel.KillHouse.serializers import (
    KillHouseSerializer,
    KillHouseRequestSerializer,
    KillRequestSerializer,
    KillHouseAssignmentInformationSerializer,
    KillHouseCheckRequestSerializer,
    KillHouseADDCARSerializer,
    VetSerializer,
    VetCheckRequestSerializer,
    ProvinceKillRequestSerializer,
    KillHouseRequestExchangeSerializer,
    KillHouseRequestExchangeReserveSerializer,
    KillHouseRequestExchangeAddCarSerializer,
    KillHouseDriverSerializer,
    KillHouseOperatorSerializer,

    KillHouseRequestActionSerializer,

    KillHouseRequestActionWinnerSerializer, DriverRequestCancelSerializer, KillHouseVetSerializer,
    KillHouseComplaintSerializer, CheckKillHouseComplaintSerializer, CheckUnusualCasualtiesSerializer,
    KillHousePercentageSerializer, KillHouseAssignmentImagesSerializer, KillRequestFactorSerializer,
    KillRequestFactorPaymentSerializer, AutomaticKillRequestSerializer, KillHouseCreditorsSerializer,
    KillHouseAllowVetSerializer, KillHouseWareHouseSerializer, KillHouseFreeBarInformationSerializer,
    KillHouseRequestForBarManagementSerializer, ProvinceKillRequestProvinceWageSerializer,
    KillHouseForProvinceWageSerializer, KillHouseforPurchaseRequestSerializer, KillHousePurchaseRequestSerializer,
    KillHouseForAutomaticStewardAllocationSerializer, KillHouseForTotalReportAutomaticStewardAllocationSerializer,
    PoultryRequestLetterForProvinceVetSerializer,
    ProvinceKillRequestForKillingInformationDiscrepancyReportSerializer, KillHouseRequestForDiffrentBarInfoSerializer,
    PoultryRequestForTotalInformationSerializer, PoultryRequestForTotalInformationInTableSerializer,
    KillHouseWareHouseForDailyBroadCastOInDetailsSerializer, KillHouseAssignmentInformationForCompletedLoadsSerializer,
    KillHouseFreeSaleBarInformationSerializer, KillHouseWageForTotalDashbordSerializer,
    KillHouseForProvinceWageWithDateSerializer, SlaughterHouseTransactionSerializer, KillHouseWageSerializer,
    KillHouseForFreeBarWageSerializer, KillHouseForFreeBarWageWithDateSerializer,
    KillHouseForTotalProvinceWageTransactionSerializer, KillHouseForTotalProvinceWageTransactionWithDAteSerializer,
    KillHouseForKillHouseRequestWageWithDateSerializer, KillHouseForKillHouseRequestWageSerializer,
    KillHouseFreeBarInformationForWageTotalSerializer,
    TotalWageInformationKillHouseExclusiveKillerSerializer, KillHouseLetterForProvinceSerializer,
    PoultryRequestoutProvinceSerializer, BarDocumentStatusSerializer, GeneralKillHouseSerializer,
    VetKillHouseSerializer, VetFarmListSerializer, KillHouseForKillHouseVetKillHouseSerializer,
    KillHouseForFreeSaleBarInformationViewSetSerializer,
    KillHouseForFreeSaleBarInformationViewSetWithDateSerializer, KillHouseForNewWageInormationSerializer,
    KillHouseRequestForInputBarsSerializer, PosKillHouseSerializer, KillHouseForProvinceWareHouseDashboardSerializer,
    ParentCompanyKillHouseForNewWageInormationSerializer, KillHouseForColdHouseSerializer,
    KillHouseColdHousesSerializer, BarDifferenceRequestSerializer, distributionKillHouseSerializer,
    KillHouseForPerformanceDashboardSerializer, DirectBuyingPaymentSerializer, KillRequestForDirectBuyingSerializer,
    ProvinceKillRequestForDirectBuyingSerializer, KillHouseForCommonlyUsedSerializer, KillHouseMarketInfoSerializer,
    KillHouseForColdHouseAllocationSerializer, KillHouseForSegmentationSerializer,
    KillHouseComparativeInformationSerializer, KillRequestForDirectBuyingTrueSerializer,
    ReturnProvinceKillRequestSerializer, TotalKillHouseRemainWeightViewSetSerializer,
    TotalKillHouseWarehouseArchiveDashboardSerializer, PspKillHouseSerializer
)
from panel.ProvinceOperator.serializers import ProvinceFactorToKillHouseSerializer, StewardAllocationSerializer
from panel.ProvinceOperator.views import ARVAN_Kill_house_Factor_URL
from panel.ReportingPanel.helper import kill_house_request_filterset_fields, \
    poultry_request_new_fields
from panel.ReportingPanel.views import get_gid_out_province
from panel.VetFarm.serializers import VetFarmSerializer
from panel.admin import PROJECT_API_KEY
from panel.filterset import KillHouseDriverFilterSet, VetFilterSet, KillHouseRequestFilterSet, \
    ProvinceKillRequestFilterSet, KillHouseFilterSet, KillRequestFilterSet, PoultryRequestFilterSet, \
    KillHouseFreeBarInformationFilterSet, DashboardEnterLoadInformationFilterSet, \
    DashboardKillHouseFreeBarInformationFilterSet, VetFarmAndKillHouseFilterSet, ProvinceKillRequestNewFilterSet, \
    DashboardKillRequestFilterSet, KillHouseFreeSaleBarInformationFilterSet, \
    BarDifferenceRequestFilterSet, DirectBuyingPaymentFilterSet, ReturnProvinceKillRequestFilterSet
from panel.helper import build_query
from panel.models import (
    KillHouse,
    KillHouseRequest,
    KillRequest,
    ProvinceCheckOperatorRequest,
    KillHouseCheckRequest,
    KillHouseAssignmentInformation,
    ProvinceFactorToKillHouse,
    KillHouseADDCAR,
    Vet,
    VetCheckRequest,
    ProvinceKillRequest,
    KillHouseRequestExchange,
    KillHouseRequestExchangeReserve,
    PoultryRequestExchange,
    KillHouseRequestExchangeAddCar,
    PoultryRequest,
    KillHouseDriver,
    KillHouseOperator,
    VetFarm,
    KillHouseRequestAction,
    KillHouseRequestActionWinner, DriverRequestCancel, KillHouseVet, PercentageOfLosses, KillHouseComplaint,
    CheckKillHouseComplaint, ProvinceFactorToKillHouseForPoultry, CheckUnusualCasualties, KillHousePercentage,
    TotalPoultryRequestQuantity, KillHouseAssignmentImages, VetSupervisor, KillRequestFactor, KillRequestFactorPayment,
    Pricing, AutomaticKillRequest, KillHouseCreditors, ShareOfAllocation, ProvinceOperator, SmsLicense,
    KillHouseAllowVet, Wallet, ProvinceAllowKillHouseRegisterCar, PoultryHatching, Poultry,
    AutoAcceptProvinceKillRequest, KillHouseWareHouse, KillHouseFreeBarInformation, Guilds,
    CityOperator, PoultryRequestAuction, ProvinceAllowKillHouseChooseStewardGuilds, KillHouseHourLimit,
    ProvinceAllowKillHouseDirectBuying, KillHousePurchaseRequest, Steward, StewardAllocation, StewardWareHouse,
    ColdHouseAllocations, KillHouseFreeSaleBarInformation, OperationLimitation,
    EvacuationPermit, TimeRange, SlaughterHouseTransaction, WageType, PercentageOfWageType,
    InternalTransaction, BarDocumentStatus, VetFarmAggregatePermission, OutProvinceCarcassesBuyer, RolesProducts,
    AutomaticDirectBuyingPermission, FreeSaleWithinprovince, CityOperatorCheckRequest, POSMachine, ColdHouse,
    BarDifferenceRequest, ChickenAgeRange, RequestLimitation, PriceConfirmation, DirectBuyingPayment,
    DirectBuyingVerification, FinePermission, IndexWeightCategory, PosSegmentation, RestrictionCarcassDistribution,
    AllowRegisterCodeForKillHouseFreeSaleBarInformation, ProductsTransactions,
    LimitationForDirectPurchaseAndBarInformation, WarehouseArchive
)
# آدرس پایه مربوط به ذخیره عکس در گالری مربوط به کشتارگاه در استوریج آروان
from panel.poultry.helpers import poultry_prediction, create_update_chicken_commission_prices
from panel.poultry.serializers import PoultryRequestSerializer, PoultryRequestForKillingInformationSerializer
from ticket.bucket import upload_to_liara
from ticket.helper import send_image_to_server

ARVAN_Kill_house_URL = 'https://profileimagedefault.s3.ir-thr-at1.arvanstorage.ir/'
ARTA_URL_REGISTER = "https://userbackend.rasadyar.com/api/register/"


class CustomPagination(PageNumberPagination):
    page_size = 10


from django.db.models import Q


def get_exclusive_killer_operation(kill_houses):
    for kill_house in kill_houses:
        total_unpaid_wage = 0
        total_paid_wage = 0
        province_kill_requests = ProvinceKillRequest.objects.filter(killhouse_user=kill_house,
                                                                    state__in=('pending', 'accepted'), trash=False,
                                                                    return_to_province=False,
                                                                    first_car_allocated_quantity=0,
                                                                    archive_wage=False,
                                                                    )
        kill_house_requests = KillHouseRequest.objects.filter(
            Q(Q(killer=kill_house) & Q(killhouse_user=kill_house)) | Q(
                Q(killer__isnull=True) & Q(killhouse_user=kill_house)) | Q(
                Q(killer__isnull=True) | Q(killer=kill_house)),
            # killhouse_user=kill_house,
            archive_wage=False,
            trash=False
        )

        kill_house_requests = kill_house_requests.filter(Q(killer=kill_house) | Q(killhouse_user=kill_house))

        free_bars = KillHouseFreeBarInformation.objects.filter(kill_house=kill_house, archive_wage=False,
                                                               trash=False)

        total_unpaid_wage += province_kill_requests.aggregate(total=Sum('total_wage_amount'))[
                                 'total'] or 0
        total_unpaid_wage += free_bars.aggregate(total=Sum('total_wage_amount'))[
                                 'total'] or 0
        total_unpaid_wage += \
            kill_house_requests.aggregate(total=Sum(F('accepted_real_weight') * F('province_kill_request__wage')))[
                'total'] or 0
        slaughter_transactions = InternalTransaction.objects.filter(
            kill_house=kill_house, status='completed',
            trash=False)

        total_paid_wage += slaughter_transactions.aggregate(total=Sum('amount'))[
                               'total'] or 0
        total_amount = total_unpaid_wage - total_paid_wage
        kill_house_purchase = KillHousePurchaseRequest.objects.filter(limitation=True, kill_house=kill_house).first()
        if kill_house_purchase:
            if total_amount >= kill_house_purchase.limitation_number:
                kill_house.show_exclusive = False
                kill_house.save()
            else:
                kill_house.show_exclusive = True
                kill_house.save()
        else:
            kill_house.show_exclusive = True
            kill_house.save()


def update_kill_house_requests(province_kill_request, poultry_request):
    # gate_way_percentage = PaymentGatewayPercentage.objects.get(trash=False)
    kill_house_requests = KillHouseRequest.objects.filter(province_kill_request=province_kill_request, trash=False)

    total_kill_house_requests_quantity = kill_house_requests.aggregate(total_quantity=Sum('accepted_real_quantity'))[
        'total_quantity']
    total_kill_house_requests_weight = kill_house_requests.aggregate(total_weight=Sum('accepted_real_weight'))[
        'total_weight']
    total_first_allocated_cars = kill_house_requests.aggregate(total_weight=Sum('quantity'))[
        'total_weight']

    province_kill_request.total_killed_quantity = total_kill_house_requests_quantity or province_kill_request.main_quantity
    province_kill_request.first_car_allocated_quantity = total_first_allocated_cars or 0
    province_kill_request.total_killed_weight = total_kill_house_requests_weight or int(
        province_kill_request.main_quantity * poultry_request.Index_weight)
    province_kill_request.total_wage_amount = province_kill_request.total_killed_weight * province_kill_request.wage

    province_kill_request.save()

    union_percent = province_kill_request.union_share_percent / 100 if province_kill_request.union_share_percent > 0 else 0
    company_percent = province_kill_request.company_share_percent / 100 if province_kill_request.company_share_percent > 0 else 0
    guilds_percent = province_kill_request.guilds_share_percent / 100 if province_kill_request.guilds_share_percent > 0 else 0
    city_share_percent = province_kill_request.city_share_percent / 100 if province_kill_request.city_share_percent > 0 else 0
    wallet_share_percent = province_kill_request.wallet_share_percent / 100 if province_kill_request.wallet_share_percent > 0 else 0
    other_share_percent = province_kill_request.other_share_percent / 100 if province_kill_request.other_share_percent > 0 else 0
    province_kill_request.union_share = int(union_percent * province_kill_request.total_wage_amount)
    province_kill_request.company_share = int(company_percent * province_kill_request.total_wage_amount)
    province_kill_request.guilds_share = int(guilds_percent * province_kill_request.total_wage_amount)
    province_kill_request.city_share = int(city_share_percent * province_kill_request.total_wage_amount)
    province_kill_request.wallet_share = int(wallet_share_percent * province_kill_request.total_wage_amount)
    province_kill_request.other_share = int(other_share_percent * province_kill_request.total_wage_amount)
    province_kill_request.save()


def update_province_kill_requests(poultry_hatching):
    province_kill_requests = ProvinceKillRequest.objects.filter(
        trash=False,
        state__in=('pending', 'accepted'),
        return_to_province=False,
        province_request__poultry_request__hatching=poultry_hatching
    )

    total_killed_quantity = province_kill_requests.aggregate(total=Sum('total_killed_quantity'))['total']
    total_extra_quantity = province_kill_requests.aggregate(total=Sum('extra_killed_quantity'))['total']

    free_filter = Q(province_request__poultry_request__free_sale_in_province=True, state__in=('pending', 'accepted'),
                    trash=False)
    governmental_filter = ~free_filter

    total_free_quantity = \
        province_kill_requests.filter(free_filter, province_request__poultry_request__export=False).aggregate(
            total=Sum('total_killed_quantity'))[
            'total']
    total_free_weight = \
        province_kill_requests.filter(free_filter, province_request__poultry_request__export=False).aggregate(
            total=Sum('total_killed_weight'))['total']
    total_governmental_quantity = \
        province_kill_requests.filter(governmental_filter, province_request__poultry_request__export=False).aggregate(
            total=Sum('total_killed_quantity'))['total']
    total_governmental_weight = \
        province_kill_requests.filter(governmental_filter, province_request__poultry_request__export=False).aggregate(
            total=Sum('total_killed_weight'))['total']
    total_export_quantity = \
        province_kill_requests.filter(province_request__poultry_request__export=True).aggregate(
            total=Sum('total_killed_quantity'))['total']
    total_export_weight = \
        province_kill_requests.filter(province_request__poultry_request__export=True).aggregate(
            total=Sum('total_killed_weight'))['total']

    poultry_hatching.free_killed_quantity = total_free_weight or 0
    poultry_hatching.free_quantity = total_free_quantity or 0
    poultry_hatching.governmental_killed_quantity = total_governmental_weight or 0
    poultry_hatching.governmental_quantity = total_governmental_quantity or 0
    poultry_hatching.export_killed_weight = total_export_weight or 0
    poultry_hatching.export_killed_quantity = total_export_quantity or 0
    poultry_hatching.extra_killed_quantity = total_extra_quantity or 0
    poultry_hatching.killed_quantity = total_killed_quantity or 0

    poultry_hatching.save()


class BarDocumentStatusViewset(viewsets.ModelViewSet):
    queryset = BarDocumentStatus.objects.all()
    permission_classes = [TokenHasReadWriteScope]
    serializer_class = BarDocumentStatusSerializer

    def list(self, request, *args, **kwargs):
        bar_documents_status = BarDocumentStatus.objects.filter(trash=False).order_by('priority_id')
        serializer = self.serializer_class(bar_documents_status, many=True)
        return Response(serializer.data, status=status.HTTP_200_OK)

    def update(self, request, pk=None, *args, **kwargs):

        if 'priority_list' in request.data:
            priority_list = request.data['priority_list']
            priorities = {item['key']: item['value'] for item in priority_list}
            bar_documents_status = BarDocumentStatus.objects.filter(trash=False).order_by('priority_id')
            for document in bar_documents_status:
                priority_id = priorities.get(str(document.key))
                if priority_id is not None:
                    document.priority_id = priority_id
                    document.save()

            return Response({"result": "با موفقیت انجام شد."}, status=status.HTTP_200_OK)
        bar_documents_status = BarDocumentStatus.objects.get(key=request.data['bar_documents_status_key'], trash=False)
        request.data.pop('bar_documents_status_key')
        serializer = self.serializer_class(bar_documents_status)
        serializer.update(instance=bar_documents_status, validated_data=request.data)
        return Response(serializer.data, status=status.HTTP_200_OK)

    def destroy(self, request, pk=None, *args, **kwargs):
        bar_documents_status = BarDocumentStatus.objects.get(id=pk, trash=False)
        if KillHouseRequest.objects.filter(bar_document_status=bar_documents_status,
                                           trash=False).exists():
            return Response({"result": "به علت استفاده ار این وضعیت سند بر روی  بار امکان حذف  وجود ندارد!"},
                            status=status.HTTP_403_FORBIDDEN)
        bar_documents_status.delete()
        return Response({"result": "با موفقیت حذف شد."},
                        status=status.HTTP_200_OK)


class KillHouseCreditorsViewSet(viewsets.ModelViewSet):
    queryset = KillHouseCreditors.objects.all()
    serializer_class = KillHouseCreditorsSerializer
    permission_classes = [TokenHasReadWriteScope]

    def list(self, request, *args, **kwargs):
        user = SystemUserProfile.objects.get(user=request.user)
        creditors = KillHouseCreditors.objects.filter(kill_house__system_address__province=user.province).order_by('id')
        serializer_request = self.serializer_class(creditors, many=True)
        return Response(serializer_request.data, status=status.HTTP_200_OK)

    def update(self, request, pk=None, *args, **kwargs):
        # refresh(request.user.id)
        creditors = KillHouseCreditors.objects.get(key=request.data["key"], trash=False)
        request.data.pop('key')
        amount = request.data['amount']
        request.data.pop('amount')

        creditors.amount -= float(amount)
        creditors.save()

        serializer = self.serializer_class(creditors)
        serializer.update(instance=creditors, validated_data=request.data)
        return Response(serializer.data, status=status.HTTP_200_OK)


# ویوست مربوط به اپراتور کشتارگاه
class KillHouseOperatorViewSet(viewsets.ModelViewSet):
    queryset = KillHouseOperator.objects.all()
    serializer_class = KillHouseOperatorSerializer
    permission_classes = [TokenHasReadWriteScope]

    def retrieve(self, request, pk=None, *args, **kwargs):
        # refresh(request.user.id)

        if 'profile' in request.GET:
            user = SystemUserProfile.objects.get(user=request.user, trash=False)
            kill_house_operator = KillHouseOperator.objects.get(user=user, trash=False)
            kill_house_operator_serializer = KillHouseOperatorSerializer(kill_house_operator)
            kill_house = KillHouse.objects.filter(kill_house_operator=kill_house_operator, trash=False)
            kill_house_serializer = KillHouseSerializer(kill_house, many=True)
            profile_info = {
                # 'profile': user_serializer.data,
                'kill_house_operator': kill_house_operator_serializer.data,
                'kill_house': kill_house_serializer.data
            }
            return Response(profile_info, status=status.HTTP_200_OK)


class KillHouseForKillHouseRequestWageViewSet(viewsets.ModelViewSet):
    queryset = KillHouse.objects.all()
    serializer_class = KillHouseForKillHouseRequestWageSerializer
    pagination_class = CustomPagination
    permission_classes = [TokenHasReadWriteScope]
    filter_backends = [DjangoFilterBackend]
    filterset_class = KillHouseFilterSet
    filterset_fields = [
        'name',
        'kill_house_operator__user__fullname',
        'kill_house_operator__user__mobile',
        'system_address__city__name',

    ]

    def list(self, request, *args, **kwargs):

        if 'date1' in request.GET:
            date1 = datetime.strptime(str(request.GET['date1']), '%Y-%m-%d').date()
            date2 = datetime.strptime(str(request.GET['date2']), '%Y-%m-%d').date()
            if request.GET['role'] == 'ProvinceOPerator':
                kill_houses = KillHouse.objects.filter(pk__in=KillHouseRequest.objects.filter(
                    kill_request__recive_date__date__gte=date1,
                    kill_request__recive_date__date__lte=date2,
                    archive_wage=False,
                    province_kill_request__union_share__gt=0,
                    trash=False).values(
                    'killhouse_user'), trash=False)
            elif request.GET['role'] == 'Company':
                kill_houses = KillHouse.objects.filter(pk__in=KillHouseRequest.objects.filter(
                    kill_request__recive_date__date__gte=date1,
                    kill_request__recive_date__date__lte=date2,
                    province_kill_request__company_share__gt=0,
                    archive_wage=False,
                    trash=False).values(
                    'killhouse_user'), trash=False)
            elif request.GET['role'] == 'Guilds':
                kill_houses = KillHouse.objects.filter(pk__in=KillHouseRequest.objects.filter(
                    kill_request__recive_date__date__gte=date1,
                    kill_request__recive_date__date__lte=date2,
                    province_kill_request__guilds_share__gt=0,
                    archive_wage=False,
                    trash=False).values(
                    'killhouse_user'), trash=False)
            else:

                kill_houses = KillHouse.objects.filter(pk__in=KillHouseRequest.objects.filter(
                    kill_request__recive_date__date__gte=date1,
                    kill_request__recive_date__date__lte=date2,
                    archive_wage=False,
                    trash=False).values(
                    'killhouse_user'), trash=False)
        else:

            if request.GET['role'] == 'ProvinceOPerator':
                kill_houses = KillHouse.objects.filter(pk__in=KillHouseRequest.objects.filter(
                    province_kill_request__union_share__gt=0,
                    archive_wage=False,
                    trash=False).values(
                    'killhouse_user'), trash=False)
            elif request.GET['role'] == 'Company':
                kill_houses = KillHouse.objects.filter(pk__in=KillHouseRequest.objects.filter(
                    province_kill_request__company_share__gt=0,
                    archive_wage=False,
                    trash=False).values(
                    'killhouse_user'), trash=False)
            elif request.GET['role'] == 'Guilds':
                kill_houses = KillHouse.objects.filter(pk__in=KillHouseRequest.objects.filter(
                    province_kill_request__guilds_share__gt=0,
                    archive_wage=False,
                    trash=False).values(
                    'killhouse_user'), trash=False)
            else:

                kill_houses = KillHouse.objects.filter(pk__in=KillHouseRequest.objects.filter(
                    archive_wage=False,
                    trash=False).values(
                    'killhouse_user'), trash=False)

        if 'search' in request.GET:
            if request.GET['search'] == 'filter':
                if request.GET['value'] != "":
                    for item in self.filterset_fields:
                        query = QueryDict('{0}__contains={1}'.format(item, request.GET['value']))
                        if (self.filterset_class(
                                data=query,
                                queryset=kill_houses
                        )
                        ).filter():
                            ps = self.filterset_class(data=query, queryset=kill_houses)
                            kill_houses = ps.filter()
                else:
                    kill_houses = kill_houses
        page_size = request.query_params.get('page_size', None)
        if page_size:
            self.pagination_class.page_size = int(page_size)

        page = self.paginate_queryset(kill_houses)
        if page is not None:
            if 'date1' in request.GET:
                serializer = KillHouseForKillHouseRequestWageWithDateSerializer(page, many=True,
                                                                                context={'request': request})
            else:

                serializer = self.get_serializer(page, many=True, context={'request': request})
            return self.get_paginated_response(serializer.data)

        if 'date1' in request.GET:
            serializer = KillHouseForProvinceWageWithDateSerializer(kill_houses, many=True,
                                                                    context={'request': request})
        else:

            serializer = self.get_serializer(kill_houses, many=True, context={'request': request})
        return Response(serializer.data, status=status.HTTP_200_OK)


class KillHouseForNewWageInormationViewSet(viewsets.ModelViewSet):
    queryset = KillHouse.objects.all()
    serializer_class = KillHouseForNewWageInormationSerializer
    pagination_class = CustomPagination
    permission_classes = [TokenHasReadWriteScope]
    filter_backends = [DjangoFilterBackend]
    filterset_class = KillHouseFilterSet
    filterset_fields = [
        'name',
        'kill_house_operator__user__fullname',
        'kill_house_operator__user__mobile',
        'system_address__city__name',

    ]

    def list(self, request, *args, **kwargs):
        kill_house_ids = KillHousePercentage.objects.filter(kill_house__type='exclusive', trash=False).values_list(
            'kill_house', flat=True)
        kill_houses = KillHouse.objects.filter(out_province=False, trash=False).exclude(id__in=kill_house_ids).order_by(
            'id')
        serializer = self.get_serializer(kill_houses, many=True, context={'request': request})
        return Response(serializer.data, status=status.HTTP_200_OK)


class KillHouseForColdHouseViewSet(viewsets.ModelViewSet):
    queryset = KillHouse.objects.all()
    serializer_class = KillHouseForColdHouseSerializer
    pagination_class = CustomPagination
    permission_classes = [TokenHasReadWriteScope]
    filter_backends = [DjangoFilterBackend]
    filterset_class = KillHouseFilterSet
    filterset_fields = [
        'name',
        'kill_house_operator__user__fullname',
        'kill_house_operator__user__mobile',
        'system_address__city__name',

    ]

    def list(self, request, *args, **kwargs):
        kill_houses = KillHouse.objects.filter(out_province=False, trash=False,
                                               pk__in=ColdHouse.objects.filter(kill_house__isnull=False).values_list(
                                                   'kill_house', flat=True)).order_by('id')
        if 'search' in request.GET:
            if request.GET['search'] == 'filter':
                kill_houses_list = []
                if request.GET['value'] != "":
                    for item in self.filterset_fields:
                        query = QueryDict('{0}__contains={1}'.format(item, request.GET['value']))
                        if (self.filterset_class(
                                data=query,
                                queryset=kill_houses
                        )
                        ).filter():
                            ps = self.filterset_class(data=query, queryset=kill_houses)
                            kill_houses_list = ps.filter()
                    kill_houses = [] if len(kill_houses_list) == 0 else kill_houses_list
        page_size = request.query_params.get('page_size', None)
        if page_size:
            self.pagination_class.page_size = int(page_size)

        page = self.paginate_queryset(kill_houses)
        if page is not None:
            serializer = self.get_serializer(page, many=True)
            return self.get_paginated_response(serializer.data)
        serializer = self.get_serializer(kill_houses, many=True)
        return Response(serializer.data, status=status.HTTP_200_OK)


class KillHouseColdHousesViewSet(viewsets.ModelViewSet):
    queryset = KillHouse.objects.all()
    serializer_class = KillHouseColdHousesSerializer
    permission_classes = [TokenHasReadWriteScope]

    def list(self, request, *args, **kwargs):
        user = SystemUserProfile.objects.get(user=request.user, trash=False)
        kill_houses = KillHouse.objects.filter(kill_house_operator__user=user, trash=False).first()
        serializer = self.get_serializer(kill_houses)
        return Response(serializer.data, status=status.HTTP_200_OK)


class ParentCompanyKillHouseForNewWageInormationViewSet(viewsets.ModelViewSet):
    queryset = KillHouse.objects.all()
    serializer_class = ParentCompanyKillHouseForNewWageInormationSerializer
    permission_classes = [AllowAny]

    def list(self, request, *args, **kwargs):
        kill_houses = KillHouse.objects.filter(out_province=False, trash=False).order_by('id')
        serializer = self.get_serializer(kill_houses, many=True)
        return Response(serializer.data, status=status.HTTP_200_OK)


class KillHouseForProvinceWareHouseDashboardViewSet(viewsets.ModelViewSet):
    queryset = KillHouse.objects.filter(out_province=False, trash=False).order_by('id')
    serializer_class = KillHouseForProvinceWareHouseDashboardSerializer
    permission_classes = [TokenHasReadWriteScope]

    def list(self, request, *args, **kwargs):
        user = SystemUserProfile.objects.get(user=request.user, trash=False)
        role = request.GET.get('role')
        kill_house_filters = {'out_province': False, 'active': True, 'trash': False}
        if role in ['CityJahad']:
            kill_house_filters['kill_house_operator__user__city'] = user.city

        kill_houses = KillHouse.objects.filter(**kill_house_filters).order_by(
            'id')

        kill_houses = kill_houses.annotate(
            allocation_count=Count(
                'kill_house_steward_allocation',
                filter=Q(kill_house_steward_allocation__receiver_state__in=['pending', 'accepted'])
            )
        ).order_by(
            '-allocation_count'
        )
        serializer = self.get_serializer(kill_houses, many=True, context={'request': request})
        return Response(serializer.data, status=status.HTTP_200_OK)


class KillHouseForTotalProvinceWareHouseDashboardViewSet(viewsets.ModelViewSet):
    queryset = KillHouse.objects.filter(out_province=False, trash=False).order_by('id')
    serializer_class = KillHouseForProvinceWareHouseDashboardSerializer
    permission_classes = [TokenHasReadWriteScope]

    def list(self, request, *args, **kwargs):
        user = SystemUserProfile.objects.get(user=request.user, trash=False)
        role = request.GET.get('role')
        kill_house_filters = {'out_province': False, 'active': True, 'trash': False}
        if role in ['CityJahad']:
            kill_house_filters['kill_house_operator__user__city'] = user.city

        kill_houses = KillHouse.objects.filter(**kill_house_filters).order_by(
            'id')

        kill_houses = kill_houses.annotate(
            allocation_count=Count(
                'kill_house_steward_allocation',
                filter=Q(kill_house_steward_allocation__receiver_state__in=['pending', 'accepted'])
            )
        ).order_by(
            '-allocation_count'
        )
        products = RolesProducts.objects.filter(kill_house__in=kill_houses, trash=False, name='مرغ گرم')

        # products = RolesProducts.objects.filter(kill_house__in=kill_houses, trash=False)
        # product_remain_weight = products.aggregate(total=Sum('total_remain_weight'))[
        #                             'total'] or 0

        if 'date1' in request.GET:
            date1 = datetime.strptime(str(request.GET['date1']), '%Y-%m-%d').date()
            date2 = datetime.strptime(str(request.GET['date2']), '%Y-%m-%d').date()
            bars_date1 = date1
            bars_date2 = date2
            # bars_date1 = date1 - timedelta(days=1)
            # bars_date2 = date2 - timedelta(days=1)

            kill_house_requests = KillHouseRequest.objects.filter(
                input_warehouse__in=kill_houses,
                kill_request__recive_date__date__gte=bars_date1,
                kill_request__recive_date__date__lte=bars_date2,
                temporary_trash=False,
                temporary_deleted=False,
                trash=False, calculate_status=True, warehouse=True)

            kill_house_free_bar_informations = KillHouseFreeBarInformation.objects.filter(Q(date__date__gte=date1,
                                                                                            date__date__lte=date2,
                                                                                            buy_type='carcass') | Q(
                create_date__date__gte=date1, create_date__date__lte=date2, buy_type='live'),
                                                                                          input_warehouse__in=kill_houses,
                                                                                          trash=False,
                                                                                          temporary_trash=False,
                                                                                          temporary_deleted=False,
                                                                                          calculate_status=True,
                                                                                          warehouse=True).exclude(
                entered_message='ورود به انبار مجازی')
            kill_house_free_Sale_bar_informations = KillHouseFreeSaleBarInformation.objects.filter(
                kill_house__in=kill_houses,
                date__date__gte=date1,
                date__date__lte=date2,
                trash=False,
                temporary_trash=False,
                temporary_deleted=False,
                calculate_status=True, warehouse=True)
            kill_house_allocations = StewardAllocation.objects.filter(kill_house__in=kill_houses, trash=False,
                                                                      receiver_state__in=('pending', 'accepted'),
                                                                      date__date__gte=date1,
                                                                      date__date__lte=date2,
                                                                      temporary_trash=False,
                                                                      temporary_deleted=False,
                                                                      to_cold_house__isnull=True,
                                                                      calculate_status=True, warehouse=True)
            segmentations = PosSegmentation.objects.filter(kill_house__in=kill_houses, trash=False,
                                                           date__date__gte=date1,
                                                           date__date__lte=date2, warehouse=True)
            cold_house_allocations = StewardAllocation.objects.filter(
                kill_house__in=kill_houses,
                date__date__gte=date1,
                date__date__lte=date2,
                to_cold_house__isnull=False,
                receiver_state__in=('accepted', 'pending'),
                trash=False, warehouse=True)
            transactions = ProductsTransactions.objects.filter(product__in=products, transaction__paid=True,
                                                               transaction__date__date__gte=date1,
                                                               transaction__date__date__lte=date2, trash=False,
                                                               warehouse=True)
            archives = WarehouseArchive.objects.filter(kill_house__in=kill_houses, date__date__gte=date1,
                                                       date__date__lte=date2, trash=False, warehouse=True)


        else:
            kill_house_requests = KillHouseRequest.objects.filter(
                input_warehouse__in=kill_houses,
                temporary_trash=False,
                temporary_deleted=False,
                trash=False, calculate_status=True, warehouse=True)

            kill_house_free_bar_informations = KillHouseFreeBarInformation.objects.filter(
                input_warehouse__in=kill_houses,
                trash=False,
                temporary_trash=False,
                temporary_deleted=False,
                calculate_status=True, warehouse=True).exclude(entered_message='ورود به انبار مجازی')
            kill_house_free_Sale_bar_informations = KillHouseFreeSaleBarInformation.objects.filter(
                kill_house__in=kill_houses,
                trash=False,
                temporary_trash=False,
                temporary_deleted=False,
                calculate_status=True, warehouse=True)
            kill_house_allocations = StewardAllocation.objects.filter(kill_house__in=kill_houses, trash=False,
                                                                      receiver_state__in=('pending', 'accepted'),
                                                                      temporary_trash=False,
                                                                      temporary_deleted=False,
                                                                      to_cold_house__isnull=True,
                                                                      calculate_status=True, warehouse=True)

            segmentations = PosSegmentation.objects.filter(kill_house__in=kill_houses, trash=False, warehouse=True)
            cold_house_allocations = StewardAllocation.objects.filter(
                kill_house__in=kill_houses,
                to_cold_house__isnull=False,
                receiver_state__in=('accepted', 'pending'),
                trash=False, warehouse=True)
            transactions = ProductsTransactions.objects.filter(product__in=products, transaction__paid=True,
                                                               trash=False, warehouse=True)
            archives = WarehouseArchive.objects.filter(kill_house__in=kill_houses, trash=False, warehouse=True)

        total_kill_house_requests_quantity = kill_house_requests.aggregate(total=Sum('accepted_real_quantity'))[
                                                 'total'] or 0
        total_kill_house_requests_weight = kill_house_requests.aggregate(total=Sum('accepted_real_weight'))[
                                               'total'] or 0
        total_entered_kill_house_requests_carcasses_weight = \
            kill_house_requests.filter(ware_house_confirmation=True).aggregate(
                total=Sum('ware_house_accepted_real_weight'))[
                'total'] or 0
        total_entered_kill_house_requests_carcasses_governmental_weight = \
            kill_house_requests.filter(ware_house_confirmation=True,
                                       province_request__poultry_request__free_sale_in_province=False).aggregate(
                total=Sum('ware_house_accepted_real_weight'))[
                'total'] or 0
        total_entered_kill_house_requests_carcasses_free_weight = \
            kill_house_requests.filter(ware_house_confirmation=True,
                                       province_request__poultry_request__free_sale_in_province=True).aggregate(
                total=Sum('ware_house_accepted_real_weight'))[
                'total'] or 0
        kill_house_free_bar_informations_live = kill_house_free_bar_informations.filter(buy_type='live')
        kill_house_free_bar_informations_carcasses = kill_house_free_bar_informations.filter(buy_type='carcass')
        total_kill_house_free_bar_quantity = \
            kill_house_free_bar_informations_live.aggregate(total=Sum('quantity'))['total'] or 0
        total_kill_house_free_bar_weight = \
            kill_house_free_bar_informations_live.aggregate(total=Sum('live_weight'))['total'] or 0
        total_kill_house_free_bar_carcasses = \
            kill_house_free_bar_informations_carcasses.aggregate(total=Sum('number_of_carcasses'))[
                'total'] or 0
        total_kill_house_free_bar_carcasses_weight = \
            kill_house_free_bar_informations_carcasses.aggregate(total=Sum('weight_of_carcasses'))[
                'total'] or 0
        total_entered_kill_house_free_bar_carcasses_weight = \
            kill_house_free_bar_informations.aggregate(total=Sum('weight_of_carcasses'))[
                'total'] or 0

        total_kill_house_free_sale__bar_carcasses_weight = \
            kill_house_free_Sale_bar_informations.aggregate(total=Sum('real_weight_of_carcasses'))[
                'total'] or 0
        total_kill_house_free_sale__bar_carcasses_governmental_weight = \
            kill_house_free_Sale_bar_informations.filter(quota='governmental').aggregate(
                total=Sum('real_weight_of_carcasses'))[
                'total'] or 0

        total_kill_house_free_sale__bar_carcasses_free_weight = \
            kill_house_free_Sale_bar_informations.filter(quota='free').aggregate(total=Sum('real_weight_of_carcasses'))[
                'total'] or 0

        total_kill_house_allocations_weight = \
            kill_house_allocations.aggregate(total=Sum('real_weight_of_carcasses'))[
                'total'] or 0
        total_kill_house_allocations_governmental_weight = \
            kill_house_allocations.filter(quota='governmental').aggregate(total=Sum('real_weight_of_carcasses'))[
                'total'] or 0
        total_kill_house_allocations_free_weight = \
            kill_house_allocations.filter(quota='free').aggregate(total=Sum('real_weight_of_carcasses'))[
                'total'] or 0

        segmentations_weight = \
            segmentations.aggregate(total=Sum('weight'))[
                'total'] or 0
        segmentations_governmental_weight = \
            segmentations.filter(quota='governmental').aggregate(total=Sum('weight'))[
                'total'] or 0
        segmentations_free_weight = \
            segmentations.filter(quota='free').aggregate(total=Sum('weight'))[
                'total'] or 0
        cold_house_allocations_weight = \
            cold_house_allocations.aggregate(total=Sum('real_weight_of_carcasses'))[
                'total'] or 0
        cold_house_allocations_governmental_weight = \
            cold_house_allocations.filter(quota='governmental').aggregate(total=Sum('real_weight_of_carcasses'))[
                'total'] or 0

        cold_house_allocations_free_weight = \
            cold_house_allocations.filter(quota='free').aggregate(total=Sum('real_weight_of_carcasses'))[
                'total'] or 0

        pos_allocated_weight_info = transactions.aggregate(
            pos_allocated_weight=Sum('cur_weight'),
            pos_governmental_allocated_weight=Sum('cur_weight',
                                                  filter=Q(price_approved=True)),
            pos_free_allocated_weight=Sum('cur_weight', filter=Q(price_approved=False)),

        )
        archives_info = archives.aggregate(
            total_archive_governmental_weight=Sum('weight', filter=Q(quota='governmental')),
            total_archive_free_weight=Sum('weight', filter=Q(quota='free')),
        )
        pos_allocated_weight = pos_allocated_weight_info['pos_allocated_weight'] or 0
        pos_governmental_allocated_weight = pos_allocated_weight_info['pos_governmental_allocated_weight'] or 0
        pos_free_allocated_weight = pos_allocated_weight_info['pos_free_allocated_weight'] or 0
        total_archive_governmental_weight = archives_info['total_archive_governmental_weight'] or 0
        total_archive_free_weight = archives_info['total_archive_free_weight'] or 0

        total_governmental_input_weight = total_entered_kill_house_requests_carcasses_governmental_weight
        total_free_input_weight = total_entered_kill_house_requests_carcasses_free_weight + total_entered_kill_house_free_bar_carcasses_weight
        total_governmental_output_weight = total_kill_house_free_sale__bar_carcasses_governmental_weight + segmentations_governmental_weight + total_kill_house_allocations_governmental_weight + cold_house_allocations_governmental_weight + int(pos_governmental_allocated_weight / 1000)
        total_free_output_weight = total_kill_house_free_sale__bar_carcasses_free_weight + total_kill_house_allocations_free_weight + segmentations_free_weight + cold_house_allocations_free_weight + int(pos_free_allocated_weight / 1000)
        total_governmental_remain_weight = (
                                                   total_governmental_input_weight - total_governmental_output_weight) - total_archive_governmental_weight if (
                                                                                                                                                                      total_governmental_input_weight - total_governmental_output_weight) - total_archive_governmental_weight > 0 else 0
        last_total_governmental_remain_weight = (
                                                        (
                                                                total_governmental_input_weight - total_governmental_output_weight) - total_archive_governmental_weight) * -1 if (
                                                                                                                                                                                         total_governmental_input_weight - total_governmental_output_weight) - total_archive_governmental_weight < 0 else 0
        total_free_remain_weight = (total_free_input_weight - total_free_output_weight) - total_archive_free_weight if (
                                                                                                                               total_free_input_weight - total_free_output_weight) - total_archive_free_weight > 0 else 0
        last_total_free_remain_weight = ((
                                                 total_free_input_weight - total_free_output_weight) - total_archive_free_weight) * -1 if (
                                                                                                                                                  total_free_input_weight - total_free_output_weight) - total_archive_free_weight < 0 else 0
        last_total_remain_weight = last_total_governmental_remain_weight + last_total_free_remain_weight
        warehouse_total_weight = total_kill_house_requests_weight + total_kill_house_free_bar_weight + total_kill_house_free_bar_carcasses_weight
        warehouse_total_entered_carcasses_weight = total_entered_kill_house_requests_carcasses_weight + total_entered_kill_house_free_bar_carcasses_weight
        result = {
            "product_remain_weight": int(total_governmental_remain_weight + total_free_remain_weight),
            "warehouse_total_quantity": int(
                total_kill_house_requests_quantity + total_kill_house_free_bar_quantity + total_kill_house_free_bar_carcasses),
            "warehouse_total_weight": int(warehouse_total_weight),
            "warehouse_total_entered_carcasses_weight": int(warehouse_total_entered_carcasses_weight),
            "total_kill_house_allocations_weight": int(total_kill_house_allocations_weight),
            "total_kill_house_free_sale_bar_carcasses_weight": int(total_kill_house_free_sale__bar_carcasses_weight),
            "segmentations_weight": int(segmentations_weight),
            "cold_house_allocations_weight": int(cold_house_allocations_weight),
            "total_governmental_input_weight": int(total_governmental_input_weight),
            "total_free_input_weight": int(total_free_input_weight),
            "total_governmental_output_weight": int(total_governmental_output_weight),
            "total_free_output_weight": int(total_free_output_weight),
            "total_governmental_remain_weight": int(total_governmental_remain_weight),
            "total_free_remain_weight": int(total_free_remain_weight),
            "last_total_governmental_remain_weight": int(last_total_governmental_remain_weight),
            "last_total_free_remain_weight": int(last_total_free_remain_weight),
            "last_total_remain_weight": int(last_total_remain_weight),
            "pos_allocated_weight": int(pos_allocated_weight / 1000),
            "pos_governmental_allocated_weight": int(pos_governmental_allocated_weight / 1000),
            "pos_free_allocated_weight": int(pos_free_allocated_weight / 1000),
            "total_archive_governmental_weight": total_archive_governmental_weight,
            "total_archive_free_weight": total_archive_free_weight,

        }
        return Response(result, status=status.HTTP_200_OK)


class KillHouseDistributionInormationViewSet(viewsets.ModelViewSet):
    queryset = KillHouse.objects.all()
    serializer_class = KillHouseForNewWageInormationSerializer
    pagination_class = CustomPagination
    permission_classes = [TokenHasReadWriteScope]

    def list(self, request, *args, **kwargs):
        role = request.GET.get('role')
        user = SystemUserProfile.objects.get(user=request.user, trash=False)
        if role == 'KillHouse':
            kill_house = KillHouse.objects.filter(kill_house_operator__user=user, trash=False).first()
            steward_allocations = StewardAllocation.objects.filter(kill_house=kill_house,
                                                                   receiver_state__in=('pending', 'accepted'),
                                                                   calculate_status=True, trash=False)
            free_sales = KillHouseFreeSaleBarInformation.objects.filter(kill_house=kill_house, trash=False,
                                                                        calculate_status=True)
            steward_allocations_weight = \
                steward_allocations.aggregate(total=Sum('real_weight_of_carcasses'))['total'] or 0

            free_sales_weight = free_sales.aggregate(total=Sum('real_weight_of_carcasses'))['total'] or 0

        else:
            guild = Guilds.objects.get(user=user, trash=False)
            steward_allocations = StewardAllocation.objects.filter(Q(steward=guild) | Q(guilds=guild),
                                                                   receiver_state__in=('pending', 'accepted'),
                                                                   calculate_status=True, trash=False)
            steward_allocations_weight = \
                steward_allocations.aggregate(total=Sum('real_weight_of_carcasses'))['total'] or 0

            free_sales_weight = 0

        result = {
            "steward_allocations_weight": steward_allocations_weight,
            "free_sales_weight": free_sales_weight,
        }

        return Response(result, status=status.HTTP_200_OK)


class KillHouseTotalDashboardForNewWageInormationViewSet(viewsets.ModelViewSet):
    queryset = KillHouse.objects.all()
    serializer_class = KillHouseForKillHouseRequestWageSerializer
    pagination_class = CustomPagination
    permission_classes = [TokenHasReadWriteScope]

    def list(self, request, *args, **kwargs):
        kill_houses = KillHouse.objects.filter(out_province=False, trash=False).order_by('id')
        total_wage_type = WageType.objects.filter(trash=False)
        province_live_wage_type = total_wage_type.filter(en_name='province-kill-request', trash=False).first()
        free_buying_live_weight_wage_type = total_wage_type.filter(en_name='live-buy', trash=False).first()
        free_buying_carcesses_weight_wage_type = total_wage_type.filter(en_name='carcasse-buy', trash=False).first()
        free_sell_carcesses_weight_wage_type = total_wage_type.filter(en_name='carcasse-sell', trash=False).first()
        province_live_wage_type_amount = province_live_wage_type.amount if province_live_wage_type.status == True else 0
        free_buying_live_weight_wage_type_amount = free_buying_live_weight_wage_type.amount if free_buying_live_weight_wage_type.status == True else 0
        free_buying_carcesses_weight_wage_type_amount = free_buying_carcesses_weight_wage_type.amount if free_buying_carcesses_weight_wage_type.status == True else 0
        free_sell_carcesses_weight_wage_type_amount = free_sell_carcesses_weight_wage_type.amount if free_sell_carcesses_weight_wage_type.status == True else 0

        province_kill_requests = ProvinceKillRequest.objects.filter(killhouse_user__in=kill_houses, trash=False,
                                                                    archive_wage=False, return_to_province=False,
                                                                    state__in=('pending', 'accepted'),
                                                                    first_car_allocated_quantity=0).order_by('id')
        kill_house_requests = KillHouseRequest.objects.filter(
            Q(Q(killhouse_user__in=kill_houses) & Q(killer__in=kill_houses)) | Q(
                Q(killhouse_user__in=kill_houses) & Q(killer__isnull=True)) | Q(
                Q(killhouse_user__in=kill_houses) | Q(killer__in=kill_houses)), archive_wage=False,
            trash=False
        )
        kill_house_free_bar_info = KillHouseFreeBarInformation.objects.filter(kill_house__in=kill_houses,
                                                                              archive_wage=False,
                                                                              trash=False)
        kill_house_free_sale_bar_info = KillHouseFreeSaleBarInformation.objects.filter(
            kill_house__in=kill_houses,
            archive_wage=False,
            trash=False)

        slaughter_transactions = InternalTransaction.objects.filter(
            kill_house__in=kill_houses, status='completed',
            trash=False)

        total_paid_wage = slaughter_transactions.aggregate(total=Sum('amount'))[
                              'total'] or 0

        total_province_live_weight = province_kill_requests.aggregate(total=Sum('total_killed_weight'))['total'] or 0
        total_province_live_weight += kill_house_requests.aggregate(total=Sum('accepted_real_weight'))['total'] or 0
        total_out_selling_province_carcasses_weight = \
            kill_house_free_sale_bar_info.aggregate(total=Sum('real_weight_of_carcasses'))['total'] or 0
        total_province_carcasses_weight = total_province_live_weight * 0.75
        total_pure_province_carcasses_weight = total_province_carcasses_weight - total_out_selling_province_carcasses_weight
        total_out_live_buying_province_carcasses_weight = \
            kill_house_free_bar_info.filter(buy_type='live').aggregate(total=Sum('live_weight'))['total'] or 0
        total_out_carcasses_buying_province_carcasses_weight = \
            kill_house_free_bar_info.filter(buy_type='carcass').aggregate(total=Sum('weight_of_carcasses'))[
                'total'] or 0
        total_pure_province_carcasses_price = total_pure_province_carcasses_weight * province_live_wage_type_amount
        total_out_selling_province_carcasses_price = total_out_selling_province_carcasses_weight * free_sell_carcesses_weight_wage_type_amount
        total_out_live_buying_province_carcasses_price = total_out_live_buying_province_carcasses_weight * free_buying_live_weight_wage_type_amount
        total_out_carcasses_buying_province_carcasses_price = total_out_carcasses_buying_province_carcasses_weight * free_buying_carcesses_weight_wage_type_amount
        total_price = total_pure_province_carcasses_price + total_out_selling_province_carcasses_price + total_out_live_buying_province_carcasses_price + total_out_carcasses_buying_province_carcasses_price

        result = {
            "total_province_live_weight": total_province_live_weight,
            "total_province_carcasses_weight": total_province_carcasses_weight,
            "total_out_selling_province_carcasses_weight": total_out_selling_province_carcasses_weight,
            "total_pure_province_carcasses_weight": total_pure_province_carcasses_weight,
            "total_pure_province_carcasses_price": total_pure_province_carcasses_price,
            "total_out_selling_province_carcasses_price": total_out_selling_province_carcasses_price,
            "total_out_carcasses_buying_province_carcasses_weight": total_out_carcasses_buying_province_carcasses_weight,
            "total_out_carcasses_buying_province_carcasses_price": total_out_carcasses_buying_province_carcasses_price,
            "total_out_live_buying_province_carcasses_weight": total_out_live_buying_province_carcasses_weight,
            "total_out_live_buying_province_carcasses_price": total_out_live_buying_province_carcasses_price,
            "total_paid_wage": total_paid_wage,
            "total_price": total_price,
            "province_live_wage_amount": province_live_wage_type_amount,
            "free_buying_live_weight_amount": free_buying_live_weight_wage_type_amount,
            "free_buying_carcesses_weight_amount": free_buying_carcesses_weight_wage_type_amount,
            "free_sell_carcesses_weight_amount": free_sell_carcesses_weight_wage_type_amount,

        }
        return Response(result, status=status.HTTP_200_OK)


class KillHouseForProvinceWageViewSet(viewsets.ModelViewSet):
    queryset = KillHouse.objects.all()
    serializer_class = KillHouseForProvinceWageSerializer
    pagination_class = CustomPagination
    permission_classes = [TokenHasReadWriteScope]
    filter_backends = [DjangoFilterBackend]
    filterset_class = KillHouseFilterSet
    filterset_fields = [
        'name',
        'kill_house_operator__user__fullname',
        'kill_house_operator__user__mobile',
        'system_address__city__name',

    ]

    def list(self, request, *args, **kwargs):

        if request.GET['type'] == 'unpaid':
            if 'date1' in request.GET:
                date1 = datetime.strptime(str(request.GET['date1']), '%Y-%m-%d').date()
                date2 = datetime.strptime(str(request.GET['date2']), '%Y-%m-%d').date()
                if request.GET['role'] == 'ProvinceOPerator':
                    kill_houses = KillHouse.objects.filter(pk__in=ProvinceKillRequest.objects.filter(
                        kill_request__recive_date__date__gte=date1,
                        kill_request__recive_date__date__lte=date2,
                        state__in=(
                            'pending',
                            'accepted'),
                        return_to_province=False,
                        archive_wage=False,
                        union_share__gt=0,
                        trash=False).values(
                        'killhouse_user'), trash=False)
                elif request.GET['role'] == 'Company':
                    kill_houses = KillHouse.objects.filter(pk__in=ProvinceKillRequest.objects.filter(
                        kill_request__recive_date__date__gte=date1,
                        kill_request__recive_date__date__lte=date2,
                        state__in=(
                            'pending',
                            'accepted'),
                        return_to_province=False,
                        archive_wage=False,
                        company_share__gt=0,
                        trash=False).values(
                        'killhouse_user'), trash=False)
                elif request.GET['role'] == 'Guilds':
                    kill_houses = KillHouse.objects.filter(pk__in=ProvinceKillRequest.objects.filter(
                        kill_request__recive_date__date__gte=date1,
                        kill_request__recive_date__date__lte=date2,
                        state__in=(
                            'pending',
                            'accepted'),
                        return_to_province=False,
                        archive_wage=False,
                        guilds_share__gt=0,
                        trash=False).values(
                        'killhouse_user'), trash=False)
                else:
                    kill_houses = KillHouse.objects.filter(pk__in=ProvinceKillRequest.objects.filter(
                        kill_request__recive_date__date__gte=date1,
                        kill_request__recive_date__date__lte=date2,
                        state__in=(
                            'pending',
                            'accepted'),
                        return_to_province=False,
                        archive_wage=False,
                        trash=False).values(
                        'killhouse_user'), trash=False)

            else:

                if request.GET['role'] == 'ProvinceOPerator':
                    kill_houses = KillHouse.objects.filter(pk__in=ProvinceKillRequest.objects.filter(
                        state__in=(
                            'pending',
                            'accepted'),
                        return_to_province=False,
                        archive_wage=False,
                        union_share__gt=0,
                        trash=False).values(
                        'killhouse_user'), trash=False)
                elif request.GET['role'] == 'Company':
                    kill_houses = KillHouse.objects.filter(pk__in=ProvinceKillRequest.objects.filter(
                        state__in=(
                            'pending',
                            'accepted'),
                        return_to_province=False,
                        company_share__gt=0,
                        archive_wage=False,
                        trash=False).values(
                        'killhouse_user'), trash=False)
                elif request.GET['role'] == 'Guilds':
                    kill_houses = KillHouse.objects.filter(pk__in=ProvinceKillRequest.objects.filter(
                        state__in=(
                            'pending',
                            'accepted'),
                        return_to_province=False,
                        archive_wage=False,

                        guilds_share__gt=0,
                        trash=False).values(
                        'killhouse_user'), trash=False)
                else:
                    kill_houses = KillHouse.objects.filter(pk__in=ProvinceKillRequest.objects.filter(

                        state__in=(
                            'pending',
                            'accepted'),
                        return_to_province=False,
                        archive_wage=False,
                        trash=False).values(
                        'killhouse_user'), trash=False)

        if 'search' in request.GET:
            if request.GET['search'] == 'filter':
                if request.GET['value'] != "":
                    for item in self.filterset_fields:
                        query = QueryDict('{0}__contains={1}'.format(item, request.GET['value']))
                        if (self.filterset_class(
                                data=query,
                                queryset=kill_houses
                        )
                        ).filter():
                            ps = self.filterset_class(data=query, queryset=kill_houses)
                            kill_houses = ps.filter()
                else:
                    kill_houses = kill_houses
        page_size = request.query_params.get('page_size', None)
        if page_size:
            self.pagination_class.page_size = int(page_size)

        page = self.paginate_queryset(kill_houses)
        if page is not None:
            if 'date1' in request.GET:
                serializer = KillHouseForProvinceWageWithDateSerializer(page, many=True, context={'request': request})
            else:

                serializer = self.get_serializer(page, many=True, context={'request': request})
            return self.get_paginated_response(serializer.data)

        if 'date1' in request.GET:
            serializer = KillHouseForProvinceWageWithDateSerializer(kill_houses, many=True,
                                                                    context={'request': request})
        else:

            serializer = self.get_serializer(kill_houses, many=True, context={'request': request})
        return Response(serializer.data, status=status.HTTP_200_OK)


# class KillHouseForProvinceWageViewSet(viewsets.ModelViewSet):
#     queryset = KillHouse.objects.all()
#     serializer_class = KillHouseForProvinceWageSerializer
#     pagination_class = CustomPagination
#     permission_classes = [TokenHasReadWriteScope]
#     filter_backends = [DjangoFilterBackend]
#     filterset_class = KillHouseFilterSet
#     filterset_fields = [
#         'name',
#         'kill_house_operator__user__fullname',
#         'kill_house_operator__user__mobile',
#         'system_address__city__name',
#
#     ]
#
#     def list(self, request, *args, **kwargs):
#
#         if request.GET['type'] == 'unpaid':
#             if 'date1' in request.GET:
#                 date1 = datetime.strptime(str(request.GET['date1']), '%Y-%m-%d').date()
#                 date2 = datetime.strptime(str(request.GET['date2']), '%Y-%m-%d').date()
#                 kill_houses = KillHouse.objects.filter(pk__in=ProvinceKillRequest.objects.filter(wage_pay=False,
#                                                                                                  kill_request__recive_date__date__gte=date1,
#                                                                                                  kill_request__recive_date__date__lte=date2,
#                                                                                                  state__in=(
#                                                                                                      'pending',
#                                                                                                      'accepted'),
#                                                                                                  archive_by_province=False,
#                                                                                                  return_to_province=False,
#                                                                                                  trash=False).values(
#                     'killhouse_user'), trash=False)
#             else:
#
#                 kill_houses = KillHouse.objects.filter(pk__in=ProvinceKillRequest.objects.filter(wage_pay=False,
#                                                                                                  state__in=(
#                                                                                                      'pending',
#                                                                                                      'accepted'),
#                                                                                                  archive_by_province=False,
#                                                                                                  return_to_province=False,
#                                                                                                  trash=False).values(
#                     'killhouse_user'), trash=False)
#
#
#         elif request.GET['type'] == 'paid':
#             if 'date1' in request.GET:
#                 date1 = datetime.strptime(str(request.GET['date1']), '%Y-%m-%d').date()
#                 date2 = datetime.strptime(str(request.GET['date2']), '%Y-%m-%d').date()
#                 kill_houses = KillHouse.objects.filter(pk__in=ProvinceKillRequest.objects.filter(wage_pay=True,
#                                                                                                  kill_request__recive_date__date__gte=date1,
#                                                                                                  kill_request__recive_date__date__lte=date2,
#                                                                                                  state__in=(
#                                                                                                      'pending',
#                                                                                                      'accepted'),
#                                                                                                  archive_by_province=False,
#                                                                                                  return_to_province=False,
#                                                                                                  trash=False).values(
#                     'killhouse_user'), trash=False)
#
#             else:
#                 kill_houses = KillHouse.objects.filter(pk__in=ProvinceKillRequest.objects.filter(wage_pay=True,
#                                                                                                  state__in=(
#                                                                                                      'pending',
#                                                                                                      'accepted'),
#                                                                                                  archive_by_province=False,
#                                                                                                  return_to_province=False,
#                                                                                                  trash=False).values(
#                     'killhouse_user'), trash=False)
#
#
#         elif request.GET['type'] == 'archive':
#             if 'date1' in request.GET:
#                 date1 = datetime.strptime(str(request.GET['date1']), '%Y-%m-%d').date()
#                 date2 = datetime.strptime(str(request.GET['date2']), '%Y-%m-%d').date()
#                 kill_houses = KillHouse.objects.filter(pk__in=ProvinceKillRequest.objects.filter(wage_pay=False,
#                                                                                                  kill_request__recive_date__date__gte=date1,
#                                                                                                  kill_request__recive_date__date__lte=date2,
#                                                                                                  state__in=(
#                                                                                                      'pending',
#                                                                                                      'accepted'),
#                                                                                                  archive_by_province=True,
#                                                                                                  return_to_province=False,
#                                                                                                  trash=False).values(
#                     'killhouse_user'), trash=False)
#
#             else:
#                 kill_houses = KillHouse.objects.filter(pk__in=ProvinceKillRequest.objects.filter(wage_pay=False,
#                                                                                                  state__in=(
#                                                                                                      'pending',
#                                                                                                      'accepted'),
#                                                                                                  archive_by_province=True,
#                                                                                                  return_to_province=False,
#                                                                                                  trash=False).values(
#                     'killhouse_user'), trash=False)
#
#         else:
#             if 'date1' in request.GET:
#                 date1 = datetime.strptime(str(request.GET['date1']), '%Y-%m-%d').date()
#                 date2 = datetime.strptime(str(request.GET['date2']), '%Y-%m-%d').date()
#                 kill_houses = KillHouse.objects.filter(
#                     pk__in=ProvinceKillRequest.objects.filter(
#                         kill_request__recive_date__date__gte=date1,
#                         kill_request__recive_date__date__lte=date2,
#                         state__in=('pending', 'accepted'), trash=False).values(
#                         'killhouse_user'), trash=False)
#             else:
#                 kill_houses = KillHouse.objects.filter(
#                     pk__in=ProvinceKillRequest.objects.filter(state__in=('pending', 'accepted'), trash=False).values(
#                         'killhouse_user'), trash=False)
#
#         if 'search' in request.GET:
#             if request.GET['search'] == 'filter':
#                 if request.GET['value'] != "":
#                     for item in self.filterset_fields:
#                         query = QueryDict('{0}__contains={1}'.format(item, request.GET['value']))
#                         if (self.filterset_class(
#                                 data=query,
#                                 queryset=kill_houses
#                         )
#                         ).filter():
#                             ps = self.filterset_class(data=query, queryset=kill_houses)
#                             kill_houses = ps.filter()
#                 else:
#                     kill_houses = kill_houses
#         page_size = request.query_params.get('page_size', None)
#         if page_size:
#             self.pagination_class.page_size = int(page_size)
#
#         page = self.paginate_queryset(kill_houses)
#         if page is not None:
#             if 'date1' in request.GET:
#                 serializer = KillHouseForProvinceWageWithDateSerializer(page, many=True, context={'request': request})
#             else:
#
#                 serializer = self.get_serializer(page, many=True, context={'request': request})
#             return self.get_paginated_response(serializer.data)
#
#         if 'date1' in request.GET:
#             serializer = KillHouseForProvinceWageWithDateSerializer(kill_houses, many=True,
#                                                                     context={'request': request})
#         else:
#
#             serializer = self.get_serializer(kill_houses, many=True, context={'request': request})
#         return Response(serializer.data, status=status.HTTP_200_OK)


class KillHouseForTotalProvinceWageTransactionViewSet(viewsets.ModelViewSet):
    queryset = KillHouse.objects.all()
    serializer_class = KillHouseForTotalProvinceWageTransactionSerializer
    pagination_class = CustomPagination
    permission_classes = [TokenHasReadWriteScope]
    filter_backends = [DjangoFilterBackend]
    filterset_class = KillHouseFilterSet
    filterset_fields = [
        'name',
        'kill_house_operator__user__fullname',
        'kill_house_operator__user__mobile',
        'system_address__city__name',

    ]

    def list(self, request, *args, **kwargs):

        if 'date1' in request.GET:
            date1 = datetime.strptime(str(request.GET['date1']), '%Y-%m-%d').date()
            date2 = datetime.strptime(str(request.GET['date2']), '%Y-%m-%d').date()
            if request.GET['role'] == 'ProvinceOperator':
                kill_houses = KillHouse.objects.filter(pk__in=InternalTransaction.objects.filter(
                    date__date__gte=date1,
                    date__date__lte=date2,
                    status='completed',
                    payer_type='kill_house',
                    union_share__gt=0,
                    trash=False).values(
                    'kill_house'), trash=False)

            elif request.GET['role'] == 'Company':
                kill_houses = KillHouse.objects.filter(pk__in=InternalTransaction.objects.filter(
                    date__date__gte=date1,
                    date__date__lte=date2,
                    status='completed',
                    payer_type='kill_house',
                    company_share__gt=0,
                    trash=False).values(
                    'kill_house'), trash=False)
            elif request.GET['role'] == 'Guilds':
                kill_houses = KillHouse.objects.filter(pk__in=InternalTransaction.objects.filter(
                    date__date__gte=date1,
                    date__date__lte=date2,
                    status='completed',
                    payer_type='kill_house',
                    guilds_share__gt=0,
                    trash=False).values(
                    'kill_house'), trash=False)

            elif request.GET['role'] == 'SuperAdmin':
                kill_houses = KillHouse.objects.filter(pk__in=InternalTransaction.objects.filter(
                    date__date__gte=date1,
                    date__date__lte=date2,
                    payer_type='kill_house',
                    status='completed',
                    trash=False).exclude(union_share=0, company_share=0, guilds_share=0).values(
                    'kill_house'), trash=False)
            else:
                kill_houses = KillHouse.objects.filter(pk__in=InternalTransaction.objects.filter(
                    date__date__gte=date1,
                    date__date__lte=date2,
                    payer_type='kill_house',
                    status='completed',
                    trash=False).values(
                    'kill_house'), trash=False)
        else:

            if request.GET['role'] == 'ProvinceOperator':
                kill_houses = KillHouse.objects.filter(pk__in=InternalTransaction.objects.filter(
                    status='completed',
                    payer_type='kill_house',
                    union_share__gt=0,
                    trash=False).values(
                    'kill_house'), trash=False)

            elif request.GET['role'] == 'Company':
                kill_houses = KillHouse.objects.filter(pk__in=InternalTransaction.objects.filter(
                    status='completed',
                    payer_type='kill_house',
                    company_share__gt=0,
                    trash=False).values(
                    'kill_house'), trash=False)
            elif request.GET['role'] == 'Guilds':
                kill_houses = KillHouse.objects.filter(pk__in=InternalTransaction.objects.filter(
                    status='completed',
                    payer_type='kill_house',
                    guilds_share__gt=0,
                    trash=False).values(
                    'kill_house'), trash=False)

            elif request.GET['role'] == 'SuperAdmin':
                kill_houses = KillHouse.objects.filter(pk__in=InternalTransaction.objects.filter(
                    status='completed',
                    payer_type='kill_house',
                    trash=False).exclude(union_share=0, company_share=0, guilds_share=0).values(
                    'kill_house'), trash=False)
            else:
                kill_houses = KillHouse.objects.filter(pk__in=InternalTransaction.objects.filter(
                    status='completed',
                    payer_type='kill_house',
                    trash=False).values(
                    'kill_house'), trash=False)

        if 'search' in request.GET:
            if request.GET['search'] == 'filter':
                if request.GET['value'] != "":
                    for item in self.filterset_fields:
                        query = QueryDict('{0}__contains={1}'.format(item, request.GET['value']))
                        if (self.filterset_class(
                                data=query,
                                queryset=kill_houses
                        )
                        ).filter():
                            ps = self.filterset_class(data=query, queryset=kill_houses)
                            kill_houses = ps.filter()
                else:
                    kill_houses = kill_houses
        page_size = request.query_params.get('page_size', None)
        if page_size:
            self.pagination_class.page_size = int(page_size)

        page = self.paginate_queryset(kill_houses)
        if page is not None:
            if 'date1' in request.GET:
                serializer = KillHouseForTotalProvinceWageTransactionWithDAteSerializer(page, many=True,
                                                                                        context={'request': request})
            else:

                serializer = self.get_serializer(page, many=True, context={'request': request})
            return self.get_paginated_response(serializer.data)

        if 'date1' in request.GET:
            serializer = KillHouseForTotalProvinceWageTransactionWithDAteSerializer(kill_houses, many=True,
                                                                                    context={'request': request})
        else:

            serializer = self.get_serializer(kill_houses, many=True, context={'request': request})
        return Response(serializer.data, status=status.HTTP_200_OK)


class KillHouseForFreeBarWageViewSet(viewsets.ModelViewSet):
    queryset = KillHouse.objects.all()
    serializer_class = KillHouseForFreeBarWageSerializer
    pagination_class = CustomPagination
    permission_classes = [TokenHasReadWriteScope]
    filter_backends = [DjangoFilterBackend]
    filterset_class = KillHouseFilterSet
    filterset_fields = [
        'name',
        'kill_house_operator__user__fullname',
        'kill_house_operator__user__mobile',
        'system_address__city__name',

    ]

    def list(self, request, *args, **kwargs):
        type = request.GET['type']

        if 'date1' in request.GET:
            date1 = datetime.strptime(str(request.GET['date1']), '%Y-%m-%d').date()
            date2 = datetime.strptime(str(request.GET['date2']), '%Y-%m-%d').date()
            if request.GET['role'] == 'ProvinceOperator':
                kill_houses = KillHouse.objects.filter(pk__in=KillHouseFreeBarInformation.objects.filter(
                    date__date__gte=date1,
                    date__date__lte=date2,
                    buy_type=type,
                    archive_wage=False,
                    union_share__gt=0,
                    trash=False).values(
                    'kill_house'), trash=False)
            elif request.GET['role'] == 'Company':
                kill_houses = KillHouse.objects.filter(pk__in=KillHouseFreeBarInformation.objects.filter(
                    date__date__gte=date1,
                    date__date__lte=date2,
                    buy_type=type,
                    company_share__gt=0,
                    archive_wage=False,
                    trash=False).values(
                    'kill_house'), trash=False)
            elif request.GET['role'] == 'Guilds':
                kill_houses = KillHouse.objects.filter(pk__in=KillHouseFreeBarInformation.objects.filter(
                    date__date__gte=date1,
                    date__date__lte=date2,
                    buy_type=type,
                    guilds_share__gt=0,
                    archive_wage=False,
                    trash=False).values(
                    'kill_house'), trash=False)
            else:

                kill_houses = KillHouse.objects.filter(pk__in=KillHouseFreeBarInformation.objects.filter(
                    date__date__gte=date1,
                    date__date__lte=date2,
                    buy_type=type,
                    archive_wage=False,
                    trash=False).values(
                    'kill_house'), trash=False)
        else:

            if request.GET['role'] == 'ProvinceOperator':
                kill_houses = KillHouse.objects.filter(pk__in=KillHouseFreeBarInformation.objects.filter(
                    buy_type=type,
                    union_share__gt=0,
                    archive_wage=False,
                    trash=False).values(
                    'kill_house'), trash=False)
            elif request.GET['role'] == 'Company':
                kill_houses = KillHouse.objects.filter(pk__in=KillHouseFreeBarInformation.objects.filter(
                    buy_type=type,
                    company_share__gt=0,
                    archive_wage=False,
                    trash=False).values(
                    'kill_house'), trash=False)
            elif request.GET['role'] == 'Guilds':
                kill_houses = KillHouse.objects.filter(pk__in=KillHouseFreeBarInformation.objects.filter(
                    buy_type=type,
                    guilds_share__gt=0,
                    archive_wage=False,
                    trash=False).values(
                    'kill_house'), trash=False)
            else:

                kill_houses = KillHouse.objects.filter(pk__in=KillHouseFreeBarInformation.objects.filter(
                    buy_type=type,
                    archive_wage=False,
                    trash=False).values(
                    'kill_house'), trash=False)
        if 'search' in request.GET:
            if request.GET['search'] == 'filter':
                if request.GET['value'] != "":
                    for item in self.filterset_fields:
                        query = QueryDict('{0}__contains={1}'.format(item, request.GET['value']))
                        if (self.filterset_class(
                                data=query,
                                queryset=kill_houses
                        )
                        ).filter():
                            ps = self.filterset_class(data=query, queryset=kill_houses)
                            kill_houses = ps.filter()
                else:
                    kill_houses = kill_houses
        page_size = request.query_params.get('page_size', None)
        if page_size:
            self.pagination_class.page_size = int(page_size)

        page = self.paginate_queryset(kill_houses)
        if page is not None:
            if 'date1' in request.GET:
                serializer = KillHouseForFreeBarWageWithDateSerializer(page, many=True, context={'request': request})
            else:

                serializer = self.get_serializer(page, many=True, context={'request': request})
            return self.get_paginated_response(serializer.data)

        if 'date1' in request.GET:
            serializer = KillHouseForFreeBarWageWithDateSerializer(kill_houses, many=True,
                                                                   context={'request': request})
        else:

            serializer = self.get_serializer(kill_houses, many=True, context={'request': request})
        return Response(serializer.data, status=status.HTTP_200_OK)


class KillHouseForFreeSaleBarInformationViewSet(viewsets.ModelViewSet):
    queryset = KillHouse.objects.all()
    serializer_class = KillHouseForFreeSaleBarInformationViewSetSerializer
    pagination_class = CustomPagination
    permission_classes = [TokenHasReadWriteScope]
    filter_backends = [DjangoFilterBackend]
    filterset_class = KillHouseFilterSet
    filterset_fields = [
        'name',
        'kill_house_operator__user__fullname',
        'kill_house_operator__user__mobile',
        'system_address__city__name',

    ]

    def list(self, request, *args, **kwargs):
        user = SystemUserProfile.objects.get(user=request.user, trash=False)
        if 'date1' in request.GET:
            date1 = datetime.strptime(str(request.GET['date1']), '%Y-%m-%d').date()
            date2 = datetime.strptime(str(request.GET['date2']), '%Y-%m-%d').date()
            if request.GET['role'] in ['ProvinceOperator', 'SuperAdmin', 'AdminX', 'Supporter']:
                free_sales = KillHouseFreeSaleBarInformation.objects.filter(trash=False, date__date__gte=date1,
                                                                            date__date__lte=date2)


            else:
                free_sales = KillHouseFreeSaleBarInformation.objects.filter(kill_house__system_address__city=user.city,
                                                                            trash=False, date__date__gte=date1,
                                                                            date__date__lte=date2)



        else:
            if request.GET['role'] in ['ProvinceOperator', 'SuperAdmin', 'AdminX', 'Supporter']:
                free_sales = KillHouseFreeSaleBarInformation.objects.filter(trash=False)



            else:
                free_sales = KillHouseFreeSaleBarInformation.objects.filter(kill_house__system_address__city=user.city,
                                                                            trash=False)

        kill_houses = KillHouse.objects.filter(pk__in=free_sales.values_list('kill_house', flat=True)).order_by('id')

        if 'date1' in request.GET:
            serializer = KillHouseForFreeSaleBarInformationViewSetWithDateSerializer(kill_houses, many=True,
                                                                                     context={'request': request})
        else:

            serializer = self.get_serializer(kill_houses, many=True, context={'request': request})
        return Response(serializer.data, status=status.HTTP_200_OK)


# ویوست مربوط به ثبت کشتارگاه


class KillHouseforPurchaseRequestViewSet(viewsets.ModelViewSet):
    queryset = KillHouse.objects.filter(trash=False, out_province=False).order_by('id')
    serializer_class = KillHouseforPurchaseRequestSerializer
    permission_classes = [TokenHasReadWriteScope]


class KillHousePurchaseRequestPermissionViewSet(viewsets.ModelViewSet):
    queryset = KillHousePurchaseRequest.objects.all()
    serializer_class = KillHousePurchaseRequestSerializer
    permission_classes = [TokenHasReadWriteScope]

    def list(self, request, *args, **kwargs):
        total_unpaid_wage = 0
        total_paid_wage = 0
        permission = True
        exclusive = False
        user = SystemUserProfile.objects.get(user=request.user, trash=False)
        kill_house_role = Group.objects.get(name='KillHouse')
        if kill_house_role in user.role.all():
            kill_house = KillHouse.objects.filter(kill_house_operator__user=user, trash=False).first()
            exclusive = True if kill_house.type == 'exclusive' else False
            purchase = KillHousePurchaseRequest.objects.filter(kill_house=kill_house).first()
            if purchase:
                if purchase.total_limitation == True:
                    permission = False
                else:
                    permission = True
            else:
                permission = True

        return Response({
            "permission": permission,
            "exclusive": exclusive
        }, status=status.HTTP_200_OK)


class KillHousePurchaseRequestViewSet(viewsets.ModelViewSet):
    queryset = KillHousePurchaseRequest.objects.all()
    serializer_class = KillHousePurchaseRequestSerializer
    permission_classes = [TokenHasReadWriteScope]

    def update(self, request, pk=None, *args, **kwargs):
        kill_house = KillHouse.objects.get(key=request.data['kill_house_key'], trash=False)
        request.data.pop('kill_house_key')
        serializer = self.serializer_class(data=request.data)
        purchace = KillHousePurchaseRequest.objects.filter(kill_house=kill_house).first()
        if purchace:
            serializer.update(instance=purchace, validated_data=request.data)
        else:
            if serializer.is_valid():
                purchace = serializer.create(validated_data=request.data)
                purchace.kill_house = kill_house
                purchace.save()

        return Response({"result": "با موفقیت انجام شد."}, status=status.HTTP_200_OK)


class TotalReportOfKillHouseWareHouseForDailyBroadCastInDetailsViewSet(viewsets.ModelViewSet):
    queryset = KillHouse.objects.all()
    serializer_class = KillHouseWareHouseForDailyBroadCastOInDetailsSerializer
    permission_classes = [TokenHasReadWriteScope]

    def list(self, request, *args, **kwargs):
        date1 = datetime.strptime(str(request.GET['date1']), '%Y-%m-%d').date()
        date2 = datetime.strptime(str(request.GET['date2']), '%Y-%m-%d').date()
        kill_house_ware_houses = KillHouseWareHouse.objects.filter(
            Q(weight_of_carcasses__gt=0) | Q(free_weight_of_carcasses__gt=0) | Q(
                pre_cold_weight_of_carcasses_to_ware_house__gt=0), date__date__gte=date1,
            date__date__lte=date2, trash=False)
        kill_houses = KillHouse.objects.filter(
            pk__in=kill_house_ware_houses.values('kill_house')
        )

        serializer = self.serializer_class(kill_houses, many=True, context={'request': request})
        return Response(serializer.data, status=status.HTTP_200_OK)


class TotalReportOfKillHouseWareHouseForDailyBroadCastViewSet(viewsets.ModelViewSet):
    queryset = KillHouseWareHouse.objects.all()
    serializer_class = KillHouseWareHouseSerializer
    permission_classes = [TokenHasReadWriteScope]

    def list(self, request, *args, **kwargs):
        date1 = datetime.strptime(str(request.GET['date1']), '%Y-%m-%d').date()
        date2 = datetime.strptime(str(request.GET['date2']), '%Y-%m-%d').date()
        kill_house_ware_houses = KillHouseWareHouse.objects.filter(
            Q(weight_of_carcasses__gt=0) | Q(free_weight_of_carcasses__gt=0) | Q(
                pre_cold_weight_of_carcasses_to_ware_house__gt=0), date__date__gte=date1,
            date__date__lte=date2, trash=False)
        number_of_kill_houses = KillHouse.objects.filter(
            pk__in=kill_house_ware_houses.values('kill_house')
        )

        steward_allocations = StewardAllocation.objects.filter(
            Q(type='manual') | Q(type='auto', system_registration_code=True),
            ware_house__in=kill_house_ware_houses, receiver_state__in=('pending', 'accepted'), trash=False).order_by(
            'id')

        guild_allocations = steward_allocations.filter(guilds__isnull=False, trash=False)
        number_of_guild = guild_allocations.values('guilds').distinct().count() if guild_allocations else 0

        steward_allocations_for_number_of_steward = steward_allocations.filter(steward__isnull=False, trash=False)
        number_of_steward = steward_allocations_for_number_of_steward.values(
            'steward').distinct().count() if steward_allocations_for_number_of_steward else 0

        total_pre_cold_quantity = \
            kill_house_ware_houses.aggregate(total=Sum('pre_cold_number_of_carcasses_to_ware_house'))[
                'total']
        total_pre_cold_weight = \
            kill_house_ware_houses.aggregate(total=Sum('pre_cold_weight_of_carcasses_to_ware_house'))[
                'total']
        total_number_of_free_carcasses = kill_house_ware_houses.aggregate(total=Sum('number_of_free_carcasses'))[
            'total']
        total_free_weight_of_carcasses = kill_house_ware_houses.aggregate(total=Sum('free_weight_of_carcasses'))[
            'total']
        total_number_of_carcasses = kill_house_ware_houses.aggregate(total=Sum('number_of_carcasses'))[
            'total']
        total_weight_of_carcasses = kill_house_ware_houses.aggregate(total=Sum('weight_of_carcasses'))[
            'total']

        final_total_number_of_carcasses = \
            kill_house_ware_houses.aggregate(total=Sum('final_total_number_of_carcasses'))[
                'total']
        final_total_weight_of_carcasses = \
            kill_house_ware_houses.aggregate(total=Sum('final_total_weight_of_carcasses'))[
                'total']

        total_remain_quantity = \
            kill_house_ware_houses.aggregate(total=Sum('remain_total_number_of_carcasses'))[
                'total']

        total_remain_weight = \
            kill_house_ware_houses.aggregate(total=Sum('remain_total_weight_of_carcasses'))[
                'total']

        total_allocated_quantity = \
            steward_allocations.aggregate(total=Sum('real_number_of_carcasses'))[
                'total']

        total_allocated_weight = \
            steward_allocations.aggregate(total=Sum('real_weight_of_carcasses'))[
                'total']

        total_accepted_allocated_quantity = \
            steward_allocations.aggregate(total=Sum('receiver_real_number_of_carcasses'))[
                'total']

        total_accepted_allocated_weight = \
            steward_allocations.aggregate(total=Sum('receiver_real_weight_of_carcasses'))[
                'total']

        return Response({
            "buyers": len(number_of_kill_houses),
            "incoming_quantity_of_cold_house": 0,
            "incoming_weight_of_cold_house": 0,
            "total_pre_cold_quantity": total_pre_cold_quantity if total_pre_cold_quantity != None else 0,
            "total_pre_cold_weight": total_pre_cold_weight if total_pre_cold_weight != None else 0,
            "total_number_of_free_carcasses": total_number_of_free_carcasses if total_number_of_free_carcasses != None else 0,
            "total_free_weight_of_carcasses": total_free_weight_of_carcasses if total_free_weight_of_carcasses != None else 0,
            "total_number_of_carcasses": total_number_of_carcasses if total_number_of_carcasses != None else 0,
            "total_weight_of_carcasses": total_weight_of_carcasses if total_weight_of_carcasses != None else 0,
            "final_total_number_of_carcasses": final_total_number_of_carcasses if final_total_number_of_carcasses != None else 0,
            "final_total_weight_of_carcasses": final_total_weight_of_carcasses if final_total_weight_of_carcasses != None else 0,
            "total_allocated_quantity": total_allocated_quantity if total_allocated_quantity != None else 0,
            "total_allocated_weight": total_allocated_weight if total_allocated_weight != None else 0,
            "total_accepted_allocated_quantity": total_accepted_allocated_quantity if total_accepted_allocated_quantity != None else 0,
            "total_accepted_allocated_weight": total_accepted_allocated_weight if total_accepted_allocated_weight != None else 0,
            "total_remain_quantity": total_remain_quantity if total_remain_quantity != None else 0,
            "total_remain_weight": total_remain_weight if total_remain_weight != None else 0,
            "number_of_guild": number_of_guild,
            "number_of_steward": number_of_steward,

        })


class TotalReportForDailyBroadCastViewSet(viewsets.ModelViewSet):
    queryset = KillHouse.objects.all()
    serializer_class = KillHouseForTotalReportAutomaticStewardAllocationSerializer
    permission_classes = [TokenHasReadWriteScope]

    def list(self, request, *args, **kwargs):
        date = datetime.strptime(str(request.GET['date']), '%Y-%m-%d').date()
        date_one_day_ago = date - timedelta(days=1)
        province_kill_requests = ProvinceKillRequest.objects.filter(state__in=('pending', 'accepted'),
                                                                    kill_request__recive_date__date=date_one_day_ago).select_related(
            'killhouse_user')
        kill_houses = KillHouse.objects.filter(
            pk__in=province_kill_requests.values('killhouse_user')
        )
        kill_house_ware_houses = KillHouseWareHouse.objects.filter(kill_house__in=kill_houses, date__date=date)
        steward_allocations = StewardAllocation.objects.filter(
            Q(type='manual') | Q(type='auto', system_registration_code=True),
            ware_house__in=kill_house_ware_houses, trash=False,
            date__date=date).order_by('id')

        total_number_of_carcasses = kill_house_ware_houses.aggregate(total=Sum('final_total_number_of_carcasses'))[
            'total']
        total_weight_of_carcasses = kill_house_ware_houses.aggregate(total=Sum('final_total_weight_of_carcasses'))[
            'total']
        allocated_total_number_of_carcasses = \
            kill_house_ware_houses.aggregate(total=Sum('allocated_total_number_of_carcasses'))['total']
        allocated_total_weight_of_carcasses = \
            kill_house_ware_houses.aggregate(total=Sum('allocated_total_weight_of_carcasses'))['total']
        remain_total_number_of_carcasses = \
            kill_house_ware_houses.aggregate(total=Sum('remain_total_number_of_carcasses'))['total']
        remain_total_weight_of_carcasses = \
            kill_house_ware_houses.aggregate(total=Sum('remain_total_weight_of_carcasses'))['total']

        return Response({
            "buyers": len(kill_house_ware_houses),
            "allocations": len(steward_allocations),
            "total_number_of_carcasses": total_number_of_carcasses if total_number_of_carcasses != None else 0,
            "total_weight_of_carcasses": total_weight_of_carcasses if total_weight_of_carcasses != None else 0,
            "allocated_total_number_of_carcasses": allocated_total_number_of_carcasses if allocated_total_number_of_carcasses != None else 0,
            "allocated_total_weight_of_carcasses": allocated_total_weight_of_carcasses if allocated_total_weight_of_carcasses != None else 0,
            "remain_total_number_of_carcasses": remain_total_number_of_carcasses if remain_total_number_of_carcasses != None else 0,
            "remain_total_weight_of_carcasses": remain_total_weight_of_carcasses if remain_total_weight_of_carcasses != None else 0,
        })


class KillHouseForTotalReportAutomaticStewardAllocationViewSet(viewsets.ModelViewSet):
    queryset = KillHouse.objects.all()
    serializer_class = KillHouseForTotalReportAutomaticStewardAllocationSerializer
    permission_classes = [TokenHasReadWriteScope]

    def list(self, request, *args, **kwargs):
        date = datetime.strptime(str(request.GET['date']), '%Y-%m-%d').date()
        kill_house = KillHouse.objects.get(key=request.GET['kill_house_key'])
        serializer = self.serializer_class(kill_house, context={'request': request})
        return Response(serializer.data, status=status.HTTP_200_OK)


class KillHouseForAutomaticStewardAllocationViewSet(viewsets.ModelViewSet):
    queryset = KillHouse.objects.all()
    serializer_class = KillHouseForAutomaticStewardAllocationSerializer
    permission_classes = [TokenHasReadWriteScope]

    def list(self, request, *args, **kwargs):
        date = datetime.strptime(str(request.GET['date']), '%Y-%m-%d').date()
        date = date - timedelta(days=1)
        if request.GET['role'] == 'KillHouse':
            user = SystemUserProfile.objects.get(user=request.user, trash=False)
            kill_house = KillHouse.objects.filter(kill_house_operator__user=user)
            serializer = self.serializer_class(kill_house, many=True, context={'request': request})
        else:
            province_kill_requests = ProvinceKillRequest.objects.filter(state__in=('pending', 'accepted'),
                                                                        kill_request__recive_date__date=date).select_related(
                'killhouse_user')
            kill_houses = KillHouse.objects.filter(
                pk__in=province_kill_requests.values('killhouse_user')
            )

            serializer = self.serializer_class(kill_houses, context={'request': request}, many=True)
        return Response(serializer.data, status=status.HTTP_200_OK)


class KillHouseViewSet(viewsets.ModelViewSet):
    queryset = KillHouse.objects.all()
    serializer_class = KillHouseSerializer
    permission_classes = [TokenHasReadWriteScope]

    # تابع مربوط به ثبت کشتارگاه
    def create(self, request, *args, **kwargs):
        group = Group.objects.get(name__exact="KillHouse")
        city = City.objects.get(name=request.data['city'])
        request.data.pop('city')
        province = Province.objects.get(key=city.province.key)
        system_profile = SystemUserProfile.objects.filter(mobile=request.data['mobile'], trash=False).last()
        if system_profile:
            if KillHouse.objects.filter(kill_house_operator__user=system_profile, trash=False).exists():
                return Response({"result": "این کشتارگاه قبلا ثبت شده است"}, status=status.HTTP_403_FORBIDDEN)

        else:
            password = request.data['password']
            data = {
                "username": request.data['mobile'],
                "password": password,
                "api_key": PROJECT_API_KEY
            }
            req = requests.post(
                url=ARTA_URL_REGISTER,
                data=data,
                verify=False
            )

            if req.status_code == 200:
                user = User(username=request.data['mobile'], first_name=request.data['first_name'],
                            last_name=request.data['last_name'])
                user.save()
                base_id = SystemUserProfile.objects.all()
                if base_id.count() > 0:
                    base_id = int(base_id.last().base_order) + 1
                else:
                    base_id = 1000
                system_profile = SystemUserProfile(
                    mobile=request.data['mobile'],
                    first_name=request.data['first_name'],
                    last_name=request.data['last_name'],
                    fullname=request.data['first_name'] + " " + request.data['last_name'],
                    user=user,
                    base_order=base_id,
                    password=password,
                    national_id=request.data['national_id'],
                    city=city,
                    province=province
                )
                system_profile.save()
            else:
                return Response({"result": "در ثبت کاربر مشکلی بوجود آمده است "}, status=status.HTTP_403_FORBIDDEN)
        address = SystemAddress(city=city, province=province, address=request.data['address'])
        address.save()
        wallet = Wallet()
        wallet.save()
        system_profile.role.add(group)
        operator = KillHouseOperator.objects.filter(user=system_profile, trash=False).last()
        if operator:
            pass
        else:
            operator = KillHouseOperator(
                user=system_profile,
                address=address,
                wallet=wallet,
            )
            operator.save()
        request.data.pop('mobile')
        request.data.pop('first_name')
        request.data.pop('last_name')
        request.data.pop('address')
        request.data.pop('national_id')
        request.data.pop('password')
        serializer = self.serializer_class(data=request.data)
        if serializer.is_valid():
            kill_house = serializer.create(validated_data=request.data)
            kill_house.kill_house_operator = operator
            kill_house.system_address = address
            kill_house.save()
            percentage = KillHousePercentage(kill_house=kill_house)
            percentage.save()
            province_allow_kill_house_choose_steward_guilds = ProvinceAllowKillHouseChooseStewardGuilds(
                kill_house=kill_house)
            province_allow_kill_house_choose_steward_guilds.save()
            province_allow_direct_buying = ProvinceAllowKillHouseDirectBuying(kill_house=kill_house)
            province_allow_direct_buying.save()
            return Response({"result": "با موفقیت ثبت شد."}, status=status.HTTP_201_CREATED)
        return Response(serializer.errors)

    # تابع برای نمایش مربوط به نمایش کشتارگاه
    def list(self, request, *args, **kwargs):
        # refresh(request.user.id)

        user = SystemUserProfile.objects.get(user=request.user, trash=False)
        if 'role' in request.GET:
            # if 'kill_house' in request.GET:
            #     kill_house = KillHouse.objects.filter(system_address__province=user.province, killer=False, trash=False)
            #
            # else:
            if request.GET['role'] == 'KillHouse':
                kill_house_operator = KillHouseOperator.objects.get(user=user, trash=False)
                kill_house = KillHouse.objects.filter(kill_house_operator=kill_house_operator,
                                                      trash=False)

            # if request.GET['role'] == 'ProvinceInspector' or request.GET['role'] == 'ProvinceOperator':
            else:
                kill_house = KillHouse.objects.filter(system_address__province=user.province, trash=False)
            serializer = KillHouseSerializer(kill_house, many=True)
        elif 'kill_house' in request.GET:
            kill_house = KillHouse.objects.filter(system_address__province=user.province,
                                                  kill_house_operator__killer=False, killer=False, trash=False)
            serializer = KillHouseSerializer(kill_house, many=True)

        elif 'all' in request.GET:
            kill_house = KillHouse.objects.filter(system_address__province=user.province, trash=False)
            serializer = KillHouseSerializer(kill_house, many=True)

        elif 'psp' in request.GET:
            kill_house = KillHouse.objects.filter(out_province=False, trash=False)
            serializer = PspKillHouseSerializer(kill_house, many=True)

        elif 'self_kill_houses' in request.GET:
            kill_house_operator = KillHouseOperator.objects.get(user=user, trash=False)
            kill_house = KillHouse.objects.filter(kill_house_operator=kill_house_operator,
                                                  trash=False)
            serializer = KillHouseSerializer(kill_house, many=True)
        elif 'exclusive-killers' in request.GET:
            kill_house = KillHouse.objects.filter(kill_house_operator__user=user, trash=False).first()
            percentage = KillHousePercentage.objects.filter(
                Q(kill_house=kill_house) | Q(kill_house_for_killer=kill_house, kill_house__type='exclusive',
                                             kill_house__show_exclusive=True),
                trash=False).values_list('kill_house__id', flat=True).distinct()
            kill_houses = KillHouse.objects.filter(id__in=percentage, trash=False)

            serializer = KillHouseSerializer(kill_houses, many=True)

        elif 'total-exclude-exclusive-killers' in request.GET:
            percentage = KillHousePercentage.objects.filter(kill_house_for_killer__isnull=False,
                                                            kill_house__type='exclusive',
                                                            kill_house__show_exclusive=True, trash=False).values_list(
                'kill_house__id', flat=True).distinct()
            kill_houses = KillHouse.objects.filter(trash=False).exclude(id__in=percentage).order_by('id', 'killer')

            serializer = distributionKillHouseSerializer(kill_houses, many=True)
            return Response(serializer.data, status=status.HTTP_200_OK)

        elif 'exclusive-killers-free-bar' in request.GET:
            kill_house = KillHouse.objects.filter(kill_house_operator__user=user, trash=False).first()

            percentage = KillHousePercentage.objects.filter(kill_house_for_killer=kill_house,
                                                            kill_house__type='exclusive',
                                                            kill_house__show_exclusive=True, trash=False).values_list(
                'kill_house__id', flat=True)

            kill_houses = KillHouse.objects.filter(Q(id__in=percentage) | Q(killer=True, type='public'), trash=False)

            serializer = KillHouseSerializer(kill_houses, many=True)

        elif 'dispenser' in request.GET:
            kill_house = KillHouse.objects.filter(system_address__province=user.province,
                                                  out_province=False, trash=False).order_by('id')
            serializer = GeneralKillHouseSerializer(kill_house, many=True)

        elif 'gate-way-kill-houses' in request.GET:
            kill_house = KillHouse.objects.filter(system_address__province=user.province,
                                                  out_province=False, trash=False)
            serializer = GeneralKillHouseSerializer(kill_house, many=True)


        else:
            try:
                kill_house_operator = KillHouseOperator.objects.get(user=user, trash=False)
                kill_house = KillHouse.objects.filter(kill_house_operator=kill_house_operator, trash=False).first()
                serializer = KillHouseSerializer(kill_house)
            except:
                kill_house = KillHouse.objects.filter(out_province=False, type='public', trash=False)
                serializer = KillHouseSerializer(kill_house, many=True)

        return Response(serializer.data, status=status.HTTP_200_OK)

    # تابع برای ویرایش درخواست کشتار ثبت شده از سمت کشتارگاه
    def update(self, request, *args, pk=None, **kwargs):
        # refresh(request.user.id)

        kill_house = KillHouse.objects.filter(
            key=request.data['kill_house_key'], trash=False
        ).select_related('kill_house_operator__user').last()
        system_user_profile = SystemUserProfile.objects.get(key=kill_house.kill_house_operator.user.key)

        if 'company_gateway_percent' in request.data.keys():
            kill_house.company_gateway_percent = request.data['company_gateway_percent']
            kill_house.union_gateway_percent = request.data['union_gateway_percent']
            kill_house.guilds_gateway_percent = request.data['guilds_gateway_percent']
            kill_house.other_gateway_percent = request.data['other_gateway_percent']
            kill_house.save()
        elif 'quota' in request.data.keys():
            kill_house.quota = request.data['quota']
            kill_house.governmental_quota = request.data['governmental_quota']
            kill_house.quota_max_kill_limit = request.data['quota_max_kill_limit']
            kill_house.quota_request = request.data['quota_request']
            kill_house.quota_custom = request.data['quota_custom']
            kill_house.quota_custom_quantity = request.data['quota_custom_quantity']
            kill_house.save()
        elif 'maximum_load_volume_increase' in request.data.keys():
            kill_house.maximum_load_volume_increase = request.data['maximum_load_volume_increase']
            kill_house.maximum_load_volume_reduction = request.data['maximum_load_volume_reduction']
            kill_house.save()

        elif 'ware_house_remaining_weight_limitation_status' in request.data.keys():
            kill_house.ware_house_remaining_weight_limitation_status = request.data[
                'ware_house_remaining_weight_limitation_status']
            kill_house.ware_house_remaining_weight_limitation = request.data['ware_house_remaining_weight_limitation']
            kill_house.ware_house_remaining_percent_limitation_status = request.data[
                'ware_house_remaining_percent_limitation_status']
            kill_house.ware_house_remaining_percent_limitation = request.data['ware_house_remaining_percent_limitation']
            kill_house.save()


        elif 'total_kill_capacity' in request.data.keys():
            kill_house.max_kill_limit = request.data['max_kill_limit']
            kill_house.total_kill_capacity = request.data['total_kill_capacity']
            kill_house.extra_bar_kill_percent = request.data['extra_bar_kill_percent']
            kill_house.save()
        elif 'name' in request.data.keys():
            kill_house.name = request.data['name']
            kill_house.save()
        elif 'active' in request.data.keys():
            kill_house.active = request.data['active']
            kill_house.save()
        elif 'type' in request.data.keys():
            kill_house.type = request.data['type']
            kill_house.save()

        elif 'out_province_selling_limitation' in request.data.keys():
            kill_house.out_province_selling_limitation = request.data['out_province_selling_limitation']
            kill_house.out_province_selling_limitation_percent = request.data['out_province_selling_limitation_percent']
            kill_house.save()
        elif 'in_province_selling_limitation' in request.data.keys():
            kill_house.in_province_selling_limitation = request.data['in_province_selling_limitation']
            kill_house.in_province_selling_limitation_percent = request.data['in_province_selling_limitation_percent']
            kill_house.save()
        elif 'governmental_selling_permission' in request.data.keys():
            kill_house.governmental_selling_permission = request.data['governmental_selling_permission']
            kill_house.in_province_governmental_selling_percent = request.data[
                'in_province_governmental_selling_percent']
            kill_house.out_province_governmental_selling_percent = request.data[
                'out_province_governmental_selling_percent']
            kill_house.segmentation_governmental_percent = request.data['segmentation_governmental_percent']

            kill_house.save()

        elif 'free_selling_permission' in request.data.keys():
            kill_house.free_selling_permission = request.data['free_selling_permission']
            kill_house.in_province_free_selling_percent = request.data['in_province_free_selling_percent']
            kill_house.out_province_free_selling_percent = request.data['out_province_free_selling_percent']
            kill_house.segmentation_free_selling_percent = request.data['segmentation_free_selling_percent']

            kill_house.save()

        elif 'ware_house_remaining_weight_archive_percent':
            kill_house.ware_house_remaining_weight_archive_percent = request.data[
                'ware_house_remaining_weight_archive_percent']
            kill_house.save()

        else:
            system_user_profile.first_name = request.data['first_name']
            system_user_profile.last_name = request.data['last_name']
            system_user_profile.fullname = request.data['first_name'] + " " + request.data['last_name']
            system_user_profile.save()
            first_mobile_number = system_user_profile.mobile
            second_mobile_number = request.data['mobile']
            request.data.pop('mobile')
            if first_mobile_number != second_mobile_number:
                if SystemUserProfile.objects.filter(mobile=second_mobile_number).exists():
                    return Response({"result": "این شماره در سامانه به نام شخص دیگری است"},
                                    status=status.HTTP_403_FORBIDDEN)
                data = {
                    "first_mobile_number": first_mobile_number,
                    "second_mobile_number": second_mobile_number,
                }
                req = requests.post(
                    url=ARTA_URL_CHANGE_MOBILE_NUMBER,
                    data=data,
                    verify=False
                )
                if req.status_code == 200:
                    second_mobile_number = second_mobile_number
                    user = User.objects.get(id=system_user_profile.user.id)
                    user.username = second_mobile_number
                    user.save()
                    system_user_profile.mobile = second_mobile_number
                    system_user_profile.save()
        return Response({"result": "باموفقیت ویرایش شد"}, status=status.HTTP_200_OK)

    # ویوست مربوط به ثبت کشتارگاه


class PosKillHouseViewSet(viewsets.ModelViewSet):
    queryset = KillHouse.objects.all()
    serializer_class = PosKillHouseSerializer
    permission_classes = [AllowAny]
    pagination_class = CustomPagination
    filter_backends = [DjangoFilterBackend]
    filterset_class = KillHouseFilterSet
    filterset_fields = [
        'name',
        'kill_house_operator__user__fullname',
        'kill_house_operator__user__mobile',
        'system_address__city__name',

    ]

    def list(self, request, *args, **kwargs):
        pos = POSMachine.objects.get(pos_id=request.GET['pos-id'], trash=False)
        if pos.kill_house:
            kill_houses = KillHouse.objects.filter(out_province=False, trash=False).order_by('id').exclude(
                id=pos.kill_house.id)

        else:
            kill_houses = KillHouse.objects.filter(out_province=False, trash=False).order_by('id')

        if 'search' in request.GET:
            if request.GET['search'] == 'filter':
                kill_houses_list = []
                if request.GET['value'] != "":
                    for item in self.filterset_fields:
                        query = QueryDict('{0}__contains={1}'.format(item, request.GET['value']))
                        if (self.filterset_class(
                                data=query,
                                queryset=kill_houses
                        )
                        ).filter():
                            ps = self.filterset_class(data=query, queryset=kill_houses)
                            kill_houses_list = ps.filter()
                    kill_houses = [] if len(kill_houses_list) == 0 else kill_houses_list

        page_size = request.query_params.get('page_size', None)
        if page_size:
            self.pagination_class.page_size = int(page_size)

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

        serializer = self.serializer_class(kill_houses, many=True)
        return Response(serializer.data, status=status.HTTP_200_OK)


class KillHouseAllowVetViewSet(viewsets.ModelViewSet):
    queryset = KillHouseAllowVet.objects.all()
    serializer_class = KillHouseAllowVetSerializer
    permission_classes = [TokenHasReadWriteScope]

    # تابع مربوط به ثبت کشتارگاه
    def create(self, request, *args, **kwargs):
        # refresh(request.user.id)

        user = SystemUserProfile.objects.get(user=request.user, trash=False)
        kill_house_operator = KillHouseOperator.objects.get(user=user)
        kill_houses = KillHouse.objects.filter(kill_house_operator=kill_house_operator)
        kill_house_allow_vets = KillHouseAllowVet.objects.filter(kill_house__in=kill_houses)
        allow = request.data['allow']
        if kill_house_allow_vets.count() > 0:
            for kill_house_allow_vet in kill_house_allow_vets:
                kill_house_allow_vet.allow = allow
                kill_house_allow_vet.save()
        else:
            for kill_house in kill_houses:
                serializer = self.serializer_class(data=request.data)
                if serializer.is_valid():
                    allow = serializer.create(validated_data=request.data)
                    allow.kill_house = kill_house
                    allow.save()
        return Response({"result": "created"}, status=status.HTTP_201_CREATED)

    def list(self, request, *args, **kwargs):

        user = SystemUserProfile.objects.get(user=request.user, trash=False)
        kill_house_operator = KillHouseOperator.objects.get(user=user)
        kill_houses = KillHouse.objects.filter(kill_house_operator=kill_house_operator)
        kill_house_allow_vet = KillHouseAllowVet.objects.filter(kill_house__in=kill_houses)
        serializer = KillHouseAllowVetSerializer(kill_house_allow_vet, many=True)
        return Response(serializer.data, status=status.HTTP_200_OK)


class KillHousePercentageViewSet(viewsets.ModelViewSet):
    queryset = KillHousePercentage.objects.all()
    serializer_class = KillHousePercentageSerializer
    permission_classes = [TokenHasReadWriteScope]

    def list(self, request, *args, **kwargs):
        percents = []
        user_profile = SystemUserProfile.objects.get(user=request.user, trash=False)
        kill_house = KillHouse.objects.filter(system_address__province=user_profile.province, trash=False)
        if kill_house:
            percents = KillHousePercentage.objects.filter(kill_house__in=kill_house).order_by('-percent')

        serializer = KillHousePercentageSerializer(percents, many=True)
        return Response(serializer.data, status=status.HTTP_200_OK)

    def update(self, request, pk=None, *args, **kwargs):
        # refresh(request.user.id)
        user = SystemUserProfile.objects.get(user=request.user, trash=False)
        if 'percentage_list' in request.data.keys():
            kill_house_percentage_lists = request.data['percentage_list']
            request.data.pop('percentage_list')
            if request.data['type'] == 'manual':
                for kill_house_percentage_list in kill_house_percentage_lists:
                    kill_house_percentage = KillHousePercentage.objects.get(key=kill_house_percentage_list["key"],
                                                                            trash=False)
                    kill_house_percentage.percent = kill_house_percentage_list["percent"]
                    if 'killer_kill_house_key' in kill_house_percentage_list.keys():
                        if kill_house_percentage_list['killer_kill_house_key'] != None:
                            kill_house_percentage.kill_house_for_killer = KillHouse.objects.get(
                                key=kill_house_percentage_list['killer_kill_house_key'], trash=False)
                    kill_house_percentage.save()
            else:

                guilds = Guilds.objects.filter(kill_house_centers_allocation__isnull=False, trash=False)
                total_count = len(guilds)
                total_weight = guilds.aggregate(total_quantity=Sum('allocation_limit')).get('total_quantity', 0)

                if total_count == 0:
                    return Response({"result": "صنفی وجود ندارد برای کشتارگاه ها و کشتارکن ها"},
                                    status=status.HTTP_403_FORBIDDEN)
                if request.data['type'] == 'guilds_weight':

                    for kill_house_percentage_list in kill_house_percentage_lists:
                        kill_house_percentage = KillHousePercentage.objects.get(key=kill_house_percentage_list["key"],
                                                                                trash=False)
                        kill_house_percentage_weight = 0
                        for guild in guilds:
                            if len(guild.kill_house_centers_allocation) == 0 or guild.kill_house_centers_allocation == None:
                                continue
                            if guild.kill_house_centers_allocation[0]['value'] == str(
                                    kill_house_percentage.kill_house.key):
                                kill_house_percentage_weight += guild.allocation_limit
                        kill_house_percentage.percent = round((kill_house_percentage_weight / total_weight) * 100, 2)
                        kill_house_percentage.guilds_weight = kill_house_percentage_weight
                        kill_house_percentage.last_guilds_update_date = str(datetime.now())
                        kill_house_percentage.save()


                else:

                    for kill_house_percentage_list in kill_house_percentage_lists:
                        kill_house_percentage = KillHousePercentage.objects.get(key=kill_house_percentage_list["key"],
                                                                                trash=False)
                        kill_house_percentage_counter = 0
                        for guild in guilds:
                            if len(guild.kill_house_centers_allocation) == 0 or guild.kill_house_centers_allocation == None:
                                continue
                            if guild.kill_house_centers_allocation[0]['value'] == str(
                                    kill_house_percentage.kill_house.key):
                                kill_house_percentage_counter += 1
                        kill_house_percentage.percent = round((kill_house_percentage_counter / total_count) * 100, 2)
                        kill_house_percentage.guilds_quantity = kill_house_percentage_counter
                        kill_house_percentage.last_guilds_update_date = str(datetime.now())
                        kill_house_percentage.save()

        elif 'percentage_key' in request.data.keys():
            percentage = KillHousePercentage.objects.get(key=request.data['percentage_key'])
            if 'identity' in request.data.keys():
                kill_house = KillHouse.objects.get(key=percentage.kill_house.key)
                if kill_house.killer == False:
                    if request.data['identity'] == 'Killer':
                        previous_state = kill_house.killer
                        if KillHousePercentage.objects.filter(
                                kill_house_for_killer=kill_house).exists():
                            return Response({
                                "result": "این کشتارگاه توسط چندین کشتارکن رزرو شده است و امکان تغییر ماهیت وجود ندارد!"},
                                status=status.HTTP_403_FORBIDDEN)
                        if KillRequest.objects.filter(remain_quantity__gt=0, slaughter_house=kill_house,
                                                      trash=False).exists():
                            return Response({
                                "result": "این کشتارگاه توسط چندین کشتارکن در قسمت اعلام نیاز کشتارگاه رزرو شده است و امکان تغییر ماهیت وجود ندارد!"},
                                status=status.HTTP_403_FORBIDDEN)

                        kill_house.killer = True
                        kill_house.save()
                        new_state = kill_house.killer
                        percentage.change_data = {
                            "previous_killer_state": previous_state,
                            "new_killer_state": new_state,
                            "type": kill_house.type,
                            "fullname": user.fullname,
                            "mobile": user.mobile,
                            "date": str(datetime.now()),
                            "kill_house": percentage.kill_house_for_killer.name if percentage.kill_house_for_killer != None else None,

                        }
                        percentage.save()


                else:
                    if request.data['identity'] == 'KillHouse':
                        previous_state = kill_house.killer
                        kill_house.killer = False
                        kill_house.save()
                        new_state = kill_house.killer
                        percentage.kill_house_for_killer = None
                        percentage.change_data = {
                            "previous_killer_state": previous_state,
                            "new_killer_state": new_state,
                            "type": kill_house.type,
                            "fullname": user.fullname,
                            "mobile": user.mobile,
                            "date": str(datetime.now()),
                            "kill_house": percentage.kill_house_for_killer.name if percentage.kill_house_for_killer != None else None,

                        }
                        percentage.save()


            else:
                kill_house = KillHouse.objects.get(key=request.data['kill_house_key'])
                percentage.kill_house_for_killer = kill_house
                if percentage.change_data:
                    percentage.change_data["kill_house"] = kill_house.name
                    percentage.change_data["date"] = str(datetime.now())
                percentage.save()
        return Response({"result": "با موفقیت ویرایش شد."}, status=status.HTTP_200_OK)


# ویوست مربوط به اضافه کردن خودرو به کشتارگاه
class KillHouseDriverViewSet(viewsets.ModelViewSet):
    queryset = KillHouseDriver.objects.all()
    serializer_class = KillHouseDriverSerializer
    permission_classes = [TokenHasReadWriteScope]
    filter_backends = [DjangoFilterBackend]
    filterset_class = KillHouseDriverFilterSet
    filterset_fields = [
        'health_code',
        'user__mobile',
        'user__national_id',
        'user__base_order',
    ]

    # تابع مربوط به اضافه کردن خودرو به کشتارگاه
    def create(self, request, *args, **kwargs):
        user = SystemUserProfile.objects.get(user=request.user, trash=False)
        role = request.data['role']
        request.data.pop('role')

        # refresh(request.user.id)
        kill_house = None
        if 'kill_house_key' in request.data.keys():
            if request.data['kill_house_key'] != None:
                kill_house = KillHouse.objects.get(key=request.data['kill_house_key'])
            request.data.pop('kill_house_key')
        if role == 'KillHouse':
            kill_house_operator = KillHouseOperator.objects.get(user=user, trash=False)
            kill_house = KillHouse.objects.filter(kill_house_operator=kill_house_operator, trash=False)
            # if not ProvinceAllowKillHouseRegisterCar.objects.filter(
            #         kill_house__in=kill_house, allow=True).exists():
            #     return Response({"result": "شما اجازه ساخت ماشین ندارید"}, status=status.HTTP_403_FORBIDDEN)
        person = SystemUserProfile.objects.get(user=request.user)
        group = Group.objects.get(name__exact="Driver")
        city = City.objects.get(name=request.data['city_name'])
        province = Province.objects.get(key=user.province.key)
        request.data.pop('city_name')
        # request.data.pop('province_name')
        if KillHouseDriver.objects.filter(pelak=request.data['pelak'], trash=False).exists():
            return Response({"result": "این ماشین قبلا ثبت شده!"}, status=status.HTTP_403_FORBIDDEN)
        system_profile = SystemUserProfile.objects.filter(mobile=request.data['driver_mobile'], trash=False)
        if system_profile.count() > 0:
            system_profile = system_profile.last()
            if group not in system_profile.role.all():
                system_profile.role.add(group)

        else:

            password = "00100"
            data = {
                "username": request.data['driver_mobile'],
                "password": password,
                "api_key": PROJECT_API_KEY
            }
            req = requests.post(
                url=ARTA_URL_REGISTER,
                data=data,
                verify=False
            )
            if req.status_code == 200:
                user = User(username=request.data['driver_mobile'], first_name=request.data['first_name'],
                            last_name=request.data['last_name'])
                user.save()
                base_id = SystemUserProfile.objects.all()
                if base_id.count() > 0:
                    base_id = int(base_id.last().base_order) + 1
                else:
                    base_id = 1000
                system_profile = SystemUserProfile(
                    mobile=request.data['driver_mobile'],
                    first_name=request.data['first_name'],
                    last_name=request.data['last_name'],
                    fullname=request.data['first_name'] + " " + request.data['last_name'],
                    user=user,
                    base_order=base_id,
                    password=password,
                    city=city,
                    province=province
                )
                system_profile.save()
                system_profile.role.add(group)


            else:
                return Response({"result": "در ثبت کاربر مشکلی پیش آمده است!"}, status=status.HTTP_403_FORBIDDEN)

        wallet = Wallet()
        wallet.save()
        serializer = self.serializer_class(data=request.data)
        if serializer.is_valid():
            full_name = request.data['first_name'] + " " + request.data['last_name']
            request.data.pop('first_name')
            request.data.pop('last_name')
            kill_house_driver = serializer.create(validated_data=request.data)
            kill_house_driver.user = system_profile
            kill_house_driver.wallet = wallet
            kill_house_driver.registrar = {
                "role": role,
                "full_name": person.fullname,
                "mobile": person.mobile,
                "date": str(kill_house_driver.create_date)
            }
            kill_house_driver.driver_name = full_name
            kill_house_driver.save()
            if kill_house != None:
                if KillHouseADDCAR.objects.filter(kill_house__in=kill_house, driver=kill_house_driver,
                                                  trash=False).exists():
                    return Response({"result": "این ماشین قبلا برای کشتارگاه ثبت شده!"},
                                    status=status.HTTP_403_FORBIDDEN)
                else:
                    add_car = KillHouseADDCAR(
                        kill_house=kill_house.last(),
                        driver=kill_house_driver
                    )
                    add_car.save()
            else:
                if kill_house_driver.type == 'rental':
                    # kill_houses = KillHouse.objects.filter(trash=False)
                    # for kill_house in kill_houses:
                    add_car = KillHouseADDCAR(
                        # kill_house=kill_house,
                        driver=kill_house_driver
                    )
                    add_car.save()

            return Response({"result": "ماشین با موفقیت ثبت شد."}, status=status.HTTP_201_CREATED)
        return Response(serializer.errors)

    def list(self, request, *args, **kwargs):
        if 'role' in request.GET:
            # refresh(request.user.id)
            user = SystemUserProfile.objects.get(user=request.user)
            list_car = []
            if 'health_code' in request.GET:

                for item in self.filterset_fields:
                    query = QueryDict('{0}={1}'.format(item, request.GET['health_code']))
                    if (self.filterset_class(
                            data=query,
                            queryset=self.queryset.filter(trash=False)
                    )
                    ).filter():
                        ps = self.filterset_class(data=query, queryset=self.queryset)
                        filtered_kill_house_driver = ps.filter()
                        serializer = self.serializer_class(filtered_kill_house_driver, many=True)
                        return Response(serializer.data)
                return Response(list_car)


            # cars = KillHouseDriver.objects.filter(health_code=request.GET['health_code'],
            #                                       trash=False)
            # if cars.count() > 0:
            #     cars = cars.last()
            #     dict1 = {
            #         "id": cars.id,
            #         "key": cars.key,
            #         "driver_name": cars.driver_name,
            #         "driver_mobile": cars.driver_mobile,
            #         "type_car": cars.type_car,
            #         "pelak": cars.pelak,
            #         "capocity": float(cars.capocity),
            #         "weight_without_load": cars.weight_without_load,
            #         "health_code": cars.health_code,
            #     }
            #     list_car.append(dict1)
            # return Response(list_car, status=status.HTTP_200_OK)
            else:
                if request.GET['role'] == 'KillHouse':
                    kill_house_drivers = KillHouseDriver.objects.filter(user__province=user.province, type='rental',
                                                                        archive=False)
                    kill_house_operator = KillHouseOperator.objects.get(user=user, trash=False)
                    kill_house = KillHouse.objects.filter(kill_house_operator=kill_house_operator, trash=False).first()
                    add_car = KillHouseADDCAR.objects.filter(kill_house=kill_house, trash=False,
                                                             archive=False).order_by('id')
                    if add_car.count() > 0:
                        kill_house_list = []
                        for add_car_obj in add_car:
                            allow = ProvinceAllowKillHouseRegisterCar.objects.filter(
                                kill_house=add_car_obj.kill_house)
                            if allow.count() > 0:
                                allow_state = allow.last().allow
                            else:
                                allow_state = None
                            kill_house_name = add_car_obj.kill_house.name
                            kill_house_key = add_car_obj.kill_house.key
                            kill_house_dict = {"kill_house_name": kill_house_name, "kill_house_key": kill_house_key,
                                               "allow_state": allow_state}
                            if not any(d["kill_house_name"] == kill_house_name for d in kill_house_list):
                                kill_house_list.append(kill_house_dict)

                            dict1 = {
                                "id": add_car_obj.driver.id,
                                "key": add_car_obj.driver.key,
                                "add_car_key": add_car_obj.key,
                                "driver_name": add_car_obj.driver.driver_name,
                                "driver_type": add_car_obj.driver.type,
                                "driver_active_state": add_car_obj.driver.active_state,
                                "add_car_active_state": add_car_obj.active_state,
                                "first_name": add_car_obj.driver.user.first_name,
                                "last_name": add_car_obj.driver.user.last_name,
                                "city": add_car_obj.driver.user.city.name,
                                "driver_mobile": add_car_obj.driver.driver_mobile,
                                "kill_house_list": kill_house_list,
                                "type_car": add_car_obj.driver.type_car,
                                "type": add_car_obj.driver.type,
                                "pelak": add_car_obj.driver.pelak,
                                "capocity": float(add_car_obj.driver.capocity),
                                "weight_without_load": add_car_obj.driver.weight_without_load,
                                "health_code": add_car_obj.driver.health_code,
                            }
                            list_car.append(dict1)
                        if kill_house_drivers:
                            for kill_house_driver in kill_house_drivers:
                                dict2 = {
                                    "id": kill_house_driver.id,
                                    "key": kill_house_driver.key,
                                    "add_car_key": None,
                                    "add_car_active_state": kill_house_driver.active_state,
                                    "driver_name": kill_house_driver.driver_name,
                                    "driver_type": kill_house_driver.type,
                                    "driver_active_state": kill_house_driver.active_state,
                                    "first_name": kill_house_driver.user.first_name,
                                    "last_name": kill_house_driver.user.last_name,
                                    "city": kill_house_driver.user.city.name,
                                    "driver_mobile": kill_house_driver.driver_mobile,
                                    "kill_house_list": [],
                                    "type_car": kill_house_driver.type_car,
                                    "type": kill_house_driver.type,
                                    "pelak": kill_house_driver.pelak,
                                    "capocity": float(kill_house_driver.capocity),
                                    "weight_without_load": kill_house_driver.weight_without_load,
                                    "health_code": kill_house_driver.health_code,
                                }
                                list_car.append(dict2)

                    return Response(list_car, status=status.HTTP_200_OK)
                else:
                    list_car = []
                    cars = KillHouseDriver.objects.filter(user__province=user.province, trash=False,
                                                          archive=False).order_by('id') \
                        .select_related('user')

                    if cars.count() > 0:
                        for car in cars:
                            add_car = KillHouseADDCAR.objects.filter(driver=car, trash=False,
                                                                     archive=False).select_related(
                                'kill_house')
                            if add_car.count() > 0:
                                kill_house_list = []
                                for add_car_obj in add_car:
                                    if add_car_obj.kill_house != None:
                                        allow = ProvinceAllowKillHouseRegisterCar.objects.filter(
                                            kill_house=add_car_obj.kill_house)
                                        if allow.count() > 0:
                                            allow_state = allow.last().allow
                                        else:
                                            allow_state = None
                                        kill_house_name = add_car_obj.kill_house.name
                                        kill_house_key = add_car_obj.kill_house.key
                                        kill_house_dict = {"kill_house_name": kill_house_name,
                                                           "kill_house_key": kill_house_key, "allow_state": allow_state}
                                        if not any(d["kill_house_name"] == kill_house_name for d in kill_house_list):
                                            kill_house_list.append(kill_house_dict)

                                    dict1 = {
                                        "id": car.id,
                                        "key": car.key,
                                        "add_car_key": None,
                                        "driver_name": car.driver_name,
                                        "driver_type": car.type,
                                        "driver_active_state": car.active_state,
                                        "type": car.type,
                                        "first_name": car.user.first_name,
                                        "last_name": car.user.last_name,
                                        "city": car.user.city.name,
                                        "driver_mobile": car.driver_mobile,
                                        "kill_house_list": kill_house_list,
                                        "type_car": car.type_car,
                                        "pelak": car.pelak,
                                        "capocity": float(car.capocity),
                                        "weight_without_load": car.weight_without_load,
                                        "health_code": car.health_code,
                                    }
                                    list_car.append(dict1)
                            else:
                                dict1 = {
                                    "id": car.id,
                                    "type": car.type,
                                    "add_car_key": None,
                                    "key": car.key,
                                    "driver_type": car.type,
                                    "driver_name": car.driver_name,
                                    "driver_active_state": car.active_state,
                                    "first_name": car.user.first_name,
                                    "last_name": car.user.last_name,
                                    "city": car.user.city.name,
                                    "driver_mobile": car.driver_mobile,
                                    "kill_house_list": [],
                                    "type_car": car.type_car,
                                    "pelak": car.pelak,
                                    "capocity": float(car.capocity),
                                    "weight_without_load": car.weight_without_load,
                                    "health_code": car.health_code,
                                }
                                list_car.append(dict1)

                        return Response(list_car, status=status.HTTP_200_OK)
                    else:
                        return Response(list_car, status=status.HTTP_200_OK)

        else:
            return Response([], status=status.HTTP_200_OK)

    def update(self, request, pk=None, *args, **kwargs):
        if 'change_activation' in request.data.keys():
            car = KillHouseDriver.objects.get(key=request.data["driver_key"])

            add_cars = KillHouseADDCAR.objects.filter(driver=car, trash=False)
            for add_car in add_cars:
                add_car.active_state = request.data['change_activation']
                add_car.save()
            car.active_state = request.data['change_activation']
            car.save()
            return Response({"result": "با موفقیت انجام شد"}, status=status.HTTP_200_OK)
        elif 'add_car_change_activation' in request.data.keys():
            add_car = KillHouseADDCAR.objects.get(key=request.data["add_car_key"], trash=False)
            add_car.active_state = request.data['add_car_change_activation']
            add_car.save()
            return Response({"result": "با موفقیت انجام شد"}, status=status.HTTP_200_OK)



        else:
            car = KillHouseDriver.objects.get(key=request.data["driver_key"])

            if 'city_name' in request.data.keys() and request.data['city_name'] != None:
                city = City.objects.get(name=request.data['city_name'])
            else:
                city = None
            request.data.pop('city_name')

            user = SystemUserProfile.objects.get(key=car.user.key)
            request.data.pop('driver_key')
            first_name = request.data['first_name']
            last_name = request.data['last_name']
            request.data.pop('first_name')
            request.data.pop('last_name')
            if first_name != None:
                user.first_name = first_name
            if last_name != None:
                user.last_name = last_name
            if city != None:
                user.city = city
            if first_name != None and last_name != None:
                car.driver_name = first_name + "" + last_name
                user.fullname = first_name + "" + last_name
            # serializer = self.serializer_class(car)
            user.save()
            car.save()
            serializer = self.serializer_class(car)
            serializer.update(instance=car, validated_data=request.data)
            return Response(serializer.data, status=status.HTTP_200_OK)

    def destroy(self, request, pk=None, *args, **kwargs):
        # refresh(request.user.id)
        car = KillHouseDriver.objects.get(key=request.GET["key"])
        if KillHouseRequest.objects.filter(active_state='active', add_car__driver=car, trash=False).exists():
            return Response({"result": "ماشین دارای بار فعال میباشد"}, status=status.HTTP_403_FORBIDDEN)

        kill_house_cars = KillHouseADDCAR.objects.filter(driver=car, trash=False)
        if kill_house_cars:
            for add_car in kill_house_cars:
                add_car.trash = True
                add_car.save()

        car.trash = True
        car.save()
        return Response('ماشین با موفقیت حذف شد', status=status.HTTP_200_OK)


class KillHouseDriverTotalDashboardViewSet(viewsets.ModelViewSet):
    queryset = KillHouseDriver.objects.all()
    serializer_class = KillHouseDriverSerializer
    permission_classes = [TokenHasReadWriteScope]

    def list(self, request, *args, **kwargs):

        if request.GET['role'] == 'KillHouse':
            user = SystemUserProfile.objects.get(trash=False, user=request.user)
            kill_house = KillHouse.objects.filter(kill_house_operator__user=user, trash=False).first()
            kill_house_drivers = KillHouseDriver.objects.filter(archive=False, pk__in=KillHouseADDCAR.objects.filter(
                Q(kill_house=kill_house) | Q(kill_house__isnull=True, driver__type='rental'), trash=False,
                archive=False).values_list(
                'driver__id', flat=True), trash=False)
            active = kill_house_drivers.filter(pk__in=KillHouseADDCAR.objects.filter(
                Q(kill_house=kill_house) | Q(kill_house__isnull=True, driver__type='rental'), trash=False,
                active_state=True, archive=False).values_list('driver__id', flat=True))
            inactive = kill_house_drivers.filter(pk__in=KillHouseADDCAR.objects.filter(
                Q(kill_house=kill_house) | Q(kill_house__isnull=True, driver__type='rental'), trash=False,
                active_state=False, archive=False).values_list('driver__id', flat=True))
            suspended = 0

        else:
            kill_house_drivers = KillHouseDriver.objects.filter(trash=False, archive=False)

            active = kill_house_drivers.filter(pk__in=KillHouseADDCAR.objects.filter(
                Q(kill_house__isnull=False) | Q(kill_house__isnull=True, driver__type='rental'), trash=False,
                active_state=True, archive=False).values_list('driver__id', flat=True))
            inactive = kill_house_drivers.filter(pk__in=KillHouseADDCAR.objects.filter(
                Q(kill_house__isnull=False) | Q(kill_house__isnull=True, driver__type='rental'), trash=False,
                active_state=False, archive=False).values_list('driver__id', flat=True))
            suspended = kill_house_drivers.exclude(pk__in=KillHouseADDCAR.objects.filter(
                Q(kill_house__isnull=False) | Q(kill_house__isnull=True, driver__type='rental'),
                trash=False, archive=False).values_list('driver__id', flat=True))
            suspended = len(suspended)

        rental = kill_house_drivers.filter(type='rental')
        exclusive = kill_house_drivers.filter(type='exclusive')

        result = {
            "total": len(kill_house_drivers),
            "exclusive": len(exclusive),
            "rental": len(rental),
            "active": len(active),
            "inactive": len(inactive),
            "suspended": suspended,
        }

        return Response(result, status=status.HTTP_200_OK)


# ویوست مربوط به اضافه کردن خودرو به کشتارگاه
class KillHouseADDCARViewSet(viewsets.ModelViewSet):
    queryset = KillHouseADDCAR.objects.all()
    serializer_class = KillHouseADDCARSerializer
    permission_classes = [TokenHasReadWriteScope]

    # تابع مربوط به اضافه کردن خودرو به کشتارگاه
    def create(self, request, *args, **kwargs):
        # refresh(request.user.id)
        kill_house = KillHouse.objects.get(key=request.data['kill_house_key'], trash=False)
        driver = KillHouseDriver.objects.get(key=request.data['driver_key'])
        request.data.pop('driver_key')
        request.data.pop('kill_house_key')
        if 'role' in request.data.keys():
            request.data.pop('role')
        serializer = self.serializer_class(data=request.data)
        if serializer.is_valid():
            if KillHouseADDCAR.objects.filter(kill_house=kill_house, driver=driver, trash=False):
                return Response({"result": "already exist"}, status=status.HTTP_403_FORBIDDEN)
            kill_house_car = serializer.create(validated_data=request.data)
            kill_house_car.kill_house = kill_house
            kill_house_car.driver = driver
            kill_house_car.save()
            return Response(serializer.data, status=status.HTTP_201_CREATED)
        return Response(serializer.errors)

    # تابع مربوط به نمایش خودروهای ثبت شده کشتارگاه
    def list(self, request, *args, **kwargs):
        # refresh(request.user.id)
        if 'kill_request_key' in request.GET:
            kill_request = KillRequest.objects.get(key=request.GET['kill_request_key'])
        list_car = []
        if 'key' in request.GET:
            poultry_request = PoultryRequest.objects.get(key=request.GET['key'])
        else:
            poultry_request = None
        if 'kill_house_key' in request.GET:
            kill_house = KillHouse.objects.get(key=request.GET['kill_house_key'], trash=False)

            if kill_house.killer == True:
                if KillHouseADDCAR.objects.filter(kill_house=kill_house, trash=False, archive=False).exists():
                    cars = KillHouseADDCAR.objects.filter(
                        Q(kill_house=kill_house) | Q(kill_house__isnull=True, driver__type='rental'),
                        trash=False, archive=False).order_by('driver__type')
                else:
                    killer_kill_house = KillHouse.objects.get(key=kill_request.slaughter_house.key)
                    cars = KillHouseADDCAR.objects.filter(
                        Q(kill_house=killer_kill_house) | Q(kill_house__isnull=True, driver__type='rental'),
                        trash=False, archive=False).order_by('driver__type')
            else:
                cars = KillHouseADDCAR.objects.filter(
                    Q(kill_house=kill_house) | Q(kill_house__isnull=True, driver__type='rental'), trash=False,
                    archive=False).order_by(
                    'driver__type')

        else:
            user = SystemUserProfile.objects.get(user=request.user, trash=False)
            kill_house_operator = KillHouseOperator.objects.get(user=user, trash=False)
            kill_house = KillHouse.objects.filter(kill_house_operator=kill_house_operator, trash=False)
            cars = KillHouseADDCAR.objects.filter(
                Q(kill_house__in=kill_house) | Q(kill_house__isnull=True, driver__type='rental'), trash=False,
                archive=False).order_by(
                'driver__type')
        # if poultry_request != None:
        #     send_date = poultry_request.send_date.date()
        #     list1 = []
        #     kill_house_requests = KillHouseRequest.objects.filter(active_state='active')
        #     for kill_house_request in kill_house_requests:
        #         if kill_house_request.province_kill_request != None:
        #             date = kill_house_request.province_request.city_request_Poultry.poultry_request.send_date.date()
        #             if send_date.year == date.year and send_date.month == date.month and send_date.day == date.day:
        #                 list1.append(kill_house_request)
        #         else:
        #             date2 = kill_house_request.kill_house_request_auction_winner.kill_house_request_auction.poultry_request.send_date.date()
        #             if send_date.year == date2.year and send_date.month == date2.month and send_date.day == date2.day:
        #                 list1.append(kill_house_request)
        #     if len(list1) > 0:
        #         for kill_house_car in cars:
        #             list2 = []
        #             i = 0
        #             for request_car in list1:
        #                 if i == len(list1):
        #                     break
        #                 if kill_house_car.driver.pelak == request_car.add_car.driver.pelak:
        #                     dict1 = {
        #                         "id": kill_house_car.id,
        #                         "key": kill_house_car.key,
        #                         "driver_name": kill_house_car.driver.driver_name,
        #                         "driver_mobile": kill_house_car.driver.driver_mobile,
        #                         "type_car": kill_house_car.driver.type_car,
        #                         "pelak": kill_house_car.driver.pelak,
        #                         "capocity": float(kill_house_car.driver.capocity),
        #                         "weight_without_load": kill_house_car.driver.weight_without_load,
        #                         "health_code": kill_house_car.driver.health_code,
        #                         "busy": True
        #                     }
        #                     list2.append(dict1)
        #                     i += 1
        #             if len(list2) > 0:
        #                 list_car.append(list2[0])
        #             else:
        #                 dict1 = {
        #                     "id": kill_house_car.id,
        #                     "key": kill_house_car.key,
        #                     "driver_name": kill_house_car.driver.driver_name,
        #                     "driver_mobile": kill_house_car.driver.driver_mobile,
        #                     "type_car": kill_house_car.driver.type_car,
        #                     "pelak": kill_house_car.driver.pelak,
        #                     "capocity": float(kill_house_car.driver.capocity),
        #                     "weight_without_load": kill_house_car.driver.weight_without_load,
        #                     "health_code": kill_house_car.driver.health_code,
        #                     "busy": False
        #                 }
        #                 list_car.append(dict1)
        #         return Response(list_car, status=status.HTTP_200_OK)

        for car in cars:
            if car.active_state == True:
                dict1 = {
                    "id": car.id,
                    "key": car.key,
                    "type": car.driver.type,
                    "driver_name": car.driver.driver_name,
                    "driver_mobile": car.driver.driver_mobile,
                    "type_car": car.driver.type_car,
                    "pelak": car.driver.pelak,
                    "capocity": float(car.driver.capocity),
                    "weight_without_load": car.driver.weight_without_load,
                    "health_code": car.driver.health_code,
                }
                list_car.append(dict1)
        return Response(list_car, status=status.HTTP_200_OK)

    # تابع مربوط به حذف خودروهای ثبت شده کشتارگاه
    def destroy(self, request, pk=None, *args, **kwargs):
        # refresh(request.user.id)
        car = KillHouseDriver.objects.get(key=request.GET["driver_key"])
        kill_house = KillHouse.objects.get(key=request.GET["kill_house_key"])
        if KillHouseRequest.objects.filter(active_state='active', add_car__driver=car, trash=False).exists():
            return Response({"result": "ماشین دارای بار فعال میباشد"}, status=status.HTTP_403_FORBIDDEN)
        add_car = KillHouseADDCAR.objects.filter(driver=car, kill_house=kill_house, trash=False)
        if add_car.count() > 0:
            add_car = add_car.last()
            add_car.trash = True
            add_car.save()
            return Response('ماشین با موفقیت حذف شد', status=status.HTTP_200_OK)
        else:
            return Response('مشکلی در حذف ماشین به وجود آمده است !', status=status.HTTP_403_FORBIDDEN)

    def update(self, request, pk=None, *args, **kwargs):
        car = KillHouseADDCAR.objects.get(key=request.data["add_car_key"])
        request.data.pop('add_car_key')
        serializer = self.serializer_class(car)
        serializer.update(instance=car, validated_data=request.data)
        return Response(serializer.data, status=status.HTTP_200_OK)


class AutomaticKillRequestViewSet(viewsets.ModelViewSet):
    queryset = AutomaticKillRequest.objects.all()
    serializer_class = AutomaticKillRequestSerializer
    permission_classes = [TokenHasReadWriteScope]

    # def create(self, request, *args, **kwargs):
    #     # refresh(request.user.id)
    #     state = request.data['active']
    #     auomatic_kill_reqs = AutomaticKillRequest.objects.all()
    #     if auomatic_kill_reqs.count() > 0:
    #         auomatic_kill_reqs = auomatic_kill_reqs.last()
    #         auomatic_kill_reqs.active = state
    #         auomatic_kill_reqs.save()
    #         serializer_request = self.serializer_class(auomatic_kill_reqs)
    #         return Response(serializer_request.data, status=status.HTTP_200_OK)
    #     else:
    #         serializer = self.serializer_class(data=request.data)
    #         if serializer.is_valid():
    #             auomatic_kill_reqs = serializer.create(validated_data=request.data)
    #
    #     serializer_request = self.serializer_class(auomatic_kill_reqs)
    #     return Response(serializer_request.data, status=status.HTTP_201_CREATED)

    def create(self, request, *args, **kwargs):
        try:
            automatic_kill_req = AutomaticKillRequest.objects.latest('id')
        except AutomaticKillRequest.DoesNotExist:
            automatic_kill_req = None

        serializer = self.serializer_class(automatic_kill_req, data=request.data)
        if serializer.is_valid():
            if automatic_kill_req:
                serializer.save()
                return Response(serializer.data, status=status.HTTP_200_OK)
            else:
                serializer.save()
                return Response(serializer.data, status=status.HTTP_201_CREATED)
        else:
            return Response(serializer.errors)


class KillRequestForPoultryViewSet(viewsets.ModelViewSet):
    queryset = KillRequest.objects.all()
    serializer_class = KillRequestSerializer
    permission_classes = [TokenHasReadWriteScope]

    def update(self, request, pk=None, *args, **kwargs):
        kill_req = KillRequest.objects.get(key=request.data['kill_req_key'], trash=False)
        kill_req.remain_quantity_for_poultry += int(request.data['quantity_sum'])
        kill_req.save()
        return Response({"result": "با موفقیت انجام شد"}, status=status.HTTP_200_OK)


class DeleteDebtorsKillRequestsViewSet(viewsets.ModelViewSet):
    queryset = KillRequest.objects.all()
    serializer_class = KillRequestSerializer
    permission_classes = [TokenHasReadWriteScope]

    def destroy(self, request, pk=None, *args, **kwargs):
        today = datetime.now().date()
        kill_requests = KillRequest.objects.filter(trash=False, recive_date__date=today, market=False)
        for kill_request in kill_requests:
            kill_house = kill_request.kill_house
            kill_house_purchase = KillHousePurchaseRequest.objects.filter(limitation=True,
                                                                          kill_house=kill_house).first()
            if kill_house_purchase:
                total_unpaid_wage = 0
                total_paid_wage = 0
                total_unpaid_wage = get_finance_info(kill_house)['total_price']
                slaughter_transactions = InternalTransaction.objects.filter(
                    Q(kill_house=kill_house) | Q(parent_kill_house=kill_house),
                    status='completed',
                    trash=False)

                total_paid_wage += slaughter_transactions.aggregate(total=Sum('amount'))[
                                       'total'] or 0
                total_amount = total_unpaid_wage - total_paid_wage
                if total_amount >= kill_house_purchase.limitation_number:
                    if not ProvinceKillRequest.objects.filter(trash=False, return_to_province=False,
                                                              kill_request__recive_date__date=today,
                                                              killhouse_user=kill_house).exists():
                        kill_request.message = 'به علت بدهی اعلام نیاز حذف گردید'
                        kill_request.trash = True
                        kill_request.save()

        return Response({"result": "با موفقیت انجام شد!"}, status=status.HTTP_200_OK)


# ویوست مربوط به ثبت درخواست کشتار از سمت کشتارگاه
class KillRequestViewSet(viewsets.ModelViewSet):
    queryset = KillRequest.objects.all()
    serializer_class = KillRequestSerializer
    permission_classes = [TokenHasReadWriteScope]
    pagination_class = CustomPagination
    filter_backends = [DjangoFilterBackend]
    filterset_class = KillRequestFilterSet
    filterset_fields = [
        'kill_house__kill_house_operator__user__fullname',
        'kill_house__kill_house_operator__user__first_name',
        'kill_house__kill_house_operator__user__last_name',
        'kill_house__kill_house_operator__user__mobile',
        'kill_house__name',
        'slaughter_house__name',
        'export_country',
        'export_code',
        'direct_buying_code',
        'poultry__user__fullname',
        'poultry__user__mobile',
        'poultry__unit_name',
    ]

    # تابع مربوط به ثبت درخواست کشتار از سمت کشتارگاه
    def create(self, request, *args, **kwargs):
        total_unpaid_wage = 0
        total_paid_wage = 0

        limitation_direct_purchase = LimitationForDirectPurchaseAndBarInformation.objects.filter(
            trash=False, active=True).first()
        is_in_limitation_range = False

        if limitation_direct_purchase:
            if not limitation_direct_purchase.allow_buying:
                is_in_limitation_range = False
            else:
                if limitation_direct_purchase.start_time and limitation_direct_purchase.end_time:
                    current_time = datetime.now().time()
                    if limitation_direct_purchase.start_time <= current_time <= limitation_direct_purchase.end_time:
                        is_in_limitation_range = True

        if not is_in_limitation_range:
            time_range = TimeRange.objects.filter(trash=False).first()
            if time_range:
                time = next(
                    (t for t in time_range.time_range if t.get("name") == "kill_request" and t.get("active", False)),
                    None)
                if time:
                    start_hour = datetime.strptime(time.get("start", 0), "%H:%M:%S").time()
                    end_hour = datetime.strptime(time.get("end", 0), "%H:%M:%S").time()
                    current_hour = datetime.now().time().replace(second=0, microsecond=0)
                    if not (start_hour < current_hour < end_hour):
                        return Response(
                            {"result": "لطفا در ساعات مجاز برای ثبت درخواست اقدام نمایید!"},
                            status=status.HTTP_403_FORBIDDEN)
        if 'role' in request.data.keys() and request.data['role'] != None:
            role = request.data['role']
            request.data.pop('role')
        else:
            role = None
        if role != None and role == 'KillHouse':
            now_request_date = datetime.now().date()
            now = datetime.now().time()
            now_hour = KillHouseHourLimit.objects.filter(trash=False).last()
            if now_hour and 'poultry_key' not in request.data.keys():
                if now_hour.active == True:
                    request_date = datetime.strptime(request.data['recive_date'], '%Y-%m-%d %H:%M:%S').date()
                    if request_date.year >= now_request_date.year and request_date.month >= now_request_date.month and request_date.day > now_request_date.day:
                        pass

                    else:
                        if now.hour >= now_hour.hour:
                            text = 'زمان ثبت درخواست کشتار درامروز تا ساعت {0} بوده است. شما میتوانید برای تاریخ های آینده درخواست ثبت نمایید ! '.format(
                                now_hour.hour)
                            if 'role' not in request.data.keys():
                                return Response({'result': text}, status=status.HTTP_403_FORBIDDEN)

        killer_kill_house = None
        user = SystemUserProfile.objects.get(user=request.user, trash=False)
        kill_house = KillHouse.objects.get(key=request.data['kill_house_key'], trash=False)
        request.data.pop('kill_house_key')
        if kill_house.out_province == True:
            return Response({
                "result": "امکان ثبت اعلام نیاز برای کشتارگاه خارج از استان وجود ندارد!"},
                status=status.HTTP_403_FORBIDDEN)
        kill_house_purchase = KillHousePurchaseRequest.objects.filter(kill_house=kill_house).first()
        if kill_house_purchase:
            if kill_house_purchase.allow == False:
                return Response({
                    "result": "شما مجاز به ثبت درخواست خرید نمیباشید جهت اطلاع با اتحادیه مرغ گوشتی استان خود تماس حاصل فرمایید"},
                    status=status.HTTP_403_FORBIDDEN)
            else:
                if kill_house_purchase.limitation == True:
                    try:
                        recive_date = datetime.strptime(str(request.data['recive_date']),
                                                        '%Y-%m-%dT%H:%M:%S.%fZ').date()
                    except:
                        recive_date = datetime.strptime(str(request.data['recive_date']), '%Y-%m-%d %H:%M:%S').date()
                    total_unpaid_wage = get_finance_info(kill_house)['total_price']
                    if kill_house.killer and kill_house.type == 'public':
                        slaughter_transactions = InternalTransaction.objects.filter(
                            kill_house=kill_house,parent_kill_house=kill_house,
                            status='completed',
                            trash=False)
                    else:
                        slaughter_transactions = InternalTransaction.objects.filter(
                            Q(kill_house=kill_house) | Q(parent_kill_house=kill_house),
                            status='completed',
                            trash=False)

                    total_paid_wage += slaughter_transactions.aggregate(total=Sum('amount'))[
                                           'total'] or 0

                    if kill_house_purchase.limitation_number <= total_unpaid_wage - total_paid_wage:
                        if not ProvinceKillRequest.objects.filter(killhouse_user=kill_house,
                                                                  kill_request__recive_date__date=recive_date,
                                                                  trash=False,
                                                                  state__in=('pending', 'accepted')).exists():
                            return Response({
                                "result": "به علت بدهی امکان ثبت درخواست وحود ندارد لطفا بدهی خود را در پنل کارمزد ها تسویه کنید"},
                                status=status.HTTP_403_FORBIDDEN)
        if kill_house.poultry_payment_limitation:
            today_check_date = datetime.now().date()
            if ProvinceKillRequest.objects.filter(Q(payment_deadline_date__date__lt=today_check_date,
                                                    extension_payment_deadline_date__isnull=True) | Q(
                payment_deadline_date__date__lt=today_check_date,
                extension_payment_deadline_date__date__lt=today_check_date), trash=False, temporary_trash=False,
                                                  return_to_province=False,
                                                  state__in=('pending', 'accepted'), payment_deadline_archive=False,
                                                  payment_deadline_state__in=('pending', 'rejected')).exists():
                return Response({
                    "result": "به دلیل عدم تسویه با مرغدار شما مجاز به خرید نمی باشید لطفا اطلاعات پرداخت را در بخش تسویه حساب بارگزاری کنید!"},
                    status=status.HTTP_403_FORBIDDEN)
        if 'killer_kill_house_key' in request.data.keys():
            if request.data['killer_kill_house_key'] != None:
                killer_kill_house = KillHouse.objects.get(key=request.data['killer_kill_house_key'], trash=False)
                request.data.pop('killer_kill_house_key')
            else:
                request.data.pop('killer_kill_house_key')
        cash = request.data['cash']
        credit = request.data['credit']
        low_weight = request.data['low_weight']
        high_weight = request.data['high_weight']
        credit = request.data['credit']
        request.data.pop('cash')
        request.data.pop('credit')
        request.data.pop('low_weight')
        request.data.pop('high_weight')
        poultry = None
        hatching = None
        if 'poultry_key' in request.data.keys():
            poultry = Poultry.objects.get(key=request.data['poultry_key'])
            hatching = PoultryHatching.objects.get(key=request.data['hatching_key'])
            request.data.pop('poultry_key')
            request.data.pop('hatching_key')
            if poultry.order_limit:
                return Response({
                    "result": "امکان ثبت کشتار برای مرغدار وجود ندارد جهت اطلاعات بیشتر بااتحادیه استان خود هماهنگ کنید!"},
                    status=status.HTTP_403_FORBIDDEN)
            if 'confirm_poultry_mobile' in request.data.keys() and len(request.data['confirm_poultry_mobile']) == 11:

                first_mobile_number = poultry.user.mobile
                second_mobile_number = request.data['confirm_poultry_mobile']
                request.data.pop('confirm_poultry_mobile')
                if first_mobile_number != second_mobile_number:
                    system_user_profile = SystemUserProfile.objects.get(mobile=first_mobile_number, trash=False)
                    system_person = SystemUserProfile.objects.filter(mobile=second_mobile_number, trash=False)
                    if system_person:
                        return Response({"result": f'این شماره در سامانه به نام {system_person.first().fullname} است'},
                                        status=status.HTTP_403_FORBIDDEN)
                    data = {
                        "first_mobile_number": first_mobile_number,
                        "second_mobile_number": second_mobile_number,
                    }
                    req = requests.post(
                        url=ARTA_URL_CHANGE_MOBILE_NUMBER,
                        data=data,
                        verify=False
                    )
                    if req.status_code == 200:
                        system_user_profile.user.username = second_mobile_number
                        system_user_profile.user.save()
                        system_user_profile.mobile = second_mobile_number
                        system_user_profile.save()

            try:
                recive_date = datetime.strptime(str(request.data['recive_date']), '%Y-%m-%dT%H:%M:%S.%fZ').date()
            except:
                recive_date = datetime.strptime(str(request.data['recive_date']), '%Y-%m-%d %H:%M:%S').date()

            if request.data['free_direct_buying'] == True:

                if kill_house.quota:
                    kill_house_info = calculate_governmental_quota(kill_house)
                    if kill_house_info == 'not_allowed':
                        return Response({"result": " امکان خرید آزاد تا تکمیل تعهد دولتی وجود ندارد!"},
                                        status=status.HTTP_403_FORBIDDEN)

            age_range = ChickenAgeRange.objects.filter(trash=False).first()
            if role and role not in ('AdminX', 'SuperAdmin'):

                if age_range.active == True:
                    chicken_age = (datetime.now().date() - hatching.date.date()).days + 1
                    if chicken_age < age_range.minimum or chicken_age > age_range.maximum:
                        return Response(
                            {"result": "به علت استاندارد نبودن سن مرغ برای کشتار امکان ثبت درخواست وجود ندارد!"},
                            status=status.HTTP_403_FORBIDDEN)
            if kill_house.max_kill_limit and kill_house.total_kill_capacity > 0:
                recive_date = datetime.strptime(str(request.data['recive_date']), '%Y-%m-%dT%H:%M:%S.%fZ').date()

                if kill_house.max_kill_limit and kill_house.total_kill_capacity > 0:
                    total_province_kill_requests = ProvinceKillRequest.objects.filter(trash=False,
                                                                                      return_to_province=False,
                                                                                      archive_wage=False,
                                                                                      state__in=('pending', 'accepted'),
                                                                                      killhouse_user=kill_house,
                                                                                      kill_request__recive_date__date=recive_date)
                    total_province_kill_requests_quantity = \
                        total_province_kill_requests.aggregate(total=Sum('total_killed_quantity'))['total'] or 0
                    if kill_house.total_kill_capacity < total_province_kill_requests_quantity + int(
                            request.data['kill_capacity']):
                        return Response({"result": "تعداد وارد شده از مانده سهمیه کشتار روزانه کشتارگاه بیشتر است !"},
                                        status=status.HTTP_403_FORBIDDEN)

        dict1 = {}
        dict2 = {}
        if kill_house.ware_house_remaining_weight_limitation_status:
            if kill_house.total_remain_warehouse_governmental_weight > kill_house.ware_house_remaining_weight_limitation:
                return Response({
                    "result": "باقی مانده انبار شما از حداکثر محدودیت وزن باقی مانده انبار بیشتر است !"},
                    status=status.HTTP_403_FORBIDDEN)

        if kill_house.ware_house_remaining_percent_limitation_status:
            if not check_kill_house_remain_limitation_weight(kill_house):
                return Response({
                    "result": "باقی مانده انبار شما از حداکثر محدودیت وزن باقی مانده روزانه انبار بیشتر است !"},
                    status=status.HTTP_403_FORBIDDEN)

        serializer = self.serializer_class(data=request.data)
        if serializer.is_valid():
            kill_request = serializer.create(validated_data=request.data)
            buying_verification = DirectBuyingVerification.objects.filter(trash=False).first()
            price_confirmation = PriceConfirmation.objects.filter(trash=False).first()
            price_confirmation = price_confirmation.poultry_status if price_confirmation else False
            kill_request.kill_house = kill_house
            free_sale_in_province = False if kill_request.free_direct_buying == False else True
            kill_request.previous_kill_capacity = kill_request.kill_capacity
            if poultry != None:
                # hatching = PoultryHatching.objects.filter(trash=False, poultry=poultry).only('chicken_breed').first()
                if 'payment_deadline_days' in request.data.keys():
                    kill_request.payment_deadline_date = datetime.now() + timedelta(
                        days=request.data['payment_deadline_days'])
                    kill_request.payment_deadline = True

                kill_request.chicken_breed = hatching.chicken_breed
                province_operator = SystemUserProfile.objects.filter(trash=False, role__name='ProvinceOperator').first()
                kill_request.poultry = poultry
                kill_request.poultry_hatching = hatching
                mobile = poultry.user.mobile
                poultry_name = poultry.user.fullname
                code = str(random.randint(10000, 99000))
                kill_request.direct_buying_code = code
                buyer = kill_request.kill_house.kill_house_operator.user.fullname
                buyer_mobile = kill_request.kill_house.kill_house_operator.user.mobile
                quantity = kill_request.kill_capacity
                kill_place = kill_request.slaughter_house.name if kill_request.slaughter_house != None else kill_request.kill_house.name
                date_str = str(kill_request.recive_date)
                # if kill_request.recive_date.date().day == datetime.now().date().day:
                try:
                    date = datetime.strptime(date_str, '%Y-%m-%dT%H:%M:%S.%f%z').date()
                except:
                    date = datetime.strptime(date_str, '%Y-%m-%d %H:%M:%S').date()
                date = jdatetime.datetime.fromgregorian(year=date.year, month=date.month,
                                                        day=date.day).strftime(
                    '%Y-%m-%d')
                date_list = reversed(date.split('-'))
                separate = "-"
                date = separate.join(date_list)
                if kill_request.export_status == False:
                    pass

                    # sms_direct_buying_sms = threading.Thread(
                    #     target=direct_buying_code_sms,
                    #     args=(
                    #         mobile, buyer, buyer_mobile, quantity, kill_place, date, code))
                    # sms_direct_buying_sms.start()
                else:
                    export_country = kill_request.export_country
                    sms_export_sms = threading.Thread(
                        target=export_code_sms,
                        args=(
                            mobile, buyer, buyer_mobile, quantity, kill_place, date, export_country,
                            code, poultry_name, province_operator.mobile))
                    sms_export_sms.start()

            # kill_request.remain_quantity_for_poultry = kill_request.kill_capacity
            if killer_kill_house != None:
                kill_request.slaughter_house = killer_kill_house
            kill_request.remain_quantity = kill_request.kill_capacity
            dict1.update({
                'cash': cash,
                'credit': credit
            })
            kill_request.buy_type = dict1
            dict2.update({
                'low_weight': low_weight,
                'high_weight': high_weight

            })
            kill_request.weight_type = dict2
            if role != None:
                kill_request.registrar = {
                    "role": role,
                    "full_name": user.fullname,
                    "date": str(kill_request.create_date)
                }
            kill_request.save()
            permission_duirect_buying = AutomaticDirectBuyingPermission.objects.first()
            if role == 'KillHouse':
                if kill_request.poultry is None:
                    if SmsLicense.objects.filter(kill_request=True).exists():
                        province_operator = ProvinceOperator.objects.filter(
                            user=SystemUserProfile.objects.get(role__name='ProvinceOperator', province=user.province))

                        if province_operator.count() > 0:
                            province_operator = province_operator.last()
                        quantity = kill_request.kill_capacity
                        chicken_breed = kill_request.chicken_breed
                        date_str = kill_request.recive_date
                        try:
                            send_date = datetime.strptime(date_str, '%Y-%m-%dT%H:%M:%S.%f%z').date()
                        except:
                            send_date = datetime.strptime(date_str, '%Y-%m-%d %H:%M:%S').date()
                        # send_date = datetime.strptime(date_str, '%Y-%m-%d %H:%M:%S').date()
                        send_date = jdatetime.datetime.fromgregorian(year=send_date.year, month=send_date.month,
                                                                     day=send_date.day).strftime('%Y-%m-%d')
                        date_list = reversed(send_date.split('-'))
                        separate = "-"
                        send_date = separate.join(date_list)
                        province = kill_request.kill_house.system_address.province.name
                        city = kill_request.kill_house.system_address.city.name
                        kill_house_name = kill_request.kill_house.name
                        province_operator_mobile = province_operator.user.mobile
                        province_operator_name = province_operator.user.fullname
                        sms_kill_request_province_sms = threading.Thread(target=kill_request_province_sms,
                                                                         args=(
                                                                             province_operator_mobile, kill_house_name,
                                                                             quantity,
                                                                             chicken_breed,
                                                                             send_date, province, city))
                        sms_kill_request_province_sms.start()
                        serializer_request = self.serializer_class(kill_request)
                if price_confirmation:
                    kill_request.price_confirmation = True
                    kill_request.save()
                return Response({"result": "درخواست شما با موفقیت برای استان ارسال شد."},
                                status=status.HTTP_201_CREATED)

            else:
                kill_request.remain_quantity = kill_request.kill_capacity
                kill_request.province_state = 'accepted'
                kill_request.final_accept = True
                kill_request.save()
                price = Pricing.objects.all()
                if price.count() > 0:
                    price = price.last()
                    factor = KillRequestFactor(
                        kill_request=kill_request,
                        amount=round(
                            (kill_request.kill_capacity * kill_request.Index_weight) * price.live_chicken_price,
                            0),
                        minimum_amount=round(
                            ((kill_request.kill_capacity * kill_request.Index_weight) * price.live_chicken_price) * (
                                    70 / 100),
                            0)

                    )
                    factor.save()
                    kill_request.factor_amount = factor.amount
                    kill_request.save()
                if kill_request.poultry is None:
                    if SmsLicense.objects.filter(kill_request=True).exists():
                        mobile = kill_request.kill_house.kill_house_operator.user.mobile
                        kill_house_name = kill_request.kill_house.name
                        sms_province_kill_request_accept_sms = threading.Thread(
                            target=province_kill_request_accept_sms,
                            args=(
                                kill_house_name,))
                        sms_province_kill_request_accept_sms.start()
                now = datetime.now().time().replace(second=0, microsecond=0)
                if price_confirmation:
                    poultry_fullname = poultry.unit_name
                    # poultry_mobile = poultry.user.mobile
                    poultry_mobile = second_mobile_number if not kill_request.direct_buying_intermediary_mobile else kill_request.direct_buying_intermediary_mobile
                    quantity = kill_request.kill_capacity
                    chicken_breed = kill_request.chicken_breed
                    request_kill_house = kill_request.kill_house.name
                    date_str = kill_request.recive_date
                    clean_date_str = date_str.split('T')[0] + ' ' + date_str.split('T')[1].split('.')[0]
                    send_date = datetime.strptime(str(clean_date_str), '%Y-%m-%d %H:%M:%S').date()
                    send_date = jdatetime.datetime.fromgregorian(year=send_date.year, month=send_date.month,
                                                                 day=send_date.day).strftime('%Y-%m-%d')
                    date_list = reversed(send_date.split('-'))
                    separate = "-"
                    send_date = separate.join(date_list)
                    confirm_price_poultry_request = threading.Thread(
                        target=confirm_price_poultry_request_direct_buying_sms,
                        args=(
                            poultry_mobile, poultry_fullname,
                            quantity, chicken_breed,
                            send_date,
                            kill_request.free_direct_buying,
                            kill_request.amount, request_kill_house,
                            code))
                    confirm_price_poultry_request.start()
                    kill_request.price_confirmation = True
                    kill_request.save()
                    return Response({"result": "درخواست شما با موفقیت ارسال شد."},
                                    status=status.HTTP_201_CREATED)
                else:
                    if permission_duirect_buying.allow == True and not buying_verification.poultry_code_mandatory and permission_duirect_buying.start_time < \
                            now < permission_duirect_buying.end_time:
                        poultry_requests = PoultryRequest.objects.filter(poultry=kill_request.poultry,
                                                                         trash=False).order_by(
                            'create_date')
                        if not hatching:
                            hatching = PoultryHatching.objects.filter(poultry=kill_request.poultry, state='pending',
                                                                      archive=False,
                                                                      allow_hatching='pending', trash=False).order_by(
                                'id').last()

                        poultry = Poultry.objects.get(key=kill_request.poultry.key, trash=False)
                        vet_farm = VetFarm.objects.filter(trash=False, poultry=poultry).first()
                        last_poultry_request = PoultryRequest.objects.all()
                        if last_poultry_request.count() > 0:
                            general_order_code = last_poultry_request.last().general_order_code + 1
                        else:
                            general_order_code = 1

                        if poultry_requests.count() > 0:
                            order_code = poultry_requests.last().order_code + 1
                        else:
                            order_code = int(str(poultry.user.base_order) + '0001')
                        city_operator = CityOperator.objects.filter(unit_name=poultry.city_operator, trash=False).last()
                        if not city_operator:
                            city_operator = CityOperator.objects.filter(unit_name='اتحادیه استان (فاقد تعاونی)',
                                                                        trash=False).last()
                        if hatching.left_over < kill_request.kill_capacity:
                            return Response({"result": "تعداد جوجه در سالن کمتر از تعداد درخواستی است"},
                                            status=status.HTTP_403_FORBIDDEN)

                        poultry_request = PoultryRequest(
                            hatching=hatching,
                            order_code=order_code,
                            general_order_code=general_order_code,
                            city_operator=city_operator,
                            poultry=poultry,
                            previous_quantity=kill_request.kill_capacity,
                            remain_quantity=kill_request.kill_capacity,
                            quantity=kill_request.kill_capacity,
                            first_quantity=kill_request.kill_capacity,
                            chicken_breed=hatching.chicken_breed,
                            Index_weight=kill_request.Index_weight,
                            state_process='accepted',
                            province_state='accepted',
                            direct_buying=True,
                            free_sale_in_province=free_sale_in_province,
                            send_date=kill_request.recive_date,
                            amount=kill_request.amount,
                        )
                        if kill_request.freezing:
                            poultry_request.freezing = True
                        poultry_request.save()
                        kill_request.poultry_request = poultry_request
                        if kill_request.export_status == True:
                            poultry_request.export = True
                        send_date_str = poultry_request.send_date
                        send_date_datetime = datetime.strptime(str(send_date_str), '%Y-%m-%dT%H:%M:%S.%fZ')
                        poultry_request.killing_age = (send_date_datetime.date() - hatching.date.date()).days + 1

                        poultry_request.state = {
                            "city_operator": city_operator.user.fullname,
                            "city_state": poultry_request.state_process,
                            "city_operator_mobile": city_operator.user.mobile,
                            "province_operator": "",
                            "province_state": ""
                        }
                        poultry_request.registrar = {
                            "role": role,
                            "fullname": user.fullname,
                            "date": str(poultry_request.create_date)
                        }
                        poultry_request.save()

                        city_operator_check_request = CityOperatorCheckRequest(
                            city_operator_system=poultry_request.city_operator,
                            poultry_request=poultry_request,
                            state='accept',
                            province_accept=True,
                            province_state='accept',
                            allow_hatching=True

                        )
                        city_operator_check_request.save()
                        province_operator = ProvinceOperator.objects.filter(
                            user=SystemUserProfile.objects.get(role__name='ProvinceOperator', province=user.province))

                        if province_operator.count() > 0:
                            province_operator = province_operator.last()

                        check = ProvinceCheckOperatorRequest(
                            province_operator_system=province_operator,
                            poultry_request=poultry_request,
                            city_request_Poultry=city_operator_check_request,
                            quantity=poultry_request.quantity,

                            state='accept',
                        )
                        check.save()
                        wage_type = WageType.objects.filter(en_name='province-kill-request', trash=False).first()
                        wage = wage_type.amount if wage_type.status == True else 0
                        percentages_wage_type = PercentageOfWageType.objects.filter(wage_type=wage_type, percent__gt=0,
                                                                                    trash=False)
                        province_killrequest = ProvinceKillRequest(
                            killhouse_user=kill_request.kill_house,
                            kill_request=kill_request,
                            province_request=check,
                            quantity=kill_request.kill_capacity,
                            total_killed_quantity=kill_request.kill_capacity,
                            total_killed_weight=int(kill_request.kill_capacity * poultry_request.Index_weight),
                            main_quantity=kill_request.kill_capacity,
                            wage=wage,
                            direct_buying=True,
                            total_wage_amount=wage * int(kill_request.kill_capacity * poultry_request.Index_weight),
                        )
                        province_killrequest.save()
                        # fine = FinePermission.objects.filter(trash=False).first()
                        # time_for_fine = datetime.now()
                        # time_for_fine = time_for_fine.replace(second=0, microsecond=0).time()
                        # if fine.direct_buying:
                        #     if fine.direct_buying_start_time < time_for_fine < fine.direct_buying_end_time:
                        #         province_killrequest.direct_buying_fine = True
                        #         province_killrequest.direct_buying_fine_amount = fine.direct_buying_fine_coefficient * province_killrequest.total_wage_amount
                        #         province_killrequest.direct_buying_fine_coefficient = fine.direct_buying_fine_coefficient
                        create_update_chicken_commission_prices()
                        if wage_type and wage_type.status == True and percentages_wage_type:
                            for percentage_wage_type in percentages_wage_type:
                                if percentage_wage_type.share_type.en_name == 'union':
                                    province_killrequest.union_share = int(
                                        (percentage_wage_type.percent / 100) * province_killrequest.total_wage_amount)
                                    province_killrequest.union_share_percent = percentage_wage_type.percent

                                elif percentage_wage_type.share_type.en_name == 'company':
                                    province_killrequest.company_share = int(
                                        (percentage_wage_type.percent / 100) * province_killrequest.total_wage_amount)
                                    province_killrequest.company_share_percent = percentage_wage_type.percent

                                elif percentage_wage_type.share_type.en_name == 'guilds':
                                    province_killrequest.guilds_share = int(
                                        (percentage_wage_type.percent / 100) * province_killrequest.total_wage_amount)
                                    province_killrequest.guilds_share_percent = percentage_wage_type.percent

                                elif percentage_wage_type.share_type.en_name == 'city':
                                    province_killrequest.city_share = int(
                                        (percentage_wage_type.percent / 100) * province_killrequest.total_wage_amount)
                                    province_killrequest.city_share_percent = percentage_wage_type.percent

                                elif percentage_wage_type.share_type.en_name == 'other':
                                    province_killrequest.other_share = int(
                                        (percentage_wage_type.percent / 100) * province_killrequest.total_wage_amount)
                                    province_killrequest.other_share_percent = percentage_wage_type.percent

                                elif percentage_wage_type.share_type.en_name == 'wallet':
                                    province_killrequest.wallet_share = int(
                                        (percentage_wage_type.percent / 100) * province_killrequest.total_wage_amount)
                                    province_killrequest.wallet_share_percent = percentage_wage_type.percent

                                else:
                                    province_killrequest.other_share = int(
                                        (percentage_wage_type.percent / 100) * province_killrequest.total_wage_amount)
                                    province_killrequest.other_share_percent = percentage_wage_type.percent
                                province_killrequest.save()

                        tomorrow = datetime.now().date() + timedelta(days=1)
                        if not KillHouseWareHouse.objects.filter(kill_house=kill_request.kill_house,
                                                                 date__date=tomorrow).exists():
                            ware_house_date = datetime(year=tomorrow.year, month=tomorrow.month, day=tomorrow.day,
                                                       hour=1,
                                                       minute=12, second=20)
                            kill_house_ware_house = KillHouseWareHouse(
                                kill_house=kill_request.kill_house,
                                date=ware_house_date
                            )
                            kill_house_ware_house.save()
                        kill_house_check = KillHouseCheckRequest(
                            province_kill_request=province_killrequest,
                            state='accepted'
                        )

                        kill_house_check.save()
                        province_killrequest.state = 'accepted'
                        if buying_verification.payment_deadline:
                            province_killrequest.payment_deadline = True
                            province_killrequest.payment_deadline_date = datetime.now() + timedelta(
                                days=request.data['payment_deadline_days'])
                        province_killrequest.save()
                        check.quantity = 0
                        check.save()

                        if poultry_request.export == True:
                            hatching.export_killed_weight += int(
                                kill_request.kill_capacity * poultry_request.Index_weight)
                            hatching.export_killed_quantity += kill_request.kill_capacity


                        elif poultry_request.free_sale_in_province == True:
                            hatching.free_killed_quantity += int(
                                kill_request.kill_capacity * poultry_request.Index_weight)
                            hatching.free_quantity += kill_request.kill_capacity

                        else:
                            hatching.governmental_killed_quantity += int(
                                kill_request.kill_capacity * poultry_request.Index_weight)
                            hatching.governmental_quantity += kill_request.kill_capacity
                        hatching.killed_quantity += kill_request.kill_capacity
                        hatching.save()
                        poultry_request.remain_quantity = 0
                        poultry_request.direct_buying_kill_place = kill_request.kill_house.name
                        poultry_request.direct_buying_buyer_info = {
                            "buyer_fullname": kill_request.kill_house.kill_house_operator.user.fullname,
                            "buyer_mobile": kill_request.kill_house.kill_house_operator.user.mobile,
                        }
                        poultry_request.save()
                        if kill_request.export_status == True:
                            kill_request.export_state = 'accepted'
                            kill_request.direct_buying_message = request.data['direct_buying_message']

                        else:
                            kill_request.direct_buying_state = 'accepted'

                        kill_request.accept_reject_date = datetime.now()

                        kill_request.save()
                        poultry_fullname = poultry.unit_name
                        # poultry_mobile = poultry.user.mobile
                        poultry_mobile = second_mobile_number if not kill_request.direct_buying_intermediary_mobile else kill_request.direct_buying_intermediary_mobile
                        quantity = kill_request.kill_capacity
                        chicken_breed = kill_request.chicken_breed
                        request_kill_house = kill_request.kill_house.name
                        date_str = kill_request.recive_date
                        if isinstance(date_str, str):
                            clean_date_str = date_str.split('.')[0]
                            clean_date_str = clean_date_str.replace('T', ' ')
                            clean_date_str = clean_date_str.replace('Z', '')

                            send_date = datetime.strptime(clean_date_str, '%Y-%m-%d %H:%M:%S').date()

                        elif isinstance(date_str, datetime):
                            send_date = date_str.date()
                        # clean_date_str = date_str.split('T')[0] + ' ' + date_str.split('T')[1].split('.')[0]
                        # send_date = datetime.strptime(str(clean_date_str), '%Y-%m-%d %H:%M:%S').date()
                        send_date = jdatetime.datetime.fromgregorian(year=send_date.year, month=send_date.month,
                                                                     day=send_date.day).strftime('%Y-%m-%d')
                        date_list = reversed(send_date.split('-'))
                        separate = "-"
                        code = "-"
                        send_date = separate.join(date_list)
                        confirm_price_poultry_request = threading.Thread(
                            target=confirm_price_poultry_request_direct_buying_sms,
                            args=(
                                poultry_mobile, poultry_fullname,
                                quantity, chicken_breed,
                                send_date,
                                kill_request.free_direct_buying,
                                kill_request.amount, request_kill_house,
                                code))
                        confirm_price_poultry_request.start()
                        bot_eitaa_for_each_province_kill_request(province_killrequest, vet_farm)
                        return Response({"result": "درخواست شما با موفقیت ارسال شد."},
                                        status=status.HTTP_201_CREATED)
                    else:
                        poultry_fullname = poultry.unit_name
                        # poultry_mobile = poultry.user.mobile
                        poultry_mobile = second_mobile_number if not kill_request.direct_buying_intermediary_mobile else kill_request.direct_buying_intermediary_mobile
                        quantity = kill_request.kill_capacity
                        chicken_breed = kill_request.chicken_breed
                        request_kill_house = kill_request.kill_house.name
                        date_str = kill_request.recive_date
                        if isinstance(date_str, str):
                            clean_date_str = date_str.split('.')[0]
                            clean_date_str = clean_date_str.replace('T', ' ')
                            clean_date_str = clean_date_str.replace('Z', '')

                            send_date = datetime.strptime(clean_date_str, '%Y-%m-%d %H:%M:%S').date()

                        elif isinstance(date_str, datetime):
                            send_date = date_str.date()
                        # clean_date_str = date_str.split('T')[0] + ' ' + date_str.split('T')[1].split('.')[0]
                        # send_date = datetime.strptime(str(clean_date_str), '%Y-%m-%d %H:%M:%S').date()
                        send_date = jdatetime.datetime.fromgregorian(year=send_date.year, month=send_date.month,
                                                                     day=send_date.day).strftime('%Y-%m-%d')
                        date_list = reversed(send_date.split('-'))
                        separate = "-"
                        code = "-"
                        send_date = separate.join(date_list)
                        confirm_price_poultry_request = threading.Thread(
                            target=confirm_price_poultry_request_direct_buying_sms,
                            args=(
                                poultry_mobile, poultry_fullname,
                                quantity, chicken_breed,
                                send_date,
                                kill_request.free_direct_buying,
                                kill_request.amount, request_kill_house,
                                code))
                        confirm_price_poultry_request.start()
                return Response({"result": "درخواست شما با موفقیت به پنل تخصیص اضافه شد."},
                                status=status.HTTP_201_CREATED)

    def list(self, request, *args, **kwargs):
        user = SystemUserProfile.objects.get(user=request.user, trash=False)
        now = datetime.now().date()
        if 'role' in request.GET:
            if request.GET['role'] == 'KillHouse':
                kill_house_operator = KillHouseOperator.objects.get(user=user, trash=False)
                kill_house = KillHouse.objects.filter(kill_house_operator=kill_house_operator, trash=False)
                date1 = datetime.strptime(str(request.GET['date1']),
                                          '%Y-%m-%d').date() if 'date1' in request.GET else now
                date2 = datetime.strptime(str(request.GET['date2']),
                                          '%Y-%m-%d').date() if 'date2' in request.GET else now
                if 'direct_buying' in request.GET:
                    from django.db.models import Value
                    kill_req_list = []
                    # if request.GET['type'] == 'pending':
                    #     querysets = KillRequest.objects.filter(kill_house__in=kill_house, recive_date__date__gte=date1,
                    #                                            recive_date__date__lte=date2, poultry__isnull=False,
                    #                                            direct_buying_state='pending',
                    #                                            export_status=False,trash=False
                    #                                            ).order_by(
                    #         'recive_date')
                    # else:
                    querysets = KillRequest.objects.filter(kill_house__in=kill_house, recive_date__date__gte=date1,
                                                           recive_date__date__lte=date2, poultry__isnull=False,
                                                           direct_buying_state__in=(
                                                               'accepted', 'rejected', 'deleted', 'pending'),
                                                           export_status=False, trash=False, market=False,
                                                           ).order_by(
                        Case(
                            When(direct_buying_state='pending', then=Value(0)),
                            default=Value(1)
                        ),
                        '-recive_date'  # مرتب‌سازی بر اساس تاریخ بعد از مرتب‌سازی بر اساس حالت
                    )
                    if 'search' in request.GET:
                        if request.GET['search'] == 'filter':
                            if request.GET['value'] != "":
                                for item in self.filterset_fields:
                                    query = QueryDict('{0}__contains={1}'.format(item, request.GET['value']))
                                    if (self.filterset_class(
                                            data=query,
                                            queryset=querysets
                                    )
                                    ).filter():
                                        ps = self.filterset_class(data=query, queryset=querysets)
                                        kill_req_list = ps.filter()
                                querysets = [] if len(kill_req_list) == 0 else kill_req_list

                    page_size = request.query_params.get('page_size', None)
                    if page_size:
                        self.pagination_class.page_size = int(page_size)

                    page = self.paginate_queryset(querysets)
                    if page is not None:
                        serializer = KillRequestSerializer(page, many=True)
                        return self.get_paginated_response(serializer.data)

                    serializer = KillRequestSerializer(querysets, many=True)
                    return Response(serializer.data, status=status.HTTP_200_OK)

                if 'export' in request.GET:
                    kill_req_list = []
                    if request.GET['type'] == 'pending':
                        querysets = KillRequest.objects.filter(kill_house__in=kill_house, recive_date__date__gte=date1,
                                                               recive_date__date__lte=date2, poultry__isnull=False,
                                                               export_status=True, market=False,
                                                               export_state='pending'
                                                               ).order_by(
                            'recive_date')
                    else:
                        querysets = KillRequest.objects.filter(kill_house__in=kill_house, recive_date__date__gte=date1,
                                                               recive_date__date__lte=date2, poultry__isnull=False,
                                                               export_status=True, market=False,
                                                               export_state__in=(
                                                                   'accepted', 'rejected', 'deleted'),
                                                               ).order_by(
                            'recive_date')

                    if 'search' in request.GET:
                        if request.GET['search'] == 'filter':
                            if request.GET['value'] != "":
                                for item in self.filterset_fields:
                                    query = QueryDict('{0}__contains={1}'.format(item, request.GET['value']))
                                    if (self.filterset_class(
                                            data=query,
                                            queryset=querysets
                                    )
                                    ).filter():
                                        ps = self.filterset_class(data=query, queryset=querysets)
                                        kill_req_list = ps.filter()
                                querysets = [] if len(kill_req_list) == 0 else kill_req_list

                    page_size = request.query_params.get('page_size', None)
                    if page_size:
                        self.pagination_class.page_size = int(page_size)

                    page = self.paginate_queryset(querysets)
                    if page is not None:
                        serializer = KillRequestSerializer(page, many=True)
                        return self.get_paginated_response(serializer.data)

                    serializer = KillRequestSerializer(querysets, many=True)
                    return Response(serializer.data, status=status.HTTP_200_OK)

                queryset_list = KillRequest.objects.filter(kill_house__in=kill_house, trash=False, market=False,
                                                           poultry__isnull=True).order_by(
                    'recive_date')
                querysets = [
                    kill_request for kill_request in queryset_list
                    if date1 <= kill_request.recive_date.date() <= date2
                ]
            elif request.GET['role'] in ['ProvinceOperator', 'SuperAdmin', 'AdminX']:
                user = SystemUserProfile.objects.get(user=request.user, trash=False)
                date1 = datetime.strptime(str(request.GET['date1']),
                                          '%Y-%m-%d').date() if 'date1' in request.GET else now
                date2 = datetime.strptime(str(request.GET['date2']),
                                          '%Y-%m-%d').date() if 'date2' in request.GET else now

                if 'direct_buying' in request.GET:
                    from django.db.models import Value
                    kill_req_list = []
                    # if request.GET['type'] == 'pending':
                    #     querysets = KillRequest.objects.filter(
                    #         recive_date__date__gte=date1,
                    #         recive_date__date__lte=date2, poultry__isnull=False,
                    #         direct_buying_state='pending',
                    #         export_status=False,trash=False
                    #     ).order_by(
                    #         'recive_date')
                    # else:
                    querysets = KillRequest.objects.filter(
                        recive_date__date__gte=date1,
                        recive_date__date__lte=date2, poultry__isnull=False, market=False,
                        final_accept=True,
                        direct_buying_state__in=(
                            'accepted', 'rejected', 'deleted', 'pending'),
                        export_status=False, trash=False
                    ).select_related(
                        'poultry', 'kill_house', 'slaughter_house', 'poultry_hatching'

                    ).order_by(
                        Case(
                            When(direct_buying_state='pending', then=Value(0)),
                            default=Value(1)
                        ),
                        '-recive_date'  # مرتب‌سازی بر اساس تاریخ بعد از مرتب‌سازی بر اساس حالت
                    )
                    if 'search' in request.GET:
                        if request.GET['search'] == 'filter':
                            if request.GET['value'] != "":
                                for item in self.filterset_fields:
                                    query = QueryDict('{0}__contains={1}'.format(item, request.GET['value']))
                                    if (self.filterset_class(
                                            data=query,
                                            queryset=querysets
                                    )
                                    ).filter():
                                        ps = self.filterset_class(data=query, queryset=querysets)
                                        kill_req_list = ps.filter()
                                querysets = [] if len(kill_req_list) == 0 else kill_req_list

                    page_size = request.query_params.get('page_size', None)
                    if page_size:
                        self.pagination_class.page_size = int(page_size)

                    page = self.paginate_queryset(querysets)
                    if page is not None:
                        serializer = KillRequestForDirectBuyingTrueSerializer(page, many=True)
                        return self.get_paginated_response(serializer.data)

                    serializer = KillRequestSerializer(querysets, many=True)
                    return Response(serializer.data, status=status.HTTP_200_OK)

                if 'export' in request.GET:
                    kill_req_list = []
                    if request.GET['type'] == 'pending':
                        querysets = KillRequest.objects.filter(
                            recive_date__date__gte=date1,
                            recive_date__date__lte=date2, poultry__isnull=False,
                            export_status=True, market=False,
                            export_state='pending'
                        ).order_by(
                            'recive_date')
                    else:
                        querysets = KillRequest.objects.filter(
                            recive_date__date__gte=date1,
                            recive_date__date__lte=date2, poultry__isnull=False,
                            export_status=True, market=False,
                            export_state__in=(
                                'accepted', 'rejected', 'deleted'),
                        ).order_by(
                            'recive_date')

                    if 'search' in request.GET:
                        if request.GET['search'] == 'filter':
                            if request.GET['value'] != "":
                                for item in self.filterset_fields:
                                    query = QueryDict('{0}__contains={1}'.format(item, request.GET['value']))
                                    if (self.filterset_class(
                                            data=query,
                                            queryset=querysets
                                    )
                                    ).filter():
                                        ps = self.filterset_class(data=query, queryset=querysets)
                                        kill_req_list = ps.filter()
                                querysets = [] if len(kill_req_list) == 0 else kill_req_list

                    page_size = request.query_params.get('page_size', None)
                    if page_size:
                        self.pagination_class.page_size = int(page_size)

                    page = self.paginate_queryset(querysets)
                    if page is not None:
                        serializer = KillRequestSerializer(page, many=True)
                        return self.get_paginated_response(serializer.data)

                    serializer = KillRequestSerializer(querysets, many=True)
                    return Response(serializer.data, status=status.HTTP_200_OK)

                querysets_list = KillRequest.objects.filter(
                    trash=False, poultry__isnull=True).order_by('-recive_date')
                # for queryset in querysets_list:
                #     if (now - queryset.recive_date.date()).days > 2:
                #         queryset.remain_quantity = 0
                #         queryset.save()

                querysets = [
                    queryset_list for queryset_list in querysets_list
                    if date1 <= queryset_list.recive_date.date() <= date2
                ]
        elif 'poultry_key' in request.GET:
            kill_requests = []
            today = datetime.now().date()
            poultry = Poultry.objects.get(key=request.GET['poultry_key'], trash=False)
            kill_requests = KillRequest.objects.filter(direct_buying_state__in=('pending', 'accepted'), market=False,
                                                       poultry=poultry, recive_date__date=today, trash=False)
            serializer = KillRequestSerializer(kill_requests, many=True)
            return Response(serializer.data, status=status.HTTP_200_OK)


        else:
            if '0' in request.GET:
                poultry_request = PoultryRequest.objects.get(key=request.GET['0'])

                queryset = KillRequest.objects.filter(
                    recive_date__year=poultry_request.send_date.year,
                    recive_date__month=poultry_request.send_date.month,
                    recive_date__day=poultry_request.send_date.day,
                    province_state='accepted', market=False,
                    # automatic=False,
                    trash=False, poultry__isnull=True).order_by('id')
                result_list = []
                if len(poultry_request.kill_house_list) != 0:
                    querysets = []
                    for item in poultry_request.kill_house_list:
                        parts = item.split("(")
                        name = parts[0].strip()
                        result_list.append(name)
                    for kill_house in result_list:
                        priority_requests = []
                        remaining_requests = []
                        for kill_request in queryset:
                            if kill_request.kill_house.name == kill_house:
                                priority_requests.append(kill_request)
                                kill_request.priority = True
                                kill_request.save()
                            else:
                                kill_request.priority = False
                                kill_request.save()
                                remaining_requests.append(kill_request)
                        for x in priority_requests:
                            if x in querysets:
                                pass
                            else:
                                querysets.append(x)
                        for y in remaining_requests:
                            if y in querysets:
                                pass
                            else:
                                querysets.append(y)


                else:

                    for kill_request in queryset:
                        kill_request.priority = False
                        kill_request.save()
                    querysets = queryset

            else:
                querysets = []
        serializer = KillRequestSerializer(querysets, many=True)
        return Response(serializer.data, status=status.HTTP_200_OK)

    # تابع مربوط به حذف درخواست کشتارهای ثبت شده از سمت کشتارگاه
    def destroy(self, request, pk=None, *args, **kwargs):
        # refresh(request.user.id)
        if 'role' in request.GET:
            kill_request = KillRequest.objects.get(key=request.GET['kill_request_key'])

            limitation_direct_purchase = LimitationForDirectPurchaseAndBarInformation.objects.filter(
                trash=False, active=True).first()

            if limitation_direct_purchase and limitation_direct_purchase.start_time and limitation_direct_purchase.end_time:
                current_time = datetime.now().time()
                if limitation_direct_purchase.start_time <= current_time <= limitation_direct_purchase.end_time:
                    record_create_time = kill_request.create_date.time()
                    if not (
                            limitation_direct_purchase.start_time <= record_create_time <= limitation_direct_purchase.end_time):
                        return Response(
                            {"result": "شما فقط می‌توانید بارهایی که در بازه زمانی مجاز ثبت شده‌اند را حذف کنید!"},
                            status=status.HTTP_403_FORBIDDEN)
            if request.GET['role'] == 'KillHouse':
                if kill_request.direct_buying_state != 'pending' and kill_request.export_status == False:
                    return Response({"result": "به علت تایید یا رد استان شما نمیتوانیددرخواست رو حذف کنید"})
                if kill_request.export_state != 'pending' and kill_request.export_status == True:
                    return Response({"result": "به علت تایید یا رد استان شما نمیتوانیددرخواست رو حذف کنید"})
            if kill_request.export_status == False:
                kill_request.direct_buying_state = 'deleted'
            else:
                kill_request.export_state = 'deleted'

            kill_request.trash = True
            kill_request.save()
            return Response({"result": "با موفقیت حذف شد"}, status=status.HTTP_200_OK)

        user = SystemUserProfile.objects.get(user=request.user)
        kill_request = KillRequest.objects.get(id=pk)
        if ProvinceKillRequest.objects.filter(kill_request=kill_request, trash=False).exists():
            return Response({"result": "error"}, status=status.HTTP_403_FORBIDDEN)
        if SmsLicense.objects.filter(kill_request=True).exists():
            province_operator = ProvinceOperator.objects.filter(
                user=SystemUserProfile.objects.get(role__name='ProvinceOperator', province=user.province))

            if province_operator.count() > 0:
                province_operator = province_operator.last()
            quantity = kill_request.kill_capacity
            chicken_breed = kill_request.chicken_breed
            date_str = str(kill_request.recive_date)
            send_date = datetime.strptime(date_str, '%Y-%m-%d %H:%M:%S').date()
            send_date = jdatetime.datetime.fromgregorian(year=send_date.year, month=send_date.month,
                                                         day=send_date.day).strftime('%Y-%m-%d')
            date_list = reversed(send_date.split('-'))
            separate = "-"
            send_date = separate.join(date_list)
            province = kill_request.kill_house.system_address.province.name
            city = kill_request.kill_house.system_address.city.name
            kill_house_name = kill_request.kill_house.name
            province_operator_mobile = province_operator.user.mobile
            province_operator_name = province_operator.user.fullname
            # kill_request_province_sms(province_operator_mobile, kill_house_name, quantity, chicken_breed,
            #                           send_date, province, city)

            sms_kill_request_delete_province_sms = threading.Thread(target=kill_request_delete_province_sms,
                                                                    args=(
                                                                        province_operator_mobile, kill_house_name,
                                                                        quantity,
                                                                        chicken_breed,
                                                                        send_date, province, city))
            sms_kill_request_delete_province_sms.start()
        kill_request.trash = True
        kill_request.save()

        return Response('request deleted', status=status.HTTP_200_OK)

    def update(self, request, pk=None, *args, **kwargs):
        # refresh(request.user.id)

        if 'kill_request_key' in request.data.keys():
            kill_request_instance = KillRequest.objects.filter(key=request.data['kill_request_key'],
                                                               trash=False).first()
            if kill_request_instance:
                limitation_direct_purchase = LimitationForDirectPurchaseAndBarInformation.objects.filter(
                    trash=False, active=True).first()

                if limitation_direct_purchase and limitation_direct_purchase.start_time and limitation_direct_purchase.end_time:
                    current_time = datetime.now().time()
                    if limitation_direct_purchase.start_time <= current_time <= limitation_direct_purchase.end_time:
                        record_create_time = kill_request_instance.create_date.time()
                        if not (
                                limitation_direct_purchase.start_time <= record_create_time <= limitation_direct_purchase.end_time):
                            return Response(
                                {
                                    "result": "شما فقط می‌توانید بارهایی که در بازه زمانی مجاز ثبت شده‌اند را ویرایش کنید!"},
                                status=status.HTTP_403_FORBIDDEN)

        if 'role' in request.data.keys():
            kill_request = KillRequest.objects.get(key=request.data['kill_request_key'])
            if kill_request.trash:
                return Response({"result": "به علت بدهی درخواست شما حذف گردید!"}, status=status.HTTP_403_FORBIDDEN)
            if request.data['role'] == 'KillHouse':
                if kill_request.direct_buying_state != 'pending':
                    return Response({"result": "به علت تایید یا رد استان شما نمیتوانیددرخواست رو ویرایش کنید"})
            request.data.pop('role')
            request.data.pop('kill_request_key')
            if 'input_direct_buying_code' in request.data.keys():
                if request.data['input_direct_buying_code'] != None or request.data['input_direct_buying_code'] != "":
                    if request.data['input_direct_buying_code'] != kill_request.direct_buying_code:
                        return Response({"result": "کد وارد شده صحیح نمی باشد"}, status=status.HTTP_403_FORBIDDEN)

                user = SystemUserProfile.objects.get(user=request.user, trash=False)
                now = datetime.now().time().replace(second=0, microsecond=0)

                free_sale_in_province = False if kill_request.free_direct_buying == False else True

                permission_duirect_buying = AutomaticDirectBuyingPermission.objects.first()

                if permission_duirect_buying.allow == True and permission_duirect_buying.start_time < \
                        now < permission_duirect_buying.end_time:
                    # kill_request.kill_capacity = int(request.data['quantity'])
                    # kill_request.remain_quantity = int(request.data['quantity'])
                    # kill_request.save()
                    # request.data.pop('quantity')
                    poultry_requests = PoultryRequest.objects.filter(poultry__user=kill_request.poultry.user,
                                                                     trash=False).order_by(
                        'create_date')

                    if kill_request.poultry_hatching:
                        hatching = kill_request.poultry_hatching
                    else:

                        hatching = PoultryHatching.objects.filter(poultry=kill_request.poultry, state='pending',
                                                                  archive=False,
                                                                  allow_hatching='pending', trash=False).order_by(
                            'id').last()

                    poultry = Poultry.objects.get(key=kill_request.poultry.key, trash=False)
                    vet_farm = VetFarm.objects.filter(trash=False, poultry=poultry).first()
                    last_poultry_request = PoultryRequest.objects.all()
                    if last_poultry_request.count() > 0:
                        general_order_code = last_poultry_request.last().general_order_code + 1
                    else:
                        general_order_code = 1

                    if poultry_requests.count() > 0:
                        order_code = poultry_requests.last().order_code + 1
                    else:
                        order_code = int(str(poultry.user.base_order) + '0001')
                    city_operator = CityOperator.objects.filter(unit_name=poultry.city_operator, trash=False).last()
                    if not city_operator:
                        city_operator = CityOperator.objects.filter(unit_name='اتحادیه استان (فاقد تعاونی)',
                                                                    trash=False).last()
                    if hatching.left_over < kill_request.kill_capacity:
                        return Response({"result": "تعداد جوجه در سالن کمتر از تعداد درخواستی است"},
                                        status=status.HTTP_403_FORBIDDEN)

                    if kill_request.kill_house.max_kill_limit and kill_request.kill_house.total_kill_capacity > 0:
                        total_province_kill_requests = ProvinceKillRequest.objects.filter(trash=False,
                                                                                          return_to_province=False,
                                                                                          archive_wage=False,
                                                                                          state__in=(
                                                                                              'pending', 'accepted'),
                                                                                          killhouse_user=kill_request.kill_house,
                                                                                          kill_request__recive_date__date=kill_request.recive_date.date())
                        total_province_kill_requests_quantity = \
                            total_province_kill_requests.aggregate(total=Sum('total_killed_quantity'))['total'] or 0
                        if kill_request.kill_house.total_kill_capacity < total_province_kill_requests_quantity + kill_request.kill_capacity:
                            return Response(
                                {"result": "تعداد وارد شده از مانده سهمیه کشتار روزانه کشتارگاه بیشتر است !"},
                                status=status.HTTP_403_FORBIDDEN)

                    poultry_request = PoultryRequest(
                        hatching=hatching,
                        order_code=order_code,
                        general_order_code=general_order_code,
                        city_operator=city_operator,
                        poultry=poultry,
                        previous_quantity=kill_request.kill_capacity,
                        remain_quantity=kill_request.kill_capacity,
                        quantity=kill_request.kill_capacity,
                        first_quantity=kill_request.kill_capacity,
                        chicken_breed=hatching.chicken_breed,
                        Index_weight=kill_request.Index_weight,
                        state_process='accepted',
                        province_state='accepted',
                        direct_buying=True,
                        amount=kill_request.amount,
                        free_sale_in_province=free_sale_in_province,
                        send_date=kill_request.recive_date
                    )
                    if kill_request.freezing:
                        poultry_request.freezing = True

                    poultry_request.save()
                    kill_request.poultry_request = poultry_request
                    poultry_prediction(poultry_request.poultry)

                    if kill_request.export_status == True:
                        poultry_request.export = True

                    send_date_str = poultry_request.send_date

                    if isinstance(send_date_str, str):
                        # حذف میلی‌ثانیه و کاراکترهای اضافی
                        clean_date_str = send_date_str.split('.')[0]  # حذف بخش .759000
                        clean_date_str = clean_date_str.replace('T', ' ')  # جایگزینی T با فاصله
                        clean_date_str = clean_date_str.replace('Z', '')  # حذف Z اگر وجود دارد

                        # تبدیل به تاریخ میلادی
                        send_date_datetime = datetime.strptime(clean_date_str, '%Y-%m-%d %H:%M:%S').date()

                    # اگر از قبل شی datetime است
                    elif isinstance(send_date_str, datetime):
                        send_date_datetime = send_date_str.date()

                    # send_date_datetime = datetime.strptime(str(send_date_str), '%Y-%m-%dT%H:%M:%S.%fZ')
                    poultry_request.killing_age = (send_date_datetime - hatching.date.date()).days + 1

                    poultry_request.state = {
                        "city_operator": city_operator.user.fullname,
                        "city_state": poultry_request.state_process,
                        "city_operator_mobile": city_operator.user.mobile,
                        "province_operator": "",
                        "province_state": ""
                    }
                    poultry_request.registrar = {
                        "role": 'KillHouse',
                        "fullname": user.fullname,
                        "date": str(poultry_request.create_date)
                    }
                    poultry_request.save()

                    city_operator_check_request = CityOperatorCheckRequest(
                        city_operator_system=poultry_request.city_operator,
                        poultry_request=poultry_request,
                        state='accept',
                        province_accept=True,
                        province_state='accept',
                        allow_hatching=True

                    )
                    city_operator_check_request.save()
                    province_operator = ProvinceOperator.objects.filter(
                        user=SystemUserProfile.objects.get(role__name='ProvinceOperator', province=user.province))

                    if province_operator.count() > 0:
                        province_operator = province_operator.last()

                    check = ProvinceCheckOperatorRequest(
                        province_operator_system=province_operator,
                        poultry_request=poultry_request,
                        city_request_Poultry=city_operator_check_request,
                        quantity=poultry_request.quantity,

                        state='accept',
                    )
                    check.save()
                    wage_type = WageType.objects.filter(en_name='province-kill-request', trash=False).first()
                    wage = wage_type.amount if wage_type.status == True else 0
                    percentages_wage_type = PercentageOfWageType.objects.filter(wage_type=wage_type, percent__gt=0,
                                                                                trash=False)
                    province_killrequest = ProvinceKillRequest(
                        killhouse_user=kill_request.kill_house,
                        kill_request=kill_request,
                        province_request=check,
                        quantity=kill_request.kill_capacity,
                        total_killed_quantity=kill_request.kill_capacity,
                        total_killed_weight=int(kill_request.kill_capacity * poultry_request.Index_weight),
                        main_quantity=kill_request.kill_capacity,
                        wage=wage,
                        direct_buying=True,
                        total_wage_amount=wage * int(kill_request.kill_capacity * poultry_request.Index_weight),
                    )
                    province_killrequest.save()
                    # fine = FinePermission.objects.filter(trash=False).first()
                    # time_for_fine = datetime.now()
                    # time_for_fine = time_for_fine.replace(second=0, microsecond=0).time()
                    # if fine.direct_buying:
                    #     if fine.direct_buying_start_time < time_for_fine < fine.direct_buying_end_time:
                    #         province_killrequest.direct_buying_fine = True
                    #         province_killrequest.direct_buying_fine_amount = (
                    #                                                                  fine.direct_buying_fine_coefficient - 1) * province_killrequest.total_wage_amount if fine.direct_buying_fine_coefficient > 1 else province_killrequest.total_wage_amount
                    #         province_killrequest.direct_buying_fine_coefficient = fine.direct_buying_fine_coefficient
                    if wage_type and wage_type.status == True and percentages_wage_type:
                        for percentage_wage_type in percentages_wage_type:
                            if percentage_wage_type.share_type.en_name == 'union':
                                province_killrequest.union_share = int(
                                    (percentage_wage_type.percent / 100) * province_killrequest.total_wage_amount)
                                province_killrequest.union_share_percent = percentage_wage_type.percent

                            elif percentage_wage_type.share_type.en_name == 'company':
                                province_killrequest.company_share = int(
                                    (percentage_wage_type.percent / 100) * province_killrequest.total_wage_amount)
                                province_killrequest.company_share_percent = percentage_wage_type.percent

                            elif percentage_wage_type.share_type.en_name == 'guilds':
                                province_killrequest.guilds_share = int(
                                    (percentage_wage_type.percent / 100) * province_killrequest.total_wage_amount)
                                province_killrequest.guilds_share_percent = percentage_wage_type.percent

                            elif percentage_wage_type.share_type.en_name == 'city':
                                province_killrequest.city_share = int(
                                    (percentage_wage_type.percent / 100) * province_killrequest.total_wage_amount)
                                province_killrequest.city_share_percent = percentage_wage_type.percent

                            elif percentage_wage_type.share_type.en_name == 'other':
                                province_killrequest.other_share = int(
                                    (percentage_wage_type.percent / 100) * province_killrequest.total_wage_amount)
                                province_killrequest.other_share_percent = percentage_wage_type.percent

                            elif percentage_wage_type.share_type.en_name == 'wallet':
                                province_killrequest.wallet_share = int(
                                    (percentage_wage_type.percent / 100) * province_killrequest.total_wage_amount)
                                province_killrequest.wallet_share_percent = percentage_wage_type.percent

                            else:
                                province_killrequest.other_share = int(
                                    (percentage_wage_type.percent / 100) * province_killrequest.total_wage_amount)
                                province_killrequest.other_share_percent = percentage_wage_type.percent
                            province_killrequest.save()

                    tomorrow = datetime.now().date() + timedelta(days=1)
                    if not KillHouseWareHouse.objects.filter(kill_house=kill_request.kill_house,
                                                             date__date=tomorrow).exists():
                        ware_house_date = datetime(year=tomorrow.year, month=tomorrow.month, day=tomorrow.day, hour=1,
                                                   minute=12, second=20)
                        kill_house_ware_house = KillHouseWareHouse(
                            kill_house=kill_request.kill_house,
                            date=ware_house_date
                        )
                        kill_house_ware_house.save()
                    kill_house_check = KillHouseCheckRequest(
                        province_kill_request=province_killrequest,
                        state='accepted'
                    )

                    kill_house_check.save()
                    province_killrequest.state = 'accepted'

                    if kill_request.payment_deadline:
                        province_killrequest.payment_deadline = True
                        province_killrequest.payment_deadline_date = kill_request.payment_deadline_date
                    province_killrequest.save()
                    check.quantity = 0
                    check.save()

                    if poultry_request.export == True:
                        hatching.export_killed_weight += int(kill_request.kill_capacity * poultry_request.Index_weight)
                        hatching.export_killed_quantity += kill_request.kill_capacity


                    elif poultry_request.free_sale_in_province == True:
                        hatching.free_killed_quantity += int(kill_request.kill_capacity * poultry_request.Index_weight)
                        hatching.free_quantity += kill_request.kill_capacity

                    else:
                        hatching.governmental_killed_quantity += int(
                            kill_request.kill_capacity * poultry_request.Index_weight)
                        hatching.governmental_quantity += kill_request.kill_capacity
                    hatching.killed_quantity += kill_request.kill_capacity
                    hatching.save()
                    poultry_request.remain_quantity = 0
                    poultry_request.direct_buying_kill_place = kill_request.kill_house.name
                    poultry_request.direct_buying_buyer_info = {
                        "buyer_fullname": kill_request.kill_house.kill_house_operator.user.fullname,
                        "buyer_mobile": kill_request.kill_house.kill_house_operator.user.mobile,
                    }
                    poultry_request.save()
                    if kill_request.export_status == True:
                        kill_request.export_state = 'accepted'
                        kill_request.direct_buying_message = request.data['direct_buying_message']

                    else:
                        kill_request.direct_buying_state = 'accepted'

                    kill_request.accept_reject_date = datetime.now()
                    kill_request.automatic_accept = True
                    kill_request.input_direct_buying_code = request.data['input_direct_buying_code']
                    kill_request.save()
                    bot_eitaa_for_each_province_kill_request(province_killrequest, vet_farm)
                    return Response({"result": "درخواست شما با موفقیت تایید و ارسال شد."},
                                    status=status.HTTP_201_CREATED)
            if 'input_export_code' in request.data.keys():
                if request.data['input_export_code'] != None or request.data['input_export_code'] != "":
                    if request.data['input_export_code'] != kill_request.export_code:
                        return Response({"result": "کد وارد شده صحیح نمی باشد"}, status=status.HTTP_403_FORBIDDEN)

            if 'final_accept' in request.data.keys():

                user = SystemUserProfile.objects.get(user=request.user, trash=False)
                kill_request.final_accept = True
                now = datetime.now().time().replace(second=0, microsecond=0)
                price_confirmation = PriceConfirmation.objects.filter(trash=False).first()
                price_confirmation = price_confirmation.poultry_status if price_confirmation else False
                buying_verification = DirectBuyingVerification.objects.filter(trash=False).first()

                if buying_verification.poultry_code_mandatory:
                    poultry_fullname = kill_request.poultry.unit_name
                    poultry_mobile = kill_request.poultry.user.mobile if not kill_request.direct_buying_intermediary_mobile else kill_request.direct_buying_intermediary_mobile
                    quantity = kill_request.kill_capacity
                    chicken_breed = kill_request.chicken_breed
                    request_kill_house = kill_request.kill_house.name
                    date_str = kill_request.recive_date
                    # clean_date_str = date_str.split('T')[0] + ' ' + date_str.split('T')[1].split('.')[0]

                    # send_date = datetime.strptime(str(date_str), '%Y-%m-%d %H:%M:%S').date()
                    # send_date = jdatetime.datetime.fromgregorian(year=send_date.year, month=send_date.month,
                    #                                              day=send_date.day).strftime('%Y-%m-%d')
                    #
                    # date_list = reversed(send_date.split('-'))
                    # separate = "-"
                    # send_date = separate.join(date_list)

                    if isinstance(date_str, str):
                        clean_date_str = date_str.split('.')[0]
                        clean_date_str = clean_date_str.replace('T', ' ')
                        clean_date_str = clean_date_str.replace('Z', '')

                        send_date = datetime.strptime(clean_date_str, '%Y-%m-%d %H:%M:%S').date()

                    elif isinstance(date_str, datetime):
                        send_date = date_str.date()

                    jalali_date = jdatetime.date.fromgregorian(
                        year=send_date.year,
                        month=send_date.month,
                        day=send_date.day
                    )

                    formatted_jalali = jalali_date.strftime('%Y-%m-%d')

                    date_parts = formatted_jalali.split('-')
                    send_date = '-'.join(reversed(date_parts))

                    confirm_price_poultry_request = threading.Thread(
                        target=confirm_price_poultry_request_direct_buying_sms,
                        args=(
                            poultry_mobile, poultry_fullname,
                            quantity, chicken_breed,
                            send_date,
                            kill_request.free_direct_buying,
                            kill_request.amount, request_kill_house,
                            kill_request.direct_buying_code))
                    confirm_price_poultry_request.start()
                    kill_request.price_confirmation = price_confirmation
                    kill_request.save()
                    return Response({"result": "درخواست شما با موفقیت تایید و ارسال شد."},
                                    status=status.HTTP_201_CREATED)
                else:
                    free_sale_in_province = False if kill_request.free_direct_buying == False else True

                    permission_duirect_buying = AutomaticDirectBuyingPermission.objects.first()

                    if permission_duirect_buying.allow == True and permission_duirect_buying.start_time < \
                            now < permission_duirect_buying.end_time:
                        # kill_request.kill_capacity = int(request.data['quantity'])
                        # kill_request.remain_quantity = int(request.data['quantity'])
                        # kill_request.save()
                        # request.data.pop('quantity')
                        poultry_requests = PoultryRequest.objects.filter(poultry__user=kill_request.poultry.user,
                                                                         trash=False).order_by(
                            'create_date')

                        if kill_request.poultry_hatching:
                            hatching = kill_request.poultry_hatching
                        else:

                            hatching = PoultryHatching.objects.filter(poultry=kill_request.poultry, state='pending',
                                                                      archive=False,
                                                                      allow_hatching='pending', trash=False).order_by(
                                'id').last()
                        # hatching = PoultryHatching.objects.filter(poultry=kill_request.poultry, state='pending',
                        #                                           archive=False,
                        #                                           allow_hatching='pending', trash=False).order_by(
                        #     'left_over').last()

                        poultry = Poultry.objects.get(key=kill_request.poultry.key, trash=False)
                        vet_farm = VetFarm.objects.filter(trash=False, poultry=poultry).first()
                        last_poultry_request = PoultryRequest.objects.all()
                        if last_poultry_request.count() > 0:
                            general_order_code = last_poultry_request.last().general_order_code + 1
                        else:
                            general_order_code = 1

                        if poultry_requests.count() > 0:
                            order_code = poultry_requests.last().order_code + 1
                        else:
                            order_code = int(str(poultry.user.base_order) + '0001')
                        city_operator = CityOperator.objects.filter(unit_name=poultry.city_operator, trash=False).last()
                        if not city_operator:
                            city_operator = CityOperator.objects.filter(unit_name='اتحادیه استان (فاقد تعاونی)',
                                                                        trash=False).last()
                        if hatching.left_over < kill_request.kill_capacity:
                            return Response({"result": "تعداد جوجه در سالن کمتر از تعداد درخواستی است"},
                                            status=status.HTTP_403_FORBIDDEN)

                        if kill_request.kill_house.max_kill_limit and kill_request.kill_house.total_kill_capacity > 0:
                            total_province_kill_requests = ProvinceKillRequest.objects.filter(trash=False,
                                                                                              return_to_province=False,
                                                                                              archive_wage=False,
                                                                                              state__in=(
                                                                                                  'pending',
                                                                                                  'accepted'),
                                                                                              killhouse_user=kill_request.kill_house,
                                                                                              kill_request__recive_date__date=kill_request.recive_date.date())
                            total_province_kill_requests_quantity = \
                                total_province_kill_requests.aggregate(total=Sum('total_killed_quantity'))['total'] or 0
                            if kill_request.kill_house.total_kill_capacity < total_province_kill_requests_quantity + kill_request.kill_capacity:
                                return Response(
                                    {"result": "تعداد وارد شده از مانده سهمیه کشتار روزانه کشتارگاه بیشتر است !"},
                                    status=status.HTTP_403_FORBIDDEN)

                        poultry_request = PoultryRequest(
                            hatching=hatching,
                            order_code=order_code,
                            general_order_code=general_order_code,
                            city_operator=city_operator,
                            poultry=poultry,
                            previous_quantity=kill_request.kill_capacity,
                            remain_quantity=kill_request.kill_capacity,
                            quantity=kill_request.kill_capacity,
                            first_quantity=kill_request.kill_capacity,
                            chicken_breed=hatching.chicken_breed,
                            Index_weight=kill_request.Index_weight,
                            state_process='accepted',
                            province_state='accepted',
                            direct_buying=True,
                            amount=kill_request.amount,
                            free_sale_in_province=free_sale_in_province,
                            send_date=kill_request.recive_date
                        )
                        if kill_request.freezing:
                            poultry_request.freezing = True

                        poultry_request.save()
                        kill_request.poultry_request = poultry_request
                        poultry_prediction(poultry_request.poultry)

                        if kill_request.export_status == True:
                            poultry_request.export = True
                        date_str = poultry_request.send_date
                        if isinstance(date_str, str):
                            # حذف میلی‌ثانیه و کاراکترهای اضافی
                            clean_date_str = date_str.split('.')[0]  # حذف بخش .759000
                            clean_date_str = clean_date_str.replace('T', ' ')  # جایگزینی T با فاصله
                            clean_date_str = clean_date_str.replace('Z', '')  # حذف Z اگر وجود دارد

                            # تبدیل به تاریخ میلادی
                            send_date_datetime = datetime.strptime(clean_date_str, '%Y-%m-%d %H:%M:%S').date()

                        # اگر از قبل شی datetime است
                        elif isinstance(date_str, datetime):
                            send_date_datetime = date_str.date()
                        # send_date_datetime = datetime.strptime(str(send_date_str), '%Y-%m-%dT%H:%M:%S')
                        poultry_request.killing_age = (send_date_datetime - hatching.date.date()).days + 1

                        poultry_request.state = {
                            "city_operator": city_operator.user.fullname,
                            "city_state": poultry_request.state_process,
                            "city_operator_mobile": city_operator.user.mobile,
                            "province_operator": "",
                            "province_state": ""
                        }
                        poultry_request.registrar = {
                            "role": "KillHouse",
                            "fullname": user.fullname,
                            "date": str(poultry_request.create_date)
                        }
                        poultry_request.save()

                        city_operator_check_request = CityOperatorCheckRequest(
                            city_operator_system=poultry_request.city_operator,
                            poultry_request=poultry_request,
                            state='accept',
                            province_accept=True,
                            province_state='accept',
                            allow_hatching=True

                        )
                        city_operator_check_request.save()
                        province_operator = ProvinceOperator.objects.filter(
                            user=SystemUserProfile.objects.get(role__name='ProvinceOperator', province=user.province))

                        if province_operator.count() > 0:
                            province_operator = province_operator.last()

                        check = ProvinceCheckOperatorRequest(
                            province_operator_system=province_operator,
                            poultry_request=poultry_request,
                            city_request_Poultry=city_operator_check_request,
                            quantity=poultry_request.quantity,

                            state='accept',
                        )
                        check.save()
                        wage_type = WageType.objects.filter(en_name='province-kill-request', trash=False).first()
                        wage = wage_type.amount if wage_type.status == True else 0
                        percentages_wage_type = PercentageOfWageType.objects.filter(wage_type=wage_type, percent__gt=0,
                                                                                    trash=False)
                        province_killrequest = ProvinceKillRequest(
                            killhouse_user=kill_request.kill_house,
                            kill_request=kill_request,
                            province_request=check,
                            quantity=kill_request.kill_capacity,
                            total_killed_quantity=kill_request.kill_capacity,
                            total_killed_weight=int(kill_request.kill_capacity * poultry_request.Index_weight),
                            main_quantity=kill_request.kill_capacity,
                            wage=wage,
                            direct_buying=True,
                            total_wage_amount=wage * int(kill_request.kill_capacity * poultry_request.Index_weight),
                        )
                        province_killrequest.save()
                        # fine = FinePermission.objects.filter(trash=False).first()
                        # time_for_fine = datetime.now()
                        # time_for_fine = time_for_fine.replace(second=0, microsecond=0).time()
                        # if fine.direct_buying:
                        #     if fine.direct_buying_start_time < time_for_fine < fine.direct_buying_end_time:
                        #         province_killrequest.direct_buying_fine = True
                        #         province_killrequest.direct_buying_fine_amount = (
                        #                                                                  fine.direct_buying_fine_coefficient - 1) * province_killrequest.total_wage_amount if fine.direct_buying_fine_coefficient > 1 else province_killrequest.total_wage_amount
                        #         province_killrequest.direct_buying_fine_coefficient = fine.direct_buying_fine_coefficient
                        if wage_type and wage_type.status == True and percentages_wage_type:
                            for percentage_wage_type in percentages_wage_type:
                                if percentage_wage_type.share_type.en_name == 'union':
                                    province_killrequest.union_share = int(
                                        (percentage_wage_type.percent / 100) * province_killrequest.total_wage_amount)
                                    province_killrequest.union_share_percent = percentage_wage_type.percent

                                elif percentage_wage_type.share_type.en_name == 'company':
                                    province_killrequest.company_share = int(
                                        (percentage_wage_type.percent / 100) * province_killrequest.total_wage_amount)
                                    province_killrequest.company_share_percent = percentage_wage_type.percent

                                elif percentage_wage_type.share_type.en_name == 'guilds':
                                    province_killrequest.guilds_share = int(
                                        (percentage_wage_type.percent / 100) * province_killrequest.total_wage_amount)
                                    province_killrequest.guilds_share_percent = percentage_wage_type.percent

                                elif percentage_wage_type.share_type.en_name == 'city':
                                    province_killrequest.city_share = int(
                                        (percentage_wage_type.percent / 100) * province_killrequest.total_wage_amount)
                                    province_killrequest.city_share_percent = percentage_wage_type.percent

                                elif percentage_wage_type.share_type.en_name == 'other':
                                    province_killrequest.other_share = int(
                                        (percentage_wage_type.percent / 100) * province_killrequest.total_wage_amount)
                                    province_killrequest.other_share_percent = percentage_wage_type.percent

                                elif percentage_wage_type.share_type.en_name == 'wallet':
                                    province_killrequest.wallet_share = int(
                                        (percentage_wage_type.percent / 100) * province_killrequest.total_wage_amount)
                                    province_killrequest.wallet_share_percent = percentage_wage_type.percent

                                else:
                                    province_killrequest.other_share = int(
                                        (percentage_wage_type.percent / 100) * province_killrequest.total_wage_amount)
                                    province_killrequest.other_share_percent = percentage_wage_type.percent
                                province_killrequest.save()

                        tomorrow = datetime.now().date() + timedelta(days=1)
                        if not KillHouseWareHouse.objects.filter(kill_house=kill_request.kill_house,
                                                                 date__date=tomorrow).exists():
                            ware_house_date = datetime(year=tomorrow.year, month=tomorrow.month, day=tomorrow.day,
                                                       hour=1,
                                                       minute=12, second=20)
                            kill_house_ware_house = KillHouseWareHouse(
                                kill_house=kill_request.kill_house,
                                date=ware_house_date
                            )
                            kill_house_ware_house.save()
                        kill_house_check = KillHouseCheckRequest(
                            province_kill_request=province_killrequest,
                            state='accepted'
                        )

                        kill_house_check.save()
                        province_killrequest.state = 'accepted'
                        if kill_request.payment_deadline:
                            province_killrequest.payment_deadline = True
                            province_killrequest.payment_deadline_date = kill_request.payment_deadline_date
                        province_killrequest.save()
                        check.quantity = 0
                        check.save()

                        if poultry_request.export == True:
                            hatching.export_killed_weight += int(
                                kill_request.kill_capacity * poultry_request.Index_weight)
                            hatching.export_killed_quantity += kill_request.kill_capacity


                        elif poultry_request.free_sale_in_province == True:
                            hatching.free_killed_quantity += int(
                                kill_request.kill_capacity * poultry_request.Index_weight)
                            hatching.free_quantity += kill_request.kill_capacity

                        else:
                            hatching.governmental_killed_quantity += int(
                                kill_request.kill_capacity * poultry_request.Index_weight)
                            hatching.governmental_quantity += kill_request.kill_capacity
                        hatching.killed_quantity += kill_request.kill_capacity
                        hatching.save()
                        poultry_request.remain_quantity = 0
                        poultry_request.direct_buying_kill_place = kill_request.kill_house.name
                        poultry_request.direct_buying_buyer_info = {
                            "buyer_fullname": kill_request.kill_house.kill_house_operator.user.fullname,
                            "buyer_mobile": kill_request.kill_house.kill_house_operator.user.mobile,
                        }
                        poultry_request.save()
                        if kill_request.export_status == True:
                            kill_request.export_state = 'accepted'
                            kill_request.direct_buying_message = request.data['direct_buying_message']

                        else:
                            kill_request.direct_buying_state = 'accepted'

                        kill_request.accept_reject_date = datetime.now()
                        kill_request.automatic_accept = True

                        kill_request.save()
                        poultry_fullname = poultry.unit_name
                        poultry_mobile = poultry.user.mobile if not kill_request.direct_buying_intermediary_mobile else kill_request.direct_buying_intermediary_mobile
                        quantity = kill_request.kill_capacity
                        chicken_breed = kill_request.chicken_breed
                        request_kill_house = kill_request.kill_house.name
                        date_str = kill_request.recive_date
                        if isinstance(date_str, str):
                            clean_date_str = date_str.split('T')[0] + ' ' + date_str.split('T')[1].split('.')[0]
                        else:
                            clean_date_str = date_str.strftime('%Y-%m-%d %H:%M:%S')
                        send_date = datetime.strptime(str(clean_date_str), '%Y-%m-%d %H:%M:%S').date()
                        send_date = jdatetime.datetime.fromgregorian(year=send_date.year, month=send_date.month,
                                                                     day=send_date.day).strftime('%Y-%m-%d')
                        date_list = reversed(send_date.split('-'))
                        separate = "-"
                        code = "-"
                        send_date = separate.join(date_list)
                        confirm_price_poultry_request = threading.Thread(
                            target=confirm_price_poultry_request_direct_buying_sms,
                            args=(
                                poultry_mobile, poultry_fullname,
                                quantity, chicken_breed,
                                send_date,
                                kill_request.free_direct_buying,
                                kill_request.amount, request_kill_house,
                                code))
                        confirm_price_poultry_request.start()

                        bot_eitaa_for_each_province_kill_request(province_killrequest, vet_farm)
                        return Response({"result": "درخواست شما با موفقیت تایید و ارسال شد."},
                                        status=status.HTTP_201_CREATED)



                    else:
                        poultry = Poultry.objects.get(key=kill_request.poultry.key, trash=False)
                        poultry_fullname = poultry.unit_name
                        poultry_mobile = poultry.user.mobile if not kill_request.direct_buying_intermediary_mobile else kill_request.direct_buying_intermediary_mobile
                        quantity = kill_request.kill_capacity
                        chicken_breed = kill_request.chicken_breed
                        request_kill_house = kill_request.kill_house.name
                        date_str = kill_request.recive_date
                        if isinstance(date_str, str):
                            clean_date_str = date_str.split('T')[0] + ' ' + date_str.split('T')[1].split('.')[0]
                        else:
                            clean_date_str = date_str.strftime('%Y-%m-%d %H:%M:%S')
                        send_date = datetime.strptime(str(clean_date_str), '%Y-%m-%d %H:%M:%S').date()
                        send_date = jdatetime.datetime.fromgregorian(year=send_date.year, month=send_date.month,
                                                                     day=send_date.day).strftime('%Y-%m-%d')
                        date_list = reversed(send_date.split('-'))
                        separate = "-"
                        code = "-"
                        send_date = separate.join(date_list)
                        confirm_price_poultry_request = threading.Thread(
                            target=confirm_price_poultry_request_direct_buying_sms,
                            args=(
                                poultry_mobile, poultry_fullname,
                                quantity, chicken_breed,
                                send_date,
                                kill_request.free_direct_buying,
                                kill_request.amount, request_kill_house,
                                code))
                        confirm_price_poultry_request.start()
                        kill_request.save()
                        return Response({"result": "درخواست شما با موفقیت تایید و ارسال شد."},
                                        status=status.HTTP_201_CREATED)
            kill_request.save()
            serializer = self.serializer_class(data=request.data)
            if serializer.is_valid():
                serializer.update(instance=kill_request, validated_data=request.data)
                return Response({"result": "با موفقیت ویرایش شد"}, status=status.HTTP_200_OK)
            else:
                return Response({"result": "در ثبت مقادیر مشکلی به وجود آمده است !"}, status=status.HTTP_403_FORBIDDEN)

        if 'previous_requests' in request.data.keys():
            now = datetime.now().date()
            user = SystemUserProfile.objects.get(user=request.user)
            querysets_list = KillRequest.objects.filter(
                kill_house__system_address__province=user.province,
                trash=False, remain_quantity__gt=0).order_by('-recive_date')
            for queryset in querysets_list:
                if (now - queryset.recive_date.date()).days > 2:
                    queryset.remain_quantity = 0
                    queryset.save()
            return Response({"result": "با موفقیت ثبت شد"},
                            status=status.HTTP_200_OK)

        province_kill_request_quantity = 0
        kill_request = KillRequest.objects.get(key=request.data["kill_request_key"], trash=False)
        request.data.pop('kill_request_key')
        quantity = int(request.data['quantity'])
        request.data.pop('quantity')
        province_kill_requests = ProvinceKillRequest.objects.filter(kill_request=kill_request, trash=False)
        if province_kill_requests.count() > 0:

            for province_kill_request in province_kill_requests:
                province_kill_request_quantity += province_kill_request.main_quantity
            if quantity < province_kill_request_quantity:
                return Response({"result": "تعداد وارد شده از تعداد تخصیص  داده شده کمتر است "},
                                status=status.HTTP_403_FORBIDDEN)
            if int(quantity) < kill_request.kill_capacity:
                kill_request.remain_quantity -= kill_request.kill_capacity - int(quantity)
            else:
                kill_request.remain_quantity += int(quantity) - kill_request.kill_capacity
        else:
            kill_request.remain_quantity = int(quantity)

        kill_request.kill_capacity = int(quantity)
        kill_request.save()
        serializer = self.serializer_class(kill_request)
        serializer.update(instance=kill_request, validated_data=request.data)
        return Response(serializer.data, status=status.HTTP_200_OK)


class KillRequestFactorViewSet(viewsets.ModelViewSet):
    queryset = KillRequestFactor.objects.all()
    serializer_class = KillRequestFactorSerializer
    permission_classes = [TokenHasReadWriteScope]

    def list(self, request, *args, **kwargs):
        now = datetime.now().date()
        date1 = datetime.strptime(str(request.GET['date1']),
                                  '%Y-%m-%d').date() if 'date1' in request.GET else now
        date2 = datetime.strptime(str(request.GET['date2']),
                                  '%Y-%m-%d').date() if 'date2' in request.GET else now
        user_profile = SystemUserProfile.objects.get(user=request.user, trash=False)
        kill_house_user = get_object_or_404(KillHouseOperator, user=user_profile)
        kill_house = KillHouse.objects.filter(kill_house_operator=kill_house_user)

        factor_list = KillRequestFactor.objects.filter(kill_request__kill_house__in=kill_house, trash=False).order_by(
            'id')
        factors = [
            kill_request_factor for kill_request_factor in factor_list
            if date1 <= kill_request_factor.kill_request.recive_date.date() <= date2
        ]
        serializer = KillRequestFactorSerializer(factors, many=True)
        return Response(serializer.data, status=status.HTTP_200_OK)

    def update(self, request, pk=None, *args, **kwargs):
        # refresh(request.user.id)
        if 'state' in request.data:
            if request.data['state'] == 'cancel':
                factor = KillRequestFactor.objects.get(key=request.data['factor_key'], trash=False)
                kill_request = KillRequest.objects.get(key=factor.kill_request.key)
                kill_request.trash = True
                kill_request.save()
                factor.trash = True
                factor.save()
            return Response({"result": "done!"}, status=status.HTTP_200_OK)


class KillRequestFactorPaymentViewSet(viewsets.ModelViewSet):
    queryset = KillRequestFactorPayment.objects.all()
    serializer_class = KillRequestFactorPaymentSerializer
    permission_classes = [TokenHasReadWriteScope]

    def create(self, request, *args, **kwargs):
        user = SystemUserProfile.objects.get(user=request.user, trash=False)
        factor = KillRequestFactor.objects.get(key=request.data['factor_key'], trash=False)
        kill_request = KillRequest.objects.get(key=factor.kill_request.key)
        kill_house = KillHouse.objects.get(key=kill_request.kill_house.key)
        request.data.pop('factor_key')
        image = request.data['image']
        request.data.pop('image')
        serializer = self.serializer_class(data=request.data)
        if serializer.is_valid():
            factor_payment = serializer.create(validated_data=request.data)
            factor_payment.kill_request_factor = factor
            factor_payment.image = send_image_to_server(image)
            factor_payment.remain_amount = float(request.data['amount'])
            factor_payment.state = 'paid'
            factor_payment.save()
            factor.state = 'paid'
            factor.save()
            kill_request.payment_info = {
                "amount": factor_payment.amount,
                "total_amount": factor.amount,
                "image": factor_payment.image,
                "date": str(factor_payment.create_date)
            }
            kill_request.factor_deposit = factor_payment.amount
            kill_request.save()
            kill_house.wallet_amount += factor_payment.amount
            kill_house.save()

            serializer_request = self.serializer_class(factor_payment)
            return Response(serializer_request.data, status=status.HTTP_201_CREATED)
        return Response(serializer.errors)


def update_province_kill_request():
    wage = ShareOfAllocation.objects.all().last()
    wage = wage.province_union if wage else 0
    for province_kill_request in ProvinceKillRequest.objects.all():
        province_request = ProvinceCheckOperatorRequest.objects.filter(
            key=province_kill_request.province_request.key).last()
        province_kill_request.total_amount = wage * (
                province_kill_request.main_quantity * province_request.poultry_request.Index_weight)
        province_kill_request.save()


from django.db import models, transaction
from django.db.models import Sum, Count, F


# ... (previous code)

class ReportingProvinceKillRequestsWageViewSet(viewsets.ModelViewSet):
    queryset = ProvinceKillRequest.objects.all()
    serializer_class = ProvinceKillRequestSerializer
    permission_classes = [TokenHasReadWriteScope]

    def list(self, request, *args, **kwargs):
        province_kill_requests = ProvinceKillRequest.objects.filter(
            trash=False, return_to_province=False, state__in=('accepted', 'pending')
        ).annotate(
            total_quantity=Sum('total_killed_quantity'),
            total_weight=Sum('total_killed_weight'),
            total_amount_wage=Sum(
                F('wage') * F('total_killed_weight')),
            total_paid=Count('id', filter=models.Q(wage_pay=True, archive_by_province=False)),
            total_unpaid=Count('id', filter=models.Q(wage_pay=False, archive_by_province=False)),
            total_archive=Count('id', filter=models.Q(wage_pay=False, archive_by_province=True)),
            # total_kill_houses=Count('kill_request__kill_house', distinct=True)
        )

        total_requests_buyers = province_kill_requests.values('kill_request__kill_house').distinct().count()
        total_requests = province_kill_requests.count()
        total_requests_quantity = province_kill_requests.aggregate(total=Sum('total_quantity'))['total']
        total_requests_weight = province_kill_requests.aggregate(total=Sum('total_weight'))['total']
        total_requests_amount = province_kill_requests.aggregate(total=Sum('total_amount_wage'))['total']
        total_paid_requests = province_kill_requests.aggregate(total=Sum('total_paid'))['total']
        total_paid_requests_quantity = \
            province_kill_requests.filter(wage_pay=True).aggregate(total=Sum('total_quantity'))['total']
        total_paid_requests_weight = province_kill_requests.filter(wage_pay=True).aggregate(total=Sum('total_weight'))[
            'total']
        total_paid_requests_amount = \
            province_kill_requests.filter(wage_pay=True).aggregate(total=Sum('total_amount_wage'))['total']
        total_unpaid_requests = province_kill_requests.aggregate(total=Sum('total_unpaid'))['total']
        total_unpaid_requests_quantity = \
            province_kill_requests.filter(wage_pay=False, archive_by_province=False).aggregate(
                total=Sum('total_quantity'))['total']
        total_unpaid_requests_weight = \
            province_kill_requests.filter(wage_pay=False, archive_by_province=False).aggregate(
                total=Sum('total_weight'))['total']
        total_unpaid_requests_amount = \
            province_kill_requests.filter(wage_pay=False, archive_by_province=False).aggregate(
                total=Sum('total_amount_wage'))['total']

        total_archive_requests = province_kill_requests.aggregate(total=Sum('total_archive'))['total']
        total_archive_requests_quantity = \
            province_kill_requests.filter(wage_pay=False, archive_by_province=True).aggregate(
                total=Sum('total_quantity'))['total']
        total_archive_requests_weight = \
            province_kill_requests.filter(wage_pay=False, archive_by_province=True).aggregate(
                total=Sum('total_weight'))['total']
        total_archive_requests_amount = \
            province_kill_requests.filter(wage_pay=False, archive_by_province=True).aggregate(
                total=Sum('total_amount_wage'))['total']
        total_free_request = province_kill_requests.filter(
            province_request__poultry_request__free_sale_in_province=True)
        total_free_request_quantity = total_free_request.aggregate(total=Sum('total_quantity'))['total']
        total_free_request_weight = total_free_request.aggregate(total=Sum('total_weight'))['total']

        total_government_request = province_kill_requests.filter(
            province_request__poultry_request__free_sale_in_province=False)
        total_government_request_quantity = total_government_request.aggregate(total=Sum('total_quantity'))['total']
        total_government_request_weight = total_government_request.aggregate(total=Sum('total_weight'))['total']

        return Response({
            "total_requests_buyers": total_requests_buyers,
            "total_requests": total_requests,
            "total_requests_quantity": total_requests_quantity,
            "total_requests_weight": total_requests_weight,
            "total_requests_amount": total_requests_amount,
            "total_paid_requests": total_paid_requests,
            "total_paid_requests_quantity": total_paid_requests_quantity if total_paid_requests_quantity != None else 0,
            "total_paid_requests_weight": total_paid_requests_weight if total_paid_requests_weight != None else 0,
            "total_paid_requests_amount": total_paid_requests_amount if total_paid_requests_amount != None else 0,
            "total_unpaid_requests": total_unpaid_requests,
            "total_unpaid_requests_quantity": total_unpaid_requests_quantity,
            "total_unpaid_requests_weight": total_unpaid_requests_weight,
            "total_unpaid_requests_amount": total_unpaid_requests_amount,
            "total_archive_requests": total_archive_requests,
            "total_archive_requests_quantity": total_archive_requests_quantity,
            "total_archive_requests_weight": total_archive_requests_weight,
            "total_archive_requests_amount": total_archive_requests_amount,
            "total_free_request": len(total_free_request),
            "total_free_request_quantity": total_free_request_quantity,
            "total_free_request_weight": total_free_request_weight,
            "total_government_request": len(total_government_request),
            "total_government_request_quantity": total_government_request_quantity,
            "total_government_request_weight": total_government_request_weight,

        }, status=status.HTTP_200_OK)


def provincearchiveprovincekillrequestforwage(province_kill_request_list, message, role, user_fullname, date):
    province_kill_requests = ProvinceKillRequest.objects.filter(key__in=province_kill_request_list,
                                                                trash=False)
    for province_kill_request in province_kill_requests:
        province_kill_request.archive_by_province = True
        province_kill_request.archive_message = message
        province_kill_request.archiver = {
            "role": role,
            "fullname": user_fullname,
            "date": date,
        }
        province_kill_request.save()


# class ReportingProvinceKillRequestsWageViewSet(viewsets.ModelViewSet):
#     queryset = ProvinceKillRequest.objects.all()
#     serializer_class = ProvinceKillRequestSerializer
#     permission_classes = [TokenHasReadWriteScope]
#
#     def list(self, request, *args, **kwargs):
#         total_requests_buyers = 0
#         total_requests = 0
#         total_requests_quantity = 0
#         total_requests_weight = 0
#         total_requests_amount = 0
#         total_paid_requests = 0
#         total_paid_requests_quantity = 0
#         total_paid_requests_weight = 0
#         total_paid_requests_amount = 0
#         total_unpaid_requests = 0
#         total_unpaid_requests_quantity = 0
#         total_unpaid_requests_weight = 0
#         total_unpaid_requests_amount = 0
#         province_kill_requests = ProvinceKillRequest.objects.filter(trash=False, state__in=('accepted', 'pending'))
#         for province_kill_request in province_kill_requests:
#             if province_kill_request.wage_pay == True:
#                 total_paid_requests +=1
#                 total_paid_requests_quantity += province_kill_request.main_quantity
#                 total_paid_requests_weight += int(province_kill_request.main_quantity * province_kill_request.province_request.poultry_request.Index_weight)
#                 total_paid_requests_amount += int(province_kill_request.wage * (province_kill_request.main_quantity * province_kill_request.province_request.poultry_request.Index_weight))
#             else:
#
#                 total_unpaid_requests +=1
#                 total_unpaid_requests_quantity += province_kill_request.main_quantity
#                 total_unpaid_requests_weight += int(province_kill_request.main_quantity * province_kill_request.province_request.poultry_request.Index_weight)
#                 total_unpaid_requests_amount += int(province_kill_request.wage * (province_kill_request.main_quantity * province_kill_request.province_request.poultry_request.Index_weight))
#
#         total_requests_buyers = len(province_kill_requests)
#         total_requests = total_paid_requests + total_unpaid_requests
#         total_requests_quantity = total_paid_requests_quantity + total_unpaid_requests_quantity
#         total_requests_weight = total_paid_requests_weight + total_unpaid_requests_weight
#         total_requests_amount = total_paid_requests_amount + total_unpaid_requests_amount
#
#
#         return Response({
#
#             "total_requests_buyers":total_requests_buyers,
#             "total_requests":total_requests,
#             "total_requests_quantity" :total_requests_quantity,
#             "total_requests_weight":total_requests_weight,
#             "total_requests_amount":total_requests_amount,
#             "total_paid_requests":total_paid_requests,
#             "total_paid_requests_quantity":total_paid_requests_quantity,
#             "total_paid_requests_weight":total_paid_requests_weight,
#             "total_paid_requests_amount":total_paid_requests_amount,
#             "total_unpaid_requests":total_unpaid_requests,
#             "total_unpaid_requests_quantity":total_unpaid_requests_quantity,
#             "total_unpaid_requests_weight":total_unpaid_requests_weight,
#             "total_unpaid_requests_amount":total_unpaid_requests_amount,
#          },status=status.HTTP_200_OK
#       )


# def auto_steward_allocation(kill_house_key, quantity, weight, date):
#     kill_house = KillHouse.objects.get(key=kill_house_key, trash=False)
#     stewards = Steward.objects.filter(guilds__steward=True, trash=False).order_by('id')
#     stewards_list = []
#     allocatated_quantity = 0
#     kill_house_total_quantity = 0
#     for steward in stewards:
#         if steward.centers_allocation != None:
#             for center_allocation in steward.centers_allocation:
#                 if str(kill_house.key) == center_allocation['value']:
#                     kill_house_total_quantity += steward.allocation_limit
#                     stewards_list.append(steward)
#     if len(stewards_list) > 0:
#         for steward_list in stewards_list:
#             allocatated_quantity = (steward_list.allocation_limit / kill_house_total_quantity) * quantity
#             auto_allocation = StewardAllocation(
#                 kill_house=kill_house,
#                 steward=steward_list,
#                 number_of_carcasses=allocatated_quantity,
#                 real_number_of_carcasses=allocatated_quantity,
#                 weight_of_carcasses=int(allocatated_quantity * weight),
#                 real_weight_of_carcasses=int(allocatated_quantity * weight),
#                 type='auto',
#                 date=date
#             )
#             auto_allocation.save()
class WalletWagePaymentViewSet(viewsets.ModelViewSet):
    queryset = ProvinceKillRequest.objects.all()
    serializer_class = ProvinceKillRequestSerializer
    permission_classes = [TokenHasReadWriteScope]

    # def update(self, request, *args, **kwargs):
    #     user = SystemUserProfile.objects.get(user=request.user, trash=False)
    #     province_kill_request_keys = []
    #     for province_kill_request_key in request.data['province_kill_requests']:
    #         province_kill_request_keys.append(province_kill_request_key)
    #     province_kill_requests = ProvinceKillRequest.objects.filter(
    #         key__in=province_kill_request_keys).order_by('id')
    #     kill_house = KillHouse.objects.get(key=province_kill_requests.last().killhouse_user.key, trash=False)
    #     now = datetime.now()
    #     total_amount = 0
    #
    #     for province_kill_request in province_kill_requests:
    #         province_kill_request.wage_pay = True
    #         province_kill_request.wallet_pay = True
    #         province_kill_request.depositor = {
    #             "role": request.data['role'],
    #             "payer": user.fullname,
    #             "date": str(now),
    #             "payment_type": 'wallet',
    #             "tracking_code": '-',
    #             "refId": '-',
    #             "orderId": '-',
    #             "total_amount": province_kill_request.total_killed_weight * province_kill_request.wage
    #         }
    #         province_kill_request.save()
    #         total_amount += province_kill_request.total_killed_weight * province_kill_request.wage
    #     transaction = ExternalTransaction(
    #         amount=total_amount,
    #         type="withdraw",
    #         transaction_type="wallet",
    #         status='completed',
    #         kill_house_user=kill_house.kill_house_operator.user,
    #         creator=user,
    #         receiver=user,
    #         creator_role='KillHouse',
    #         receiver_role='ProvinceOperator',
    #         payer=kill_house.kill_house_operator.user.fullname,
    #
    #     )
    #     transaction.save()
    #
    #     return Response({"result": "با موفقیت انجام شد!"}, status=status.HTTP_200_OK)


# ویوست مربوط به تخصیص به کشتارگاه توسط استان
class ProvinceKillRequestViewSet(viewsets.ModelViewSet):
    queryset = ProvinceKillRequest.objects.all()
    serializer_class = ProvinceKillRequestSerializer
    permission_classes = [TokenHasReadWriteScope]
    filterset_class = ProvinceKillRequestNewFilterSet

    # تابع مربوط به تخصیص به کشتارگاه توسط استان
    def create(self, request, *args, **kwargs):
        wage = 0
        province_check = ProvinceCheckOperatorRequest.objects.get(key=request.data['province_check_request_key'],
                                                                  trash=False)
        if province_check.poultry_request.price_confirmation and not province_check.poultry_request.input_price_confirmation_code:
            return Response({"result": "به علت عدم ورود کد احراز مرغدار امکان تخصیص وجود ندارد!"},
                            status=status.HTTP_403_FORBIDDEN)

        if province_check.poultry_request.freezing == True:
            wage_type = WageType.objects.filter(en_name='province-kill-request-freezing', trash=False).first()
        else:

            wage_type = WageType.objects.filter(en_name='province-kill-request', trash=False).first()
        if wage_type.status == True:
            wage = wage_type.amount
        time_range = TimeRange.objects.filter(trash=False).first()
        if time_range:
            time = next(
                (t for t in time_range.time_range if
                 t.get("name") == "province_kill_request" and t.get("active", False)), None)
            if time:
                start_hour = datetime.strptime(time.get("start", 0), "%H:%M:%S").time()
                end_hour = datetime.strptime(time.get("end", 0), "%H:%M:%S").time()
                current_hour = datetime.now().time().replace(second=0, microsecond=0)
                if not (start_hour < current_hour < end_hour):
                    return Response(
                        {"result": "لطفا در ساعات مجاز برای ثبت درخواست اقدام نمایید!"},
                        status=status.HTTP_403_FORBIDDEN)
        now = datetime.now().date()
        kill_request = KillRequest.objects.get(key=request.data['kill_request_key'], trash=False)
        if OperationLimitation.objects.all().first().province_allocation_limitation == True:

            if now != kill_request.recive_date.date():
                return Response({"result": "مغایرت در تاریخ اعلام نیاز کشتار گاه و تاریخ تخصیص به کشتارگاه !"},
                                status=status.HTTP_403_FORBIDDEN)
        kill_house = KillHouse.objects.get(id=kill_request.kill_house.id, trash=False)
        poultry_request = PoultryRequest.objects.get(key=province_check.poultry_request.key)
        hatching = PoultryHatching.objects.get(key=poultry_request.hatching.key)
        if hatching.left_over < int(request.data['quantity']):
            return Response({"result": "تعداد تخصیص داده شده کمتر از تعداد موجود در سالن مرغدار است!"},
                            status=status.HTTP_403_FORBIDDEN)

        request.data.pop('kill_request_key')
        request.data.pop('province_check_request_key')
        if poultry_request.send_date.year != kill_request.recive_date.year or poultry_request.send_date.month != kill_request.recive_date.month or poultry_request.send_date.day != kill_request.recive_date.day:
            return Response({"result": "تاریخ درخواست کشتارها یکی نیست!"}, status=status.HTTP_403_FORBIDDEN)
        if province_check.quantity == 0:
            return Response("forbidden", status=status.HTTP_403_FORBIDDEN)
        if int(request.data['quantity']) > kill_request.remain_quantity:
            return Response({"result": "تعداد وارد شده از مانده سهمیه بیشتر است !"}, status=status.HTTP_403_FORBIDDEN)
        if kill_house.max_kill_limit and kill_house.total_kill_capacity > 0:
            total_province_kill_requests = ProvinceKillRequest.objects.filter(trash=False, return_to_province=False,
                                                                              archive_wage=False,
                                                                              state__in=('pending', 'accepted'),
                                                                              killhouse_user=kill_house,
                                                                              kill_request__recive_date__date=kill_request.recive_date.date())
            total_province_kill_requests_quantity = \
                total_province_kill_requests.aggregate(total=Sum('total_killed_quantity'))['total'] or 0

            if kill_house.total_kill_capacity < total_province_kill_requests_quantity + int(request.data['quantity']):
                return Response({"result": "تعداد وارد شده از مانده سهمیه کشتار روزانه کشتارگاه بیشتر است !"},
                                status=status.HTTP_403_FORBIDDEN)

        if poultry_request.free_sale_in_province == True:

            if kill_house.quota:
                kill_house_info = calculate_governmental_quota(kill_house)
                if kill_house_info == 'not_allowed':
                    return Response({"result": " امکان خرید آزاد تا تکمیل تعهد دولتی وجود ندارد!"},
                                    status=status.HTTP_403_FORBIDDEN)

        if kill_house.ware_house_remaining_weight_limitation_status:
            if kill_house.total_remain_warehouse_governmental_weight > kill_house.ware_house_remaining_weight_limitation:
                return Response({
                    "result": "باقی مانده انبار شما از حداکثر محدودیت وزن باقی مانده انبار بیشتر است !"},
                    status=status.HTTP_403_FORBIDDEN)

        if kill_house.ware_house_remaining_percent_limitation_status:
            if not check_kill_house_remain_limitation_weight(kill_house):
                return Response({
                    "result": "باقی مانده انبار شما از حداکثر محدودیت وزن باقی مانده روزانه انبار بیشتر است !"},
                    status=status.HTTP_403_FORBIDDEN)

        province_kills = ProvinceKillRequest.objects.filter(killhouse_user=kill_house,
                                                            province_request__city_request_Poultry__poultry_request_id=province_check.city_request_Poultry.poultry_request.id,
                                                            state__in=('pending', 'accepted'), trash=False)
        if province_kills.count() > 0:
            province = province_kills.last()

            if province.main_quantity == province.quantity:
                province.total_killed_quantity += int(request.data['quantity'])
                province.total_killed_weight += int(int(request.data['quantity']) * poultry_request.Index_weight)
            province.quantity += int(request.data['quantity'])
            province.main_quantity += int(request.data['quantity'])
            kill_request.remain_quantity = kill_request.remain_quantity - int(request.data['quantity'])
            kill_request.save()
            province.save()
            province_check.quantity -= int(request.data['quantity'])
            province_check.save()
            poultry_request.remain_quantity -= int(request.data['quantity'])
            poultry_request.save()
            if poultry_request.export == True:
                hatching.export_killed_weight += int(int(request.data['quantity']) * poultry_request.Index_weight)
                hatching.export_killed_quantity += int(request.data['quantity'])
            elif poultry_request.free_sale_in_province == True:
                hatching.free_killed_quantity += int(int(request.data['quantity']) * poultry_request.Index_weight)
                hatching.free_quantity += int(request.data['quantity'])
            else:
                hatching.governmental_killed_quantity += int(
                    int(request.data['quantity']) * poultry_request.Index_weight)

                hatching.governmental_quantity += int(request.data['quantity'])
            hatching.save()
            tomorrow = now + timedelta(days=1)
            if not KillHouseWareHouse.objects.filter(kill_house=kill_house, date__date=tomorrow).exists():
                ware_house_date = datetime(year=tomorrow.year, month=tomorrow.month, day=tomorrow.day, hour=1,
                                           minute=12, second=20)
                kill_house_ware_house = KillHouseWareHouse(
                    kill_house=kill_house,
                    date=ware_house_date
                )
                kill_house_ware_house.save()
            province.total_wage_amount = province.total_killed_weight * province.wage
            province.save()
            percentages_wage_type = PercentageOfWageType.objects.filter(wage_type=wage_type, percent__gt=0, trash=False)

            if wage_type and wage_type.status == True and percentages_wage_type:
                for percentage_wage_type in percentages_wage_type:
                    if percentage_wage_type.share_type.en_name == 'union':
                        province.union_share = int((percentage_wage_type.percent / 100) * province.total_wage_amount)
                        province.union_share_percent = percentage_wage_type.percent
                        province.save()
                    elif percentage_wage_type.share_type.en_name == 'company':
                        province.company_share = int((percentage_wage_type.percent / 100) * province.total_wage_amount)
                        province.company_share_percent = percentage_wage_type.percent
                        province.save()

                    elif percentage_wage_type.share_type.en_name == 'guilds':
                        province.guilds_share = int((percentage_wage_type.percent / 100) * province.total_wage_amount)
                        province.guilds_share_percent = percentage_wage_type.percent
                        province.save()
                    elif percentage_wage_type.share_type.en_name == 'city':
                        province.city_share = int((percentage_wage_type.percent / 100) * province.total_wage_amount)
                        province.city_share_percent = percentage_wage_type.percent
                        province.save()

                    elif percentage_wage_type.share_type.en_name == 'wallet':
                        province.wallet_share = int((percentage_wage_type.percent / 100) * province.total_wage_amount)
                        province.wallet_share_percent = percentage_wage_type.percent
                        province.save()

                    elif percentage_wage_type.share_type.en_name == 'other':
                        province.other_share = int((percentage_wage_type.percent / 100) * province.total_wage_amount)
                        province.other_share_percent = percentage_wage_type.percent
                        province.save()

                    else:
                        province.other_share = int((percentage_wage_type.percent / 100) * province.total_wage_amount)
                        province.other_share_percent = percentage_wage_type.percent
                        province.save()

            return Response({"result": "object create"}, status=status.HTTP_201_CREATED)

        serializer = self.serializer_class(data=request.data)

        if serializer.is_valid():
            province_kill_request_list = []
            if hatching.left_over < int(request.data['quantity']):
                return Response({"result": "تعداد تخصیص داده شده بیشتر از تعداد موجود در سالن مرغدار است!"},
                                status=status.HTTP_403_FORBIDDEN)
            province_kill_request = serializer.create(validated_data=request.data)
            province_kill_request.kill_request = kill_request
            province_kill_request.province_request = province_check
            province_kill_request.wage = wage
            province_kill_request.state = "pending"
            if province_check.quantity < int(request.data['quantity']):
                province_kill_request.quantity = province_check.quantity
            province_kill_request.killhouse_user = kill_house
            province_kill_request.main_quantity = int(request.data['quantity'])
            province_kill_request.total_killed_quantity = province_kill_request.main_quantity
            province_kill_request.total_killed_weight = int(
                province_kill_request.main_quantity * poultry_request.Index_weight)
            province_kill_request.total_wage_amount = province_kill_request.total_killed_weight * province_kill_request.wage
            percentages_wage_type = PercentageOfWageType.objects.filter(wage_type=wage_type, percent__gt=0, trash=False)
            if wage_type and wage_type.status == True and percentages_wage_type:
                for percentage_wage_type in percentages_wage_type:
                    if percentage_wage_type.share_type.en_name == 'union':
                        province_kill_request.union_share = int(
                            (percentage_wage_type.percent / 100) * province_kill_request.total_wage_amount)
                        province_kill_request.union_share_percent = percentage_wage_type.percent
                    elif percentage_wage_type.share_type.en_name == 'company':
                        province_kill_request.company_share = int(
                            (percentage_wage_type.percent / 100) * province_kill_request.total_wage_amount)
                        province_kill_request.company_share_percent = percentage_wage_type.percent

                    elif percentage_wage_type.share_type.en_name == 'guilds':
                        province_kill_request.guilds_share = int(
                            (percentage_wage_type.percent / 100) * province_kill_request.total_wage_amount)
                        province_kill_request.guilds_share_percent = percentage_wage_type.percent
                    elif percentage_wage_type.share_type.en_name == 'city':
                        province_kill_request.city_share = int(
                            (percentage_wage_type.percent / 100) * province_kill_request.total_wage_amount)
                        province_kill_request.city_share_percent = percentage_wage_type.percent

                    elif percentage_wage_type.share_type.en_name == 'other':
                        province_kill_request.other_share = int(
                            (percentage_wage_type.percent / 100) * province_kill_request.total_wage_amount)
                        province_kill_request.other_share_percent = percentage_wage_type.percent

                    elif percentage_wage_type.share_type.en_name == 'wallet':
                        province_kill_request.wallet_share = int(
                            (percentage_wage_type.percent / 100) * province_kill_request.total_wage_amount)
                        province_kill_request.wallet_share_percent = percentage_wage_type.percent

                    else:
                        province_kill_request.other_share = int(
                            (percentage_wage_type.percent / 100) * province_kill_request.total_wage_amount)
                        province_kill_request.other_share_percent = percentage_wage_type.percent
                    province_kill_request.save()

            province_kill_request.save()
            poultry_request.remain_quantity -= province_kill_request.main_quantity
            poultry_request.save()

            province_check.quantity = province_check.quantity - int(int(request.data['quantity']))
            if province_check.quantity < 0 or province_check.quantity == 0:
                province_check.quantity = 0
                province_check.province_show_kill_house = 'accepted'
            province_check.save()
            kill_request.remain_quantity -= province_kill_request.main_quantity
            kill_request.save()
            kill_house_request_serializer = self.serializer_class(province_kill_request)
            dict1 = {
                "kill_house_req_key": str(province_kill_request.key),
                "kill_req_key": province_kill_request.kill_request.key,
                "province_kill_request_state": province_kill_request.state,
                "kill_house_name": province_kill_request.kill_request.kill_house.name,
                "kill_house_user_name": province_kill_request.kill_request.kill_house.kill_house_operator.user.fullname,
                "kill_house_user_city": province_kill_request.kill_request.kill_house.kill_house_operator.address.city.name,
                "kill_house_mobile": province_kill_request.kill_request.kill_house.kill_house_operator.user.mobile,
                "quantity": province_kill_request.quantity,
                "fee": province_kill_request.fee,
                "time": province_kill_request.kill_request.recive_time,
                "date": province_kill_request.kill_request.recive_date,
            }

            factor = KillRequestFactor.objects.filter(kill_request=kill_request)
            if factor.count() > 0:
                factor = factor.last()
                if KillRequestFactorPayment.objects.filter(kill_request_factor=factor).exists():
                    factor.state = 'paid'
                else:
                    factor.state = 'unpaid'
                factor.save()
            province_kill_request_list.append(province_kill_request.key)

            if AutoAcceptProvinceKillRequest.objects.filter(allow=True).exists():
                kill_house_check = KillHouseCheckRequest(
                    province_kill_request=province_kill_request,
                    role="ProvinceOperator",
                    state="accepted"

                )
                province_kill_request.state = 'accepted'
                kill_house_check.save()
                province_kill_request.save()
            if poultry_request.export == True:
                hatching.export_killed_weight += int(int(request.data['quantity']) * poultry_request.Index_weight)
                hatching.export_killed_quantity += int(request.data['quantity'])
            elif poultry_request.free_sale_in_province == True:
                hatching.free_killed_quantity += int(int(request.data['quantity']) * poultry_request.Index_weight)
                hatching.free_quantity += int(request.data['quantity'])
            else:
                hatching.governmental_killed_quantity += int(
                    int(request.data['quantity']) * poultry_request.Index_weight)

                hatching.governmental_quantity += int(request.data['quantity'])
            hatching.save()
            vet_farm = VetFarm.objects.filter(trash=False, poultry=hatching.poultry).first()
            if SmsLicense.objects.filter(province_kill_request=True).exists():
                kill_house_name = kill_house.name
                kill_house_mobile = kill_house.kill_house_operator.user.mobile
                kill_house_second_mobile = kill_house.alternate_number
                quantity = province_kill_request.quantity
                sale_in_province = province_check.poultry_request.free_sale_in_province
                amount = province_check.poultry_request.amount
                chicken_breed = province_check.poultry_request.chicken_breed
                poultry_name = province_check.poultry_request.poultry.unit_name
                poultry_mobile = province_check.poultry_request.poultry.user.mobile
                date_str = str(province_check.poultry_request.send_date)
                send_date = datetime.strptime(date_str, '%Y-%m-%d %H:%M:%S').date()
                send_date = jdatetime.datetime.fromgregorian(year=send_date.year, month=send_date.month,
                                                             day=send_date.day).strftime('%Y-%m-%d')
                date_list = reversed(send_date.split('-'))
                separate = "-"
                send_date = separate.join(date_list)
                province = province_check.poultry_request.poultry.address.province.name
                city = province_check.poultry_request.poultry.address.city.name
                province_kill_request_to_kill_house_sms(kill_house_mobile, quantity, chicken_breed, send_date,
                                                        poultry_name,
                                                        poultry_mobile, province, city, sale_in_province, amount,
                                                        kill_house_name
                                                        )
                if kill_house_second_mobile != None:
                    province_kill_request_to_kill_house_sms_threading = threading.Thread(
                        target=province_kill_request_to_kill_house_sms,
                        args=(
                            kill_house_second_mobile, quantity, chicken_breed, send_date,
                            poultry_name,
                            poultry_mobile, province, city, sale_in_province, amount,
                            kill_house_name
                        ))
                    province_kill_request_to_kill_house_sms_threading.start()
            if not KillHouseWareHouse.objects.filter(kill_house=kill_house, date__date=now).exists():
                ware_house_date = datetime(year=now.year, month=now.month, day=now.day, hour=1, minute=12, second=20)
                kill_house_ware_house = KillHouseWareHouse(
                    kill_house=kill_house,
                    date=ware_house_date
                )
                kill_house_ware_house.save()
            if base_url_sms == 'ha':
                poultry_name = province_kill_request.province_request.poultry_request.poultry.unit_name
                poultry_mobile = province_kill_request.province_request.poultry_request.poultry.user.mobile
                quantity = province_kill_request.main_quantity
                Index_weight = province_kill_request.province_request.poultry_request.Index_weight
                kill_house_name = province_kill_request.killhouse_user.name
                kill_house_mobile = province_kill_request.killhouse_user.kill_house_operator.user.mobile
                date_str = str(
                    province_kill_request.province_request.poultry_request.send_date)
                send_date = datetime.strptime(date_str, '%Y-%m-%d %H:%M:%S').date()
                send_date = jdatetime.datetime.fromgregorian(year=send_date.year, month=send_date.month,
                                                             day=send_date.day).strftime('%Y-%m-%d')
                date_list = reversed(send_date.split('-'))
                separate = "-"
                send_date = separate.join(date_list)
                # city = province_kill_request.province_request.poultry_request.poultry.address.city.name
                # vet_farm = VetFarm.objects.filter(
                #     poultry=province_kill_request.province_request.poultry_request.poultry).first()
                # sms_allocation_for_vet_farm(poultry_name, poultry_mobile,
                #                             quantity, Index_weight, kill_house_name, kill_house_mobile, city, send_date,
                #                             vet_farm.vet.user.mobile)
            create_update_chicken_commission_prices()
            bot_eitaa_for_each_province_kill_request(province_kill_request, vet_farm)
            return Response(dict1, status=status.HTTP_201_CREATED)
        return Response(serializer.errors, status=status.HTTP_403_FORBIDDEN)

    # تابع مربوط به نمایش  تخصیصات به کشتارگاها توسط استان
    def list(self, request, *args, **kwargs):
        now = datetime.now().date()
        user = SystemUserProfile.objects.get(user=request.user, trash=False)
        # refresh(request.user.id)
        info_dict_list = []
        exclusive_killer = False
        info_list = []
        province_kill_reqs = []

        if 'role' in request.GET:
            if request.GET['role'] == 'KillHouse':
                date1 = datetime.strptime(str(request.GET['date1']),
                                          '%Y-%m-%d').date() if 'date1' in request.GET else now
                date2 = datetime.strptime(str(request.GET['date2']),
                                          '%Y-%m-%d').date() if 'date2' in request.GET else now
                kill_house = KillHouse.objects.filter(kill_house_operator__user=user,
                                                      trash=False)

                if 'car' in request.GET:
                    if KillHousePercentage.objects.filter(kill_house_for_killer__in=kill_house,
                                                          kill_house__type='exclusive').exists():
                        exclusive_killer = True
                    province_kill_reqs = ProvinceKillRequest.objects.filter(
                        Q(killhouse_user__in=kill_house) | Q(
                            kill_request__slaughter_house__in=kill_house),
                        province_request__poultry_request__send_date__date__gte=date1,
                        province_request__poultry_request__send_date__date__lte=date2,
                        state='accepted',
                        return_to_province=False,
                        province_request__city_request_Poultry__poultry_request__final_state='pending',
                        trash=False, quantity__gt=0).order_by(
                        'province_request__city_request_Poultry__poultry_request__send_date')
                    # province_kill_reqs = [
                    #     province_request for province_request in province_kill_req_lists
                    #     if date1 <= province_request.province_request.poultry_request.send_date.date() <= date2
                    # ]
                elif 'id' in request.GET:
                    poultry_request = PoultryRequest.objects.get(id=int(request.GET['id']))
                    province_kill_reqs = ProvinceKillRequest.objects.filter(state='accepted',
                                                                            killhouse_user__in=kill_house,
                                                                            province_request__city_request_Poultry__poultry_request=poultry_request,
                                                                            province_request__city_request_Poultry__poultry_request__final_state='pending',
                                                                            trash=False).order_by(
                        'province_request__city_request_Poultry__poultry_request__send_date')
                elif 'allocations' in request.GET:
                    if 'date1' in request.GET and 'date2' in request.GET:
                        trash = True if 'deleted_object' in request.GET else False
                        province_kill_requests = ProvinceKillRequest.objects.filter(
                            Q(killhouse_user__in=kill_house) | Q(
                                kill_request__slaughter_house__in=kill_house),
                            trash=trash,
                            delete_message__isnull=False if trash else True,
                            kill_request__recive_date__date__gte=date1,
                            kill_request__recive_date__date__lte=date2,
                            temporary_trash=False, temporary_deleted=False
                        ).select_related(
                            'province_request__poultry_request__poultry',
                            'province_request__city_request_Poultry__poultry_request__poultry__user',
                            'province_request__city_request_Poultry__poultry_request__poultry__user__city',
                            'kill_request__kill_house',
                            'kill_request__kill_house__kill_house_operator__user',
                            'kill_request__kill_house__system_address__city'
                        ).values(
                            "province_request__poultry_request__order_code",
                            "province_request__poultry_request__amount",
                            "province_request__poultry_request__financial_operation",
                            "province_request__poultry_request__Index_weight",
                            "province_request__poultry_request__send_date",
                            "province_request__poultry_request__freezing",
                            "province_request__poultry_request__export",
                            "province_request__poultry_request__poultry__unit_name",
                            "province_request__poultry_request__poultry__user__fullname",
                            "province_request__city_request_Poultry__poultry_request__poultry__user__mobile",
                            "province_request__city_request_Poultry__poultry_request__poultry__user__city__name",
                            "province_request__poultry_request__quantity",
                            "kill_request__market",
                            "kill_request__kill_house__name",
                            "kill_request__kill_house__kill_house_operator__user__mobile",
                            "kill_request__kill_house__system_address__city__name",
                            "create_date",
                            "main_quantity",
                            "quantity",
                            "return_to_province",
                            "returner",
                            "key",
                            "state",
                            "kill_house_price",
                            "province_request__poultry_request__union",
                            "province_request__poultry_request__direct_buying",
                            "province_request__poultry_request__free_sale_in_province",
                            # "allocated_car_state"
                        ).order_by('province_request__poultry_request__send_date')
                        value = request.GET.get('value')
                        search = request.GET.get('search')
                        if value and search == 'filter':
                            if value != 'undefined' and value.strip():
                                province_kill_requests = province_kill_requests.filter(
                                    build_query(self.filterset_class, value)
                                )
                        province_kill_reqs_list_final_state = []
                        for request_data in province_kill_requests:
                            allocated_car_state = True if request_data.get('main_quantity') != request_data.get(
                                'quantity') else False

                            internal_dict = {
                                "order_code": request_data.get('province_request__poultry_request__order_code'),
                                "freezing": request_data.get('province_request__poultry_request__freezing'),
                                "export": request_data.get('province_request__poultry_request__export'),
                                "amount": request_data.get('province_request__poultry_request__amount'),
                                "financial_operation": request_data.get(
                                    'province_request__poultry_request__financial_operation'),
                                "index_weight": request_data.get('province_request__poultry_request__Index_weight'),
                                "total_weight": request_data.get('main_quantity') * request_data.get(
                                    'province_request__poultry_request__Index_weight'),
                                "send_date": request_data.get('province_request__poultry_request__send_date'),
                                "poultry_unit_name": request_data.get(
                                    'province_request__poultry_request__poultry__unit_name'),
                                "poultry_full_name": request_data.get(
                                    'province_request__poultry_request__poultry__user__fullname'),
                                "poultry_mobile": request_data.get(
                                    'province_request__city_request_Poultry__poultry_request__poultry__user__mobile'),
                                "poultry_city": request_data.get(
                                    'province_request__city_request_Poultry__poultry_request__poultry__user__city__name'),
                                "poultry_quantity": request_data.get('province_request__poultry_request__quantity'),
                                "kill_house_name": request_data.get('kill_request__kill_house__name'),
                                "market": request_data.get('kill_request__market'),
                                "kill_house_mobile": request_data.get(
                                    'kill_request__kill_house__kill_house_operator__user__mobile'),
                                "kill_house_city": request_data.get(
                                    'kill_request__kill_house__system_address__city__name'),
                                "date_of_allocate": request_data.get('create_date'),
                                "allocated_quantity": request_data.get('main_quantity'),
                                "return_to_province": request_data.get('return_to_province'),
                                "returner": request_data.get('returner'),
                                "allocated_remain_quantity": request_data.get('quantity') if request_data.get(
                                    'return_to_province') == False else 0,
                                "province_kill_request_key": request_data.get('key'),
                                "allocated_state": request_data.get('state'),
                                "union": request_data.get('province_request__poultry_request__union'),
                                "direct_buying": request_data.get(
                                    'province_request__poultry_request__direct_buying'),
                                "allocated_car_state": allocated_car_state,
                                "free_sale_in_province": request_data.get(
                                    'province_request__poultry_request__free_sale_in_province'),
                                "kill_house_price": request_data.get('kill_house_price')
                            }

                            province_kill_reqs_list_final_state.append(internal_dict)
                        return Response(province_kill_reqs_list_final_state, status=status.HTTP_200_OK)
                elif 'allocated_car_state' in request.GET:
                    if 'date1' in request.GET and 'date2' in request.GET:
                        trash = True if 'deleted_object' in request.GET else False
                        province_kill_requests = ProvinceKillRequest.objects.filter(
                            Q(killhouse_user__in=kill_house) | Q(
                                kill_request__slaughter_house__in=kill_house),
                            trash=trash,
                            delete_message__isnull=False if trash else True,
                            kill_request__recive_date__date__gte=date1,
                            kill_request__recive_date__date__lte=date2,
                            temporary_trash=False, temporary_deleted=False, first_car_allocated_quantity=0
                        ).select_related(
                            'province_request__poultry_request__poultry',
                            'province_request__city_request_Poultry__poultry_request__poultry__user',
                            'province_request__city_request_Poultry__poultry_request__poultry__user__city',
                            'kill_request__kill_house',
                            'kill_request__kill_house__kill_house_operator__user',
                            'kill_request__kill_house__system_address__city'
                        ).values(
                            "province_request__poultry_request__order_code",
                            "province_request__poultry_request__amount",
                            "province_request__poultry_request__financial_operation",
                            "province_request__poultry_request__Index_weight",
                            "province_request__poultry_request__send_date",
                            "province_request__poultry_request__freezing",
                            "province_request__poultry_request__export",
                            "province_request__poultry_request__poultry__unit_name",
                            "province_request__poultry_request__poultry__user__fullname",
                            "province_request__city_request_Poultry__poultry_request__poultry__user__mobile",
                            "province_request__city_request_Poultry__poultry_request__poultry__user__city__name",
                            "province_request__poultry_request__quantity",
                            "kill_request__kill_house__name",
                            "kill_request__market",
                            "kill_request__kill_house__kill_house_operator__user__mobile",
                            "kill_request__kill_house__system_address__city__name",
                            "create_date",
                            "main_quantity",
                            "quantity",
                            "return_to_province",
                            "returner",
                            "key",
                            "state",
                            "kill_house_price",
                            "province_request__poultry_request__union",
                            "province_request__poultry_request__direct_buying",
                            "province_request__poultry_request__free_sale_in_province",
                            # "allocated_car_state"
                        ).order_by('province_request__poultry_request__send_date')
                        value = request.GET.get('value')
                        search = request.GET.get('search')
                        if value and search == 'filter':
                            if value != 'undefined' and value.strip():
                                province_kill_requests = province_kill_requests.filter(
                                    build_query(self.filterset_class, value)
                                )
                        province_kill_reqs_list_final_state = []
                        for request_data in province_kill_requests:
                            allocated_car_state = True if request_data.get('main_quantity') != request_data.get(
                                'quantity') else False

                            internal_dict = {
                                "order_code": request_data.get('province_request__poultry_request__order_code'),
                                "freezing": request_data.get('province_request__poultry_request__freezing'),
                                "export": request_data.get('province_request__poultry_request__export'),
                                "amount": request_data.get('province_request__poultry_request__amount'),
                                "financial_operation": request_data.get(
                                    'province_request__poultry_request__financial_operation'),
                                "index_weight": request_data.get('province_request__poultry_request__Index_weight'),
                                "total_weight": request_data.get('main_quantity') * request_data.get(
                                    'province_request__poultry_request__Index_weight'),
                                "send_date": request_data.get('province_request__poultry_request__send_date'),
                                "poultry_unit_name": request_data.get(
                                    'province_request__poultry_request__poultry__unit_name'),
                                "poultry_full_name": request_data.get(
                                    'province_request__poultry_request__poultry__user__fullname'),
                                "poultry_mobile": request_data.get(
                                    'province_request__city_request_Poultry__poultry_request__poultry__user__mobile'),
                                "poultry_city": request_data.get(
                                    'province_request__city_request_Poultry__poultry_request__poultry__user__city__name'),
                                "poultry_quantity": request_data.get('province_request__poultry_request__quantity'),
                                "kill_house_name": request_data.get('kill_request__kill_house__name'),
                                "market": request_data.get('kill_request__market'),
                                "kill_house_mobile": request_data.get(
                                    'kill_request__kill_house__kill_house_operator__user__mobile'),
                                "kill_house_city": request_data.get(
                                    'kill_request__kill_house__system_address__city__name'),
                                "date_of_allocate": request_data.get('create_date'),
                                "allocated_quantity": request_data.get('main_quantity'),
                                "return_to_province": request_data.get('return_to_province'),
                                "returner": request_data.get('returner'),
                                "allocated_remain_quantity": request_data.get('quantity') if request_data.get(
                                    'return_to_province') == False else 0,
                                "province_kill_request_key": request_data.get('key'),
                                "allocated_state": request_data.get('state'),
                                "union": request_data.get('province_request__poultry_request__union'),
                                "direct_buying": request_data.get(
                                    'province_request__poultry_request__direct_buying'),
                                "allocated_car_state": allocated_car_state,
                                "free_sale_in_province": request_data.get(
                                    'province_request__poultry_request__free_sale_in_province'),
                                "kill_house_price": request_data.get('kill_house_price')
                            }

                            province_kill_reqs_list_final_state.append(internal_dict)
                        return Response(province_kill_reqs_list_final_state, status=status.HTTP_200_OK)
                else:
                    province_kill_reqs = ProvinceKillRequest.objects.filter(
                        province_request__poultry_request__send_date__date__gte=date1,
                        province_request__poultry_request__send_date__date__lte=date2, killhouse_user__in=kill_house,
                        province_request__city_request_Poultry__poultry_request__final_state='pending',
                        trash=False,
                        state='pending',
                        dont_show_kill_house=False).select_related('province_request__poultry_request').order_by(
                        'province_request__city_request_Poultry__poultry_request__send_date')

                    # province_kill_reqs = [
                    #     province_request for province_request in province_kill_req_list
                    #     if date1 <= province_request.province_request.poultry_request.send_date.date() <= date2
                    # ]
            elif request.GET['role'] in ['ProvinceOperator', 'SuperAdmin', 'AdminX', 'Supporter']:

                if 'id' in request.GET:
                    poultry_request = PoultryRequest.objects.get(id=int(request.GET['id']))
                    province_kill_reqs = ProvinceKillRequest.objects.filter(state='accepted',
                                                                            province_request__city_request_Poultry__poultry_request=poultry_request,
                                                                            trash=False).order_by(
                        'province_request__city_request_Poultry__poultry_request__send_date')
                elif 'allocations' in request.GET:
                    if 'date1' in request.GET and 'date2' in request.GET:
                        date1 = datetime.strptime(str(request.GET['date1']), '%Y-%m-%d').date()
                        date2 = datetime.strptime(str(request.GET['date2']), '%Y-%m-%d').date()
                        trash = True if 'deleted_object' in request.GET else False
                        province_kill_requests = ProvinceKillRequest.objects.filter(
                            province_request__city_request_Poultry__poultry_request__poultry__user__province=user.province,
                            trash=trash,
                            delete_message__isnull=False if trash else True,
                            kill_request__recive_date__date__gte=date1,
                            kill_request__recive_date__date__lte=date2,
                            temporary_trash=False, temporary_deleted=False
                        ).select_related(
                            'province_request__poultry_request__poultry',
                            'province_request__city_request_Poultry__poultry_request__poultry__user',
                            'province_request__city_request_Poultry__poultry_request__poultry__user__city',
                            'kill_request__kill_house',
                            'kill_request__kill_house__kill_house_operator__user',
                            'kill_request__kill_house__system_address__city'
                        ).values(
                            "province_request__poultry_request__order_code",
                            "province_request__poultry_request__amount",
                            "province_request__poultry_request__financial_operation",
                            "province_request__poultry_request__Index_weight",
                            "province_request__poultry_request__send_date",
                            "province_request__poultry_request__freezing",
                            "province_request__poultry_request__export",
                            "province_request__poultry_request__poultry__unit_name",
                            "province_request__poultry_request__poultry__user__fullname",
                            "province_request__city_request_Poultry__poultry_request__poultry__user__mobile",
                            "province_request__city_request_Poultry__poultry_request__poultry__user__city__name",
                            "province_request__poultry_request__quantity",
                            "kill_request__kill_house__name",
                            "kill_request__market",
                            "kill_request__kill_house__kill_house_operator__user__mobile",
                            "kill_request__kill_house__system_address__city__name",
                            "create_date",
                            "main_quantity",
                            "quantity",
                            "return_to_province",
                            "returner",
                            "key",
                            "state",
                            "kill_house_price",
                            "province_request__poultry_request__union",
                            "province_request__poultry_request__direct_buying",
                            "province_request__poultry_request__free_sale_in_province",
                            # "allocated_car_state"
                        ).order_by('province_request__poultry_request__send_date')
                        value = request.GET.get('value')
                        search = request.GET.get('filter')
                        if value and search == 'search':
                            if value != 'undefined' and value.strip():
                                province_kill_requests = province_kill_requests.filter(
                                    build_query(self.filterset_class, value)
                                )
                        province_kill_reqs_list_final_state = []
                        for request_data in province_kill_requests:
                            allocated_car_state = True if request_data.get('main_quantity') != request_data.get(
                                'quantity') else False

                            internal_dict = {
                                "order_code": request_data.get('province_request__poultry_request__order_code'),
                                "freezing": request_data.get('province_request__poultry_request__freezing'),
                                "export": request_data.get('province_request__poultry_request__export'),
                                "amount": request_data.get('province_request__poultry_request__amount'),
                                "financial_operation": request_data.get(
                                    'province_request__poultry_request__financial_operation'),
                                "index_weight": request_data.get('province_request__poultry_request__Index_weight'),
                                "total_weight": request_data.get('main_quantity') * request_data.get(
                                    'province_request__poultry_request__Index_weight'),
                                "send_date": request_data.get('province_request__poultry_request__send_date'),
                                "poultry_unit_name": request_data.get(
                                    'province_request__poultry_request__poultry__unit_name'),
                                "poultry_full_name": request_data.get(
                                    'province_request__poultry_request__poultry__user__fullname'),
                                "poultry_mobile": request_data.get(
                                    'province_request__city_request_Poultry__poultry_request__poultry__user__mobile'),
                                "poultry_city": request_data.get(
                                    'province_request__city_request_Poultry__poultry_request__poultry__user__city__name'),
                                "poultry_quantity": request_data.get('province_request__poultry_request__quantity'),
                                "kill_house_name": request_data.get('kill_request__kill_house__name'),
                                "market": request_data.get('kill_request__market'),
                                "kill_house_mobile": request_data.get(
                                    'kill_request__kill_house__kill_house_operator__user__mobile'),
                                "kill_house_city": request_data.get(
                                    'kill_request__kill_house__system_address__city__name'),
                                "date_of_allocate": request_data.get('create_date'),
                                "allocated_quantity": request_data.get('main_quantity'),
                                "return_to_province": request_data.get('return_to_province'),
                                "returner": request_data.get('returner'),
                                "allocated_remain_quantity": request_data.get('quantity') if request_data.get(
                                    'return_to_province') == False else 0,
                                "province_kill_request_key": request_data.get('key'),
                                "allocated_state": request_data.get('state'),
                                "union": request_data.get('province_request__poultry_request__union'),
                                "direct_buying": request_data.get(
                                    'province_request__poultry_request__direct_buying'),
                                "allocated_car_state": allocated_car_state,
                                "free_sale_in_province": request_data.get(
                                    'province_request__poultry_request__free_sale_in_province'),
                                "kill_house_price": request_data.get('kill_house_price')
                            }

                            province_kill_reqs_list_final_state.append(internal_dict)
                        return Response(province_kill_reqs_list_final_state, status=status.HTTP_200_OK)
                elif 'allocated_car_state' in request.GET:
                    if 'date1' in request.GET and 'date2' in request.GET:
                        date1 = datetime.strptime(str(request.GET['date1']), '%Y-%m-%d').date()
                        date2 = datetime.strptime(str(request.GET['date2']), '%Y-%m-%d').date()
                        trash = True if 'deleted_object' in request.GET else False
                        province_kill_requests = ProvinceKillRequest.objects.filter(
                            province_request__city_request_Poultry__poultry_request__poultry__user__province=user.province,
                            trash=trash,
                            delete_message__isnull=False if trash else True,
                            kill_request__recive_date__date__gte=date1,
                            kill_request__recive_date__date__lte=date2,
                            temporary_trash=False, temporary_deleted=False, first_car_allocated_quantity=0
                        ).select_related(
                            'province_request__poultry_request__poultry',
                            'province_request__city_request_Poultry__poultry_request__poultry__user',
                            'province_request__city_request_Poultry__poultry_request__poultry__user__city',
                            'kill_request__kill_house',
                            'kill_request__kill_house__kill_house_operator__user',
                            'kill_request__kill_house__system_address__city'
                        ).values(
                            "province_request__poultry_request__order_code",
                            "province_request__poultry_request__amount",
                            "province_request__poultry_request__financial_operation",
                            "province_request__poultry_request__Index_weight",
                            "province_request__poultry_request__send_date",
                            "province_request__poultry_request__freezing",
                            "province_request__poultry_request__export",
                            "province_request__poultry_request__poultry__unit_name",
                            "province_request__poultry_request__poultry__user__fullname",
                            "province_request__city_request_Poultry__poultry_request__poultry__user__mobile",
                            "province_request__city_request_Poultry__poultry_request__poultry__user__city__name",
                            "province_request__poultry_request__quantity",
                            "kill_request__kill_house__name",
                            "kill_request__market",
                            "kill_request__kill_house__kill_house_operator__user__mobile",
                            "kill_request__kill_house__system_address__city__name",
                            "create_date",
                            "main_quantity",
                            "quantity",
                            "return_to_province",
                            "returner",
                            "key",
                            "state",
                            "kill_house_price",
                            "province_request__poultry_request__union",
                            "province_request__poultry_request__direct_buying",
                            "province_request__poultry_request__free_sale_in_province",
                            # "allocated_car_state"
                        ).order_by('province_request__poultry_request__send_date')
                        value = request.GET.get('value')
                        search = request.GET.get('filter')
                        if value and search == 'search':
                            if value != 'undefined' and value.strip():
                                province_kill_requests = province_kill_requests.filter(
                                    build_query(self.filterset_class, value)
                                )
                        province_kill_reqs_list_final_state = []
                        for request_data in province_kill_requests:
                            allocated_car_state = True if request_data.get('main_quantity') != request_data.get(
                                'quantity') else False

                            internal_dict = {
                                "order_code": request_data.get('province_request__poultry_request__order_code'),
                                "freezing": request_data.get('province_request__poultry_request__freezing'),
                                "export": request_data.get('province_request__poultry_request__export'),
                                "amount": request_data.get('province_request__poultry_request__amount'),
                                "financial_operation": request_data.get(
                                    'province_request__poultry_request__financial_operation'),
                                "index_weight": request_data.get('province_request__poultry_request__Index_weight'),
                                "total_weight": request_data.get('main_quantity') * request_data.get(
                                    'province_request__poultry_request__Index_weight'),
                                "send_date": request_data.get('province_request__poultry_request__send_date'),
                                "poultry_unit_name": request_data.get(
                                    'province_request__poultry_request__poultry__unit_name'),
                                "poultry_full_name": request_data.get(
                                    'province_request__poultry_request__poultry__user__fullname'),
                                "poultry_mobile": request_data.get(
                                    'province_request__city_request_Poultry__poultry_request__poultry__user__mobile'),
                                "poultry_city": request_data.get(
                                    'province_request__city_request_Poultry__poultry_request__poultry__user__city__name'),
                                "poultry_quantity": request_data.get('province_request__poultry_request__quantity'),
                                "kill_house_name": request_data.get('kill_request__kill_house__name'),
                                "market": request_data.get('kill_request__market'),
                                "kill_house_mobile": request_data.get(
                                    'kill_request__kill_house__kill_house_operator__user__mobile'),
                                "kill_house_city": request_data.get(
                                    'kill_request__kill_house__system_address__city__name'),
                                "date_of_allocate": request_data.get('create_date'),
                                "allocated_quantity": request_data.get('main_quantity'),
                                "return_to_province": request_data.get('return_to_province'),
                                "returner": request_data.get('returner'),
                                "allocated_remain_quantity": request_data.get('quantity') if request_data.get(
                                    'return_to_province') == False else 0,
                                "province_kill_request_key": request_data.get('key'),
                                "allocated_state": request_data.get('state'),
                                "union": request_data.get('province_request__poultry_request__union'),
                                "direct_buying": request_data.get(
                                    'province_request__poultry_request__direct_buying'),
                                "allocated_car_state": allocated_car_state,
                                "free_sale_in_province": request_data.get(
                                    'province_request__poultry_request__free_sale_in_province'),
                                "kill_house_price": request_data.get('kill_house_price')
                            }

                            province_kill_reqs_list_final_state.append(internal_dict)
                        return Response(province_kill_reqs_list_final_state, status=status.HTTP_200_OK)
            elif request.GET['role'] == 'KillHouseVet':
                vet = Vet.objects.filter(user=user, trash=False)
                if vet.count() > 0:
                    vet = vet.last()
                    kill_house_vet = KillHouseVet.objects.filter(vet=vet)
                    kill_house_vet = kill_house_vet.last()

                if 'id' in request.GET:
                    poultry_request = PoultryRequest.objects.get(id=int(request.GET['id']))
                    province_kill_reqs = ProvinceKillRequest.objects.filter(state='accepted',
                                                                            killhouse_user=kill_house_vet.kill_house,
                                                                            province_request__city_request_Poultry__poultry_request=poultry_request,
                                                                            trash=False).order_by(
                        'province_request__city_request_Poultry__poultry_request__send_date')
                else:
                    province_kill_reqs = ProvinceKillRequest.objects.filter(killhouse_user=kill_house_vet.kill_house,
                                                                            trash=False).order_by(
                        'province_request__city_request_Poultry__poultry_request__send_date')
            elif request.GET['role'] == 'VetFarm':
                vet = Vet.objects.filter(user=user, trash=False)
                poultries = []
                if vet.count() > 0:
                    vet = vet.last()
                    vet_farms = VetFarm.objects.filter(vet=vet)
                    for vet_farm in vet_farms:
                        if vet_farm.poultry in poultries:
                            pass
                        else:
                            poultries.append(vet_farm.poultry)
                if len(poultries) == 0:
                    return Response([], status=status.HTTP_200_OK)
                province_kill_reqs = ProvinceKillRequest.objects.filter(
                    province_request__poultry_request__poultry__in=poultries,
                    province_request__poultry_request__poultry__address__province=vet.user.province,
                    trash=False).order_by(
                    'province_request__city_request_Poultry__poultry_request__send_date')
            elif request.GET['role'] == 'VetSupervisor':
                vet = VetSupervisor.objects.get(user=user, trash=False)

                province_kill_reqs = ProvinceKillRequest.objects.filter(
                    province_request__poultry_request__poultry__address__province=vet.user.province,
                    trash=False).order_by(
                    'province_request__city_request_Poultry__poultry_request__send_date')


        else:
            if 'state' in request.GET:
                if request.GET['state'] == 'accepted':
                    province_kill_reqs = ProvinceKillRequest.objects.filter(state='accepted', trash=False)
            else:
                province_kill_reqs = ProvinceKillRequest.objects.filter(vet_state='accepted', trash=False)
        if len(province_kill_reqs) == 0:
            return Response(province_kill_reqs, status=status.HTTP_200_OK)
        value = request.GET.get('value')
        search = request.GET.get('search')
        if value and search == 'filter':
            if value != 'undefined' and value.strip():
                province_kill_reqs = province_kill_reqs.filter(
                    build_query(self.filterset_class, value)
                )
        for province_kill_req in province_kill_reqs:
            check_key = KillHouseCheckRequest.objects.filter(province_kill_request=province_kill_req)
            if check_key.count() > 0:
                check_key = check_key.last().key
            else:
                check_key = None
            internal_dict_infos = {
                "poultry_req_id": province_kill_req.province_request.city_request_Poultry.poultry_request.id,
                "freezing": province_kill_req.province_request.city_request_Poultry.poultry_request.freezing,
                "direct_buying": province_kill_req.province_request.city_request_Poultry.poultry_request.direct_buying,
                "export": province_kill_req.province_request.city_request_Poultry.poultry_request.export,
                "amount": province_kill_req.province_request.city_request_Poultry.poultry_request.amount,
                "financial_operation": province_kill_req.province_request.city_request_Poultry.poultry_request.financial_operation,
                "poultry_req_key": province_kill_req.province_request.city_request_Poultry.poultry_request.key,
                "province_kill_req_key": province_kill_req.key,
                "poultry_name": province_kill_req.province_request.city_request_Poultry.poultry_request.poultry.user.fullname,
                "order_code": province_kill_req.province_request.city_request_Poultry.poultry_request.order_code,
                "send_date": province_kill_req.province_request.city_request_Poultry.poultry_request.send_date,
                "city": province_kill_req.province_request.city_request_Poultry.poultry_request.poultry.address.city.name,
                "province": province_kill_req.province_request.city_request_Poultry.poultry_request.poultry.user.province.name,
                "poultry_mobile": province_kill_req.province_request.city_request_Poultry.poultry_request.poultry.user.mobile,
                "kill_house_key": province_kill_req.kill_request.kill_house.key,
                "kill_house_check_key": check_key,
                "kill_house_name": province_kill_req.kill_request.kill_house.name,
                "kill_house_mobile": province_kill_req.kill_request.kill_house.kill_house_operator.user.mobile,
                "quantity": province_kill_req.quantity if province_kill_req.return_to_province == False else 0,
                "main_quantity": province_kill_req.main_quantity,
                "time": province_kill_req.kill_request.recive_time,
                "date": province_kill_req.kill_request.recive_date,
                "age": (
                               datetime.now() - province_kill_req.province_request.city_request_Poultry.poultry_request.hatching.date).days + 1,
                "province_kill_req": province_kill_req.key,
                "return_to_province": province_kill_req.return_to_province,
                "returner": province_kill_req.returner,
                "kill_request_key": province_kill_req.kill_request.key,
                "market": province_kill_req.kill_request.market,
                "province_kill_state": province_kill_req.state,
                "allocated_quantity": province_kill_req.main_quantity - province_kill_req.quantity,
                "remain_quantity": province_kill_req.quantity,
                "chicken_breed": province_kill_req.kill_request.chicken_breed,
                "index_weight": province_kill_req.province_request.poultry_request.Index_weight,
                "total_weight": province_kill_req.main_quantity * province_kill_req.province_request.poultry_request.Index_weight,
                "province_kill_reviewer": province_kill_req.reviewer,
                "province_kill_clearance_code": province_kill_req.clearance_code,
                "exclusive_killer": exclusive_killer,
                "kill_house_price": province_kill_req.kill_house_price,
                "province_kill_request_key": province_kill_req.key,
                "kill_house_assignments": "",
                "free_sale_in_province": province_kill_req.province_request.poultry_request.free_sale_in_province,

            }
            kill_house_check = KillHouseCheckRequest.objects.filter(province_kill_request=province_kill_req,
                                                                    trash=False)
            if kill_house_check:
                kill_house_check = kill_house_check.last()
                internal_dict_infos.update({
                    "kill_house_check_key": kill_house_check.key,
                })
            for kill_house_req_obj in KillHouseRequest.objects.filter(
                    province_kill_request=province_kill_req, trash=False):
                internal_kill_house_request_dict_infos = {
                    "kill_house_req_key": kill_house_req_obj.key,
                    "kill_req_key": kill_house_req_obj.kill_request.key,
                    "barcod": kill_house_req_obj.bar_code,
                    "kill_house_state": kill_house_req_obj.state,
                    "kill_house_name": kill_house_req_obj.kill_request.kill_house.name,
                    "kill_house_user_name": kill_house_req_obj.kill_request.kill_house.kill_house_operator.user.fullname,
                    "kill_house_user_city": kill_house_req_obj.kill_request.kill_house.kill_house_operator.address.city.name,
                    "kill_house_mobile": kill_house_req_obj.kill_request.kill_house.kill_house_operator.user.mobile,
                    "quantity": kill_house_req_obj.quantity,
                    "time": kill_house_req_obj.kill_request.recive_time,
                    "date": kill_house_req_obj.kill_request.recive_date,
                    "cars": kill_house_req_obj.car,
                    "show_kill_house": kill_house_req_obj.show_kill_house,
                    "kill_house_message": kill_house_req_obj.kill_house_message,
                }

                info_list.append(internal_kill_house_request_dict_infos)

            internal_dict_infos["kill_house_assignments"] = info_list

            info_dict_list.append(internal_dict_infos)
        return Response(info_dict_list, status=status.HTTP_200_OK)

    def update(self, request, pk=None, *args, **kwargs):
        user = SystemUserProfile.objects.get(user=request.user, trash=False)
        role = request.data['role']
        request.data.pop('role')
        if 'type' in request.data.keys():
            if request.data['type'] == 'archive':
                user_fullname = user.fullname
                date = str(datetime.now())
                archive_province_kill_request_wage_threading = threading.Thread(
                    target=provincearchiveprovincekillrequestforwage,
                    args=(
                        request.data['province_kill_request_list'], request.data['message'], role, user_fullname, date
                    ))
                archive_province_kill_request_wage_threading.start()
                return Response({"result": "با موفقیت انجام شد"}, status=status.HTTP_200_OK)


            elif request.data['type'] == 'return_archive':
                user_fullname = user.fullname
                date = str(datetime.now().date())
                province_kill_request = ProvinceKillRequest.objects.get(key=request.data['province_kill_request_key'])
                province_kill_request.archive_by_province = False
                if 'return_archive_message' in request.data.keys():
                    province_kill_request.return_archive_message = request.data['return_archive_message']
                province_kill_request.returner = {
                    "fullname": user_fullname,
                    "date": date,
                    "role": role
                }
                province_kill_request.save()
                return Response({"result": "با موفقیت انجام شد"}, status=status.HTTP_200_OK)
        elif 'edit_allocation_quantity' in request.data.keys():
            wage = 0
            province_kill_request = ProvinceKillRequest.objects.get(key=request.data['province_kill_request_key'],
                                                                    trash=False)
            if province_kill_request.market:
                return Response({"result": "امکان ویرایش برای تخصیصات  پنل معاملات وجود ندارد!"},
                                status=status.HTTP_403_FORBIDDEN)
            poultry_request = PoultryRequest.objects.get(key=province_kill_request.province_request.poultry_request.key,
                                                         trash=False)
            if poultry_request.freezing == True:
                wage_type = WageType.objects.filter(en_name='province-kill-request-freezing', trash=False).first()
            else:

                wage_type = WageType.objects.filter(en_name='province-kill-request', trash=False).first()
            if wage_type.status == True:
                wage = wage_type.amount
            hatching = PoultryHatching.objects.get(key=poultry_request.hatching.key, trash=False)
            if KillHouseRequest.objects.filter(trash=False, province_kill_request=province_kill_request).exists():
                return Response({"result": "برای این  تخصیص بارایجاد شده است امکان ویرایش وجود ندارد"},
                                status=status.HTTP_403_FORBIDDEN)
            amount = province_kill_request.main_quantity
            if request.data['quantity'] > amount:
                different_amount = request.data['quantity'] - amount
                province_kill_requests = ProvinceKillRequest.objects.filter(trash=False, return_to_province=False,
                                                                            province_request__poultry_request=poultry_request)
                total_quantity = \
                    province_kill_requests.aggregate(total=Sum('main_quantity'))['total'] or 0
                if different_amount + total_quantity > poultry_request.quantity:
                    return Response({"result": "تعداد وارد شده بیشتر از اعلام نیاز مرغدار است!"},
                                    status=status.HTTP_403_FORBIDDEN)
                total_quantity_for_hatching = province_kill_requests.aggregate(total=Sum('total_killed_quantity'))[
                                                  'total'] or 0
                if different_amount + total_quantity_for_hatching > hatching.left_over:
                    return Response({"result": "تعداد وارد شده بیشتر از باقی مانده جوجه ریزی مرغدار است!"},
                                    status=status.HTTP_403_FORBIDDEN)
                province_kill_requests_for_kill_request = ProvinceKillRequest.objects.filter(trash=False,
                                                                                             return_to_province=False,
                                                                                             kill_request=province_kill_request.kill_request)
                total_quantity_for_kill_request = \
                    province_kill_requests_for_kill_request.aggregate(total=Sum('main_quantity'))['total'] or 0
                if province_kill_request.kill_request.kill_capacity < total_quantity_for_kill_request + different_amount:
                    return Response({"result": "تعداد وارد شده بیشتر از اعلام نیاز کشتارگاه است!"},
                                    status=status.HTTP_403_FORBIDDEN)
                province_kill_request.province_request.quantity -= different_amount
                if province_kill_request.province_request.quantity < 0:
                    province_kill_request.province_request.quantity = 0
                province_kill_request.province_request.save()
                province_kill_request.kill_request.remain_quantity = province_kill_request.kill_request.kill_capacity - total_quantity_for_kill_request
                province_kill_request.kill_request.remain_quantity -= different_amount
                province_kill_request.kill_request.save()
                poultry_request.remain_quantity -= different_amount
                poultry_request.save()
            else:
                province_kill_requests_for_kill_request = ProvinceKillRequest.objects.filter(trash=False,
                                                                                             return_to_province=False,
                                                                                             kill_request=province_kill_request.kill_request)
                total_quantity_for_kill_request = \
                    province_kill_requests_for_kill_request.aggregate(total=Sum('main_quantity'))['total'] or 0
                different_amount = amount - request.data['quantity']
                province_kill_request.province_request.quantity += different_amount
                province_kill_request.province_request.save()
                province_kill_request.kill_request.remain_quantity = province_kill_request.kill_request.kill_capacity - total_quantity_for_kill_request
                province_kill_request.kill_request.remain_quantity += different_amount
                province_kill_request.kill_request.save()
                poultry_request.remain_quantity += different_amount
                poultry_request.save()

            province_kill_request.main_quantity = int(request.data['quantity'])
            province_kill_request.total_killed_quantity = province_kill_request.main_quantity
            province_kill_request.total_killed_weight = int(
                province_kill_request.main_quantity * poultry_request.Index_weight)
            province_kill_request.total_wage_amount = province_kill_request.total_killed_weight * province_kill_request.wage
            percentages_wage_type = PercentageOfWageType.objects.filter(wage_type=wage_type, percent__gt=0, trash=False)
            if wage_type and wage_type.status == True and percentages_wage_type:
                for percentage_wage_type in percentages_wage_type:
                    if percentage_wage_type.share_type.en_name == 'union':
                        province_kill_request.union_share = int(
                            (percentage_wage_type.percent / 100) * province_kill_request.total_wage_amount)
                        province_kill_request.union_share_percent = percentage_wage_type.percent
                    elif percentage_wage_type.share_type.en_name == 'company':
                        province_kill_request.company_share = int(
                            (percentage_wage_type.percent / 100) * province_kill_request.total_wage_amount)
                        province_kill_request.company_share_percent = percentage_wage_type.percent

                    elif percentage_wage_type.share_type.en_name == 'guilds':
                        province_kill_request.guilds_share = int(
                            (percentage_wage_type.percent / 100) * province_kill_request.total_wage_amount)
                        province_kill_request.guilds_share_percent = percentage_wage_type.percent
                    elif percentage_wage_type.share_type.en_name == 'city':
                        province_kill_request.city_share = int(
                            (percentage_wage_type.percent / 100) * province_kill_request.total_wage_amount)
                        province_kill_request.city_share_percent = percentage_wage_type.percent

                    elif percentage_wage_type.share_type.en_name == 'other':
                        province_kill_request.other_share = int(
                            (percentage_wage_type.percent / 100) * province_kill_request.total_wage_amount)
                        province_kill_request.other_share_percent = percentage_wage_type.percent

                    elif percentage_wage_type.share_type.en_name == 'wallet':
                        province_kill_request.wallet_share = int(
                            (percentage_wage_type.percent / 100) * province_kill_request.total_wage_amount)
                        province_kill_request.wallet_share_percent = percentage_wage_type.percent

                    else:
                        province_kill_request.other_share = int(
                            (percentage_wage_type.percent / 100) * province_kill_request.total_wage_amount)
                        province_kill_request.other_share_percent = percentage_wage_type.percent
                    province_kill_request.save()

            province_kill_request.save()
            update_province_kill_requests(hatching)
            poultry_prediction(hatching.poultry)

            return Response({"result": "با موفقیت انجام شد"}, status=status.HTTP_200_OK)

        else:

            province_kill_request = ProvinceKillRequest.objects.get(key=request.data['province_kill_request_key'])
            request.data.pop('province_kill_request_key')
            if 'kill_house_price' not in request.data.keys():
                if province_kill_request.prev_total_amount == None:
                    province_kill_request.prev_total_amount = province_kill_request.total_amount
                province_kill_request.total_amount_editor = {
                    "role": role,
                    "fullname": user.fullname,
                    "mobile": user.mobile,
                    "date": str(datetime.now())
                }
                province_kill_request.save()
            if 'kill_house_price' in request.data.keys():
                kill_house_requests = KillHouseRequest.objects.filter(trash=False,
                                                                      province_kill_request=province_kill_request)
                if kill_house_requests:
                    kill_house_requests.update(amount=request.data['kill_house_price'])

            serializer = self.serializer_class(province_kill_request)
            serializer.update(instance=province_kill_request, validated_data=request.data)
            return Response(serializer.data, status=status.HTTP_200_OK)

    def destroy(self, request, pk=None, *args, **kwargs):
        # refresh(request.user.id)

        if 'delete_allocation' in request.GET:

            province_kill_request = ProvinceKillRequest.objects.get(key=request.GET['province_kill_request_key'],
                                                                    trash=False)
            if request.GET['role'] == 'KillHouse':
                if province_kill_request.market:
                    return Response({
                        "result": "امکان حذف برای تخصیص پنل معاملاتی وجود ندارد. در صورت نیاز به کاربر اتحادیه اطلاع دهید."},
                        status=status.HTTP_403_FORBIDDEN)

                now = datetime.now()
                now_time = now.time()
                if now.date() != province_kill_request.kill_request.recive_date.date():
                    return Response({"result": "با توجه به مغایرت تاریخ امکان حذف وجود ندارد!"},
                                    status=status.HTTP_403_FORBIDDEN)

                if now_time.hour >= 16:
                    return Response({"result": "با توجه به اتمام زمان حذف مجاز امکان حذف وجود ندارد!"},
                                    status=status.HTTP_403_FORBIDDEN)

            if province_kill_request.quantity != province_kill_request.main_quantity:
                return Response({"result": "برای تخصیص ماشین ثبت شده امکان حذف وجود ندارد!"},
                                status=status.HTTP_403_FORBIDDEN)

            poultry_request = PoultryRequest.objects.get(key=province_kill_request.province_request.poultry_request.key,
                                                         trash=False)
            province_check = ProvinceCheckOperatorRequest.objects.get(poultry_request=poultry_request)

            hatching = PoultryHatching.objects.get(key=poultry_request.hatching.key, trash=False)
            if poultry_request.export == True:
                hatching.export_killed_weight -= int(int(request.data['quantity']) * poultry_request.Index_weight)
                hatching.export_killed_quantity -= int(request.data['quantity'])
            elif poultry_request.free_sale_in_province == True:
                hatching.free_killed_quantity -= province_kill_request.total_killed_weight
                # hatching.free_killed_quantity -= int(province_kill_request.main_quantity * poultry_request.Index_weight)
                hatching.free_quantity -= province_kill_request.total_killed_quantity
                # hatching.free_quantity -= province_kill_request.main_quantity
            else:
                hatching.governmental_killed_quantity -= province_kill_request.total_killed_weight
                # hatching.governmental_killed_quantity -= int(
                #     province_kill_request.main_quantity * poultry_request.Index_weight)

                hatching.governmental_quantity -= province_kill_request.total_killed_quantity
                # hatching.governmental_quantity -= province_kill_request.main_quantity
            # hatching.killed_quantity -= province_kill_request.main_quantity
            hatching.save()

            if poultry_request.remain_quantity > 0:
                # province_check = ProvinceCheckOperatorRequest.objects.get(poultry_request=poultry_request)
                province_check.quantity += province_kill_request.main_quantity
                province_check.save()
                poultry_request.remain_quantity += province_kill_request.main_quantity
                poultry_request.save()
            else:

                # province_check = ProvinceCheckOperatorRequest.objects.get(poultry_request=poultry_request)
                province_check.quantity += province_kill_request.main_quantity
                province_check.save()
                poultry_request.remain_quantity += province_kill_request.main_quantity
                poultry_request.save()
                # poultry_request.quantity -= province_kill_request.quantity
                # poultry_request.first_quantity -= province_kill_request.quantity
                # poultry_request.previous_quantity -= province_kill_request.quantity
                # poultry_request.save()
                # if poultry_request.quantity == 0:
                # poultry_request.trash = True
                # poultry_request.save()
                # hatching.left_over += province_kill_request.quantity
                # hatching.state = 'pending'
                # hatching.allow_hatching = 'pending'
                # hatching.save()
            kill_request = KillRequest.objects.get(key=province_kill_request.kill_request.key)
            kill_request.remain_quantity += province_kill_request.main_quantity
            if kill_request.market:
                user = SystemUserProfile.objects.get(trash=False, user=request.user)
                kill_request.market_state_message = {
                    "fullname": user.fullname,
                    "mobile": user.mobile,
                    "date": str(datetime.now())
                }
                kill_request.market_state = 'deleted'
            else:
                if kill_request.poultry_request:
                    kill_request.trash = True
            kill_request.save()
            province_kill_request.delete_message = request.GET['message']
            province_kill_request.trash = True
            user = SystemUserProfile.objects.get(user=request.user, trash=False)
            province_kill_request.returner = {"fullname": user.fullname, "mobile": user.mobile,
                                              "date": str(datetime.now())}
            province_kill_request.save()
            bot_eitaa_for_each_delete_province_kill_request(province_kill_request)
            return Response({"result": "با موفقیت حذف شد"}, status=status.HTTP_200_OK)
        elif 'return_allocation_quantity' in request.GET:
            user = SystemUserProfile.objects.get(user=request.user, trash=False)

            province_kill_request = ProvinceKillRequest.objects.get(key=request.GET['province_kill_request_key'],
                                                                    trash=False)
            if province_kill_request.quantity == 0:
                return Response({"result": "باقی مانده تخصیص صفر است امکان بازگشت تعداد وجود ندارد"},
                                status=status.HTTP_403_FORBIDDEN)
            amount = province_kill_request.quantity

            poultry_request = PoultryRequest.objects.get(key=province_kill_request.province_request.poultry_request.key,
                                                         trash=False)
            hatching = PoultryHatching.objects.get(key=poultry_request.hatching.key, trash=False)

            if province_kill_request.main_quantity - province_kill_request.quantity == 0:
                province_check = ProvinceCheckOperatorRequest.objects.get(poultry_request=poultry_request)
                province_check.quantity += province_kill_request.main_quantity
                province_check.save()
                poultry_request.remain_quantity += province_kill_request.main_quantity
                poultry_request.save()
                kill_request = KillRequest.objects.get(key=province_kill_request.kill_request.key)
                kill_request.remain_quantity += province_kill_request.main_quantity
                if kill_request.market:
                    kill_request.market_state = 'deleted'
                    user = SystemUserProfile.objects.get(trash=False, user=request.user)
                    kill_request.market_state_message = {
                        "fullname": user.fullname,
                        "mobile": user.mobile,
                        "date": str(datetime.now())
                    }

                else:
                    if kill_request.poultry_request:
                        kill_request.trash = True
                kill_request.save()
                if poultry_request.export == True:
                    hatching.export_killed_weight -= int(int(request.data['quantity']) * poultry_request.Index_weight)
                    hatching.export_killed_quantity -= int(request.data['quantity'])
                elif poultry_request.free_sale_in_province == True:
                    hatching.free_killed_quantity -= province_kill_request.total_killed_weight
                    # hatching.free_killed_quantity -= int(amount * poultry_request.Index_weight)
                    hatching.free_quantity -= province_kill_request.total_killed_quantity
                    # hatching.free_quantity -= amount
                else:
                    hatching.governmental_killed_quantity -= province_kill_request.total_killed_weight
                    # hatching.governmental_killed_quantity -= int(amount * poultry_request.Index_weight)
                    hatching.governmental_quantity -= province_kill_request.total_killed_quantity
                    # hatching.governmental_quantity -= amount
                # hatching.killed_quantity -= amount
                hatching.save()
                # province_kill_request.trash = True
                province_kill_request.quantity = 0
                province_kill_request.total_killed_quantity = 0
                province_kill_request.total_killed_weight = 0
                province_kill_request.return_to_province = True
                province_kill_request.returner = {"fullname": user.fullname, "mobile": user.mobile,
                                                  "date": str(datetime.now())}
                province_kill_request.save()
                bot_eitaa_for_each_delete_province_kill_request(province_kill_request)
            else:

                province_check = ProvinceCheckOperatorRequest.objects.get(poultry_request=poultry_request)
                province_check.quantity += province_kill_request.main_quantity - province_kill_request.quantity
                province_check.save()
                poultry_request.remain_quantity += province_kill_request.main_quantity - province_kill_request.quantity
                poultry_request.save()
                kill_request = KillRequest.objects.get(key=province_kill_request.kill_request.key)
                kill_request.remain_quantity += province_kill_request.main_quantity - province_kill_request.quantity
                kill_request.save()
                if poultry_request.export == True:
                    hatching.export_killed_weight -= int(int(request.data['quantity']) * poultry_request.Index_weight)
                    hatching.export_killed_quantity -= int(request.data['quantity'])
                elif poultry_request.free_sale_in_province == True:
                    hatching.free_killed_quantity -= int((
                                                                 province_kill_request.main_quantity - province_kill_request.quantity) * poultry_request.Index_weight)
                    # hatching.free_killed_quantity -= int(amount * poultry_request.Index_weight)
                    hatching.free_quantity -= province_kill_request.total_killed_quantity
                    # hatching.free_quantity -= amount
                else:
                    hatching.governmental_killed_quantity -= int((
                                                                         province_kill_request.main_quantity - province_kill_request.quantity) * poultry_request.Index_weight)
                    # hatching.governmental_killed_quantity -= int(amount * poultry_request.Index_weight)
                    hatching.governmental_quantity -= province_kill_request.main_quantity - province_kill_request.quantity
                    # hatching.governmental_quantity -= amount
                # hatching.killed_quantity -= amount
                hatching.save()
                province_kill_request.main_quantity = province_kill_request.main_quantity - province_kill_request.quantity
                province_kill_request.quantity = 0
                province_kill_request.save()

            return Response({"result": "با موفقیت انجام شد"}, status=status.HTTP_200_OK)
        queryset = ProvinceKillRequest.objects.get(key=request.GET['key'])
        poultry_request = PoultryRequest.objects.get(key=queryset.province_request.poultry_request.key)
        hatching = PoultryHatching.objects.get(key=poultry_request.hatching.key, trash=False)
        check = KillHouseCheckRequest.objects.filter(province_kill_request=queryset, state='accepted')
        if check.count() > 0:
            return Response({"result": "can not delete"}, status=status.HTTP_403_FORBIDDEN)
        province = ProvinceCheckOperatorRequest.objects.get(key=queryset.province_request.key)
        province.quantity += queryset.quantity
        province.save()
        kill_request = KillRequest.objects.get(key=queryset.kill_request.key)
        kill_request.remain_quantity += queryset.quantity
        kill_request.save()
        # queryset.delete()
        poultry_request.remain_quantity += queryset.quantity
        poultry_request.save()
        if poultry_request.export == True:
            hatching.export_killed_weight -= int(int(request.data['quantity']) * poultry_request.Index_weight)
            hatching.export_killed_quantity -= int(request.data['quantity'])
        elif poultry_request.free_sale_in_province == True:
            hatching.free_killed_quantity -= queryset.total_killed_weight
            # hatching.free_killed_quantity -= int(queryset.quantity * poultry_request.Index_weight)
            hatching.free_quantity -= queryset.total_killed_quantity
        else:
            hatching.governmental_killed_quantity -= queryset.total_killed_weight
            # hatching.governmental_killed_quantity -= int(
            #     queryset.quantity * poultry_request.Index_weight)
            hatching.governmental_quantity -= queryset.total_killed_quantity
        # hatching.killed_quantity -= queryset.total_killed_quantity
        hatching.save()
        bot_eitaa_for_each_delete_province_kill_request(queryset)
        queryset.delete()
        return Response(status=status.HTTP_200_OK)


class KillHouseWageForTotalDashbordViewSet(viewsets.ModelViewSet):
    queryset = KillHouse.objects.all()
    serializer_class = KillHouseWageForTotalDashbordSerializer
    permission_classes = [TokenHasReadWriteScope]

    def list(self, request, *args, **kwargs):
        user = SystemUserProfile.objects.get(user=request.user, trash=False)
        kill_house = KillHouse.objects.filter(kill_house_operator__user=user, trash=False).first()
        serializer = self.get_serializer(kill_house)
        return Response(serializer.data, status=status.HTTP_200_OK)


class ProvinceKillRequestProvinceWageViewSet(viewsets.ModelViewSet):
    queryset = ProvinceKillRequest.objects.all()
    serializer_class = ProvinceKillRequestProvinceWageSerializer
    pagination_class = CustomPagination
    permission_classes = [TokenHasReadWriteScope]
    filter_backends = [DjangoFilterBackend]
    filterset_class = ProvinceKillRequestFilterSet
    filterset_fields = [
        'province_request__poultry_request__chicken_breed',
        'province_request__poultry_request__order_code',
        'province_request__poultry_request__poultry__address__city__name',
        'province_request__poultry_request__poultry__user__mobile',
        'province_request__poultry_request__poultry__user__fullname',

    ]

    def list(self, request, *args, **kwargs):
        user = SystemUserProfile.objects.get(user=request.user, trash=False)
        if 'type' in request.GET:
            if 'date1' in request.GET:
                date1 = datetime.strptime(str(request.GET['date1']), '%Y-%m-%d').date()

                date2 = datetime.strptime(str(request.GET['date2']), '%Y-%m-%d').date()

            if request.GET['role'] in ['ProvinceOperator', 'SuperAdmin', 'AdminX', 'Company', 'Guilds', 'Supporter']:
                if request.GET['type'] == 'unpaid':
                    if 'date1' in request.GET:

                        if request.GET['role'] == 'ProvinceOperator':
                            province_kill_request = self.queryset.filter(
                                killhouse_user__key=request.GET['kill_house_key'],
                                state__in=('pending', 'accepted'),
                                return_to_province=False,
                                archive_wage=False,
                                kill_request__recive_date__date__gte=date1,
                                kill_request__recive_date__date__lte=date2,
                                union_share__gt=0,
                                trash=False).order_by('kill_request__recive_date')
                        elif request.GET['role'] == 'Company':
                            province_kill_request = self.queryset.filter(
                                killhouse_user__key=request.GET['kill_house_key'],
                                state__in=('pending', 'accepted'),
                                return_to_province=False,
                                archive_wage=False,
                                kill_request__recive_date__date__gte=date1,
                                kill_request__recive_date__date__lte=date2,
                                company_share__gt=0,
                                trash=False).order_by('kill_request__recive_date')

                        elif request.GET['role'] == 'Guilds':
                            province_kill_request = self.queryset.filter(
                                killhouse_user__key=request.GET['kill_house_key'],
                                state__in=('pending', 'accepted'),
                                return_to_province=False,
                                archive_wage=False,
                                kill_request__recive_date__date__gte=date1,
                                kill_request__recive_date__date__lte=date2,
                                guilds_share__gt=0,
                                trash=False).order_by('kill_request__recive_date')

                        elif request.GET['role'] in ['SuperAdmin', 'AdminX', 'Supporter']:
                            province_kill_request = self.queryset.filter(
                                killhouse_user__key=request.GET['kill_house_key'],
                                state__in=('pending', 'accepted'),
                                return_to_province=False,
                                archive_wage=False,
                                kill_request__recive_date__date__gte=date1,
                                kill_request__recive_date__date__lte=date2,
                                trash=False).order_by('kill_request__recive_date')
                    else:
                        if request.GET['role'] == 'ProvinceOperator':
                            province_kill_request = self.queryset.filter(
                                killhouse_user__key=request.GET['kill_house_key'],
                                state__in=('pending', 'accepted'),
                                return_to_province=False,
                                archive_wage=False,
                                union_share__gt=0,
                                trash=False).order_by('kill_request__recive_date')
                        elif request.GET['role'] == 'Company':
                            province_kill_request = self.queryset.filter(
                                killhouse_user__key=request.GET['kill_house_key'],
                                state__in=('pending', 'accepted'),
                                return_to_province=False,
                                archive_wage=False,
                                company_share__gt=0,
                                trash=False).order_by('kill_request__recive_date')

                        elif request.GET['role'] == 'Guilds':
                            province_kill_request = self.queryset.filter(
                                killhouse_user__key=request.GET['kill_house_key'],
                                state__in=('pending', 'accepted'),
                                return_to_province=False,
                                archive_wage=False,
                                guilds_share__gt=0,
                                trash=False).order_by('kill_request__recive_date')

                        elif request.GET['role'] in ['SuperAdmin', 'AdminX', 'Supporter']:
                            province_kill_request = self.queryset.filter(
                                killhouse_user__key=request.GET['kill_house_key'],
                                state__in=('pending', 'accepted'),
                                return_to_province=False,
                                archive_wage=False,
                                trash=False).order_by('kill_request__recive_date')


            else:
                user = SystemUserProfile.objects.get(user=request.user, trash=False)
                kill_house = KillHouse.objects.filter(kill_house_operator__user=user, trash=False)

                if request.GET['type'] == 'unpaid':
                    if 'date1' in request.GET:

                        province_kill_request = self.queryset.filter(killhouse_user__in=kill_house,
                                                                     state__in=('pending', 'accepted'),
                                                                     return_to_province=False,
                                                                     archive_wage=False,
                                                                     kill_request__recive_date__date__gte=date1,
                                                                     kill_request__recive_date__date__lte=date2,
                                                                     trash=False).order_by('kill_request__recive_date')
                    else:
                        province_kill_request = self.queryset.filter(killhouse_user__in=kill_house,
                                                                     state__in=('pending', 'accepted'), wage_pay=False,
                                                                     archive_wage=False,
                                                                     return_to_province=False,
                                                                     trash=False).order_by('kill_request__recive_date')

            if 'search' in request.GET:
                if request.GET['search'] == 'filter':
                    if request.GET['value'] != "":
                        for item in self.filterset_fields:
                            query = QueryDict('{0}__contains={1}'.format(item, request.GET['value']))
                            if (self.filterset_class(
                                    data=query,
                                    queryset=province_kill_request
                            )
                            ).filter():
                                ps = self.filterset_class(data=query, queryset=province_kill_request)
                                province_kill_request = ps.filter()
                    else:
                        province_kill_request = province_kill_request

            page_size = request.query_params.get('page_size', None)
            if page_size:
                self.pagination_class.page_size = int(page_size)

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

            serializer = self.get_serializer(province_kill_request, many=True)
            return Response(serializer.data, status=status.HTTP_200_OK)


# class ProvinceKillRequestProvinceWageViewSet(viewsets.ModelViewSet):
#     queryset = ProvinceKillRequest.objects.all()
#     serializer_class = ProvinceKillRequestProvinceWageSerializer
#     pagination_class = CustomPagination
#     permission_classes = [TokenHasReadWriteScope]
#     filter_backends = [DjangoFilterBackend]
#     filterset_class = ProvinceKillRequestFilterSet
#     filterset_fields = [
#         'province_request__poultry_request__chicken_breed',
#         'province_request__poultry_request__order_code',
#         'province_request__poultry_request__poultry__address__city__name',
#         'province_request__poultry_request__poultry__user__mobile',
#         'province_request__poultry_request__poultry__user__fullname',
#
#     ]
#
#     def list(self, request, *args, **kwargs):
#         if 'type' in request.GET:
#             if 'date1' in request.GET:
#                 date1 = datetime.strptime(str(request.GET['date1']), '%Y-%m-%d').date()
#
#                 date2 = datetime.strptime(str(request.GET['date2']), '%Y-%m-%d').date()
#
#             if request.GET['role'] in ['ProvinceOperator', 'SuperAdmin']:
#                 if request.GET['type'] == 'unpaid':
#                     if 'date1' in request.GET:
#
#                         province_kill_request = self.queryset.filter(killhouse_user__key=request.GET['kill_house_key'],
#                                                                      state__in=('pending', 'accepted'), wage_pay=False,
#                                                                      archive_by_province=False,
#                                                                      return_to_province=False,
#                                                                      kill_request__recive_date__date__gte=date1,
#                                                                      kill_request__recive_date__date__lte=date2,
#                                                                      trash=False).order_by('kill_request__recive_date')
#                     else:
#                         province_kill_request = self.queryset.filter(killhouse_user__key=request.GET['kill_house_key'],
#                                                                      state__in=('pending', 'accepted'), wage_pay=False,
#                                                                      archive_by_province=False,
#                                                                      return_to_province=False,
#                                                                      trash=False).order_by('kill_request__recive_date')
#
#                 elif request.GET['type'] == 'archive':
#                     if 'date1' in request.GET:
#
#                         province_kill_request = self.queryset.filter(killhouse_user__key=request.GET['kill_house_key'],
#                                                                      state__in=('pending', 'accepted'), wage_pay=False,
#                                                                      archive_by_province=True,
#                                                                      return_to_province=False,
#                                                                      kill_request__recive_date__date__gte=date1,
#                                                                      kill_request__recive_date__date__lte=date2,
#                                                                      trash=False).order_by('kill_request__recive_date')
#                     else:
#                         province_kill_request = self.queryset.filter(killhouse_user__key=request.GET['kill_house_key'],
#                                                                      state__in=('pending', 'accepted'), wage_pay=False,
#                                                                      archive_by_province=True,
#                                                                      return_to_province=False,
#
#                                                                      trash=False).order_by('kill_request__recive_date')
#
#
#                 else:
#                     if 'date1' in request.GET:
#
#                         province_kill_request = self.queryset.filter(killhouse_user__key=request.GET['kill_house_key'],
#                                                                      state__in=('pending', 'accepted'), wage_pay=True,
#                                                                      archive_by_province=False,
#                                                                      return_to_province=False,
#                                                                      kill_request__recive_date__date__gte=date1,
#                                                                      kill_request__recive_date__date__lte=date2,
#                                                                      trash=False).order_by('kill_request__recive_date')
#                     else:
#                         province_kill_request = self.queryset.filter(killhouse_user__key=request.GET['kill_house_key'],
#                                                                      state__in=('pending', 'accepted'), wage_pay=True,
#                                                                      archive_by_province=False,
#                                                                      return_to_province=False,
#                                                                      trash=False).order_by('kill_request__recive_date')
#
#             else:
#                 user = SystemUserProfile.objects.get(user=request.user, trash=False)
#                 kill_house = KillHouse.objects.filter(kill_house_operator__user=user, trash=False)
#
#                 if request.GET['type'] == 'unpaid':
#                     if 'date1' in request.GET:
#
#                         province_kill_request = self.queryset.filter(killhouse_user__in=kill_house,
#                                                                      state__in=('pending', 'accepted'), wage_pay=False,
#                                                                      archive_by_province=False,
#                                                                      return_to_province=False,
#                                                                      kill_request__recive_date__date__gte=date1,
#                                                                      kill_request__recive_date__date__lte=date2,
#                                                                      trash=False).order_by('kill_request__recive_date')
#                     else:
#                         province_kill_request = self.queryset.filter(killhouse_user__in=kill_house,
#                                                                      state__in=('pending', 'accepted'), wage_pay=False,
#                                                                      archive_by_province=False,
#                                                                      return_to_province=False,
#                                                                      trash=False).order_by('kill_request__recive_date')
#                 elif request.GET['type'] == 'archive':
#                     if 'date1' in request.GET:
#
#                         province_kill_request = self.queryset.filter(killhouse_user__in=kill_house,
#                                                                      state__in=('pending', 'accepted'), wage_pay=False,
#                                                                      archive_by_province=True,
#                                                                      return_to_province=False,
#                                                                      kill_request__recive_date__date__gte=date1,
#                                                                      kill_request__recive_date__date__lte=date2,
#                                                                      trash=False).order_by('kill_request__recive_date')
#                     else:
#
#                         province_kill_request = self.queryset.filter(killhouse_user__in=kill_house,
#                                                                      state__in=('pending', 'accepted'), wage_pay=False,
#                                                                      archive_by_province=True,
#                                                                      return_to_province=False,
#                                                                      trash=False).order_by('kill_request__recive_date')
#
#                 else:
#
#                     if 'date1' in request.GET:
#
#                         province_kill_request = self.queryset.filter(killhouse_user__in=kill_house,
#                                                                      state__in=('pending', 'accepted'), wage_pay=True,
#                                                                      archive_by_province=False,
#                                                                      return_to_province=False,
#                                                                      kill_request__recive_date__date__gte=date1,
#                                                                      kill_request__recive_date__date__lte=date2,
#                                                                      trash=False).order_by('kill_request__recive_date')
#                     else:
#                         province_kill_request = self.queryset.filter(killhouse_user__in=kill_house,
#                                                                      state__in=('pending', 'accepted'), wage_pay=True,
#                                                                      archive_by_province=False,
#                                                                      return_to_province=False,
#                                                                      trash=False).order_by('kill_request__recive_date')
#             if 'search' in request.GET:
#                 if request.GET['search'] == 'filter':
#                     if request.GET['value'] != "":
#                         for item in self.filterset_fields:
#                             query = QueryDict('{0}__contains={1}'.format(item, request.GET['value']))
#                             if (self.filterset_class(
#                                     data=query,
#                                     queryset=province_kill_request
#                             )
#                             ).filter():
#                                 ps = self.filterset_class(data=query, queryset=province_kill_request)
#                                 province_kill_request = ps.filter()
#                     else:
#                         province_kill_request = province_kill_request
#
#             page_size = request.query_params.get('page_size', None)
#             if page_size:
#                 self.pagination_class.page_size = int(page_size)
#
#             page = self.paginate_queryset(province_kill_request)
#             if page is not None:
#                 serializer = self.get_serializer(page, many=True)
#                 return self.get_paginated_response(serializer.data)
#
#             serializer = self.get_serializer(province_kill_request, many=True)
#             return Response(serializer.data, status=status.HTTP_200_OK)


# ویوست مربوط به تایید یا رد تخصیص از سمت استان توسط کشتارگاه
class KillHouseCheckRequestViewSet(viewsets.ModelViewSet):
    queryset = KillHouseCheckRequest.objects.all()
    serializer_class = KillHouseCheckRequestSerializer
    permission_classes = [TokenHasReadWriteScope]

    # تابع مربوط به تایید یا رد تخصیص از سمت استان توسط کشتارگاه
    def create(self, request, *args, **kwargs):
        # refresh(request.user.id)
        user = SystemUserProfile.objects.get(user=request.user)
        # role = request.data['role']
        province_kill_house_request = ProvinceKillRequest.objects.get(key=request.data['province_kill_request_key'],
                                                                      trash=False)
        kill_request = KillRequest.objects.get(id=province_kill_house_request.kill_request.id, trash=False)
        request.data.pop('province_kill_request_key')
        # request.data.pop('role')
        province_check = ProvinceCheckOperatorRequest.objects.get(id=province_kill_house_request.province_request.id,
                                                                  trash=False)
        poultry_request = PoultryRequest.objects.get(key=province_check.poultry_request.key)
        hatching = PoultryHatching.objects.get(key=poultry_request.hatching.key)
        serializer = self.serializer_class(data=request.data)
        if serializer.is_valid():
            if KillHouseCheckRequest.objects.filter(province_kill_request=province_kill_house_request,
                                                    trash=False).exists():
                return Response({'result': 'already exist'}, status=status.HTTP_403_FORBIDDEN)
            kill_house_check_request = serializer.create(validated_data=request.data)
            kill_house_check_request.province_kill_request = province_kill_house_request

            if kill_house_check_request.state == 'accepted':
                province_kill_house_request.state = 'accepted'
                province_kill_house_request.save()
                # barcode = kill_house_request.bar_code
                # driver_mobile = kill_house_request.car['driver_mobile']
                # driver_name = kill_house_request.car['driver_name']
                # quantity = kill_house_request.quantity
                # kill_house = kill_house_request.kill_request.kill_house.name
                # poultry = kill_house_request.province_request.city_request_Poultry.poultry_request.user.fullname
                # province = kill_house_request.province_request.city_request_Poultry.poultry_request.user.address.province
                # city = kill_house_request.province_request.city_request_Poultry.poultry_request.user.address.city
                # address = kill_house_request.province_request.city_request_Poultry.poultry_request.user.address.address
                # date = kill_house_request.province_request.city_request_Poultry.poultry_request.send_date.date()
                # date = (str(jdatetime.datetime.fromgregorian(year=date.year, month=date.month, day=date.day).date()))
                # time1 = kill_request.recive_time
                # list1 = reversed(date.split('-'))
                # s = "-"
                # date1 = s.join(list1)
                # time = reversed(kill_request.recive_time.split('-'))
                # o = "-"
                # time1 = o.join(time)
                # driver_sms(driver_mobile, driver_name, quantity, poultry, barcode, province, city, address, date,
                #            time1,
                #            kill_house)
            elif kill_house_check_request.state == 'rejected':
                if poultry_request.free_sale_in_province == True:
                    hatching.free_killed_quantity -= int(
                        province_kill_house_request.main_quantity * poultry_request.Index_weight)
                    hatching.free_killed_quantity -= province_kill_house_request.main_quantity
                else:
                    hatching.governmental_killed_quantity -= int(
                        province_kill_house_request.main_quantity * poultry_request.Index_weight)
                    hatching.governmental_quantity -= province_kill_house_request.main_quantity
                # hatching.killed_quantity -= province_kill_house_request.main_quantity
                hatching.save()
                province_kill_house_request.state = 'rejected'
                province_kill_house_request.message = kill_house_check_request.message
                province_kill_house_request.save()
                province_check.quantity += province_kill_house_request.quantity
                province_check.save()
                # kill_request.cars.append(kill_house_request.car)
                kill_request.remain_quantity += province_kill_house_request.quantity
                kill_request.save()
                poultry_request.remain_quantity += province_kill_house_request.quantity
                poultry_request.save()
            # kill_house_check_request.role = {
            #     "role": role,
            #     "name": user.fullname,
            #     "mobile": user.mobile
            # }
            kill_house_check_request.save()
            if kill_house_check_request.state == 'accepted':
                # if SmsLicense.objects.filter().exists():
                province_operator = ProvinceOperator.objects.filter(
                    user=SystemUserProfile.objects.get(role__name='ProvinceOperator', province=user.province))

                if province_operator.count() > 0:
                    province_operator = province_operator.last()
                province_operator_mobile = province_operator.user.mobile
                province_operator_name = province_operator.user.fullname
                kill_house_name = kill_house_check_request.province_kill_request.kill_request.kill_house.name
                kill_house_mobile = kill_house_check_request.province_kill_request.kill_request.kill_house.kill_house_operator.user.mobile
                quantity = kill_house_check_request.province_kill_request.quantity
                chicken_breed = kill_house_check_request.province_kill_request.province_request.poultry_request.chicken_breed
                poultry_name = kill_house_check_request.province_kill_request.province_request.poultry_request.poultry.unit_name
                poultry_mobile = kill_house_check_request.province_kill_request.province_request.poultry_request.poultry.user.mobile
                Index_weight = kill_house_check_request.province_kill_request.province_request.poultry_request.Index_weight
                date_str = str(
                    kill_house_check_request.province_kill_request.province_request.poultry_request.send_date)
                send_date = datetime.strptime(date_str, '%Y-%m-%d %H:%M:%S').date()
                send_date = jdatetime.datetime.fromgregorian(year=send_date.year, month=send_date.month,
                                                             day=send_date.day).strftime('%Y-%m-%d')
                date_list = reversed(send_date.split('-'))
                separate = "-"
                send_date = separate.join(date_list)
                province = kill_house_check_request.province_kill_request.province_request.poultry_request.poultry.address.province.name
                city = kill_house_check_request.province_kill_request.province_request.poultry_request.poultry.address.city.name
                # kill_house_province_kill_request_accept_to_province_sms(province_operator_mobile,
                #                                                         province_operator_name, quantity,
                #                                                         chicken_breed, send_date, poultry_name,
                #                                                         poultry_mobile, province, city, kill_house_name,
                #
                #                                                         )

            kill_house_check_request_serializer = self.serializer_class(kill_house_check_request)
            return Response(kill_house_check_request_serializer.data, status=status.HTTP_201_CREATED)
        return Response(serializer.errors, status=status.HTTP_403_FORBIDDEN)


class KillHouseWareHouseAcceptedKillHouseRequestViewSet(viewsets.ModelViewSet):
    queryset = KillHouseRequest.objects.all()
    serializer_class = KillHouseRequestSerializer
    permission_classes = [TokenHasReadWriteScope]

    def update(self, request, pk=None, *args, **kwargs):
        kill_house_request = KillHouseRequest.objects.get(key=request.data['kill_house_request_key'], trash=False)
        request.data.pop('kill_house_request_key')
        kill_house = kill_house_request.killhouse_user
        bar_date = kill_house_request.kill_request.recive_date.date() + timedelta(days=1)
        now = datetime.now().date()
        product = RolesProducts.objects.filter(parent_product__product_id=2, kill_house=kill_house).first()
        if not product:
            return Response(
                {"result": "جهت افزایش موجودی محصول ابتدا محصول را برای کشتارگاه ثبت کنید! "},
                status=status.HTTP_403_FORBIDDEN)
        if kill_house_request.date_of_ware_house:
            if now != datetime.strptime(kill_house_request.date_of_ware_house, '%Y-%m-%d %H:%M:%S.%f').date():
                return Response(
                    {"result": "بازه زمانی ویرایش این بار به اتمام رسیده ! "},
                    status=status.HTTP_403_FORBIDDEN)
            input_weight = request.data['ware_house_accepted_real_weight'] if request.data[
                                                                                  'input_type'] == 'input_weight' else int(
                kill_house_request.accepted_real_weight - (
                        (kill_house_request.accepted_real_weight * request.data['loss_percent']) / 100))
            if kill_house_request.ware_house_accepted_real_weight > input_weight:
                diffrence = kill_house_request.ware_house_accepted_real_weight - input_weight
                if product.total_remain_weight - diffrence < 0:
                    return Response(
                        {"result": "به علت منفی شدن موجودی انبار امکان ویرایش وجود ندارد! "},
                        status=status.HTTP_403_FORBIDDEN)

        if request.data['input_type'] == 'input_weight':
            kill_house_request.ware_house_accepted_real_quantity = request.data['ware_house_accepted_real_quantity']
            kill_house_request.ware_house_accepted_real_weight = request.data['ware_house_accepted_real_weight']
            kill_house_request.weight_loss = request.data['loss_percent']
        else:
            # kill_house_request.ware_house_accepted_real_quantity = int(kill_house_request.accepted_real_quantity - (
            #         (kill_house_request.accepted_real_quantity * request.data['loss_percent']) / 100))
            kill_house_request.ware_house_accepted_real_quantity = kill_house_request.accepted_real_quantity
            kill_house_request.ware_house_accepted_real_weight = int(kill_house_request.accepted_real_weight - (
                    (kill_house_request.accepted_real_weight * request.data['loss_percent']) / 100))
            kill_house_request.weight_loss = request.data['loss_percent']
        poultry_prediction(kill_house_request.province_request.poultry_request.poultry)

        kill_house_request.ware_house_input_type = request.data['input_type']
        kill_house_request.ware_house_confirmation = True
        kill_house_request.date_of_ware_house = str(datetime.now())
        govermental_commitment_percent = kill_house.in_province_governmental_selling_percent
        free_commitment_percent = kill_house.in_province_free_selling_percent
        if kill_house_request.province_request.poultry_request.free_sale_in_province:
            kill_house_request.warehouse_commitment_weight = int(
                (free_commitment_percent / 100) * kill_house_request.ware_house_accepted_real_weight)
        else:
            kill_house_request.warehouse_commitment_weight = int(
                (govermental_commitment_percent / 100) * kill_house_request.ware_house_accepted_real_weight)
        if 'input_warehouse' in request.data.keys():
            if request.data['input_warehouse'] == 'self':
                kill_house_request.input_warehouse = kill_house_request.killhouse_user
            else:
                kill_house_request.input_warehouse = kill_house_request.killer
                product = RolesProducts.objects.filter(parent_product__product_id=2,
                                                       kill_house=kill_house_request.killer).first()

        else:
            kill_house_request.input_warehouse = kill_house_request.killhouse_user

        kill_house_request.save()
        kill_house_requests_product_warehousing(product)
        return Response({"result": "با موفقیت انجام شد"}, status=status.HTTP_200_OK)


#  ویوست مربوط به ایجاد درخواست کشتار توسط کشتارگاه بعد از تخصیص
class KillHouseRequestViewSet(viewsets.ModelViewSet):
    queryset = KillHouseRequest.objects.all()
    serializer_class = KillHouseRequestSerializer
    permission_classes = [TokenHasReadWriteScope]

    #  تابع مربوط به ایجاد درخواست کشتار توسط کشتارگاه بعد از تخصیص
    def create(self, request, *args, **kwargs):

        limitation_direct_purchase = LimitationForDirectPurchaseAndBarInformation.objects.filter(
            trash=False, active=True).first()
        is_in_limitation_range = False

        if limitation_direct_purchase and limitation_direct_purchase.start_time and limitation_direct_purchase.end_time:
            current_time = datetime.now().time()
            if limitation_direct_purchase.start_time <= current_time <= limitation_direct_purchase.end_time:
                is_in_limitation_range = True

        if not is_in_limitation_range:
            time_range = TimeRange.objects.filter(trash=False).first()
            if time_range:
                time = next(
                    (t for t in time_range.time_range if
                     t.get("name") == "kill_house_request" and t.get("active", False)),
                    None)
                if time:
                    start_hour = datetime.strptime(time.get("start", 0), "%H:%M:%S").time()
                    end_hour = datetime.strptime(time.get("end", 0), "%H:%M:%S").time()
                    current_hour = datetime.now().time().replace(second=0, microsecond=0)
                    if not (start_hour < current_hour < end_hour):
                        return Response(
                            {"result": "لطفا در ساعات مجاز برای ثبت درخواست اقدام نمایید!"},
                            status=status.HTTP_403_FORBIDDEN)
        real_car = None
        killer_for_kill_house = None
        if 'real_car_key' in request.data.keys():
            real_car = KillHouseADDCAR.objects.get(key=request.data['real_car_key'], trash=False)
            request.data.pop('real_car_key')
        date_time_of_now = datetime.now().date()
        tomorrow = datetime.now().date() + timedelta(days=1)
        role = request.data['role']
        request.data.pop('role')
        dict1 = {}
        try:
            kill_house_auction_winner_key = request.data['winner_key']

            kill_house_auction_winner = KillHouseRequestActionWinner.objects.get(key=kill_house_auction_winner_key,
                                                                                 trash=False)
            kill_house = kill_house_auction_winner.kill_house_request_auction.kill_house
            request.data.pop('winner_key')

        except:
            kill_house_auction_winner = None

        try:
            kill_house_check_key = request.data['kill_house_check_key']

            kill_house_check = KillHouseCheckRequest.objects.get(key=kill_house_check_key, trash=False)
            kill_house = kill_house_check.province_kill_request.kill_request.kill_house
            request.data.pop('kill_house_check_key')

        except:
            kill_house_check = None
        if kill_house_check != None:
            kill_house = KillHouse.objects.get(id=kill_house_check.province_kill_request.kill_request.kill_house.id,
                                               trash=False)
            kill_req = KillRequest.objects.get(id=kill_house_check.province_kill_request.kill_request.id, trash=False)
            if OperationLimitation.objects.all().first().kill_house_allocation_limitation == True:

                if date_time_of_now != kill_req.recive_date.date():
                    # if date_time_of_now > kill_req.recive_date.date() + timedelta(days=1):
                    return Response({"result": "مغایرت در تاریخ اعلام نیاز کشتار گاه و تاریخ تخصیص به خودرو !"},
                                    status=status.HTTP_403_FORBIDDEN)
            province_request = ProvinceCheckOperatorRequest.objects.get(
                id=kill_house_check.province_kill_request.province_request.id, trash=False)
            province_kill_request = ProvinceKillRequest.objects.get(id=kill_house_check.province_kill_request.id,
                                                                    trash=False)
            if province_kill_request.market:
                if province_kill_request.first_car_allocated_quantity > 0:
                    if province_kill_request.total_killed_quantity + request.data[
                        'quantity'] > province_kill_request.main_quantity:
                        return Response(
                            {"result": "مجموع  حجم ماشین های ایجاد شده بیشتر از تخصیص  داده شده از پنل معاملات میباشد"},
                            status=status.HTTP_403_FORBIDDEN)
                else:
                    if request.data['quantity'] > province_kill_request.main_quantity:
                        return Response(
                            {"result": "مجموع  حجم ماشین های ایجاد شده بیشتر از تخصیص  داده شده از پنل معاملات میباشد"},
                            status=status.HTTP_403_FORBIDDEN)
            poultry_request = PoultryRequest.objects.get(key=province_request.poultry_request.key)
            poultry_hatching = PoultryHatching.objects.get(key=poultry_request.hatching.key)

            user = province_request.city_request_Poultry.poultry_request.poultry.user
            if province_kill_request.quantity == 0:
                return Response({"result": "quantity is 0"}, status=status.HTTP_403_FORBIDDEN)
        elif kill_house_auction_winner != None:
            user = kill_house_auction_winner.kill_house_request_auction.poultry_request.poultry.user
            kill_house = KillHouse.objects.get(id=kill_house_auction_winner.kill_house_request_auction.kill_house.id,
                                               trash=False)
        if 'killer_key' in request.data.keys():
            if request.data['killer_key'] != None:
                killer_for_kill_house = KillHouse.objects.get(key=request.data['killer_key'], trash=False)
                if kill_house.id != killer_for_kill_house.id:
                    kill_house_purchase = KillHousePurchaseRequest.objects.filter(limitation=True,
                                                                                  kill_house=killer_for_kill_house).first()
                    if kill_house_purchase:
                        total_unpaid_wage = 0
                        total_paid_wage = 0

                        total_unpaid_wage = get_finance_info(killer_for_kill_house)['total_price']
                        slaughter_transactions = InternalTransaction.objects.filter(
                            kill_house=killer_for_kill_house, status='completed',
                            trash=False)

                        total_paid_wage += slaughter_transactions.aggregate(total=Sum('amount'))[
                                               'total'] or 0
                        total_amount = total_unpaid_wage - total_paid_wage
                        if total_amount >= kill_house_purchase.limitation_number:
                            return Response(
                                {
                                    "result": "به علت بدهی کشتارکن اختصاصی امکان ایجاد بار برای کشتار کن امکان پذیر نیست!"},
                                status=status.HTTP_403_FORBIDDEN)
            request.data.pop('killer_key')

        car = request.data['car']
        add_car = KillHouseADDCAR.objects.get(key=car['key'], trash=False)
        request.data.pop('car')
        if request.data['quantity'] > (poultry_hatching.left_over + province_kill_request.main_quantity + (
                (poultry_hatching.quantity * 5) / 100)):
            return Response({"result": "تعداد قطعه وارد شده بیشتراز مانده در سالن مرغدار است!"},
                            status=status.HTTP_403_FORBIDDEN)
        if kill_house.max_kill_limit and kill_house.total_kill_capacity > 0:
            extra_bar_kill_percent = (kill_house.extra_bar_kill_percent / 100) * kill_house.total_kill_capacity

            total_province_kill_requests = ProvinceKillRequest.objects.filter(trash=False, return_to_province=False,
                                                                              archive_wage=False,
                                                                              state__in=('pending', 'accepted'),
                                                                              killhouse_user=kill_house,
                                                                              first_car_allocated_quantity=0,
                                                                              kill_request__recive_date__date=kill_req.recive_date.date()).exclude(
                id=kill_house_check.province_kill_request.id)

            total_province_kill_requests_quantity_with_out_bar = \
                total_province_kill_requests.aggregate(total=Sum('total_killed_quantity'))['total'] or 0

            total_kill_house_requests = KillHouseRequest.objects.filter(trash=False,
                                                                        archive_wage=False,
                                                                        killhouse_user=kill_house,
                                                                        kill_request__recive_date__date=kill_req.recive_date.date())
            total_kill_house_requests_quantity = \
                total_kill_house_requests.aggregate(total=Sum('accepted_real_quantity'))['total'] or 0

            if (
                    kill_house.total_kill_capacity + extra_bar_kill_percent) < total_kill_house_requests_quantity + \
                    request.data['quantity'] + total_province_kill_requests_quantity_with_out_bar:
                return Response({"result": "تعداد وارد شده از مانده سهمیه کشتار روزانه کشتارگاه بیشتر است !"},
                                status=status.HTTP_403_FORBIDDEN)
        serializer = self.serializer_class(data=request.data)
        if serializer.is_valid():
            kill_house_request = serializer.create(validated_data=request.data)
            kill_house_request.accepted_real_quantity = int(kill_house_request.quantity)
            kill_house_request.accepted_real_weight = float(
                kill_house_request.quantity) * kill_house_check.province_kill_request.province_request.poultry_request.Index_weight
            if kill_house_check != None:
                bar_code = KillHouseRequest.objects.filter(
                    province_request__city_request_Poultry__poultry_request__poultry__user=user, trash=False)

            else:
                bar_code = KillHouseRequest.objects.filter(
                    kill_house_request_auction_winner__kill_house_request_auction__poultry_request__poultry__user=user,
                    trash=False)
            if bar_code.count() > 0:
                bar_code = bar_code.order_by(
                    'create_date')
                if bar_code.last().bar_code != None:
                    kill_house_request.bar_code = bar_code.last().bar_code + 1

            else:
                if kill_house_check != None:
                    kill_house_request.bar_code = int(
                        str(province_request.city_request_Poultry.poultry_request.order_code) + '0001')
                else:
                    kill_house_request.bar_code = int(
                        str(kill_house_auction_winner.kill_house_request_auction.poultry_request.order_code) + '0001')

            if kill_house_check != None:
                kill_house_request.kill_request = kill_req
                kill_house_request.province_request = province_request
                kill_house_request.fee = kill_house_check.province_kill_request.fee
                kill_house_request.province_kill_request = province_kill_request
                kill_house_request.amount = province_kill_request.kill_house_price
                if kill_house_check.state == 'accepted':
                    kill_house_request.state = "accepted"
                kill_house_request.save()

            else:

                kill_house_request.kill_house_request_auction_winner = kill_house_auction_winner
                kill_house_request.state = "accepted"
                kill_house_request.fee = kill_house_auction_winner.fee
                kill_house_request.auction = True
                kill_house_auction_winner.quantity -= int(kill_house_request.quantity)
                kill_house_auction_winner.save()
                kill_house_request.role = {
                    'role': role,
                    'name': user.fullname,
                    'mobile': user.mobile
                }
                kill_house_request.save()

            kill_house_request.car = car
            kill_house_request.add_car = add_car
            if real_car != None:
                kill_house_request.real_add_car = real_car
            if killer_for_kill_house != None:
                kill_house_request.killer = killer_for_kill_house
            kill_house_request.killhouse_user = kill_house
            kill_house_request.show_kill_house = "accepted"
            kill_house_request.save()
            province_kill_request.first_car_allocated_quantity += kill_house_request.quantity
            province_kill_request.save()

            kill_house_request_serializer = self.serializer_class(kill_house_request)

            ware_house = KillHouseWareHouse.objects.filter(kill_house=kill_house, date__date=tomorrow).first()
            if not ware_house:
                ware_house = KillHouseWareHouse(
                    kill_house=kill_house,
                    date=tomorrow
                )
                ware_house.save()

            update_kill_house_requests(province_kill_request, poultry_request)
            update_province_kill_requests(poultry_hatching)
            poultry_prediction(poultry_hatching.poultry)
            vet_farm = VetFarm.objects.filter(trash=False,
                                              poultry=kill_house_request.province_request.poultry_request.poultry).first()
            if vet_farm:
                car_allocation_vet_farm_sms(kill_house_request.kill_request.recive_date.date(),
                                            kill_house_request.province_request.poultry_request.poultry.user.fullname,
                                            kill_house_request.province_request.poultry_request.hatching.chicken_age,
                                            kill_house_request.quantity, kill_house_request.add_car.driver.type_car,
                                            kill_house_request.traffic_code,
                                            kill_house_request.add_car.driver.pelak,
                                            kill_house_request.kill_request.kill_house.name,
                                            vet_farm.vet.user.mobile,
                                            kill_house_request.province_request.poultry_request.amount,
                                            kill_house_request.province_request.poultry_request.free_sale_in_province)

            if kill_house_check != None:

                dict1 = {
                    "kill_house_req_key": str(kill_house_request.key),
                    "kill_req_key": kill_house_request.kill_request.key,
                    "barcod": kill_house_request.bar_code,
                    "kill_house_state": kill_house_request.state,
                    "kill_house_name": kill_house_request.kill_request.kill_house.name,
                    "kill_house_user_name": kill_house_request.kill_request.kill_house.kill_house_operator.user.fullname,
                    "kill_house_user_city": kill_house_request.kill_request.kill_house.system_address.city.name,
                    "kill_house_mobile": kill_house_request.kill_request.kill_house.kill_house_operator.user.mobile,
                    "quantity": kill_house_request.quantity,
                    "time": kill_house_request.kill_request.recive_time,
                    "date": kill_house_request.kill_request.recive_date,
                    "car": kill_house_request.car,
                }
            elif kill_house_auction_winner != None:

                dict1 = {
                    "kill_house_req_key": str(kill_house_request.key),
                    "barcod": kill_house_request.bar_code,
                    "kill_house_state": kill_house_request.state,
                    "kill_house_name": kill_house_request.kill_house_request_auction_winner.kill_house_request_auction.kill_house.name,
                    "kill_house_user_name": kill_house_request.kill_house_request_auction_winner.kill_house_request_auction.kill_house.kill_house_operator.user.fullname,
                    "kill_house_user_city": kill_house_request.kill_house_request_auction_winner.kill_house_request_auction.kill_house.system_address.city.name,
                    "kill_house_mobile": kill_house_request.kill_house_request_auction_winner.kill_house_request_auction.kill_house.kill_house_operator.user.mobile,
                    "quantity": kill_house_request.quantity,
                    "date": kill_house_request.kill_house_request_auction_winner.kill_house_request_auction.poultry_request.send_date,
                    "car": kill_house_request.car,
                }

            # ارسال بار به ایتای دامپزشک (فقط برای همدان و در ساعات 16 تا 23:59)
            if base_url_for_sms_report == 'ha':
                current_hour = datetime.now().hour
                if 16 <= current_hour <= 23:
                    try:
                        send_single_bar_to_eitaa(kill_house_request)
                    except Exception as e:
                        pass

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

    #  تابع مربوط به نمایش درخواست کشتار های ایجاد شده توسط کشتارگاه بعد از تخصیص
    def list(self, request, *args, **kwargs):
        from django.db.models import Q
        info_dict = []
        info_list = []
        # refresh(request.user.id)

        if request.GET['operator'] == 'ProvinceOperator':
            queryset = KillHouseRequest.objects.filter(trash=False).order_by('create_date')
            serializer = KillHouseRequestSerializer(queryset, many=True)
            return Response(serializer.data, status=status.HTTP_200_OK)
        elif request.GET['operator'] == 'VetSupervisor':
            now = datetime.now().date()
            date1 = datetime.strptime(str(request.GET['date1']),
                                      '%Y-%m-%d').date() if 'date1' in request.GET else now
            date2 = datetime.strptime(str(request.GET['date2']),
                                      '%Y-%m-%d').date() if 'date2' in request.GET else now

            querysets_list = KillHouseRequest.objects.filter(
                vet_state__in=('pending', 'accepted'),
                active_state__in=('active', 'inactive'), trash=False).order_by(
                'create_date')
            queryset = [
                queryset_list for queryset_list in querysets_list
                if date1 <= queryset_list.province_request.poultry_request.send_date.date() <= date2
            ]
            if len(queryset) > 0:
                info_list = []

                for kill_house_req_obj in queryset:
                    kill_place = kill_house_req_obj.kill_request.kill_house.name if not kill_house_req_obj.kill_request.slaughter_house else kill_house_req_obj.kill_request.slaughter_house.name
                    real_car = None
                    if kill_house_req_obj.real_add_car != None:
                        real_car = {
                            "real_driver_name": kill_house_req_obj.real_add_car.driver.driver_name,
                            "real_driver_mobile": kill_house_req_obj.real_add_car.driver.driver_mobile,
                            "real_pelak": kill_house_req_obj.real_add_car.driver.pelak,
                            "real_type_car": kill_house_req_obj.real_add_car.driver.type_car
                        }
                    exclusive_killer = None
                    if kill_house_req_obj.killer != None:
                        exclusive_killer = {
                            "killer_name": kill_house_req_obj.killer.name,
                            "killer_mobile": kill_house_req_obj.killer.kill_house_operator.user.mobile,
                            "killer_fullname": kill_house_req_obj.killer.kill_house_operator.user.fullname,
                        }
                    vet_check_date = None
                    vet_check = VetCheckRequest.objects.filter(kill_house_request=kill_house_req_obj).first()
                    if vet_check:
                        vet_check_date = vet_check.create_date
                    if kill_house_req_obj.province_kill_request != None:

                        internal_dict_infos = {
                            "poultry_request_id": kill_house_req_obj.province_request.city_request_Poultry.poultry_request.id,
                            "poultry_request_key": kill_house_req_obj.province_request.city_request_Poultry.poultry_request.key,
                            "chicken_breed": kill_house_req_obj.province_request.city_request_Poultry.poultry_request.chicken_breed,
                            "index_weight": kill_house_req_obj.province_request.city_request_Poultry.poultry_request.Index_weight,
                            "amount": kill_house_req_obj.province_request.city_request_Poultry.poultry_request.amount,
                            "bar_amount": kill_house_req_obj.amount,
                            "poultry_name": kill_house_req_obj.province_request.city_request_Poultry.poultry_request.poultry.user.fullname,
                            "poultry_mobile": kill_house_req_obj.province_request.city_request_Poultry.poultry_request.poultry.user.mobile,
                            "send_date": kill_house_req_obj.province_request.city_request_Poultry.poultry_request.send_date,
                            "create_date": kill_house_req_obj.province_request.city_request_Poultry.poultry_request.create_date,
                            "poultry_request_quantity": kill_house_req_obj.province_request.city_request_Poultry.poultry_request.quantity,
                            "poultry_city": kill_house_req_obj.province_request.city_request_Poultry.poultry_request.poultry.user.city.name,
                            "poultry_province": kill_house_req_obj.province_request.city_request_Poultry.poultry_request.poultry.user.province.name,
                            "barcod": kill_house_req_obj.bar_code,
                            "order_code": kill_house_req_obj.province_request.city_request_Poultry.poultry_request.order_code,
                            "freezing": kill_house_req_obj.province_request.city_request_Poultry.poultry_request.freezing,
                            "kill_house_name": kill_house_req_obj.kill_request.kill_house.name,
                            "kill_house_mobile": kill_house_req_obj.kill_request.kill_house.kill_house_operator.user.mobile,
                            "quantity": kill_house_req_obj.quantity,
                            "time": kill_house_req_obj.kill_request.recive_time,
                            "date": kill_house_req_obj.kill_request.recive_date,
                            "accepted_real_quantity": kill_house_req_obj.accepted_real_quantity,
                            "accepted_real_weight": kill_house_req_obj.accepted_real_weight,
                            "kill_house_request_key": kill_house_req_obj.key,
                            "clearance_code": kill_house_req_obj.clearance_code,
                            "vet_state": kill_house_req_obj.vet_state,
                            "traffic_code": kill_house_req_obj.traffic_code,
                            "driver_name": kill_house_req_obj.add_car.driver.driver_name,
                            "driver_mobile": kill_house_req_obj.add_car.driver.driver_mobile,
                            "pelak": kill_house_req_obj.add_car.driver.pelak,
                            "car_key": kill_house_req_obj.add_car.key,
                            "type_car": kill_house_req_obj.add_car.driver.type_car,
                            "real_car": real_car,
                            "killer": exclusive_killer,
                            "age": (
                                           datetime.now() - kill_house_req_obj.province_kill_request.province_request.city_request_Poultry.poultry_request.hatching.date).days + 1,

                            "vet_check_date": vet_check_date,
                            "first_weight": kill_house_req_obj.quantity * kill_house_req_obj.province_kill_request.province_request.city_request_Poultry.poultry_request.Index_weight,
                            "kill_place": kill_place,
                            "auction": "False"
                        }
                    elif kill_house_req_obj.kill_house_request_auction_winner != None:

                        internal_dict_infos = {
                            "poultry_request_id": kill_house_req_obj.kill_house_request_auction_winner.kill_house_request_auction.poultry_request.id,
                            "poultry_request_key": kill_house_req_obj.kill_house_request_auction_winner.kill_house_request_auction.poultry_request.key,
                            "poultry_name": kill_house_req_obj.kill_house_request_auction_winner.kill_house_request_auction.poultry_request.poultry.user.fullname,
                            "mobile": kill_house_req_obj.kill_house_request_auction_winner.kill_house_request_auction.poultry_request.poultry.user.mobile,
                            "city": kill_house_req_obj.kill_house_request_auction_winner.kill_house_request_auction.poultry_request.poultry.user.city.name,
                            "province": kill_house_req_obj.kill_house_request_auction_winner.kill_house_request_auction.poultry_request.poultry.user.province.name,
                            "send_date": kill_house_req_obj.kill_house_request_auction_winner.kill_house_request_auction.poultry_request.send_date,
                            "freezing": kill_house_req_obj.kill_house_request_auction_winner.kill_house_request_auction.poultry_request.freezing,
                            "create_date": kill_house_req_obj.kill_house_request_auction_winner.kill_house_request_auction.poultry_request.create_date,
                            "poultry_quantity": kill_house_req_obj.kill_house_request_auction_winner.kill_house_request_auction.poultry_request.quantity,
                            "barcod": kill_house_req_obj.bar_code,
                            "kill_house_name": kill_house_req_obj.kill_house_request_auction_winner.kill_house_request_auction.kill_house.name,
                            "kill_house_mobile": kill_house_req_obj.kill_house_request_auction_winner.kill_house_request_auction.kill_house.kill_house_operator.user.mobile,
                            "quantity": kill_house_req_obj.quantity,
                            "time": kill_house_req_obj.kill_request.recive_time,
                            "date": kill_house_req_obj.kill_request.recive_date,
                            "kill_house_request_key": kill_house_req_obj.key,
                            "auction": "True"

                        }

                    info_list.append(internal_dict_infos)
                # info_dict.append(info_list)
            return Response(info_list, status=status.HTTP_200_OK)

        elif request.GET['operator'] == 'KillHouseVet':
            user = SystemUserProfile.objects.get(user=request.user, trash=False)
            # vet = Vet.objects.get(user=user, trash=False)
            kill_house_vet = KillHouseVet.objects.filter(vet__user=user, trash=False)
            kill_house_list = kill_house_vet.values_list('kill_house', flat=True).distinct()
            # for kill_house in kill_house_vet:
            #     kill_house_list.append(kill_house.kill_house)

            now = datetime.now().date()
            date1 = datetime.strptime(str(request.GET['date1']),
                                      '%Y-%m-%d').date() if 'date1' in request.GET else now
            date2 = datetime.strptime(str(request.GET['date2']),
                                      '%Y-%m-%d').date() if 'date2' in request.GET else now

            queryset = KillHouseRequest.objects.filter(
                Q(killhouse_user__in=kill_house_list) | Q(
                    kill_request__slaughter_house__in=kill_house_list),
                province_request__poultry_request__send_date__date__gte=date1,
                province_request__poultry_request__send_date__date__lte=date2,
                vet_state__in=('pending', 'accepted'),
                active_state__in=('active', 'inactive'), trash=False).order_by(
                'create_date')
            # queryset = [
            #     queryset_list for queryset_list in querysets_list
            #     if date1 <= queryset_list.province_request.poultry_request.send_date.date() <= date2
            # ]
            if len(queryset) > 0:
                info_dict = []
                info_list = []

                for kill_house_req_obj in queryset:
                    kill_place = kill_house_req_obj.kill_request.kill_house.name if not kill_house_req_obj.kill_request.slaughter_house else kill_house_req_obj.kill_request.slaughter_house.name
                    vet_check_date = None
                    real_car = None
                    if kill_house_req_obj.real_add_car != None:
                        real_car = {
                            "real_driver_name": kill_house_req_obj.real_add_car.driver.driver_name,
                            "real_driver_mobile": kill_house_req_obj.real_add_car.driver.driver_mobile,
                            "real_pelak": kill_house_req_obj.real_add_car.driver.pelak,
                            "real_type_car": kill_house_req_obj.real_add_car.driver.type_car
                        }
                    exclusive_killer = None
                    if kill_house_req_obj.killer != None:
                        exclusive_killer = {
                            "killer_name": kill_house_req_obj.killer.name,
                            "killer_mobile": kill_house_req_obj.killer.kill_house_operator.user.mobile,
                            "killer_fullname": kill_house_req_obj.killer.kill_house_operator.user.fullname,
                        }
                    vet_check = VetCheckRequest.objects.filter(kill_house_request=kill_house_req_obj).first()
                    if vet_check:
                        vet_check_date = vet_check.create_date
                    if kill_house_req_obj.province_kill_request != None:

                        internal_dict_infos = {
                            "poultry_request_id": kill_house_req_obj.province_request.city_request_Poultry.poultry_request.id,
                            "poultry_request_key": kill_house_req_obj.province_request.city_request_Poultry.poultry_request.key,
                            "chicken_breed": kill_house_req_obj.province_request.city_request_Poultry.poultry_request.chicken_breed,
                            "index_weight": kill_house_req_obj.province_request.city_request_Poultry.poultry_request.Index_weight,
                            "amount": kill_house_req_obj.province_request.city_request_Poultry.poultry_request.amount,
                            "bar_amount": kill_house_req_obj.amount,
                            "poultry_name": kill_house_req_obj.province_request.city_request_Poultry.poultry_request.poultry.user.fullname,
                            "poultry_mobile": kill_house_req_obj.province_request.city_request_Poultry.poultry_request.poultry.user.mobile,
                            "send_date": kill_house_req_obj.province_request.city_request_Poultry.poultry_request.send_date,
                            "freezing": kill_house_req_obj.province_request.city_request_Poultry.poultry_request.freezing,
                            "create_date": kill_house_req_obj.province_request.city_request_Poultry.poultry_request.create_date,
                            "poultry_request_quantity": kill_house_req_obj.province_request.city_request_Poultry.poultry_request.quantity,
                            "poultry_city": kill_house_req_obj.province_request.city_request_Poultry.poultry_request.poultry.user.city.name,
                            "poultry_province": kill_house_req_obj.province_request.city_request_Poultry.poultry_request.poultry.user.province.name,
                            "barcod": kill_house_req_obj.bar_code,
                            "order_code": kill_house_req_obj.province_request.city_request_Poultry.poultry_request.order_code,
                            "kill_house_name": kill_house_req_obj.kill_request.kill_house.name,
                            "kill_house_mobile": kill_house_req_obj.kill_request.kill_house.kill_house_operator.user.mobile,
                            "quantity": kill_house_req_obj.quantity,
                            "time": kill_house_req_obj.kill_request.recive_time,
                            "date": kill_house_req_obj.kill_request.recive_date,
                            "accepted_real_quantity": kill_house_req_obj.accepted_real_quantity,
                            "accepted_real_weight": kill_house_req_obj.accepted_real_weight,
                            "kill_house_request_key": kill_house_req_obj.key,
                            "clearance_code": kill_house_req_obj.clearance_code,
                            "vet_state": kill_house_req_obj.vet_state,
                            "traffic_code": kill_house_req_obj.traffic_code,
                            "driver_name": kill_house_req_obj.add_car.driver.driver_name,
                            "driver_mobile": kill_house_req_obj.add_car.driver.driver_mobile,
                            "pelak": kill_house_req_obj.add_car.driver.pelak,
                            "car_key": kill_house_req_obj.add_car.key,
                            "type_car": kill_house_req_obj.add_car.driver.type_car,
                            "real_car": real_car,
                            "killer": exclusive_killer,
                            "first_weight": kill_house_req_obj.quantity * kill_house_req_obj.province_kill_request.province_request.city_request_Poultry.poultry_request.Index_weight,
                            "age": (
                                           datetime.now() - kill_house_req_obj.province_kill_request.province_request.city_request_Poultry.poultry_request.hatching.date).days + 1,

                            "vet_check_date": vet_check_date,
                            "kill_place": kill_place,
                            "auction": "False"
                        }
                    elif kill_house_req_obj.kill_house_request_auction_winner != None:

                        internal_dict_infos = {
                            "poultry_request_id": kill_house_req_obj.kill_house_request_auction_winner.kill_house_request_auction.poultry_request.id,
                            "poultry_request_key": kill_house_req_obj.kill_house_request_auction_winner.kill_house_request_auction.poultry_request.key,
                            "poultry_name": kill_house_req_obj.kill_house_request_auction_winner.kill_house_request_auction.poultry_request.poultry.user.fullname,
                            "mobile": kill_house_req_obj.kill_house_request_auction_winner.kill_house_request_auction.poultry_request.poultry.user.mobile,
                            "city": kill_house_req_obj.kill_house_request_auction_winner.kill_house_request_auction.poultry_request.poultry.user.city.name,
                            "province": kill_house_req_obj.kill_house_request_auction_winner.kill_house_request_auction.poultry_request.poultry.user.province.name,
                            "send_date": kill_house_req_obj.kill_house_request_auction_winner.kill_house_request_auction.poultry_request.send_date,
                            "freezing": kill_house_req_obj.kill_house_request_auction_winner.kill_house_request_auction.poultry_request.freezing,
                            "create_date": kill_house_req_obj.kill_house_request_auction_winner.kill_house_request_auction.poultry_request.create_date,
                            "poultry_quantity": kill_house_req_obj.kill_house_request_auction_winner.kill_house_request_auction.poultry_request.quantity,
                            "barcod": kill_house_req_obj.bar_code,
                            "kill_house_name": kill_house_req_obj.kill_house_request_auction_winner.kill_house_request_auction.kill_house.name,
                            "kill_house_mobile": kill_house_req_obj.kill_house_request_auction_winner.kill_house_request_auction.kill_house.kill_house_operator.user.mobile,
                            "quantity": kill_house_req_obj.quantity,
                            "time": kill_house_req_obj.kill_request.recive_time,
                            "date": kill_house_req_obj.kill_request.recive_date,
                            "kill_house_request_key": kill_house_req_obj.key,
                            "auction": "True"

                        }

                    info_list.append(internal_dict_infos)
                # info_dict.append(info_list)
            return Response(info_list, status=status.HTTP_200_OK)

        elif request.GET['operator'] == 'KillHouse':
            # info_dict = []
            info_list = []
            user = SystemUserProfile.objects.get(user=request.user, trash=False)
            now = datetime.now().date()
            date1 = datetime.strptime(str(request.GET['date1']),
                                      '%Y-%m-%d').date() if 'date1' in request.GET else now
            date2 = datetime.strptime(str(request.GET['date2']),
                                      '%Y-%m-%d').date() if 'date2' in request.GET else now
            if 'role' in request.GET:
                if request.GET['role'] == 'KillHouseVet':
                    vet = Vet.objects.filter(user=user, trash=False)
                    if vet.count() > 0:
                        kill_house_list = []
                        vet = vet.last()
                        kill_house_vet = KillHouseVet.objects.filter(vet=vet, trash=False)
                        for k_vet in kill_house_vet:
                            kill_house_list.append(k_vet.kill_house)
                        # kill_house = KillHouse.objects.filter(key=kill_house_vet.kill_house.key, trash=False)
                        kill_house_allow_vet = KillHouseAllowVet.objects.filter(kill_house__in=kill_house_list)

                        if kill_house_allow_vet.count() > 0:

                            kill_house_allow_vet = kill_house_allow_vet.last()
                            if vet != None and kill_house_allow_vet.allow == False:
                                return Response(info_list)

                        kill_requests_list = KillHouseRequest.objects.filter((Q(killhouse_user__in=kill_house_list) | Q(
                            kill_request__slaughter_house__in=kill_house_list)),
                                                                             active_state__in=('active', 'inactive'),
                                                                             trash=False)
                        now = datetime.now().date()
                        date1 = datetime.strptime(str(request.GET['date1']),
                                                  '%Y-%m-%d').date() if 'date1' in request.GET else now
                        date2 = datetime.strptime(str(request.GET['date2']),
                                                  '%Y-%m-%d').date() if 'date2' in request.GET else now
                        kill_requests = [
                            kill_request_list for kill_request_list in kill_requests_list
                            if date1 <= kill_request_list.kill_request.recive_date.date() <= date2
                        ]
                        for kill_house_req_obj in kill_requests:
                            vet_check_date = None
                            real_car = None
                            if kill_house_req_obj.real_add_car != None:
                                real_car = {
                                    "real_driver_name": kill_house_req_obj.real_add_car.driver.driver_name,
                                    "real_driver_mobile": kill_house_req_obj.real_add_car.driver.driver_mobile,
                                    "real_pelak": kill_house_req_obj.real_add_car.driver.pelak,
                                    "real_type_car": kill_house_req_obj.real_add_car.driver.type_car
                                }
                            exclusive_killer = None
                            if kill_house_req_obj.killer != None:
                                exclusive_killer = {
                                    "killer_name": kill_house_req_obj.killer.name,
                                    "killer_mobile": kill_house_req_obj.killer.kill_house_operator.user.mobile,
                                    "killer_fullname": kill_house_req_obj.killer.kill_house_operator.user.fullname,
                                }
                            vet_check = VetCheckRequest.objects.filter(kill_house_request=kill_house_req_obj).first()
                            if vet_check:
                                vet_check_date = vet_check.create_date
                            if kill_house_req_obj.province_kill_request != None:
                                check = KillHouseCheckRequest.objects.get(
                                    province_kill_request=kill_house_req_obj.province_kill_request)
                                bar_info = KillHouseAssignmentInformation.objects.filter(
                                    kill_house_request=kill_house_req_obj)
                                if bar_info.count() > 0:
                                    bar_info = bar_info.last()
                                    assignment_info = {
                                        "kill_house_assignment_key": bar_info.key,
                                        "kill_house_weight_without_load": bar_info.car_weight_without_load,
                                        "kill_house_weight_with_load": bar_info.car_weight_with_load,
                                        "kill_house_image_without_load": bar_info.car_weight_without_load_image,
                                        "kill_house_image_with_load": bar_info.car_weight_with_load_image,
                                        "kill_house_net_weight": bar_info.net_weight,
                                        "driver_name": bar_info.kill_house_request.add_car.driver.driver_name,
                                        "pelak": bar_info.kill_house_request.add_car.driver.pelak,
                                        "type_car": bar_info.kill_house_request.add_car.driver.type_car,
                                        "kill_house_assignment_state": bar_info.state,
                                        "real_quantity": bar_info.real_quantity,

                                    }
                                else:
                                    assignment_info = None

                                internal_dict_infos = {
                                    "poultry_request_id": kill_house_req_obj.province_request.city_request_Poultry.poultry_request.id,
                                    "poultry_request_key": kill_house_req_obj.province_request.city_request_Poultry.poultry_request.key,
                                    "amount": kill_house_req_obj.province_request.city_request_Poultry.poultry_request.amount,
                                    "bar_amount": kill_house_req_obj.amount,
                                    "poultry_name": kill_house_req_obj.province_request.city_request_Poultry.poultry_request.poultry.user.fullname,
                                    "poultry_mobile": kill_house_req_obj.province_request.city_request_Poultry.poultry_request.poultry.user.mobile,
                                    "send_date": kill_house_req_obj.province_request.city_request_Poultry.poultry_request.send_date,
                                    "freezing": kill_house_req_obj.province_request.city_request_Poultry.poultry_request.freezing,
                                    "create_date": kill_house_req_obj.province_request.city_request_Poultry.poultry_request.create_date,
                                    "poultry_request_quantity": kill_house_req_obj.province_request.city_request_Poultry.poultry_request.quantity,
                                    "poultry_city": kill_house_req_obj.province_request.city_request_Poultry.poultry_request.poultry.user.city.name,
                                    "poultry_province": kill_house_req_obj.province_request.city_request_Poultry.poultry_request.poultry.user.province.name,
                                    "barcod": kill_house_req_obj.bar_code,
                                    "order_code": kill_house_req_obj.province_request.city_request_Poultry.poultry_request.order_code,
                                    "kill_house_name": kill_house_req_obj.kill_request.kill_house.name,
                                    "kill_house_mobile": kill_house_req_obj.kill_request.kill_house.kill_house_operator.user.mobile,
                                    "quantity": kill_house_req_obj.quantity,
                                    "time": kill_house_req_obj.kill_request.recive_time,
                                    "date": kill_house_req_obj.kill_request.recive_date,
                                    "kill_house_request_key": kill_house_req_obj.key,
                                    "vet_state": kill_house_req_obj.vet_state,
                                    "traffic_code": kill_house_req_obj.traffic_code,
                                    "driver_name": kill_house_req_obj.add_car.driver.driver_name,
                                    "driver_mobile": kill_house_req_obj.add_car.driver.driver_mobile,
                                    "pelak": kill_house_req_obj.add_car.driver.pelak,
                                    "car_key": kill_house_req_obj.add_car.key,
                                    "type_car": kill_house_req_obj.add_car.driver.type_car,
                                    "real_car": real_car,
                                    "killer": exclusive_killer,
                                    "kill_house_check_key": check.key,
                                    "bar_info": assignment_info,
                                    "auction": "False",
                                    "kill_house_create_date": kill_house_req_obj.create_date,
                                    "accepted_real_quantity": kill_house_req_obj.accepted_real_quantity,
                                    "accepted_real_weight": kill_house_req_obj.accepted_real_weight,
                                    "vet_check_date": vet_check_date,
                                    "first_weight": kill_house_req_obj.quantity * kill_house_req_obj.province_kill_request.province_request.city_request_Poultry.poultry_request.Index_weight,

                                    "age": (
                                                   datetime.now() - kill_house_req_obj.province_kill_request.province_request.city_request_Poultry.poultry_request.hatching.date).days + 1,

                                }

                            elif kill_house_req_obj.kill_house_request_auction_winner != None:

                                internal_dict_infos = {
                                    "poultry_name": kill_house_req_obj.kill_house_request_auction_winner.kill_house_request_auction.poultry_request.poultry.user.fullname,
                                    "poultry_mobile": kill_house_req_obj.kill_house_request_auction_winner.kill_house_request_auction.poultry_request.poultry.user.mobile,
                                    "barcod": kill_house_req_obj.bar_code,
                                    "kill_house_name": kill_house_req_obj.kill_house_request_auction_winner.kill_house_request_auction.kill_house.name,
                                    "kill_house_mobile": kill_house_req_obj.kill_house_request_auction_winner.kill_house_request_auction.kill_house.kill_house_operator.user.mobile,
                                    "quantity": kill_house_req_obj.quantity,
                                    "time": kill_house_req_obj.kill_request.recive_time,
                                    "date": kill_house_req_obj.kill_request.recive_date,
                                    "cars": kill_house_req_obj.car,
                                    "kill_house_request_key": kill_house_req_obj.key
                                }

                            info_list.append(internal_dict_infos)
                        # info_dict.append(info_list)
                        return Response(info_list, status=status.HTTP_200_OK)

                else:
                    # kill_house_operator = KillHouseOperator.objects.get(user=user, trash=False)
                    kill_house = KillHouse.objects.filter(kill_house_operator__user=user, trash=False)
                    kill_request_car = KillHouseRequest.objects.filter(
                        (Q(killhouse_user__in=kill_house) | Q(kill_request__slaughter_house__in=kill_house) | Q(
                            killer__in=kill_house)), kill_request__recive_date__date__gte=date1,
                        kill_request__recive_date__date__lte=date2,
                        active_state__in=('active', 'inactive'),
                        assignment_state_archive='pending',
                        trash=False).select_related('province_request__city_request_Poultry__poultry_request',
                                                    'real_add_car__driver', 'killer',
                                                    'kill_request__kill_house__kill_house_operator')

                    # kill_request_car = [
                    #     kill_request for kill_request in kill_requests
                    #     if date1 <= kill_request.kill_request.recive_date.date() <= date2
                    # ]
                    for kill_house_req_obj in kill_request_car:
                        vet_check_date = None
                        real_car = None
                        if kill_house_req_obj.real_add_car != None:
                            real_car = {
                                "real_driver_name": kill_house_req_obj.real_add_car.driver.driver_name,
                                "real_driver_mobile": kill_house_req_obj.real_add_car.driver.driver_mobile,
                                "real_pelak": kill_house_req_obj.real_add_car.driver.pelak,
                                "real_type_car": kill_house_req_obj.real_add_car.driver.type_car
                            }
                        exclusive_killer = None
                        if kill_house_req_obj.killer != None:
                            exclusive_killer = {
                                "killer_name": kill_house_req_obj.killer.name,
                                "killer_mobile": kill_house_req_obj.killer.kill_house_operator.user.mobile,
                                "killer_fullname": kill_house_req_obj.killer.kill_house_operator.user.fullname,
                            }
                        vet_check = VetCheckRequest.objects.filter(kill_house_request=kill_house_req_obj).first()
                        if vet_check:
                            vet_check_date = vet_check.create_date
                        if kill_house_req_obj.province_kill_request != None:
                            check = KillHouseCheckRequest.objects.get(
                                province_kill_request=kill_house_req_obj.province_kill_request)
                            bar_info = KillHouseAssignmentInformation.objects.filter(
                                kill_house_request=kill_house_req_obj)
                            if bar_info.count() > 0:
                                bar_info = bar_info.last()
                                assignment_info = {
                                    "kill_house_assignment_key": bar_info.key,
                                    "kill_house_weight_without_load": bar_info.car_weight_without_load,
                                    "kill_house_weight_with_load": bar_info.car_weight_with_load,
                                    "kill_house_image_without_load": bar_info.car_weight_without_load_image,
                                    "kill_house_image_with_load": bar_info.car_weight_with_load_image,
                                    "kill_house_net_weight": bar_info.net_weight,
                                    "driver_name": bar_info.kill_house_request.add_car.driver.driver_name,
                                    "pelak": bar_info.kill_house_request.add_car.driver.pelak,
                                    "type_car": bar_info.kill_house_request.add_car.driver.type_car,
                                    "kill_house_assignment_state": bar_info.state,
                                    "real_quantity": bar_info.real_quantity,

                                }
                            else:
                                assignment_info = None

                            internal_dict_infos = {
                                "poultry_request_id": kill_house_req_obj.province_request.city_request_Poultry.poultry_request.id,
                                "poultry_request_key": kill_house_req_obj.province_request.city_request_Poultry.poultry_request.key,
                                "amount": kill_house_req_obj.province_request.city_request_Poultry.poultry_request.amount,
                                "bar_amount": kill_house_req_obj.amount,
                                "poultry_name": kill_house_req_obj.province_request.city_request_Poultry.poultry_request.poultry.user.fullname,
                                "poultry_mobile": kill_house_req_obj.province_request.city_request_Poultry.poultry_request.poultry.user.mobile,
                                "send_date": kill_house_req_obj.province_request.city_request_Poultry.poultry_request.send_date,
                                "freezing": kill_house_req_obj.province_request.city_request_Poultry.poultry_request.freezing,
                                "create_date": kill_house_req_obj.province_request.city_request_Poultry.poultry_request.create_date,
                                "poultry_request_quantity": kill_house_req_obj.province_request.city_request_Poultry.poultry_request.quantity,
                                "poultry_city": kill_house_req_obj.province_request.city_request_Poultry.poultry_request.poultry.user.city.name,
                                "poultry_province": kill_house_req_obj.province_request.city_request_Poultry.poultry_request.poultry.user.province.name,
                                "barcod": kill_house_req_obj.bar_code,
                                "order_code": kill_house_req_obj.province_request.city_request_Poultry.poultry_request.order_code,
                                "kill_house_name": kill_house_req_obj.kill_request.kill_house.name,
                                "kill_house_mobile": kill_house_req_obj.kill_request.kill_house.kill_house_operator.user.mobile,
                                "quantity": kill_house_req_obj.quantity,
                                "time": kill_house_req_obj.kill_request.recive_time,
                                "date": kill_house_req_obj.kill_request.recive_date,
                                "kill_house_request_key": kill_house_req_obj.key,
                                "vet_state": kill_house_req_obj.vet_state,
                                "traffic_code": kill_house_req_obj.traffic_code,
                                "driver_name": kill_house_req_obj.add_car.driver.driver_name,
                                "driver_mobile": kill_house_req_obj.add_car.driver.driver_mobile,
                                "pelak": kill_house_req_obj.add_car.driver.pelak,
                                "car_key": kill_house_req_obj.add_car.key,
                                "type_car": kill_house_req_obj.add_car.driver.type_car,
                                "real_car": real_car,
                                "killer": exclusive_killer,
                                "kill_house_check_key": check.key,
                                "free_sale_in_province": kill_house_req_obj.province_request.poultry_request.free_sale_in_province,
                                "bar_info": assignment_info,
                                "age": (
                                               datetime.now() - kill_house_req_obj.province_kill_request.province_request.city_request_Poultry.poultry_request.hatching.date).days + 1,

                                "auction": "False",
                                "kill_house_create_date": kill_house_req_obj.create_date,
                                "accepted_real_quantity": kill_house_req_obj.accepted_real_quantity,
                                "accepted_real_weight": kill_house_req_obj.accepted_real_weight,
                                "vet_check_date": vet_check_date,
                                "first_weight": kill_house_req_obj.quantity * kill_house_req_obj.province_kill_request.province_request.city_request_Poultry.poultry_request.Index_weight,

                            }

                        elif kill_house_req_obj.kill_house_request_auction_winner != None:

                            internal_dict_infos = {
                                "poultry_name": kill_house_req_obj.kill_house_request_auction_winner.kill_house_request_auction.poultry_request.poultry.user.fullname,
                                "poultry_mobile": kill_house_req_obj.kill_house_request_auction_winner.kill_house_request_auction.poultry_request.poultry.user.mobile,
                                "barcod": kill_house_req_obj.bar_code,
                                "kill_house_name": kill_house_req_obj.kill_house_request_auction_winner.kill_house_request_auction.kill_house.name,
                                "kill_house_mobile": kill_house_req_obj.kill_house_request_auction_winner.kill_house_request_auction.kill_house.kill_house_operator.user.mobile,
                                "quantity": kill_house_req_obj.quantity,
                                "time": kill_house_req_obj.kill_request.recive_time,
                                "date": kill_house_req_obj.kill_request.recive_date,
                                "cars": kill_house_req_obj.car,
                                "kill_house_request_key": kill_house_req_obj.key
                            }

                        info_list.append(internal_dict_infos)
                    # info_dict.append(info_list)
                    return Response(info_list, status=status.HTTP_200_OK)

    #  تابع مربوط به ویرایش درخواست کشتار های ایجاد شده توسط کشتارگاه بعد از تخصیص
    def update(self, request, pk=None, *args, **kwargs):
        # refresh(request.user.id)
        now = datetime.now().date()
        user = SystemUserProfile.objects.get(user=request.user, trash=False)
        kill_house_request = KillHouseRequest.objects.get(key=request.data['key'], trash=False)

        if 'traffic_code' in request.data.keys():
            if kill_house_request.clearance_code:
                return Response(
                    {"result": "به علت وارد شدن کد قرنطینه، امکان ویرایش وجود ندارد!"},
                    status=status.HTTP_403_FORBIDDEN
                )

            bar_date = kill_house_request.kill_request.recive_date.date()
            if now != bar_date:
                return Response(
                    {"result": "فقط بار همان روز قابل ویرایش است!"},
                    status=status.HTTP_403_FORBIDDEN
                )

        if 'non_receipt' not in request.data.keys():
            if 'bar_document_status_key' in request.data.keys() and request.data['bar_document_status_key'] != None:
                document_status = BarDocumentStatus.objects.get(key=request.data['bar_document_status_key'])
                kill_house_request.bar_document_status = document_status
                kill_house_request.save()
                request.data.pop('bar_document_status_key')

            if 'quarantine_quantity' not in request.data.keys():
                role = request.data['role']
                if role == 'KillHouse' and now > kill_house_request.kill_request.recive_date.date() + timedelta(days=1) \
                        and 'traffic_code' in request.data.keys():
                    return Response(
                        {"result": "تنها یک روز بعد از ثبت اطلاعات امکان تغییر وجود دارد!"},
                        status=status.HTTP_403_FORBIDDEN)
                request.data.pop('role')
                kill_house_request.editor_traffic_code = {
                    "role": role,
                    "full_name": user.first_name,
                    "mobile": user.mobile
                }
                kill_house_request.save()

        # kill_house_request.assignment_state_archive = 'accepted'
        # kill_house_request.save()
        serializer = self.serializer_class(kill_house_request)
        serializer.update(instance=kill_house_request, validated_data=request.data)
        if kill_house_request.bar_document_status is not None and kill_house_request.bar_document_status.sms == True:
            document_discrepancy_sms(kill_house_request.killhouse_user.killer, kill_house_request.killhouse_user.name,
                                     kill_house_request.bar_code, kill_house_request.bar_document_status.title,
                                     kill_house_request.killhouse_user.kill_house_operator.user.mobile,
                                     kill_house_request.kill_request.recive_date.date())
        return Response(serializer.data, status=status.HTTP_200_OK)

    #  تابع مربوط به حذف درخواست کشتار های ایجاد شده توسط کشتارگاه بعد از تخصیص
    def destroy(self, request, pk=None, *args, **kwargs):
        # refresh(request.user.id)
        tomorrow = datetime.now().date() + timedelta(days=1)
        user = SystemUserProfile.objects.get(user=request.user, trash=False)
        if 'delete_bar' in request.GET:

            kill_house_req = KillHouseRequest.objects.get(key=request.GET['kill_house_request_key'], trash=False)

            if KillHouseAssignmentInformation.objects.filter(kill_house_request=kill_house_req, trash=False).exists():
                return Response({"result": "به علت ورود اطلاعات بار امکان حذف وجود ندارد!"},
                                status=status.HTTP_403_FORBIDDEN)

            # if kill_house_req.vet_state == 'accepted' or kill_house_req.assignment_state_archive == 'True':
            #     return Response({"result": "به علت تایید تخلیه توسط دامپزشک امکان حذف وجود ندارد!"},
            #                     status=status.HTTP_403_FORBIDDEN)
            province_kill_req = ProvinceKillRequest.objects.get(key=kill_house_req.province_kill_request.key,
                                                                trash=False)
            kill_house_req.trash = True
            kill_house_req.save()
            province_kill_req.first_car_allocated_quantity -= kill_house_req.quantity
            if province_kill_req.first_car_allocated_quantity < 0:
                province_kill_req.first_car_allocated_quantity = 0
            province_kill_req.save()
            # kill_house_requests = KillHouseRequest.objects.filter(province_kill_request=province_kill_req,
            #                                                       trash=False)

            poultry_request = PoultryRequest.objects.get(key=province_kill_req.province_request.poultry_request.key,
                                                         trash=False)
            hatching = PoultryHatching.objects.get(key=poultry_request.hatching.key, trash=False)
            update_kill_house_requests(province_kill_req, poultry_request)
            update_province_kill_requests(hatching)
            poultry_prediction(hatching.poultry)


        else:
            kill_house_req = KillHouseRequest.objects.get(key=request.GET['kill_house_request_key'], trash=False)
            if KillHouseAssignmentInformation.objects.filter(kill_house_request=kill_house_req, trash=False).exists():
                return Response({"result": "به علت ورود اطلاعات بار امکان حذف وجود ندارد!"},
                                status=status.HTTP_403_FORBIDDEN)
            if kill_house_req.vet_state == 'accepted' or kill_house_req.clearance_code != None:
                return Response({"result": "به علت وارد شدن کد قرنطینه امکان حذف وجود ندارد!"},
                                status=status.HTTP_403_FORBIDDEN)
            kill_house_req.trash = True
            kill_house_req.save()

            if kill_house_req.kill_house_request_auction_winner != None:
                kill_house_request_auction_winner = KillHouseRequestActionWinner.objects.get(
                    key=kill_house_req.kill_house_request_auction_winner.key)
                kill_house_request_auction_winner.quantity += kill_house_req.quantity
                kill_house_request_auction_winner.save()
            else:
                province_kill_request = ProvinceKillRequest.objects.get(key=kill_house_req.province_kill_request.key,
                                                                        trash=False)
                province_kill_request.first_car_allocated_quantity -= kill_house_req.quantity
                if province_kill_request.first_car_allocated_quantity < 0:
                    province_kill_request.first_car_allocated_quantity = 0
                province_kill_request.save()
                # kill_house_requests = KillHouseRequest.objects.filter(province_kill_request=province_kill_request,
                #                                                       trash=False)
                poultry_request = PoultryRequest.objects.get(
                    key=province_kill_request.province_request.poultry_request.key,
                    trash=False)
                hatching = PoultryHatching.objects.get(key=poultry_request.hatching.key, trash=False)
                vet_farm = VetFarm.objects.filter(trash=False,
                                                  poultry=kill_house_req.province_request.poultry_request.poultry).first()
                delete_car_allocation_vet_farm_sms(kill_house_req.kill_request.recive_date.date(),
                                                   kill_house_req.province_request.poultry_request.poultry.user.fullname,
                                                   kill_house_req.province_request.poultry_request.hatching.chicken_age,
                                                   kill_house_req.quantity, kill_house_req.add_car.driver.type_car,
                                                   kill_house_req.traffic_code,
                                                   kill_house_req.add_car.driver.pelak,
                                                   kill_house_req.kill_request.kill_house.name,
                                                   vet_farm.vet.user.mobile,
                                                   kill_house_req.province_request.poultry_request.amount,
                                                   kill_house_req.province_request.poultry_request.free_sale_in_province
                                                   )
                update_kill_house_requests(province_kill_request, poultry_request)
                update_province_kill_requests(hatching)
                poultry_prediction(hatching.poultry)

        kill_house_req.trash = True
        if 'message' in request.GET:
            message = request.GET['message']
        else:
            message = 'حذف توسط کشتارگاه'

        kill_house_req.message = message
        role = request.GET['role'] if 'role' in request.GET else 'KillHouse'
        now = datetime.now()
        kill_house_req.bar_remover = {
            "full_name": user.fullname,
            "role": role,
            "mobile": user.mobile,
            "date": str(now)
        }
        kill_house_req.save()

        ware_house = KillHouseWareHouse.objects.filter(kill_house=kill_house_req.killhouse_user,
                                                       date__date=tomorrow).first()
        if ware_house:
            ware_house.final_total_number_of_carcasses -= kill_house_req.accepted_real_quantity
            ware_house.final_total_weight_of_carcasses -= kill_house_req.accepted_real_weight
            ware_house.total_number_of_carcasses -= kill_house_req.accepted_real_quantity
            ware_house.total_weight_of_carcasses -= kill_house_req.accepted_real_weight
            ware_house.remain_total_number_of_carcasses -= kill_house_req.accepted_real_quantity
            ware_house.remain_total_weight_of_carcasses -= kill_house_req.accepted_real_weight
            ware_house.bar_quantity -= 1
            # ware_house.allocated_quantity -= kill_house_req.accepted_real_quantity
            ware_house.bar_live_weight -= kill_house_req.accepted_real_weight
            ware_house.number_of_carcasses -= kill_house_req.accepted_real_quantity
            ware_house.save()
        return Response("object deleted", status=status.HTTP_200_OK)


class UpdateKillHouseRequestViewSet(viewsets.ModelViewSet):
    queryset = KillHouseRequest.objects.all()
    serializer_class = KillHouseRequestSerializer
    permission_classes = [TokenHasReadWriteScope]

    def update(self, request, pk=None, *args, **kwargs):
        now = datetime.now().date()
        kill_house_request = KillHouseRequest.objects.get(key=request.data['key'], trash=False)
        if 'traffic_code' in request.data.keys() or 'car_key' in request.data.keys():
            if kill_house_request.clearance_code:
                return Response(
                    {"result": "به علت وارد شدن کد قرنطینه، امکان ویرایش وجود ندارد!"},
                    status=status.HTTP_403_FORBIDDEN
                )

            bar_date = kill_house_request.kill_request.recive_date.date()
            if now != bar_date:
                return Response(
                    {"result": "فقط بار همان روز قابل ویرایش است!"},
                    status=status.HTTP_403_FORBIDDEN
                )
        if 'car_key' in request.data.keys():
            add_car = KillHouseADDCAR.objects.get(key=request.data['car_key'], trash=False)
            kill_house_request.add_car = add_car
            kill_house_request.car = {
                "id": add_car.id,
                "key": str(add_car.key),
                "pelak": add_car.driver.pelak,
                "capocity": add_car.driver.capocity,
                "type_car": add_car.driver.type_car,
                "driver_name": add_car.driver.driver_name,
                "driver_mobile": add_car.driver.driver_mobile,
                "weight_without_load": add_car.driver.weight_without_load,
            }
            kill_house_request.save()
            request.data.pop('car_key')

        serializer = self.serializer_class(kill_house_request)
        serializer.update(instance=kill_house_request, validated_data=request.data)
        return Response(serializer.data, status=status.HTTP_200_OK)


class KillHouseRequestPricingViewSet(viewsets.ModelViewSet):
    queryset = KillHouseRequest.objects.all()
    serializer_class = KillHouseRequestSerializer
    permission_classes = [TokenHasReadWriteScope]

    def update(self, request, pk=None, *args, **kwargs):
        now = datetime.now()
        user = SystemUserProfile.objects.get(user=request.user, trash=False)
        kill_house_request = KillHouseRequest.objects.get(key=request.data['key'], trash=False)
        role = request.data.get('role')
        image = request.FILES.get('file')
        if image:
            file_url = upload_to_liara(image, image.name)
            kill_house_request.image = file_url
        if kill_house_request.price_registerar:
            kill_house_request.price_editor = user.fullname
            kill_house_request.price_editor_role = role
            kill_house_request.price_editor_date = now
        else:
            kill_house_request.price_registerar = user.fullname
            kill_house_request.price_registerar_role = role
            kill_house_request.price_register_date = now
        kill_house_request.save()
        serializer = self.serializer_class(kill_house_request)
        serializer.update(instance=kill_house_request, validated_data=request.data)
        return Response({"result": "با موفقیت انجام شد"}, status=status.HTTP_200_OK)


class KillHouseRequestForCompleteInformationViewSet(viewsets.ModelViewSet):
    queryset = KillHouseRequest.objects.all()
    serializer_class = KillHouseRequestForBarManagementSerializer
    permission_classes = [TokenHasReadWriteScope]
    pagination_class = CustomPagination
    filter_backends = [DjangoFilterBackend]
    filterset_class = KillHouseRequestFilterSet
    filterset_fields = [
        'killhouse_user__kill_house_operator__user__fullname',
        'killhouse_user__kill_house_operator__user__mobile',
        'province_request__poultry_request__poultry__user__fullname',
        'province_request__poultry_request__poultry__user__mobile',
        'province_request__poultry_request__order_code',
        'bar_code',
    ]

    #  تابع مربوط به نمایش درخواست کشتار های ایجاد شده توسط کشتارگاه بعد از تخصیص
    def list(self, request, *args, **kwargs):
        kill_house_request_list = []
        now = datetime.now().date()
        user = SystemUserProfile.objects.get(user=request.user, trash=False)
        date1 = datetime.strptime(str(request.GET['date1']),
                                  '%Y-%m-%d').date() if 'date1' in request.GET else now
        date2 = datetime.strptime(str(request.GET['date2']),
                                  '%Y-%m-%d').date() if 'date2' in request.GET else now
        if request.GET['role'] == 'KillHouseVet':
            kill_house_vet = KillHouseVet.objects.filter(vet__user=user, trash=False)
            kill_house_list = kill_house_vet.values_list('kill_house', flat=True).distinct()
            kill_house_requests = KillHouseRequest.objects.filter(
                Q(killhouse_user__in=kill_house_list) | Q(
                    kill_request__slaughter_house__in=kill_house_list), kill_request__recive_date__date__gte=date1,
                kill_request__recive_date__date__lte=date2,
                assignment_state_archive='pending',
                non_receipt=False,
                trash=False).order_by(
                'create_date')

        else:

            kill_house = KillHouse.objects.filter(kill_house_operator__user=user, trash=False)
            kill_house_requests = KillHouseRequest.objects.filter(
                (Q(killhouse_user__in=kill_house) | Q(kill_request__slaughter_house__in=kill_house) | Q(
                    killer__in=kill_house)), kill_request__recive_date__date__gte=date1,
                kill_request__recive_date__date__lte=date2,
                assignment_state_archive='pending',
                non_receipt=False,
                trash=False)

        if 'search' in request.GET:
            if request.GET['search'] == 'filter':
                if request.GET['value'] != "" and request.GET['value'] != 'undefined':
                    for item in self.filterset_fields:
                        query = QueryDict('{0}__contains={1}'.format(item, request.GET['value']))
                        if (self.filterset_class(
                                data=query,
                                queryset=kill_house_requests
                        )
                        ).filter():
                            ps = self.filterset_class(data=query, queryset=kill_house_requests)
                            kill_house_request_list = ps.filter()
                    kill_house_requests = [] if len(kill_house_request_list) == 0 else kill_house_request_list

        page_size = request.query_params.get('page_size', None)
        if page_size:
            self.pagination_class.page_size = int(page_size)

        page = self.paginate_queryset(kill_house_requests)
        if page is not None:
            serializer = self.serializer_class(page, many=True)
            return self.get_paginated_response(serializer.data)

        serializer = self.serializer_class(kill_house_requests, many=True)
        return Response(serializer.data, status=status.HTTP_200_OK)


class KillHouseRequestStatisticsDashboardViewSet(viewsets.ModelViewSet):
    queryset = KillHouseRequest.objects.all()
    permission_classes = [AllowAny]
    serializer_class = KillHouseRequestSerializer

    def list(self, request, *args, **kwargs):

        now = timezone.now().date()
        ten_days_ago = now - timedelta(days=int(request.GET['day']))

        kill_house_requests_list = []

        for day in range(int(request.GET['day']) + 1):
            date = ten_days_ago + timedelta(days=day)

            total_quantites = KillHouseRequest.objects.filter(
                kill_request__recive_date__date=date,
                trash=False
            ).aggregate(total_quantity=Sum('quantity'))['total_quantity'] or 0

            if 'role' in request.GET:
                if request.GET['role'] == 'CityOperator':
                    user = SystemUserProfile.objects.get(user=request.user)
                    city_operator = CityOperator.objects.get(trash=False, user=user)
                    total_quantity = total_quantites.filter(
                        province_request__poultry_request__poultry__city_operator=city_operator.unit_name)
                elif request.GET['role'] in ['CityJahad', 'CityPoultry']:
                    user = SystemUserProfile.objects.get(user=request.user)
                    total_quantity = total_quantites.filter(
                        province_request__poultry_request__poultry__address__city=user.city)
                else:
                    total_quantity = total_quantites
            else:
                total_quantity = total_quantites

            kill_house_requests_list.append({"date": str(date), "quantity": total_quantity})

        return Response(kill_house_requests_list)


class KillHouseRequestWeightStatisticsDashboardViewSet(viewsets.ModelViewSet):
    queryset = KillHouseRequest.objects.all()
    permission_classes = [AllowAny]
    serializer_class = KillHouseRequestSerializer

    def list(self, request, *args, **kwargs):

        now = timezone.now().date()
        ten_days_ago = now - timedelta(days=int(request.GET['day']))

        kill_house_requests_list = []

        for day in range(int(request.GET['day']) + 1):
            date = ten_days_ago + timedelta(days=day)
            total_weight = 0
            kill_house_requestes = KillHouseRequest.objects.filter(
                kill_request__recive_date__date=date,
                trash=False
            )

            if 'role' in request.GET:
                if request.GET['role'] == 'CityOperator':
                    user = SystemUserProfile.objects.get(user=request.user)
                    city_operator = CityOperator.objects.get(trash=False, user=user)
                    kill_house_requests = kill_house_requestes.filter(
                        province_request__poultry_request__poultry__city_operator=city_operator.unit_name)
                elif request.GET['role'] in ['CityJahad', 'CityPoultry']:
                    user = SystemUserProfile.objects.get(user=request.user)
                    kill_house_requests = kill_house_requestes.filter(
                        province_request__poultry_request__poultry__address__city=user.city)
                else:
                    kill_house_requests = kill_house_requestes
            else:
                kill_house_requests = kill_house_requestes
            if kill_house_requests:
                for kill_house_request in kill_house_requests:
                    kill_house_request_information = KillHouseAssignmentInformation.objects.filter(
                        kill_house_request=kill_house_request).last()
                    if kill_house_request_information:
                        total_weight += kill_house_request_information.net_weight
                    else:
                        total_weight += kill_house_request.province_request.poultry_request.Index_weight * kill_house_request.quantity

            kill_house_requests_list.append({"date": str(date), "weight": total_weight})

        return Response(kill_house_requests_list)


class KillHouseRequestChangeStateViewSet(viewsets.ModelViewSet):
    queryset = KillHouseRequest.objects.all()
    serializer_class = KillHouseRequestSerializer
    permission_classes = [TokenHasReadWriteScope]

    def update(self, request, pk=None, *args, **kwargs):
        # refresh(request.user.id)

        keys = request.data['keys']
        request.data.pop('keys')
        for key in keys:
            kill_house_request = KillHouseRequest.objects.get(key=key, trash=False)
            kill_house_request.show_kill_house = 'accepted'
            kill_house_request.save()
        return Response("objects updated", status=status.HTTP_200_OK)


class KillHouseAssignmentImagesViewSet(viewsets.ModelViewSet):
    queryset = KillHouseAssignmentImages.objects.all()
    serializer_class = KillHouseAssignmentImagesSerializer
    permission_classes = [TokenHasReadWriteScope]

    # تابع مربوط به وارد کردن اطلاعات بار توسط کشتارگاه

    def create(self, request, *args, **kwargs):
        # refresh(request.user.id)
        role = request.data['role']
        request.data.pop('role')
        kill_house = KillHouse.objects.get(key=request.data['kill_house_key'], trash=False)
        request.data.pop('kill_house_key')

        try:
            health_certificate_image = request.data['health_certificate_img']
            request.data.pop('health_certificate_img')

        except:
            health_certificate_image = None
        try:
            national_card_image = request.data['national_card_image']
        except:
            national_card_image = None
        try:
            birth_certificate_image = request.data['birth_certificate_image']
        except:
            birth_certificate_image = None
        try:
            police_clearance_image = request.data['police_clearance_image']
        except:
            police_clearance_image = None
        try:
            no_addiction_image = request.data['no_addiction_image']
        except:
            no_addiction_image = None

        serializer = self.serializer_class(data=request.data)
        if serializer.is_valid():
            kill_house_images = KillHouseAssignmentImages.objects.filter(kill_house=kill_house)
            if kill_house_images.count() > 0:
                kill_house_images = kill_house_images.last()
            else:
                kill_house_images = serializer.create(validated_data=request.data)
            if health_certificate_image != None:
                kill_house_images.health_certificate_image = send_image_to_server(health_certificate_image)
            if national_card_image != None:
                kill_house_images.national_card_image = send_image_to_server(national_card_image)
            if birth_certificate_image != None:
                kill_house_images.birth_certificate_image = send_image_to_server(birth_certificate_image)
            if police_clearance_image != None:
                kill_house_images.police_clearance_image = send_image_to_server(police_clearance_image)
            if no_addiction_image != None:
                kill_house_images.no_addiction_image = send_image_to_server(no_addiction_image)
            kill_house_images.save()

            kill_house_images_serializer = self.serializer_class(kill_house_images)
            return Response(kill_house_images_serializer.data, status=status.HTTP_201_CREATED)

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


class KillHouseAssignmentInformationForAggregateLoadViewSet(viewsets.ModelViewSet):
    queryset = KillHouseAssignmentInformation.objects.all()
    serializer_class = KillHouseAssignmentInformationSerializer
    permission_classes = [TokenHasReadWriteScope]

    def create(self, request, *args, **kwargs):
        now = datetime.now().date()
        user = SystemUserProfile.objects.get(user=request.user)
        kill_house_request = KillHouseRequest.objects.get(key=request.data['kill_house_request_key'], trash=False)
        province_kill_request = ProvinceKillRequest.objects.get(key=kill_house_request.province_kill_request.key)
        poultry_request = PoultryRequest.objects.get(key=province_kill_request.province_request.poultry_request.key)
        hatching = PoultryHatching.objects.get(key=poultry_request.hatching.key)
        kill_house_check = KillHouseCheckRequest.objects.get(
            province_kill_request__key=kill_house_request.province_kill_request.key)
        if OperationLimitation.objects.all().first().vet_check_kill_house_assignment_limitation == True:
            if kill_house_request.vet_state == 'pending':
                return Response({"result": "به علت عدم تایید تخلیه دامپزشک کشتارگاه امکان ثبت اطلاعات وجود ندارد!"},
                                status=status.HTTP_403_FORBIDDEN)
        date_time_of_now = datetime.now().date()
        if OperationLimitation.objects.all().first().kill_house_assignment_limitation == True:

            if date_time_of_now > kill_house_request.kill_request.recive_date.date() + timedelta(days=1):
                return Response({"result": "به علت مغایرت در تاریخ ثبت و تاریخ کشتار امکان ثبت اطلاعات وجود ندارد!"},
                                status=status.HTTP_403_FORBIDDEN)
        role = request.data['role']
        request.data.pop('kill_house_request_key')
        request.data.pop('role')
        assignment_info = KillHouseAssignmentInformation.objects.filter(kill_house_request=kill_house_request).first()
        if not assignment_info:
            assignment_info = KillHouseAssignmentInformation()
            assignment_info.save()

            # serializer = self.serializer_class(data=request.data)
            # if serializer.is_valid():
            #     assignment_info = serializer.create(validated_data=request.data)
        assignment_info.kill_house_check = kill_house_check
        assignment_info.kill_house_request = kill_house_request
        assignment_info.car_weight_with_load = int(request.data['net_weight'])
        assignment_info.net_weight = int(request.data['net_weight'])
        assignment_info.real_quantity = int(request.data['real_quantity'])
        assignment_info.importer = {
            "fullname": user.fullname,
            "mobile": user.mobile,
            "date": str(now),
            "role": role
        }
        assignment_info.save()
        kill_house_request.accepted_real_weight = int(request.data['net_weight'])
        kill_house_request.accepted_real_quantity = int(request.data['real_quantity'])
        kill_house_request.accepted_assignment_real_quantity = int(request.data['net_weight'])
        kill_house_request.accepted_assignment_real_weight = int(request.data['real_quantity'])
        kill_house_request.save()
        # kill_house_requests = KillHouseRequest.objects.filter(province_kill_request=province_kill_request,
        #                                                       trash=False)

        update_kill_house_requests(province_kill_request, poultry_request)
        update_province_kill_requests(hatching)
        poultry_prediction(hatching.poultry)

        kill_house_request.accepted_real_weight = int(request.data['net_weight'])
        kill_house_request.accepted_real_quantity = int(request.data['real_quantity'])
        assignment_info.save()
        if assignment_info.net_weight != 0 and assignment_info.real_quantity != 0 and assignment_info.car_weight_with_load_image != None:
            kill_house_request.assignment_state_archive = 'True'
        kill_house_request.save()

        return Response({"result": "با موفقیت ثبت شد"}, status=status.HTTP_201_CREATED)

    def update(self, request, pk=None, *args, **kwargs):
        image = request.data['image']
        role = request.data['role']
        now = datetime.now()
        user = SystemUserProfile.objects.get(user=request.user, trash=False)
        ran = ''.join(random.choices(string.ascii_uppercase + string.digits, k=15))
        image_url = send_image_to_server(image)
        # upload_object_resize(image_data=image, bucket_name="profileimagedefault",
        #                      object_name="{0}.jpg".format(str(ran)))
        if 'bar_key' in request.data.keys():
            bar_key = request.data['bar_key']
            request.data.pop('bar_key')
            kill_house_request = KillHouseRequest.objects.get(key=bar_key, trash=False)
            kill_house_check = KillHouseCheckRequest.objects.get(
                province_kill_request__key=kill_house_request.province_kill_request.key)
            assignment_info = KillHouseAssignmentInformation.objects.filter(
                kill_house_request__key=bar_key).first()
            if OperationLimitation.objects.all().first().vet_check_kill_house_assignment_limitation == True:
                if kill_house_request.vet_state == 'pending':
                    return Response({"result": "به علت عدم تایید تخلیه دامپزشک کشتارگاه امکان ثبت اطلاعات وجود ندارد!"},
                                    status=status.HTTP_403_FORBIDDEN)
            date_time_of_now = datetime.now().date()
            if OperationLimitation.objects.all().first().kill_house_assignment_limitation == True:

                if date_time_of_now > kill_house_request.kill_request.recive_date.date() + timedelta(days=1):
                    return Response(
                        {"result": "به علت مغایرت در تاریخ ثبت و تاریخ کشتار امکان ثبت اطلاعات وجود ندارد!"},
                        status=status.HTTP_403_FORBIDDEN)

            if not assignment_info:
                assignment_info = KillHouseAssignmentInformation(kill_house_check=kill_house_check,
                                                                 kill_house_request=kill_house_request)
                assignment_info.save()
                # serializer = self.serializer_class(data=request.data)
                # if serializer.is_valid():
                #     assignment_info = serializer.create(validated_data=request.data)
            # assignment_info.car_weight_with_load_image = ARVAN_Kill_house_URL + "{0}.jpg".format(str(ran))
            assignment_info.car_weight_with_load_image = image_url
            assignment_info.importer = {
                "fullname": user.fullname,
                "mobile": user.mobile,
                "date": str(now),
                "role": role
            }
            assignment_info.save()
            kill_house_request = KillHouseRequest.objects.get(key=bar_key, trash=False)
            if assignment_info.net_weight != 0 and assignment_info.real_quantity != 0 and assignment_info.car_weight_with_load_image != None:
                kill_house_request.assignment_state_archive = 'True'
                kill_house_request.save()

        else:
            assingment_info_keys = request.data['bar_keys']
            request.data.pop('bar_keys')
            for assingment_info_key in assingment_info_keys:
                kill_house_request = KillHouseRequest.objects.get(key=assingment_info_key, trash=False)
                kill_house_check = KillHouseCheckRequest.objects.get(
                    province_kill_request__key=kill_house_request.province_kill_request.key)
                if OperationLimitation.objects.all().first().vet_check_kill_house_assignment_limitation == True:
                    if kill_house_request.vet_state == 'pending':
                        return Response(
                            {"result": "به علت عدم تایید تخلیه دامپزشک کشتارگاه امکان ثبت اطلاعات وجود ندارد!"},
                            status=status.HTTP_403_FORBIDDEN)
                date_time_of_now = datetime.now().date()
                if OperationLimitation.objects.all().first().kill_house_assignment_limitation == True:

                    if date_time_of_now > kill_house_request.kill_request.recive_date.date() + timedelta(days=1):
                        return Response(
                            {"result": "به علت مغایرت در تاریخ ثبت و تاریخ کشتار امکان ثبت اطلاعات وجود ندارد!"},
                            status=status.HTTP_403_FORBIDDEN)

                assignment_info = KillHouseAssignmentInformation.objects.filter(
                    kill_house_request__key=assingment_info_key).first()

                if not assignment_info:
                    assignment_info = KillHouseAssignmentInformation(kill_house_check=kill_house_check,
                                                                     kill_house_request=kill_house_request)
                    assignment_info.save()

                if assignment_info.car_weight_with_load_image == None:
                    # assignment_info.car_weight_with_load_image = ARVAN_Kill_house_URL + "{0}.jpg".format(str(ran))
                    assignment_info.car_weight_with_load_image = image_url
                    assignment_info.importer = {
                        "fullname": user.fullname,
                        "mobile": user.mobile,
                        "date": str(now),
                        "role": role
                    }
                    assignment_info.save()
                kill_house_request = KillHouseRequest.objects.get(key=assignment_info.kill_house_request.key,
                                                                  trash=False)
                if assignment_info.net_weight != 0 and assignment_info.real_quantity != 0 and assignment_info.car_weight_with_load_image != None:
                    kill_house_request.assignment_state_archive = 'True'
                    kill_house_request.save()

        return Response({"result": "با موفقیت ثبت شد"}, status=status.HTTP_200_OK)


# class KillHouseAssignmentInformationForcompletedloadsViewSet(viewsets.ModelViewSet):
#     queryset = KillHouseAssignmentInformation.objects.all()
#     serializer_class = KillHouseAssignmentInformationSerializer
#     permission_classes = [TokenHasReadWriteScope]
#
#     def list(self, request, *args, **kwargs):
#         # refresh(request.user.id)
#         user = SystemUserProfile.objects.get(user=request.user, trash=False)
#         now = datetime.now().date()
#         date1 = datetime.strptime(str(request.GET['date1']),
#                                   '%Y-%m-%d').date() if 'date1' in request.GET else now
#         date2 = datetime.strptime(str(request.GET['date2']),
#                                   '%Y-%m-%d').date() if 'date2' in request.GET else now
#         province = user.province.name
#         if request.GET['role'] in ('ProvinceFinancial', 'ProvinceOperator'):
#             kill_house_assignments = KillHouseAssignmentInformation.objects.filter(
#                 Q(car_weight_with_load_image__isnull=False) | Q(car_weight_without_load_image__isnull=False),
#                 kill_house_request__killhouse_user__kill_house_operator__address__province__name=province,
#                 net_weight__gt=0,
#                 real_quantity__gt=0,
#                 kill_house_request__kill_request__recive_date__date__gte=date1,
#                 kill_house_request__kill_request__recive_date__date__lte=date2,
#                 trash=False).select_related(
#                 'kill_house_request__province_request__poultry_request__hatching',
#                 'kill_house_request__province_request__poultry_request__poultry',
#                 'kill_house_request__province_request__poultry_request__poultry__user__city',
#                 'kill_house_request__province_request__poultry_request__poultry__user__province',
#                 'kill_house_request__province_request__poultry_request__poultry__user',
#
#                 'kill_house_request__kill_request__kill_house',
#                 'kill_house_request__kill_request__slaughter_house',
#                 'kill_house_request__killhouse_user',
#                 'kill_house_request__killhouse_user__kill_house_operator__user',
#                 'kill_house_request__add_car__driver',
#                 'kill_house_request__real_add_car__driver',
#             ).values(
#                 "kill_house_request__province_request__poultry_request__poultry__user__province__name",
#                 "kill_house_request__province_request__poultry_request__poultry__user__city__name",
#                 "kill_house_request__province_request__poultry_request__poultry__user__fullname",
#                 "kill_house_request__province_request__poultry_request__poultry__user__mobile",
#                 "kill_house_request__province_request__poultry_request__poultry__unit_name",
#                 "kill_house_request__province_request__poultry_request__poultry__key",
#                 "kill_house_request__province_request__poultry_request__order_code",
#                 "kill_house_request__province_request__poultry_request__quantity",
#                 "kill_house_request__province_request__poultry_request__id",
#                 "kill_house_request__province_request__poultry_request__Index_weight",
#                 "kill_house_request__province_request__poultry_request__chicken_breed",
#                 "kill_house_request__province_request__poultry_request__create_date",
#                 "kill_house_request__province_request__poultry_request__send_date",
#                 "kill_house_request__province_request__poultry_request__cell_type",
#                 "kill_house_request__province_request__poultry_request__hatching__losses",
#                 "kill_house_request__province_request__poultry_request__hatching__date",
#                 "kill_house_request__killhouse_user",
#                 'kill_house_request__kill_request__kill_house__name',
#                 'kill_house_request__kill_request__slaughter_house__name',
#                 "kill_house_request__add_car__driver__driver_name",
#                 "kill_house_request__add_car__driver__driver_mobile",
#                 "kill_house_request__add_car__driver__type_car",
#                 "kill_house_request__add_car__driver__pelak",
#                 "kill_house_request__add_car__driver__health_code",
#                 "kill_house_request__real_add_car__driver__driver_name",
#                 "kill_house_request__real_add_car__driver__driver_mobile",
#                 "kill_house_request__real_add_car__driver__type_car",
#                 "kill_house_request__real_add_car__driver__pelak",
#                 "kill_house_request__real_add_car__driver__health_code",
#                 "kill_house_request__quantity",
#                 "kill_house_request__bar_code",
#                 "kill_house_request__quarantine_quantity",
#                 "kill_house_request__vet_state",
#                 "kill_house_request__assignment_state_archive",
#                 "kill_house_request__clearance_code",
#                 "kill_house_request__traffic_code",
#                 "kill_house_request__accepted_real_quantity",
#                 "kill_house_request__accepted_real_weight",
#                 "kill_house_request",
#                 "car_weight_without_load",
#                 "car_weight_without_load_image",
#                 "car_weight_with_load",
#                 "car_weight_with_load_image",
#                 "net_weight",
#                 "state",
#                 "real_quantity",
#                 "protest_time",
#
#                 # "allocated_car_state"
#             )
#         else:
#             if request.GET['role'] == 'KillHouse':
#                 operator = KillHouseOperator.objects.get(user=user, trash=False)
#                 kill_house = KillHouse.objects.filter(kill_house_operator=operator, trash=False)
#             else:
#                 vet = Vet.objects.get(user=user)
#                 kill_house_vet = KillHouseVet.objects.filter(vet=vet, trash=False)
#                 kill_house_list = [kill_house.kill_house.key for kill_house in kill_house_vet]
#                 kill_house = KillHouse.objects.filter(key__in=kill_house_list)
#
#             kill_house_assignments = KillHouseAssignmentInformation.objects.filter(
#                 # state='pending',
#                 Q(car_weight_with_load_image__isnull=False) | Q(car_weight_without_load_image__isnull=False),
#
#                 kill_house_request__killhouse_user__in=kill_house,
#                 # car_weight_with_load_image__isnull=False,
#                 net_weight__gt=0,
#                 real_quantity__gt=0,
#                 trash=False,
#                 kill_house_request__kill_request__recive_date__date__gte=date1,
#                 kill_house_request__kill_request__recive_date__date__lte=date2,
#                 unusual_casualties=False).select_related(
#                 'kill_house_request__province_request__poultry_request__hatching',
#                 'kill_house_request__province_request__poultry_request__poultry',
#                 'kill_house_request__province_request__poultry_request__poultry__user__city',
#                 'kill_house_request__province_request__poultry_request__poultry__user__province',
#                 'kill_house_request__province_request__poultry_request__poultry__user',
#
#                 'kill_house_request__kill_request__kill_house',
#                 'kill_house_request__kill_request__slaughter_house',
#                 'kill_house_request__killhouse_user',
#                 'kill_house_request__killhouse_user__kill_house_operator__user',
#                 'kill_house_request__add_car__driver',
#                 'kill_house_request__real_add_car__driver',
#             ).values(
#                 "kill_house_request__province_request__poultry_request__poultry__user__province__name",
#                 "kill_house_request__province_request__poultry_request__poultry__user__city__name",
#                 "kill_house_request__province_request__poultry_request__poultry__user__fullname",
#                 "kill_house_request__province_request__poultry_request__poultry__user__mobile",
#                 "kill_house_request__province_request__poultry_request__poultry__unit_name",
#                 "kill_house_request__province_request__poultry_request__poultry__key",
#                 "kill_house_request__province_request__poultry_request__order_code",
#                 "kill_house_request__province_request__poultry_request__quantity",
#                 "kill_house_request__province_request__poultry_request__id",
#                 "kill_house_request__province_request__poultry_request__Index_weight",
#                 "kill_house_request__province_request__poultry_request__chicken_breed",
#                 "kill_house_request__province_request__poultry_request__create_date",
#                 "kill_house_request__province_request__poultry_request__send_date",
#                 "kill_house_request__province_request__poultry_request__cell_type",
#                 "kill_house_request__province_request__poultry_request__hatching__losses",
#                 "kill_house_request__province_request__poultry_request__hatching__date",
#                 "kill_house_request__killhouse_user",
#                 'kill_house_request__kill_request__kill_house__name',
#                 'kill_house_request__kill_request__slaughter_house__name',
#                 "kill_house_request__add_car__driver__driver_name",
#                 "kill_house_request__add_car__driver__driver_mobile",
#                 "kill_house_request__add_car__driver__type_car",
#                 "kill_house_request__add_car__driver__pelak",
#                 "kill_house_request__add_car__driver__health_code",
#                 "kill_house_request__real_add_car__driver__driver_name",
#                 "kill_house_request__real_add_car__driver__driver_mobile",
#                 "kill_house_request__real_add_car__driver__type_car",
#                 "kill_house_request__real_add_car__driver__pelak",
#                 "kill_house_request__real_add_car__driver__health_code",
#                 "kill_house_request__quantity",
#                 "kill_house_request__bar_code",
#                 "kill_house_request__quarantine_quantity",
#                 "kill_house_request__vet_state",
#                 "kill_house_request__assignment_state_archive",
#                 "kill_house_request__clearance_code",
#                 "kill_house_request__traffic_code",
#                 "kill_house_request__accepted_real_quantity",
#                 "kill_house_request__accepted_real_weight",
#                 "kill_house_request",
#                 "car_weight_without_load",
#                 "car_weight_without_load_image",
#                 "car_weight_with_load",
#                 "car_weight_with_load_image",
#                 "net_weight",
#                 "state",
#                 "real_quantity",
#                 "protest_time",
#
#                 # "allocated_car_state"
#             )
#
#         assignments_list_final_state = []
#         allocation = ShareOfAllocation.objects.all()
#         if allocation.count() > 0:
#             allocation = allocation.last().total
#         else:
#             allocation = 0
#         for request_data in kill_house_assignments:
#             poultry_name_of_bank_user = None
#             poultry_bank_name = None
#             poultry_card = None
#             poultry_account = None
#             poultry_shaba = None
#             province_name_of_bank_user = None
#             province_bank_name = None
#             province_card = None
#             province_account = None
#             province_shaba = None
#             kill_house_vet = KillHouseVet.objects.filter(
#                 kill_house=request_data.get('kill_house_request__killhouse_user'), trash=False).select_related('vet__user').values(
#                 'vet__user__fullname',
#                 'vet__user__mobile',
#             )
#             if kill_house_vet.count() > 0:
#                 kill_house_vet = kill_house_vet.last()
#                 kill_house_vet_name = kill_house_vet.get('vet__user__fullname')
#                 kill_house_vet_mobile = kill_house_vet.get('vet__user__mobile')
#             if request_data.get('kill_house_request__kill_request__slaughter_house') != None:
#                 kill_place = request_data.get('kill_house_request__kill_request__slaughter_house__name')
#             else:
#                 kill_place = request_data.get('kill_house_request__kill_request__kill_house__name')
#
#             vet_check = VetCheckRequest.objects.filter(
#                 kill_house_request=request_data.get('kill_house_request'), trash=False).select_related('kill_house_request').values('kill_house_request','create_date').first()
#
#             vet_check_date = vet_check.get('create_date') if vet_check else None
#             poultry = Poultry.objects.filter(
#                 key=request_data.get('kill_house_request__province_request__poultry_request__poultry__key'),
#                 trash=False).select_related('user_bank_info').values(
#                 'user_bank_info',
#                 'user_bank_info__name_of_bank_user',
#                 'user_bank_info__bank_name',
#                 'user_bank_info__card',
#                 'user_bank_info__account',
#                 'user_bank_info__shaba',
#             ).first()
#             if poultry.get('user_bank_info') != None:
#                 poultry_name_of_bank_user = poultry.get('user_bank_info__name_of_bank_user')
#                 poultry_bank_name = poultry.get('user_bank_info__bank_name')
#                 poultry_card = poultry.get('user_bank_info__card')
#                 poultry_account = poultry.get('user_bank_info__account')
#                 poultry_shaba = poultry.get('user_bank_info__shaba')
#             operator = ProvinceOperator.objects.filter(trash=False).select_related('user_bank_info').values(
#                 'user_bank_info',
#                 'user_bank_info__name_of_bank_user',
#                 'user_bank_info__bank_name',
#                 'user_bank_info__card',
#                 'user_bank_info__account',
#                 'user_bank_info__shaba',
#             )
#             if operator.last().get('user_bank_info') != None:
#                 operator = operator.last()
#                 province_name_of_bank_user = operator.get('user_bank_info__name_of_bank_user')
#                 province_bank_name = operator.get('user_bank_info__bank_name')
#                 province_card = operator.get('user_bank_info__card')
#                 province_account = operator.get('user_bank_info__account')
#                 province_shaba = operator.get('user_bank_info__shaba')
#
#             internal_dict = {
#                 "order_code": request_data.get('kill_house_request__province_request__poultry_request__order_code'),
#                 "poultry_province": request_data.get(
#                     'kill_house_request__province_request__poultry_request__poultry__user__province__name'),
#                 "poultry_city": request_data.get(
#                     'kill_house_request__province_request__poultry_request__poultry__user__city__name'),
#                 "poultry_fullname": request_data.get(
#                     'kill_house_request__province_request__poultry_request__poultry__user__fullname'),
#                 "poultry_mobile": request_data.get(
#                     'kill_house_request__province_request__poultry_request__poultry__user__mobile'),
#                 "poultry_name": request_data.get(
#                     'kill_house_request__province_request__poultry_request__poultry__unit_name'),
#                 "poultry_key": request_data.get('kill_house_request__province_request__poultry_request__poultry__key'),
#                 "poultry_request_quantity": request_data.get(
#                     'kill_house_request__province_request__poultry_request__quantity'),
#                 "poultry_request_id": request_data.get('kill_house_request__province_request__poultry_request__id'),
#                 "Index_weight": request_data.get('kill_house_request__province_request__poultry_request__Index_weight'),
#                 "chicken_breed": request_data.get(
#                     'kill_house_request__province_request__poultry_request__chicken_breed'),
#                 "create_date": request_data.get('kill_house_request__province_request__poultry_request__create_date'),
#                 "send_date": request_data.get('kill_house_request__province_request__poultry_request__send_date'),
#                 "cell_type": request_data.get('kill_house_request__province_request__poultry_request__cell_type'),
#                 "losses": request_data.get('kill_house_request__province_request__poultry_request__hatching__losses'),
#                 "hatching__date": request_data.get(
#                     'kill_house_request__province_request__poultry_request__hatching__date'),
#                 "driver_name": request_data.get('kill_house_request__add_car__driver__driver_name'),
#                 "driver_mobile": request_data.get('kill_house_request__add_car__driver__driver_mobile'),
#                 "type_car": request_data.get('kill_house_request__add_car__driver__type_car'),
#                 "pelak": request_data.get('kill_house_request__add_car__driver__pelak'),
#                 "health_code": request_data.get('kill_house_request__add_car__driver__health_code'),
#                 "real_driver_name": request_data.get('kill_house_request__real_add_car__driver__driver_name'),
#                 "real_driver_mobile": request_data.get('kill_house_request__real_add_car__driver__driver_mobile'),
#                 "real_type_car": request_data.get('kill_house_request__real_add_car__driver__type_car'),
#                 "real_pelak": request_data.get('kill_house_request__real_add_car__driver__pelak'),
#                 "real_health_code": request_data.get('kill_house_request__real_add_car__driver__health_code'),
#                 "quantity": request_data.get('kill_house_request__quantity'),
#                 "bar_code": request_data.get('kill_house_request__bar_code'),
#                 "quarantine_quantity": request_data.get('kill_house_request__quarantine_quantity'),
#                 "vet_state": request_data.get('kill_house_request__vet_state'),
#                 "assignment_state_archive": request_data.get('kill_house_request__assignment_state_archive'),
#                 "clearance_code": request_data.get('kill_house_request__clearance_code'),
#                 "traffic_code": request_data.get('kill_house_request__traffic_code'),
#                 "accepted_real_quantity": request_data.get('kill_house_request__accepted_real_quantity'),
#                 "accepted_real_weight": request_data.get('kill_house_request__accepted_real_weight'),
#                 "car_weight_without_load": request_data.get('car_weight_without_load'),
#                 "car_weight_without_load_image": request_data.get('car_weight_without_load_image'),
#                 "car_weight_with_load": request_data.get('car_weight_with_load'),
#                 "car_weight_with_load_image": request_data.get('car_weight_with_load_image'),
#                 "net_weight": request_data.get('net_weight'),
#                 "state": request_data.get('state'),
#                 "real_quantity": request_data.get('real_quantity'),
#                 "protest_time": request_data.get('protest_time'),
#                 "average_weight": request_data.get('net_weight') / request_data.get('real_quantity') ,
#                 "first_weight": request_data.get('kill_house_request__quantity') * request_data.get('kill_house_request__province_request__poultry_request__Index_weight') ,
#                 "poultry_name_of_bank_user": poultry_name_of_bank_user,
#                 "poultry_bank_name": poultry_bank_name,
#                 "poultry_card": poultry_card,
#                 "poultry_account": poultry_account,
#                 "poultry_shaba": poultry_shaba,
#                 "province_name_of_bank_user": province_name_of_bank_user,
#                 "province_bank_name": province_bank_name,
#                 "province_card": province_card,
#                 "province_account": province_account,
#                 "province_shaba": province_shaba,
#                 "kill_house_vet_name": kill_house_vet_name,
#                 "kill_house_vet_mobile": kill_house_vet_mobile,
#                 "kill_place": kill_place,
#                 "vet_check_date": vet_check_date,
#                 "allocation": allocation,
#
#             }
#
#             assignments_list_final_state.append(internal_dict)
#         return Response(len(assignments_list_final_state), status=status.HTTP_200_OK)
class KillHouseAssignmentInformationForcompletedloadsViewSet(viewsets.ModelViewSet):
    queryset = KillHouseAssignmentInformation.objects.all()
    serializer_class = KillHouseAssignmentInformationForCompletedLoadsSerializer
    permission_classes = [TokenHasReadWriteScope]
    pagination_class = CustomPagination

    def list(self, request, *args, **kwargs):
        # refresh(request.user.id)
        user = SystemUserProfile.objects.get(user=request.user, trash=False)
        now = datetime.now().date()
        date1 = datetime.strptime(str(request.GET['date1']),
                                  '%Y-%m-%d').date() if 'date1' in request.GET else now
        date2 = datetime.strptime(str(request.GET['date2']),
                                  '%Y-%m-%d').date() if 'date2' in request.GET else now
        province = user.province.name
        if request.GET['role'] in ('ProvinceFinancial', 'ProvinceOperator'):
            kill_house_assignments = KillHouseAssignmentInformation.objects.filter(
                Q(car_weight_with_load_image__isnull=False) | Q(car_weight_without_load_image__isnull=False),
                kill_house_request__killhouse_user__kill_house_operator__address__province__name=province,
                net_weight__gt=0,
                real_quantity__gt=0,
                kill_house_request__kill_request__recive_date__date__gte=date1,
                kill_house_request__kill_request__recive_date__date__lte=date2,
                trash=False)
        else:
            if request.GET['role'] == 'KillHouse':
                operator = KillHouseOperator.objects.get(user=user, trash=False)
                kill_house = KillHouse.objects.filter(kill_house_operator=operator, trash=False)
            else:
                vet = Vet.objects.get(user=user)
                kill_house_vet = KillHouseVet.objects.filter(vet=vet, trash=False)
                kill_house_list = [kill_house.kill_house.key for kill_house in kill_house_vet]
                kill_house = KillHouse.objects.filter(key__in=kill_house_list)

            kill_house_assignments = KillHouseAssignmentInformation.objects.filter(
                # state='pending',
                Q(car_weight_with_load_image__isnull=False) | Q(car_weight_without_load_image__isnull=False),

                kill_house_request__killhouse_user__in=kill_house,
                # car_weight_with_load_image__isnull=False,
                net_weight__gt=0,
                real_quantity__gt=0,
                trash=False,
                kill_house_request__kill_request__recive_date__date__gte=date1,
                kill_house_request__kill_request__recive_date__date__lte=date2,
                unusual_casualties=False)
        page_size = request.query_params.get('page_size', None)
        if page_size:
            self.pagination_class.page_size = int(page_size)

        page = self.paginate_queryset(kill_house_assignments)
        if page is not None:
            serializer = self.get_serializer(page, many=True)
            return self.get_paginated_response(serializer.data)
        serializer = self.serializer_class(kill_house_assignments, many=True)
        return Response(serializer.data, status=status.HTTP_200_OK)


# ویوست مربوط به وارد کردن اطلاعات بار توسط کشتارگاه
class KillHouseAssignmentInformationViewSet(viewsets.ModelViewSet):
    queryset = KillHouseAssignmentInformation.objects.all()
    serializer_class = KillHouseAssignmentInformationSerializer
    permission_classes = [TokenHasReadWriteScope]
    pagination_class = CustomPagination
    filter_backends = [DjangoFilterBackend]
    filterset_class = KillHouseRequestFilterSet
    filterset_fields = [
        'killhouse_user__kill_house_operator__user__fullname',
        'killhouse_user__kill_house_operator__user__mobile',
        'province_request__poultry_request__poultry__user__fullname',
        'province_request__poultry_request__poultry__user__mobile',
        'province_request__poultry_request__order_code',
        'bar_code',
        'bar_document_status__title',
    ]

    # تابع مربوط به وارد کردن اطلاعات بار توسط کشتارگاه

    def create(self, request, *args, **kwargs):
        # refresh(request.user.id)
        pic = []
        dict1 = {}
        role = request.data['role']
        request.data.pop('role')
        date_time_of_now = datetime.now().date()
        kill_house_request = KillHouseRequest.objects.get(key=request.data['kill_house_request_key'], trash=False)
        province_kill_request = ProvinceKillRequest.objects.get(key=kill_house_request.province_kill_request.key)
        if OperationLimitation.objects.all().first().vet_check_kill_house_assignment_limitation == True:
            if kill_house_request.vet_state == 'pending':
                return Response({"result": "به علت عدم تایید تخلیه دامپزشک کشتارگاه امکان ثبت اطلاعات وجود ندارد!"},
                                status=status.HTTP_403_FORBIDDEN)
        if OperationLimitation.objects.all().first().kill_house_assignment_limitation == True:
            if date_time_of_now > kill_house_request.kill_request.recive_date.date() + timedelta(days=1):
                return Response({"result": "به علت مغایرت در تاریخ ثبت و تاریخ کشتار امکان ثبت اطلاعات وجود ندارد!"},
                                status=status.HTTP_403_FORBIDDEN)

        # if kill_house_request.vet_state == 'pending':
        #     return Response({"result": "بار توسط دامپزشک تخلیه نشده است !"}, status=status.HTTP_403_FORBIDDEN)
        if kill_house_request.province_kill_request != None:
            kill_house_check = KillHouseCheckRequest.objects.get(
                province_kill_request__key=kill_house_request.province_kill_request.key)
        else:
            kill_house_check = None
        # if 'car_without_load_image' in request.data.keys() and 'car_with_load_image' in request.data.keys():
        #     if request.data['car_without_load_image'] != None and request.data['car_with_load_image'] != None:
        #         car_without_load_image = request.data['car_without_load_image']
        #         car_with_load_image = request.data['car_with_load_image']
        #         pic.append(car_without_load_image)
        #         pic.append(car_with_load_image)
        #     request.data.pop('car_without_load_image')
        #     request.data.pop('car_with_load_image')

        if 'car_with_load_image' in request.data.keys():
            if request.data['car_with_load_image'] != None:
                car_with_load_image = request.data['car_with_load_image']
                pic.append(car_with_load_image)
            request.data.pop('car_with_load_image')

        request.data.pop('kill_house_request_key')

        if KillHouseAssignmentInformation.objects.filter(kill_house_request=kill_house_request).exists():
            return Response({'result': 'already exist'}, status=status.HTTP_403_FORBIDDEN)
        if 'killer_key' in request.data.keys():
            if request.data['killer_key'] != None:
                killer = KillHouse.objects.get(key=request.data['killer_key'])
                kill_house_request.killer = killer
            request.data.pop('killer_key')
        serializer = self.serializer_class(data=request.data)
        if serializer.is_valid():
            assignment_info = serializer.create(validated_data=request.data)
            if kill_house_check != None:
                assignment_info.kill_house_check = kill_house_check
            assignment_info.kill_house_request = kill_house_request
            if len(pic) > 0:
                for p in pic:
                    ran = ''.join(random.choices(string.ascii_uppercase + string.digits, k=15))
                    # upload_object_resize(image_data=p, bucket_name="profileimagedefault",
                    #                      object_name="{0}.jpg".format(str(ran)))
                    # if p == car_without_load_image:
                    #     assignment_info.car_weight_without_load_image = ARVAN_Kill_house_URL + "{0}.jpg".format(
                    #         str(ran))
                    #     # os.remove("{0}.jpg".format(str(ran)))
                    # else:
                    # assignment_info.car_weight_with_load_image = ARVAN_Kill_house_URL + "{0}.jpg".format(str(ran))
                    assignment_info.car_weight_with_load_image = send_image_to_server(p)
                    # os.remove("{0}.jpg".format(str(ran)))
            kill_house_request.assignment_state_archive = 'True'
            kill_house_request.save()
            if role == 'Poultry':
                dict1.update({
                    "Poultry": True,
                    "CityOperator": False,
                    "ProvinceOperator": False,
                    "ProvinceFinancial": False,
                    "KillHouse": False,
                })
            elif role == 'CityOperator':
                dict1.update({
                    "Poultry": False,
                    "CityOperator": True,
                    "ProvinceOperator": False,
                    "ProvinceFinancial": False,
                    "KillHouse": False,
                })
            elif role == 'ProvinceFinancial':
                dict1.update({
                    "Poultry": False,
                    "CityOperator": False,
                    "ProvinceOperator": False,
                    "ProvinceFinancial": True,
                    "KillHouse": False,
                })
            elif role == 'ProvinceOperator':
                dict1.update({
                    "Poultry": False,
                    "CityOperator": False,
                    "ProvinceOperator": True,
                    "ProvinceFinancial": False,
                    "KillHouse": False,
                })
            else:
                dict1.update({
                    "Poultry": False,
                    "CityOperator": False,
                    "ProvinceOperator": False,
                    "ProvinceFinancial": False,
                    "KillHouse": True,
                })
            assignment_info.importer = dict1
            now = datetime.now()
            houre = PercentageOfLosses.objects.all()
            if houre.count() > 0:
                houre = houre.last().houre
            assignment_info.protest_time = now + timedelta(hours=int(houre))
            assignment_info.net_weight = float(assignment_info.car_weight_with_load) - float(
                assignment_info.car_weight_without_load)
            assignment_info.save()
            kill_house_request.active_state = 'inactive'
            poultry = PoultryRequest.objects.get(
                key=kill_house_request.province_request.city_request_Poultry.poultry_request.key)
            poultry.assignment = True
            poultry.save()
            kill_house_request.accepted_real_quantity = assignment_info.real_quantity
            kill_house_request.accepted_real_weight = assignment_info.net_weight
            kill_house_request.accepted_assignment_real_quantity = assignment_info.real_quantity
            kill_house_request.accepted_assignment_real_weight = assignment_info.net_weight
            kill_house_request.save()
            hatching = PoultryHatching.objects.get(key=poultry.hatching.key)
            update_kill_house_requests(province_kill_request, poultry)
            update_province_kill_requests(hatching)
            poultry_prediction(hatching.poultry)
            kill_house_request.accepted_real_quantity = assignment_info.real_quantity
            kill_house_request.accepted_real_weight = assignment_info.net_weight
            kill_house_request.save()
            assignment_info_serializer = self.serializer_class(assignment_info)
            return Response(assignment_info_serializer.data, status=status.HTTP_201_CREATED)

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

    # تابع مربوط به نمایش اطلاعات بار وارد شده توسط کشتارگاه
    def list(self, request, *args, **kwargs):
        user = SystemUserProfile.objects.get(user=request.user)
        # user = SystemUserProfile.objects.get(user=request.user)
        date1 = datetime.strptime(str(request.GET['date1']), '%Y-%m-%d').date()
        date2 = datetime.strptime(str(request.GET['date2']), '%Y-%m-%d').date()
        kill_house = []
        kill_house_requests_list = []

        if request.GET['role'] == 'KillHouse':
            kill_house = KillHouse.objects.filter(kill_house_operator__user=user, trash=False)

        elif request.GET['role'] == 'KillHouseVet':
            kill_house_vets = KillHouseVet.objects.filter(vet__user=user, trash=False).select_related('kill_house')
            for kill_house_vet in kill_house_vets:
                kill_house.append(kill_house_vet.kill_house)

        else:
            kill_house = KillHouse.objects.filter(system_address__province=user.province, trash=False)

        if request.GET['role'] in ['CityOperator', 'CityJahad', 'CityPoultry']:
            if request.GET['role'] == 'CityOperator':
                city_operator = CityOperator.objects.get(user=user, trash=False)
                if 'without_bar_document' in request.GET and request.GET['without_bar_document'] == "true":
                    kill_house_requests = KillHouseRequest.objects.filter(
                        (Q(killhouse_user__in=kill_house) | Q(kill_request__slaughter_house__in=kill_house)),
                        kill_request__recive_date__date__gte=date1,
                        kill_request__recive_date__date__lte=date2,
                        assignment_state_archive='True',
                        bar_document_status__isnull=True,
                        non_receipt=False,
                        trash=False, province_request__poultry_request__poultry__city_operator=city_operator.unit_name,

                    ).order_by('-kill_request__recive_date')
                else:

                    kill_house_requests = KillHouseRequest.objects.filter(
                        (Q(killhouse_user__in=kill_house) | Q(kill_request__slaughter_house__in=kill_house)),
                        kill_request__recive_date__date__gte=date1,
                        kill_request__recive_date__date__lte=date2,
                        assignment_state_archive='True',
                        non_receipt=False,
                        trash=False, province_request__poultry_request__poultry__city_operator=city_operator.unit_name,

                    ).order_by('-kill_request__recive_date')
            else:
                if 'without_bar_document' in request.GET and request.GET['without_bar_document'] == "true":
                    kill_house_requests = KillHouseRequest.objects.filter(
                        (Q(killhouse_user__in=kill_house) | Q(kill_request__slaughter_house__in=kill_house)),
                        kill_request__recive_date__date__gte=date1,
                        kill_request__recive_date__date__lte=date2,
                        assignment_state_archive='True',
                        bar_document_status__isnull=True,
                        non_receipt=False,
                        trash=False, province_request__poultry_request__poultry__address__city=user.city

                    ).order_by('-kill_request__recive_date')
                else:
                    kill_house_requests = KillHouseRequest.objects.filter(
                        (Q(killhouse_user__in=kill_house) | Q(kill_request__slaughter_house__in=kill_house)),
                        kill_request__recive_date__date__gte=date1,
                        kill_request__recive_date__date__lte=date2,
                        assignment_state_archive='True',
                        non_receipt=False,
                        trash=False, province_request__poultry_request__poultry__address__city=user.city

                    ).order_by('-kill_request__recive_date')

        else:

            if 'without_bar_document' in request.GET and request.GET['without_bar_document'] == "true":
                kill_house_requests = KillHouseRequest.objects.filter(
                    (Q(killhouse_user__in=kill_house) | Q(kill_request__slaughter_house__in=kill_house) | Q(
                        killer__in=kill_house)),
                    kill_request__recive_date__date__gte=date1,
                    kill_request__recive_date__date__lte=date2,
                    assignment_state_archive='True',
                    bar_document_status__isnull=True,
                    non_receipt=False,
                    trash=False,

                ).order_by('-kill_request__recive_date')
            else:

                kill_house_requests = KillHouseRequest.objects.filter(
                    (Q(killhouse_user__in=kill_house) | Q(kill_request__slaughter_house__in=kill_house) | Q(
                        killer__in=kill_house)),
                    kill_request__recive_date__date__gte=date1,
                    kill_request__recive_date__date__lte=date2,
                    assignment_state_archive='True',
                    non_receipt=False,
                    trash=False,

                ).order_by('-kill_request__recive_date')

        if 'search' in request.GET:
            if request.GET['search'] == 'filter':
                if request.GET['value'] != "" and request.GET['value'] != 'undefined':
                    for item in self.filterset_fields:
                        query = QueryDict('{0}__contains={1}'.format(item, request.GET['value']))
                        if (self.filterset_class(
                                data=query,
                                queryset=kill_house_requests
                        )
                        ).filter():
                            ps = self.filterset_class(data=query, queryset=kill_house_requests)
                            kill_house_requests_list = ps.filter()
                    kill_house_requests = [] if len(kill_house_requests_list) == 0 else kill_house_requests_list

        page_size = request.query_params.get('page_size', None)
        if page_size:
            self.pagination_class.page_size = int(page_size)

        page = self.paginate_queryset(kill_house_requests)
        if page is not None:
            serializer = KillHouseRequestForBarManagementSerializer(page, many=True)
            return self.get_paginated_response(serializer.data)

        serializer = KillHouseRequestForBarManagementSerializer(kill_house_requests, many=True)
        return Response(serializer.data, status=status.HTTP_200_OK)

    # تابع مربوط به نمایش اطلاعات بار وارد شده توسط کشتارگاه
    def update(self, request, pk=None, *args, **kwargs):
        # refresh(request.user.id)

        role = request.data['role']
        request.data.pop('role')
        kill_house_assignment = KillHouseAssignmentInformation.objects.get(key=request.data['key'], trash=False)
        if kill_house_assignment.state == 'accepted':
            return Response({"result": "به علت تایید اطلاعات از سمت استان امکان ویرایش وجود ندارد!"})
        kill_house_request = KillHouseRequest.objects.get(key=kill_house_assignment.kill_house_request.key)
        province_kill_request = ProvinceKillRequest.objects.get(key=kill_house_request.province_kill_request.key)
        poultry_request = PoultryRequest.objects.get(key=province_kill_request.province_request.poultry_request.key)
        date_time_of_now = datetime.now().date()
        if OperationLimitation.objects.all().first().kill_house_assignment_limitation == True:

            if date_time_of_now > kill_house_request.kill_request.recive_date.date() + timedelta(days=1):
                return Response({"result": "به علت مغایرت در تاریخ ثبت و تاریخ کشتار امکان ثبت اطلاعات وجود ندارد!"},
                                status=status.HTTP_403_FORBIDDEN)
        hatching = PoultryHatching.objects.get(key=poultry_request.hatching.key)
        car_with_load_image = request.data['car_with_load_image']
        request.data.pop('key')

        request.data.pop('car_with_load_image')
        if 'killer_key' in request.data.keys():
            if request.data['killer_key'] != None:
                killer = KillHouse.objects.get(key=request.data['killer_key'])
                kill_house_request.killer = killer
            request.data.pop('killer_key')

        pic = []
        # if 'car_without_load_image' in request.data.keys():
        #     car_without_load_image = request.data['car_without_load_image']
        #     request.data.pop('car_without_load_image')
        #     pic.append(car_without_load_image)
        pic.append(car_with_load_image)

        for p in pic:
            ran = ''.join(random.choices(string.ascii_uppercase + string.digits, k=15))
            # upload_object_resize(image_data=p, bucket_name="profileimagedefault",
            #                      object_name="{0}.jpg".format(str(ran)))
            # if p == car_without_load_image:
            #     kill_house_assignment.car_weight_without_load_image = ARVAN_Kill_house_URL + "{0}.jpg".format(str(ran))
            #     # os.remove("{0}.jpg".format(str(ran)))
            #
            # else:
            # kill_house_assignment.car_weight_with_load_image = ARVAN_Kill_house_URL + "{0}.jpg".format(str(ran))
            kill_house_assignment.car_weight_with_load_image = send_image_to_server(p)
            # os.remove("{0}.jpg".format(str(ran)))
        kill_house_assignment.state = 'pending'
        if role == 'Poultry':
            kill_house_assignment.poultry_update = True
        elif role == 'CityOperator':
            kill_house_assignment.city_update = True
        elif role == 'ProvinceFinancial':
            kill_house_assignment.province_update = True

        kill_house_assignment.state = 'pending'
        kill_house_assignment.net_weight = request.data['car_weight_with_load'] - request.data[
            'car_weight_without_load']
        kill_house_assignment.save()
        kill_house_request.accepted_real_quantity = request.data['real_quantity']
        kill_house_request.accepted_real_weight = request.data['car_weight_with_load'] - request.data[
            'car_weight_without_load']
        kill_house_request.accepted_assignment_real_quantity = int(request.data['real_quantity'])
        kill_house_request.accepted_assignment_real_weight = request.data['car_weight_with_load'] - request.data[
            'car_weight_without_load']
        kill_house_request.assignment_state_archive = 'True'
        kill_house_request.save()
        hatching = PoultryHatching.objects.get(key=poultry_request.hatching.key)
        update_kill_house_requests(province_kill_request, poultry_request)
        update_province_kill_requests(hatching)
        poultry_prediction(hatching.poultry)
        serializer = self.serializer_class(kill_house_assignment)
        serializer.update(instance=kill_house_assignment, validated_data=request.data)
        return Response(serializer.data, status=status.HTTP_200_OK)


# ویوست مربوط به ایجاد و ویرایش و جذف و نمایش فاکتور از سمت استان برای کشتارگاه
class ProvinceFactorToKillHouseViewSet(viewsets.ModelViewSet):
    queryset = ProvinceFactorToKillHouse.objects.all()
    serializer_class = ProvinceFactorToKillHouseSerializer
    permission_classes = [TokenHasReadWriteScope]


# ویوست مربوط به ایجاد و ویرایش و جذف و نمایش  نماینده دامپزشکی برای  کشتارگاه
class VetViewSet(viewsets.ModelViewSet):
    queryset = Vet.objects.all()
    serializer_class = VetSerializer
    permission_classes = [TokenHasReadWriteScope]
    filter_backends = [DjangoFilterBackend]
    filterset_class = VetFilterSet
    pagination_class = CustomPagination
    filterset_fields = [
        'user__national_id',
        'user__base_order',
        'user__mobile',

    ]

    # تابع مربوط به ایجاد نماینده دامپزشکی برای  کشتارگاه
    def create(self, request, *args, **kwargs):
        # refresh(request.user.id)

        user = UserProfile.objects.get(key=request.data['user_key'], trash=False)
        kill_house = KillHouse.objects.get(key=request.data['kill_house_key'], trash=False)
        request.data.pop('user_key')
        request.data.pop('kill_house_key')
        serializer = self.serializer_class(data=request.data)
        if serializer.is_valid():
            vet = serializer.create(validated_data=request.data)
            vet.kill_house = kill_house
            vet.user = user
            vet.save()
            vet_serializer = self.serializer_class(vet)
            return Response(vet_serializer.data, status=status.HTTP_201_CREATED)

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

    def retrieve(self, request, pk=None, *args, **kwargs):

        # refresh(request.user.id)

        if 'kill_house_info' in request.GET:
            user = SystemUserProfile.objects.get(user=request.user, trash=False)
            vet = Vet.objects.get(user=user, trash=False)
            kill_house_vet = KillHouseVet.objects.filter(vet=vet)
            if kill_house_vet.count() > 0:
                kill_house_vet = kill_house_vet.last()
                profile_info = {
                    'kill_house_name': kill_house_vet.kill_house.name,
                    'kill_house_user': kill_house_vet.kill_house.kill_house_operator.user.fullname,
                    'kill_house_mobile': kill_house_vet.kill_house.kill_house_operator.user.mobile,
                    'kill_house_city': kill_house_vet.kill_house.kill_house_operator.user.city.name,
                    'kill_house_province': kill_house_vet.kill_house.kill_house_operator.user.province.name,
                }
                return Response(profile_info, status=status.HTTP_200_OK)

        if 'profile' in request.GET:
            user = SystemUserProfile.objects.get(user=request.user, trash=False)
            user_serializer = SystemUserProfileSerializer(user)
            vet = Vet.objects.get(user=user, trash=False)
            vet_serializer = VetSerializer(vet)
            vet_farm = VetFarm.objects.filter(vet=vet, trash=False)
            serializer = VetFarmSerializer(vet_farm, many=True)
            kill_house_vet = KillHouseVet.objects.filter(vet=vet)
            if kill_house_vet.count() > 0:
                kill_house_vet_serializer = KillHouseVetSerializer(kill_house_vet.last())
                profile_info = {
                    # 'profile': user_serializer.data,
                    'vet': vet_serializer.data,
                    'kill_house_vet': kill_house_vet_serializer.data
                }
            else:

                profile_info = {
                    # 'profile': user_serializer.data,
                    'vet': vet_serializer.data
                    # 'vet_farms':serializer.data
                }
            return Response(profile_info, status=status.HTTP_200_OK)

    def list(self, request, *args, **kwargs):
        value = request.GET.get('value')
        search = request.GET.get('search')
        vet_farm_flag = request.GET.get('vet_farm')

        excluded_ids = set()
        if vet_farm_flag:
            if vet_farm_flag == 'true':
                excluded_ids = set(VetFarm.objects.filter(trash=False).values_list('vet__id', flat=True).distinct())
            elif vet_farm_flag == 'false':
                excluded_ids = set(
                    KillHouseVet.objects.filter(trash=False).values_list('vet__id', flat=True).distinct())
        else:
            vet_farm_ids = set(VetFarm.objects.filter(trash=False).values_list('vet__id', flat=True).distinct())
            kill_house_ids = set(KillHouseVet.objects.filter(trash=False).values_list('vet__id', flat=True).distinct())
            excluded_ids = vet_farm_ids.union(kill_house_ids)

        vets = Vet.objects.filter(trash=False)
        if vet_farm_flag:
            vets = vets.filter(id__in=excluded_ids)
        else:
            vets = vets.exclude(id__in=excluded_ids)

        if value and search == 'filter' and value.strip() and value != 'undefined':
            vets = vets.filter(build_query(VetFarmAndKillHouseFilterSet, value))

        page_size = request.query_params.get('page_size')
        if page_size:
            self.pagination_class.page_size = int(page_size)

        page = self.paginate_queryset(vets)
        if page is not None:
            serializer_class = (
                VetFarmListSerializer if vet_farm_flag == 'true' else VetKillHouseSerializer
                if vet_farm_flag == 'false' else VetSerializer
            )
            serializer = serializer_class(page, many=True)
            return self.get_paginated_response(serializer.data)

        serializer = VetKillHouseSerializer(vets, many=True)
        return Response(serializer.data, status=status.HTTP_200_OK)


class KillHouseVetViewSet(viewsets.ModelViewSet):
    queryset = KillHouseVet.objects.all()
    serializer_class = KillHouseVetSerializer
    permission_classes = [TokenHasReadWriteScope]

    def create(self, request, *args, **kwargs):
        # refresh(request.user.id)
        if 'role' in request.data.keys():
            if request.data['role'] == 'ProvinceInspector' or request.data['role'] == 'ProvinceOperator':
                user = SystemUserProfile.objects.get(key=request.data['user_key'])
                vet = Vet.objects.get(user=user, trash=False)
                request.data.pop('user_key')
                request.data.pop('role')


        else:
            request.data.pop('role')
            user = SystemUserProfile.objects.get(user=request.user)
            vet = Vet.objects.get(user=user, trash=False)
        kill_house = KillHouse.objects.get(key=request.data['key'])
        request.data.pop('key')
        serializer = self.serializer_class(data=request.data)
        if serializer.is_valid():
            kill_house_vet = serializer.create(validated_data=request.data)
            kill_house_vet.vet = vet
            kill_house_vet.kill_house = kill_house
            kill_house_vet.save()
            kill_house_vet_serializer = self.serializer_class(kill_house_vet)
            return Response(kill_house_vet_serializer.data, status=status.HTTP_201_CREATED)
        return Response({"result": "مشکلی پیش آمذه است !"}, status=status.HTTP_403_FORBIDDEN)

    def destroy(self, request, pk=None, *args, **kwargs):
        try:
            user = SystemUserProfile.objects.get(key=request.GET['user_key'])
            vet = Vet.objects.get(user=user, trash=False)
            kill_house = KillHouse.objects.get(key=request.GET['key'])
            kill_house_vet = KillHouseVet.objects.get(kill_house=kill_house, vet=vet, trash=False)
            kill_house_vet.trash = True
            kill_house_vet.save()

            return Response(status=status.HTTP_200_OK)
        except:
            return Response({"result": "مشکلی پیش آمده است !"}, status=status.HTTP_403_FORBIDDEN)


# ویوست مربوط به تایید یا رد بار رسیده به کشتارگاه توسط نماینده دامپزشکی
class VetCheckRequestViewSet(viewsets.ModelViewSet):
    queryset = VetCheckRequest.objects.all()
    serializer_class = VetCheckRequestSerializer
    permission_classes = [TokenHasReadWriteScope]

    # تابع مربوط به تایید یا رد بار رسیده به کشتارگاه توسط نماینده دامپزشکی
    def create(self, request, *args, **kwargs):
        # refresh(request.user.id)
        user = SystemUserProfile.objects.get(user=request.user)
        vet = Vet.objects.get(user=user, trash=False)
        kill_house_vet = KillHouseVet.objects.filter(vet=vet, trash=False).last()
        kill_house_req = KillHouseRequest.objects.get(key=request.data['kill_house_request_key'], trash=False)
        evacuation_permit = EvacuationPermit.objects.all().first()
        if evacuation_permit:
            if evacuation_permit.type == 'force':
                if kill_house_req.clearance_code == None:
                    return Response(
                        {"result": "قبل از ورود کد قرنطینه توسط دامپزشک فارم امکان تایید تخلیه وجود ندارد!"},
                        status=status.HTTP_403_FORBIDDEN)
        if OperationLimitation.objects.all().first().kill_house_vet_limitation == True:

            if kill_house_req.assignment_state_archive == 'True':
                return Response({"result": "به علت ورود اطلاعات بار امکان تایید تخلیه وجود ندارد!"},
                                status=status.HTTP_403_FORBIDDEN)
        province_kill_request = ProvinceKillRequest.objects.get(key=kill_house_req.province_kill_request.key,
                                                                trash=False)
        if int(request.data['accepted_real_quantity']) > 0 and request.data['accepted_real_weight'] > 0:
            kill_house_req.accepted_real_quantity = int(request.data['accepted_real_quantity'])
            kill_house_req.accepted_real_weight = request.data['accepted_real_weight']
        kill_house_req.vet_accepted_real_quantity = int(request.data['accepted_real_quantity'])
        kill_house_req.vet_accepted_real_weight = request.data['accepted_real_weight']
        kill_house_req.save()

        poultry_request = PoultryRequest.objects.get(key=province_kill_request.province_request.poultry_request.key)
        hatching = PoultryHatching.objects.get(key=poultry_request.hatching.key)
        request.data.pop('kill_house_request_key')
        if 'accepted_real_quantity' in request.data.keys() and 'accepted_real_weight' in request.data.keys():
            if request.data['accepted_real_quantity'] != None and request.data['accepted_real_weight'] != None:
                if int(request.data['accepted_real_quantity']) > 0 and request.data['accepted_real_weight'] > 0:
                    if kill_house_req.assignment_state_archive == 'pending' and kill_house_req.accepted_assignment_real_quantity == 0:
                        update_kill_house_requests(province_kill_request, poultry_request)
                        update_province_kill_requests(hatching)
                        poultry_prediction(hatching.poultry)

                # kill_house_req.accepted_real_quantity = int(request.data['accepted_real_quantity'])
                kill_house_req.vet_accepted_real_quantity = int(request.data['accepted_real_quantity'])

            request.data.pop('accepted_real_quantity')
        if 'accepted_real_weight' in request.data.keys():
            if request.data['accepted_real_weight'] != None:
                # kill_house_req.accepted_real_weight = request.data['accepted_real_weight']
                kill_house_req.vet_accepted_real_weight = request.data['accepted_real_weight']
            request.data.pop('accepted_real_weight')
        serializer = self.serializer_class(data=request.data)
        if serializer.is_valid():
            vet_check = serializer.create(validated_data=request.data)
            vet_check.kill_house_request = kill_house_req
            if vet_check.state == 'accepted':
                kill_house_req.vet_state = 'accepted'
                kill_house_req.active_state = 'inactive'
                kill_house_req.save()
            else:
                kill_house_req.vet_state = 'rejected'
                kill_house_req.active_state = 'inactive'
                kill_house_req.save()

            vet_check.kill_house_vet = kill_house_vet
            vet_check.save()
            vet_check_serializer = self.serializer_class(vet_check)
            return Response(vet_check_serializer.data, status=status.HTTP_201_CREATED)

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


# ویوست مربوط به ایجاد نمایش و ویرایش  و حذف درخواست بورسی کشتارگاه
class KillHouseRequestExchangeViewSet(viewsets.ModelViewSet):
    queryset = KillHouseRequestExchange.objects.all()
    permission_classes = [TokenHasReadWriteScope]
    serializer_class = KillHouseRequestExchangeSerializer

    # تابع مربوط به ایجاد درخواست بورسی کشتارگاه
    def create(self, request, *args, **kwargs):
        # refresh(request.user.id)
        user = UserProfile.objects.get(user=request.user, trash=False)
        kill_house = KillHouse.objects.get(user=user, trash=False)
        serializer = self.serializer_class(data=request.data)
        if serializer.is_valid():
            kill_house_request_exchange = serializer.create(validated_data=request.data)
            kill_house_request_exchange.user = user
            kill_house_request_exchange.kill_house = kill_house
            kill_house_request_exchange.save()
            return Response(serializer.data, status=status.HTTP_201_CREATED)
        return Response(serializer.errors)


# ویوست مربوط به ایجاد نمایش و ویرایش  و حذف درخواست بورسی رزرو شده کشتارگاه
class KillHouseRequestExchangeReserveViewSet(viewsets.ModelViewSet):
    queryset = KillHouseRequestExchangeReserve.objects.all()
    permission_classes = [TokenHasReadWriteScope]
    serializer_class = KillHouseRequestExchangeReserveSerializer

    # تابع مربوط به ایجاد درخواست بورسی رزرو شده کشتارگاه
    def create(self, request, *args, **kwargs):
        # refresh(request.user.id)
        user = UserProfile.objects.get(user=request.user, trash=False)
        kill_house = KillHouse.objects.get(user=user, trash=False)
        poultry_exchange = PoultryRequestExchange.objects.get(key=request.data['key'], trash=False)
        serializer = self.serializer_class(data=request.data)
        if serializer.is_valid():
            kill_house_request_exchange_reserve = serializer.create(validated_data=request.data)
            kill_house_request_exchange_reserve.poultry_exchange = poultry_exchange
            kill_house_request_exchange_reserve.kill_house = kill_house
            kill_house_request_exchange_reserve.save()
            poultry_exchange.state = 'reserved'
            poultry_exchange.save()

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


# ویوست مربوط به ایجاد نمایش و ویرایش  و حذف درخواست بورسی رزرو شده کشتارگاه
class KillHouseRequestActionViewSet(viewsets.ModelViewSet):
    queryset = KillHouseRequestAction.objects.all()
    permission_classes = [TokenHasReadWriteScope]
    serializer_class = KillHouseRequestActionSerializer

    def create(self, request, *args, **kwargs):
        # refresh(request.user.id)
        user = SystemUserProfile.objects.get(user=request.user, trash=False)
        kill_house = KillHouse.objects.get(kill_house_operator__user=user, trash=False)
        poultry_request = PoultryRequest.objects.get(key=request.data['key'], trash=False)
        request.data.pop('key')
        serializer = self.serializer_class(data=request.data)
        if serializer.is_valid():
            kill_house_auction = serializer.create(validated_data=request.data)
            kill_house_auction.kill_house = kill_house
            kill_house_auction.poultry_request = poultry_request
            kill_house_auction.date = datetime.now() + timedelta(minutes=10)
            kill_house_auction.save()
            kill_house_auction_serializer = self.serializer_class(kill_house_auction)
            return Response(kill_house_auction_serializer.data, status=status.HTTP_201_CREATED)
        return Response(serializer.errors)

    def list(self, request, *args, **kwargs):
        # refresh(request.user.id)
        user = SystemUserProfile.objects.get(user=request.user, trash=False)
        kill_house_operator = KillHouseOperator.objects.get(user=user, trash=False)
        kill_house = KillHouse.objects.get(kill_house_operator=kill_house_operator, trash=False)
        queryset = KillHouseRequestAction.objects.filter(kill_house=kill_house, trash=False)
        # queryset = WareHouseFactor.objects.all().order_by('-create_date')
        serializer = KillHouseRequestActionSerializer(queryset, many=True)
        return Response(serializer.data, status=status.HTTP_200_OK)

    def destroy(self, request, pk=None, *args, **kwargs):
        # refresh(request.user.id)
        queryset = KillHouseRequestAction.objects.get(key__exact=request.GET["key"], trash=False)
        now = datetime.now()
        if now.hour <= queryset.date.hour and now.minute <= queryset.date.minute:
            queryset.delete()
            return Response({"result": "object deleted"}, status=status.HTTP_200_OK)
        else:
            return Response({"result": "object can not deleted"}, status=status.HTTP_403_FORBIDDEN)


# ویوست مربوط به ایجاد نمایش و ویرایش  و حذف درخواست بورسی رزرو شده کشتارگاه
class KillHouseRequestActionWinnerViewSet(viewsets.ModelViewSet):
    queryset = KillHouseRequestActionWinner.objects.all()
    permission_classes = [TokenHasReadWriteScope]
    serializer_class = KillHouseRequestActionWinnerSerializer

    def list(self, request, *args, **kwargs):
        # refresh(request.user.id)
        user = SystemUserProfile.objects.get(user=request.user, trash=False)
        kill_house_operator = KillHouseOperator.objects.get(user=user, trash=False)
        kill_house = KillHouse.objects.get(kill_house_operator=kill_house_operator, trash=False)
        queryset = KillHouseRequestActionWinner.objects.filter(kill_house_request_auction__kill_house=kill_house,
                                                               trash=False)
        # queryset = WareHouseFactor.objects.all().order_by('-create_date')
        serializer = KillHouseRequestActionWinnerSerializer(queryset, many=True)
        return Response(serializer.data, status=status.HTTP_200_OK)


# ویوست مربوط به ایجاد نمایش و ویرایش و ... اضافه کردن ماشین به درخواست بورسی رزرو شده تایید شده کشتارگاه
class KillHouseRequestExchangeAddCarViewSet(viewsets.ModelViewSet):
    queryset = KillHouseRequestExchangeAddCar.objects.all()
    permission_classes = [TokenHasReadWriteScope]
    serializer_class = KillHouseRequestExchangeAddCarSerializer

    # تابع مربوط به اضافه کردن ماشین به درخواست بورسی رزرو شده تایید شده کشتارگاه
    def create(self, request, *args, **kwargs):
        # refresh(request.user.id)
        kill_house_reserve = KillHouseRequestExchangeReserve.objects.get(key=request.data['key'], trash=False)
        serializer = self.serializer_class(data=request.data)
        if serializer.is_valid():
            kill_house_request_exchange_add_car = serializer.create(validated_data=request.data)
            kill_house_request_exchange_add_car.kill_house_reserve = kill_house_reserve
            kill_house_request_exchange_add_car.save()
            return Response(serializer.data, status=status.HTTP_201_CREATED)
        return Response(serializer.errors)


class DriverViewSet(viewsets.ModelViewSet):
    queryset = KillHouseDriver.objects.all()
    serializer_class = KillHouseDriverSerializer
    permission_classes = [TokenHasReadWriteScope]

    def list(self, request, *args, **kwargs):
        # refresh(request.user.id)
        """
        Show Driver Cars Information
        """
        if 'my_car' in request.GET:
            # get user object
            userprofile = SystemUserProfile.objects.get(
                user=request.user, trash=False
            )
            # get driver object & cars information
            # driver = self.queryset.get(user=userprofile, trash=False)
            # cars_objects = driver.Kill_house_add_car
            # serializer = KillHouseADDCARSerializer(cars_objects)
            # return Response(serializer.data, status=status.HTTP_200_OK)
            cars = KillHouseDriver.objects.filter(user=userprofile, trash=False)
            # cars_objects = KillHouseADDCAR.objects.filter(driver=driver, trash=False)
            # serializer = KillHouseADDCARSerializer(cars_objects, many=True)
            serializer = KillHouseDriverSerializer(cars, many=True)
            return Response(serializer.data, status=status.HTTP_200_OK)

        # Show Driver Kill Requests Allocation
        if 'my_allocations' in request.GET:
            driver_allocations = []
            # get user object
            userprofile = SystemUserProfile.objects.get(
                user=request.user, trash=False
            )
            # get driver object & cars information
            # driver = self.queryset.get(user=userprofile, trash=False)
            # cars_object = driver.Kill_house_add_car
            kill_reqs = KillHouseRequest.objects.filter(add_car__driver__user=userprofile, trash=False)
            # for item in kill_req:
            #     if str(cars_object.key) == item.car['key']:
            #         driver_allocations.append(item)
            serializer = KillHouseRequestSerializer(kill_reqs, many=True)
            return Response(serializer.data, status=status.HTTP_200_OK)

        return Response("Enter The Parameter", status=status.HTTP_400_BAD_REQUEST)

    def retrieve(self, request, pk=None, *args, **kwargs):
        # refresh(request.user.id)
        if 'profile' in request.GET:
            user = SystemUserProfile.objects.get(user=request.user, trash=False)
            kill_house_driver = KillHouseDriver.objects.get(user=user, trash=False)
            kill_house_driver_serializer = KillHouseDriverSerializer(kill_house_driver)
            profile_info = {
                'profile': kill_house_driver_serializer.data,
            }
            return Response(profile_info, status=status.HTTP_200_OK)


class DriverRequestCancelViewSet(viewsets.ModelViewSet):
    queryset = DriverRequestCancel.objects.all()
    serializer_class = DriverRequestCancelSerializer
    permission_classes = [TokenHasReadWriteScope]

    def create(self, request, *args, **kwargs):
        # refresh(request.user.id)
        kill_house_request = KillHouseRequest.objects.get(key=request.data['kill_house_request_key'], trash=False)
        request.data.pop('kill_house_request_key')
        add_car = KillHouseADDCAR.objects.get(key=request.data['Kill_house_add_car_key'], trash=False)
        request.data.pop('Kill_house_add_car_key')
        if KillHouseAssignmentInformation.objects.filter(kill_house_request=kill_house_request).exists():
            return Response({"result": "can not cancel"}, status=status.HTTP_403_FORBIDDEN)
        serializer = self.serializer_class(data=request.data)
        if serializer.is_valid():
            driver_cancel = serializer.create(validated_data=request.data)
            if kill_house_request.province_kill_request != None:
                province_kill_request = ProvinceKillRequest.objects.get(
                    key=kill_house_request.province_kill_request.key, trash=False)
                province_kill_request.quantity += kill_house_request.quantity
                province_kill_request.save()
            else:
                kill_house_request_auction = KillHouseRequestActionWinner.objects.get(
                    key=kill_house_request.kill_house_request_auction_winner.key, trash=False)
                kill_house_request_auction.quantity += kill_house_request.quantity
                kill_house_request_auction.save()
            driver_cancel.kill_house_request = kill_house_request
            driver_cancel.Kill_house_add_car = add_car
            driver_cancel.save()
            kill_house_request.trash = True
            kill_house_request.save()
            return Response(serializer.data, status=status.HTTP_201_CREATED)
        return Response(serializer.errors)


class KillHouseComplaintViewSet(viewsets.ModelViewSet):
    queryset = KillHouseComplaint.objects.all()
    serializer_class = KillHouseComplaintSerializer
    permission_classes = [TokenHasReadWriteScope]

    def create(self, request, *args, **kwargs):
        # refresh(request.user.id)
        user = SystemUserProfile.objects.get(user=request.user)
        role = request.data['role']
        request.data.pop('role')
        image_list = []
        bar = KillHouseAssignmentInformation.objects.get(key=request.data['bar_key'], trash=False)
        request.data.pop('bar_key')
        percent = request.data['percent']
        request.data.pop('percent')
        try:
            images = request.data['image']
            request.data.pop('image')
        except:
            images = None
        serializer = self.serializer_class(data=request.data)
        if serializer.is_valid():
            complaint = serializer.create(validated_data=request.data)
            complaint.bar = bar
            if images != None:
                for image in images:
                    image_list.append(send_image_to_server(image))
                complaint.image = image_list
            if percent != None:
                complaint.percent = percent
            complaint.save()
            bar.unusual_casualties = True
            bar.save()
            if role == 'KillHouse':
                kill_house = KillHouse.objects.get(kill_house_operator__user=user)
                kill_house_name = kill_house.kill_house_operator.user.fullname
                information = {
                    "role": role,
                    "kill_house_name": kill_house.name,
                    "kill_house_operator_name": kill_house_name,
                    "date": str(complaint.create_date)
                }

            elif role == "KillHouseVet":
                vet = Vet.objects.get(user=user)
                kill_house_vet = KillHouseVet.objects.get(vet=vet)
                kill_house_vet_name = kill_house_vet.vet.user.fullname

                information = {
                    "role": role,
                    "kill_house_vet": kill_house_vet_name,
                    "date": str(complaint.create_date)
                }

            complaint.registrar = information
            complaint.save()

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

        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

    def list(self, request, *args, **kwargs):
        # refresh(request.user.id)
        user = SystemUserProfile.objects.get(user=request.user)
        if 'role' in request.GET:
            killhousecomplaints = []
            if request.GET['role'] == 'KillHouse':
                kill_house_operator = KillHouseOperator.objects.get(user=user)
                kill_house = KillHouse.objects.get(kill_house_operator=kill_house_operator)
                killhousecomplaints = KillHouseComplaint.objects.filter(
                    bar__kill_house_request__killhouse_user=kill_house)
                if killhousecomplaints.count() > 0:
                    serializer = KillHouseComplaintSerializer(killhousecomplaints, many=True)
                    return Response(serializer.data, status=status.HTTP_200_OK)
            elif request.GET['role'] == 'KillHouseVet':
                vet = Vet.objects.get(user=user)
                kill_house_vet = KillHouseVet.objects.get(vet=vet)
                kill_house = KillHouse.objects.get(key=kill_house_vet.kill_house.key)
                killhousecomplaints = KillHouseComplaint.objects.filter(
                    bar__kill_house_request__killhouse_user=kill_house)
                if killhousecomplaints.count() > 0:
                    serializer = KillHouseComplaintSerializer(killhousecomplaints, many=True)
                    return Response(serializer.data, status=status.HTTP_200_OK)
            else:
                killhousecomplaints = KillHouseComplaint.objects.filter(
                    bar__kill_house_request__killhouse_user__system_address__province__id=user.province.id)
                if killhousecomplaints.count() > 0:
                    serializer = KillHouseComplaintSerializer(killhousecomplaints, many=True)
                    return Response(serializer.data, status=status.HTTP_200_OK)
            return Response(killhousecomplaints, status=status.HTTP_200_OK)

    def update(self, request, *args, **kwargs):
        # refresh(request.user.id)
        Killhousecomplaint = KillHouseComplaint.objects.get(key=request.data['key'])
        new_bar = KillHouseAssignmentInformation.objects.get(key=request.data['bar_key'], trash=False)
        request.data.pop('key')
        request.data.pop('bar_key')
        percent = request.data['percent']
        new_title = request.data['title']
        new_image = request.data['image']
        new_percent = request.data['percent']
        new_message = request.data['message']

        Killhousecomplaint.bar = new_bar
        Killhousecomplaint.title = new_title
        Killhousecomplaint.image = new_image
        Killhousecomplaint.percent = new_percent
        Killhousecomplaint.message = new_message
        Killhousecomplaint.save()

        return Response(status=status.HTTP_200_OK)

    def destroy(self, request, *args, **kwargs):
        # refresh(request.user.id)
        Killhousecomplaint = KillHouseComplaint.objects.get(key=request.data['key'])
        Killhousecomplaint.trash = True
        Killhousecomplaint.save()

        return Response(status=status.HTTP_200_OK)


class CheckKillHouseComplaintViewSet(viewsets.ModelViewSet):
    queryset = CheckKillHouseComplaint.objects.all()
    serializer_class = CheckKillHouseComplaintSerializer
    permission_classes = [TokenHasReadWriteScope]

    def create(self, request, *args, **kwargs):
        # refresh(request.user.id)
        complaint = KillHouseComplaint.objects.get(key=request.data['complaint_key'], trash=False)
        request.data.pop('complaint_key')
        serializer = self.serializer_class(data=request.data)
        if serializer.is_valid():
            percent = PercentageOfLosses.objects.all()
            if percent.count() > 0:
                percent = percent.last()
            else:
                return Response('dont have PercentageOfLosses ', status=status.HTTP_403_FORBIDDEN)

            check = serializer.create(validated_data=request.data)
            check.camplaint = complaint
            if check.state == 'accepted':
                bar = KillHouseAssignmentInformation.objects.get(key=complaint.bar.key)
                complaint_percent = complaint.percent
                if float(complaint_percent) > float(percent.percent):
                    main_percent = float(complaint_percent) - float(percent.percent)
                    bar.car_weight_with_load = float(bar.car_weight_with_load) - (
                            (main_percent / 100) * (float(bar.car_weight_with_load)))
                    bar.net_weight = float(bar.net_weight) - (
                            (main_percent / 100) * (float(bar.net_weight)))
                    bar.save()
                province_factor = ProvinceFactorToKillHouse.objects.filter(
                    province_check_info__kill_house_assignment__key=complaint.bar.key)
                poultry_factor = ProvinceFactorToKillHouseForPoultry.objects.filter(
                    province_check_info__kill_house_assignment__key=complaint.bar.key)

            complaint.save()
            return Response(serializer.data, status=status.HTTP_201_CREATED)

        return Response(serializer.errors)


class KillHouseBarReportingViewSet(viewsets.ModelViewSet):
    queryset = KillHouseAssignmentInformation.objects.all()
    serializer_class = KillHouseAssignmentInformationSerializer
    permission_classes = [AllowAny]

    def create(self, request, *args, **kwargs):
        return Response(status=status.HTTP_401_UNAUTHORIZED)

    def update(self, request, *args, **kwargs):
        return Response(status=status.HTTP_401_UNAUTHORIZED)

    def destroy(self, request, *args, **kwargs):
        return Response(status=status.HTTP_401_UNAUTHORIZED)

    def partial_update(self, request, *args, **kwargs):
        return Response(status=status.HTTP_401_UNAUTHORIZED)

    def list(self, request, *args, **kwargs):
        total_list = []
        net_weight = 0
        api_key = request.GET['api_key']
        if api_key == PROJECT_API_KEY:
            for kill_house in KillHouse.objects.filter(system_address__province__id=1):
                internal_list = []

                date_time = datetime.strptime(request.GET['date'], '%Y-%m-%d')

                assignments = KillHouseAssignmentInformation.objects.filter(
                    kill_house_request__killhouse_user=kill_house, create_date__year=date_time.year,
                    create_date__month=date_time.month, create_date__day=date_time.day)
                if assignments.count() > 0:

                    for assignment in assignments:
                        net_weight += assignment.net_weight

                    internal_dict = {

                        "date": date_time,
                        "weight": net_weight,
                    }
                    internal_list.append(internal_dict)

                    kill_house_dict = {
                        "kill_house_name": kill_house.name,
                        "fullname": kill_house.kill_house_operator.user.fullname,
                        "mobile": kill_house.kill_house_operator.user.mobile,
                        "city": kill_house.system_address.city.name,
                        "province": kill_house.system_address.province.name,
                        "bar_info": internal_list,
                    }
                    total_list.append(kill_house_dict)

            return Response(total_list, status=status.HTTP_200_OK)


class CheckUnusualCasualtiesViewSet(viewsets.ModelViewSet):
    queryset = CheckUnusualCasualties.objects.all()
    serializer_class = CheckUnusualCasualtiesSerializer
    permission_classes = [AllowAny]

    def create(self, request, *args, **kwargs):
        # refresh(request.user.id)
        user = SystemUserProfile.objects.get(user=request.user)
        # return Response(user.fullname)
        kill_house_complaint = KillHouseComplaint.objects.get(key=request.data['key'])
        request.data.pop('key')
        bar_info = KillHouseAssignmentInformation.objects.get(key=kill_house_complaint.bar.key)
        state = request.data['state']
        if state == "accepted":
            percentage_losses = PercentageOfLosses.objects.all()
            if percentage_losses.count() > 0:
                percentage_losses = percentage_losses.last().percent
            else:
                return Response({"result": "enter percentage of losses"}, status=status.HTTP_403_FORBIDDEN)
            weight = kill_house_complaint.bar.net_weight - (kill_house_complaint.bar.net_weight * (
                    (kill_house_complaint.percent / 100) - (percentage_losses / 100)))
            bar_info.weight_withs_losses = weight
            bar_info.save()
        serializer = self.serializer_class(data=request.data)
        if serializer.is_valid():
            unusualcasualties = serializer.create(validated_data=request.data)
            unusualcasualties.complaint = kill_house_complaint
            if unusualcasualties.state == 'accepted':
                kill_house_complaint.state = 'accepted'
                kill_house_complaint.save()
            if unusualcasualties.state == 'rejected':
                unusualcasualties.message = request.data['message']
                kill_house_complaint.state = 'rejected'
                kill_house_complaint.message = request.data['message']
                kill_house_complaint.save()
            unusualcasualties.save()
            inter_dict = {
                "operatorname": user.fullname,
                "create_date": str(unusualcasualties.create_date),
                "role": request.data['role'],
                "state": unusualcasualties.state,
            }
            unusualcasualties.role = inter_dict
            unusualcasualties.save()
            return Response(serializer.data, status=status.HTTP_201_CREATED)


@api_view(["POST"])
@csrf_exempt
@permission_classes([AllowAny])
def make_kill_request(request):
    user = SystemUserProfile.objects.get(user=request.user)
    now = datetime.now().date()
    for kill_house in KillHouse.objects.filter(system_address__province=user.province):
        debt_amount = 0
        percentage = KillHousePercentage.objects.get(kill_house=kill_house)
        total_poultry_request = TotalPoultryRequestQuantity.objects.filter(create_date__year=now.year,
                                                                           create_date__month=now.month,
                                                                           create_date__day=now.day).order_by('id')
        first_average_weight = 0
        first_assignment_average_weight = 0
        seconde_average_weight = 0
        seconde_assignment_average_weight = 0
        all_assigntments = KillHouseAssignmentInformation.objects.filter(
            kill_house_request__killhouse_user=kill_house).order_by('id')
        if all_assigntments.count() > 0:
            for all_assigntment in all_assigntments:
                first_assignment_average_weight += all_assigntment.net_weight / all_assigntment.real_quantity
            first_average_weight += round(first_assignment_average_weight / all_assigntments.count(), 2)
            four_all_assigntments = KillHouseAssignmentInformation.objects.filter(
                kill_house_request__killhouse_user=kill_house).order_by('id')[:4]

            for four_last_assingment in four_all_assigntments:
                seconde_assignment_average_weight += four_last_assingment.net_weight / four_last_assingment.real_quantity
            seconde_average_weight += round(seconde_assignment_average_weight / four_all_assigntments.count(), 2)

        if total_poultry_request.count() > 0:
            total_poultry_request = total_poultry_request.last()
            if total_poultry_request.input_quantity != 0:
                percentage.quantity = int(((percentage.percent / 100) / 100) * total_poultry_request.input_quantity)
            else:
                percentage.quantity = int(((percentage.percent / 10000) * total_poultry_request.quantity))
            percentage.save()
            poultry_factors = ProvinceFactorToKillHouseForPoultry.objects.filter(
                province_check_info__kill_house_assignment__kill_house_request__killhouse_user=kill_house,
                paid_state='pending')
            province_factors = ProvinceFactorToKillHouse.objects.filter(
                province_check_info__kill_house_assignment__kill_house_request__killhouse_user=kill_house,
                paid_state='pending')
            if poultry_factors.count() > 0:
                for poultry_factor in poultry_factors:
                    debt_amount += poultry_factor.total_price
            if province_factors.count() > 0:

                for province_factor in province_factors:
                    debt_amount += province_factor.total_price

            kill_req = KillRequest(
                kill_capacity=percentage.quantity,
                remain_quantity=percentage.quantity,
                recive_time='06 - 14',
                recive_date=datetime.now(),
                first_average_weight=seconde_average_weight,
                second_average_weight=first_average_weight,
                kill_house=kill_house

            )
            kill_req.save()
            if debt_amount > 0:
                kill_req.debt_amount = debt_amount
                kill_req.debt = True
                kill_req.save()

    return JsonResponse({"msg": "Done"})


class KillHouseNewViewSet(viewsets.ModelViewSet):
    queryset = KillHouse.objects.select_related('kill_house_operator__user').filter(trash=False)
    # queryset = KillHouse.objects.filter(trash=False)
    serializer_class = KillHouseSerializer
    permission_classes = [TokenHasReadWriteScope]

    def list(self, request, *args, **kwargs):
        # refresh(request.user.id)
        kill_houses = self.queryset.all()

        FullName = [kill_house.kill_house_operator.user.fullname for kill_house in kill_houses]

        return Response(FullName, status=status.HTTP_200_OK)


class KillHouseWareHouseViewSet(viewsets.ModelViewSet):
    queryset = KillHouseWareHouse.objects.all()
    serializer_class = KillHouseWareHouseSerializer
    permission_classes = [TokenHasReadWriteScope]

    def list(self, request, *args, **kwargs):
        now = datetime.now().date()
        date = datetime.strptime(request.GET['date'],
                                 '%Y-%m-%d').date() if 'date' in request.GET else now
        if 'kill_house_key' in request.GET:
            kill_house = KillHouse.objects.get(key=request.GET['kill_house_key'], trash=False)
        else:
            user = SystemUserProfile.objects.get(user=request.user, trash=False)
            kill_house = KillHouse.objects.filter(kill_house_operator__user=user, trash=False).first()

        kill_house_ware_house = KillHouseWareHouse.objects.filter(kill_house=kill_house,
                                                                  date__date=date,
                                                                  trash=False).last()

        if kill_house_ware_house is None:
            ware_house_date = datetime(year=date.year, month=date.month, day=date.day, hour=1, minute=12, second=20)
            kill_house_ware_house = KillHouseWareHouse(
                kill_house=kill_house,
                date=ware_house_date
            )
            kill_house_ware_house.save()

        bar_quantity = 0
        allocated_quantity = 0
        bar_live_weight = 0
        number_of_carcasses = 0
        update_number_of_carcasses = 0
        weight_of_carcasses = 0
        update_weight_of_carcasses = 0
        ave_weight_of_carcasses = 0
        free_number_of_carcasses = 0
        free_weight_of_carcasses = 0
        free_sale_number_of_carcasses = 0
        free_sale_weight_of_carcasses = 0
        free_bar_quantity = 0
        free_sale_bar_quantity = 0
        total_bar_quantity = 0
        total_number_of_carcasses = 0
        total_weight_of_carcasses = 0

        # assingments = KillHouseAssignmentInformation.objects.filter(kill_house_request__killhouse_user=kill_house,
        #                                                             state__in=('pending', 'accepted'),
        #                                                             kill_house_request__kill_request__recive_date__year=date.year,
        #                                                             kill_house_request__kill_request__recive_date__month=date.month,
        #                                                             kill_house_request__kill_request__recive_date__day=date.day,
        #                                                             trash=False).select_related('kill_house_request')
        one_day_ago = date - timedelta(days=1)

        kill_house_requests = KillHouseRequest.objects.filter(killhouse_user=kill_house,
                                                              kill_request__recive_date__date=one_day_ago,
                                                              ware_house_confirmation=True, trash=False)
        if kill_house_requests.count() > 0:
            for kill_house_request in kill_house_requests:
                bar_quantity += 1
                allocated_quantity += kill_house_request.accepted_real_quantity
                bar_live_weight += kill_house_request.accepted_real_weight
                number_of_carcasses += kill_house_request.ware_house_accepted_real_quantity
                weight_of_carcasses += kill_house_request.ware_house_accepted_real_weight
                # kill_house_loss_percentage = KillHousePercentageOfLosses.objects.all().last()
                # if kill_house_loss_percentage:
                #     weight_of_carcasses += kill_house_request.accepted_real_weight - (
                #             (kill_house_loss_percentage.percent / 100) * kill_house_request.accepted_real_weight)
                # else:
                #     weight_of_carcasses += kill_house_request.accepted_real_weight - (
                #             (25 / 100) * kill_house_request.accepted_real_weight)

                ave_weight_of_carcasses += weight_of_carcasses / number_of_carcasses
        free_bars = KillHouseFreeBarInformation.objects.filter(kill_house=kill_house, date__date=date, ware_house=True,
                                                               trash=False)
        freezing_quantity = 0
        freezing_weight = 0
        freezing_bars = ColdHouseAllocations.objects.filter(kill_house_ware_house=kill_house_ware_house,
                                                            state__in=('pending', 'accepted'), date__date=date,
                                                            trash=False)
        if len(freezing_bars) > 0:
            for freezing_bar in freezing_bars:
                freezing_quantity += freezing_bar.accepted_quantity if freezing_bar.accepted_quantity > 0 else freezing_bar.quantity
                freezing_weight += freezing_bar.accepted_weight if freezing_bar.accepted_weight > 0 else freezing_bar.weight
        if free_bars.count() > 0:
            for free_bar in free_bars:
                free_bar_quantity += 1
                free_number_of_carcasses += free_bar.number_of_carcasses
                free_weight_of_carcasses += free_bar.weight_of_carcasses
        kill_house_free_sale_bar_info = KillHouseFreeSaleBarInformation.objects.filter(kill_house=kill_house,
                                                                                       date__date=date,
                                                                                       trash=False)
        if kill_house_free_sale_bar_info.count() > 0:
            for kill_house_free_sale in kill_house_free_sale_bar_info:
                free_sale_bar_quantity += 1
                free_sale_number_of_carcasses += kill_house_free_sale.number_of_carcasses
                free_sale_weight_of_carcasses += kill_house_free_sale.weight_of_carcasses

        update_number_of_carcasses = kill_house_ware_house.updated_number_of_carcasses
        update_weight_of_carcasses = kill_house_ware_house.updated_weight_of_carcasses
        total_bar_quantity = bar_quantity + free_bar_quantity + free_sale_bar_quantity
        total_number_of_carcasses = number_of_carcasses + free_number_of_carcasses + kill_house_ware_house.pre_cold_number_of_carcasses_to_ware_house
        update_total_number_of_carcasses = update_number_of_carcasses + free_number_of_carcasses + kill_house_ware_house.pre_cold_number_of_carcasses_to_ware_house if update_number_of_carcasses > 0 else 0
        total_weight_of_carcasses = weight_of_carcasses + free_weight_of_carcasses + kill_house_ware_house.pre_cold_weight_of_carcasses_to_ware_house
        update_total_weight_of_carcasses = update_weight_of_carcasses + free_weight_of_carcasses + kill_house_ware_house.pre_cold_weight_of_carcasses_to_ware_house if update_weight_of_carcasses > 0 else 0

        kill_house_ware_house.bar_quantity = bar_quantity
        kill_house_ware_house.allocated_quantity = allocated_quantity
        kill_house_ware_house.bar_live_weight = bar_live_weight
        kill_house_ware_house.number_of_carcasses = number_of_carcasses
        kill_house_ware_house.update_number_of_carcasses = update_number_of_carcasses
        kill_house_ware_house.weight_of_carcasses = weight_of_carcasses
        kill_house_ware_house.update_weight_of_carcasses = update_weight_of_carcasses
        kill_house_ware_house.ave_weight_of_carcasses = weight_of_carcasses / number_of_carcasses if number_of_carcasses > 0 else 0
        kill_house_ware_house.update_ave_weight_of_carcasses = update_weight_of_carcasses / update_number_of_carcasses if update_number_of_carcasses > 0 else 0
        kill_house_ware_house.free_bar_quantity = free_bar_quantity
        kill_house_ware_house.number_of_free_carcasses = free_number_of_carcasses
        kill_house_ware_house.free_weight_of_carcasses = free_weight_of_carcasses
        kill_house_ware_house.free_sale_quantity = free_sale_number_of_carcasses
        kill_house_ware_house.free_sale_weight = free_sale_weight_of_carcasses
        kill_house_ware_house.total_bar_quantity = total_bar_quantity
        kill_house_ware_house.freezing_quantity = freezing_quantity
        kill_house_ware_house.freezing_weight = freezing_weight
        kill_house_ware_house.total_number_of_carcasses = total_number_of_carcasses
        kill_house_ware_house.update_total_number_of_carcasses = update_total_number_of_carcasses
        kill_house_ware_house.total_weight_of_carcasses = total_weight_of_carcasses
        kill_house_ware_house.update_total_weight_of_carcasses = update_total_weight_of_carcasses
        if update_total_weight_of_carcasses == 0:
            kill_house_ware_house.remain_total_weight_of_carcasses = total_weight_of_carcasses - kill_house_ware_house.allocated_total_weight_of_carcasses if kill_house_ware_house.pre_cold_weight_of_carcasses_self_ware_house == 0 else 0
        else:
            kill_house_ware_house.remain_total_weight_of_carcasses = update_total_weight_of_carcasses - kill_house_ware_house.allocated_total_weight_of_carcasses if kill_house_ware_house.pre_cold_weight_of_carcasses_self_ware_house == 0 else 0
        if update_total_number_of_carcasses == 0:
            kill_house_ware_house.remain_total_number_of_carcasses = total_number_of_carcasses - kill_house_ware_house.allocated_total_number_of_carcasses if kill_house_ware_house.pre_cold_number_of_carcasses_self_ware_house == 0 else 0
        else:
            kill_house_ware_house.remain_total_number_of_carcasses = update_total_number_of_carcasses - kill_house_ware_house.allocated_total_number_of_carcasses if kill_house_ware_house.pre_cold_number_of_carcasses_self_ware_house == 0 else 0
        kill_house_ware_house.final_total_number_of_carcasses = kill_house_ware_house.update_total_number_of_carcasses if kill_house_ware_house.update_total_number_of_carcasses > 0 else kill_house_ware_house.total_number_of_carcasses
        kill_house_ware_house.final_total_weight_of_carcasses = kill_house_ware_house.update_total_weight_of_carcasses if kill_house_ware_house.update_total_weight_of_carcasses > 0 else kill_house_ware_house.total_weight_of_carcasses
        kill_house_ware_house.save()

        if 'state' in request.GET:
            total_number_of_carcasses_temp = kill_house_ware_house.update_total_number_of_carcasses if kill_house_ware_house.update_total_number_of_carcasses > 0 else kill_house_ware_house.total_number_of_carcasses
            total_weight_of_carcasses_temp = kill_house_ware_house.update_total_weight_of_carcasses if kill_house_ware_house.update_total_weight_of_carcasses > 0 else kill_house_ware_house.total_weight_of_carcasses
            update_fields = {
                "ware_house_key": kill_house_ware_house.key,
                "total_number_of_carcasses": kill_house_ware_house.final_total_number_of_carcasses,
                "pre_cold_number_of_carcasses_self_ware_house": kill_house_ware_house.pre_cold_number_of_carcasses_self_ware_house,
                "pre_cold_weight_of_carcasses_self_ware_house": kill_house_ware_house.pre_cold_weight_of_carcasses_self_ware_house,
                "total_weight_of_carcasses": kill_house_ware_house.final_total_weight_of_carcasses,
                "allocated_total_number_of_carcasses": kill_house_ware_house.allocated_total_number_of_carcasses,
                "allocated_total_weight_of_carcasses": kill_house_ware_house.allocated_total_weight_of_carcasses,
                "remain_total_number_of_carcasses": kill_house_ware_house.remain_total_number_of_carcasses,
                "remain_total_weight_of_carcasses": kill_house_ware_house.remain_total_weight_of_carcasses,
                "freezing_quantity": kill_house_ware_house.freezing_quantity,
                "freezing_weight": kill_house_ware_house.freezing_weight,
                "free_sale_quantity": kill_house_ware_house.free_sale_quantity,
                "free_sale_weight": kill_house_ware_house.free_sale_weight,
                "total_average_weight_of_carcasses": round(
                    kill_house_ware_house.final_total_weight_of_carcasses / kill_house_ware_house.final_total_number_of_carcasses,
                    2) if kill_house_ware_house.final_total_number_of_carcasses > 0 else 0,

            }
            return Response(update_fields, status=status.HTTP_200_OK)

        serializer = KillHouseWareHouseSerializer(kill_house_ware_house)
        return Response(serializer.data, status=status.HTTP_200_OK)

    def update(self, request, pk=None, *args, **kwargs):
        ware_house = KillHouseWareHouse.objects.get(key=request.data['key'])
        ware_house.updated_number_of_carcasses = int(request.data['updated_number_of_carcasses'])
        ware_house.updated_weight_of_carcasses = request.data['updated_weight_of_carcasses']
        ware_house.total_weight_of_carcasses = request.data[
                                                   'updated_weight_of_carcasses'] + ware_house.free_weight_of_carcasses
        ware_house.total_number_of_carcasses = int(request.data[
                                                       'updated_number_of_carcasses']) + ware_house.number_of_free_carcasses
        ware_house.save()
        serializer = self.serializer_class(ware_house)
        serializer.update(instance=ware_house, validated_data=request.data)
        return Response(serializer.data, status=status.HTTP_200_OK)


class KillHouseWareHouseForDispensersViewSet(viewsets.ModelViewSet):
    queryset = KillHouseWareHouse.objects.all()
    serializer_class = KillHouseWareHouseSerializer
    permission_classes = [TokenHasReadWriteScope]

    def list(self, request, *args, **kwargs):
        date1 = datetime.strptime(request.GET['date1'], '%Y-%m-%d').date()
        date2 = datetime.strptime(request.GET['date2'], '%Y-%m-%d').date()
        user = SystemUserProfile.objects.get(user=request.user, trash=False)
        if request.GET['role'] in ('CityCommerce', 'CityJahad', 'CityPoultry', 'CityOperator'):
            kill_house_ware_houses = KillHouseWareHouse.objects.filter(kill_house__system_address__city=user.city,
                                                                       date__date__gte=date1, date__date__lte=date2,
                                                                       trash=False)
        else:
            kill_house_ware_houses = KillHouseWareHouse.objects.filter(date__date__gte=date1, date__date__lte=date2,
                                                                       trash=False)
        result = {
            "kill_houses": len(kill_house_ware_houses.values_list('kill_house', flat=True).distinct()),

            "total_number_of_carcasses": kill_house_ware_houses.aggregate(total=Sum('final_total_number_of_carcasses'))[
                                             'total'] or 0,
            "total_weight_of_carcasses": kill_house_ware_houses.aggregate(total=Sum('final_total_weight_of_carcasses'))[
                                             'total'] or 0,
            "pre_cold_number_of_carcasses_self_ware_house":
                kill_house_ware_houses.aggregate(total=Sum('pre_cold_number_of_carcasses_self_ware_house'))[
                    'total'] or 0,
            "pre_cold_weight_of_carcasses_self_ware_house":
                kill_house_ware_houses.aggregate(total=Sum('pre_cold_weight_of_carcasses_self_ware_house'))[
                    'total'] or 0,
            "allocated_total_number_of_carcasses":
                kill_house_ware_houses.aggregate(total=Sum('allocated_total_number_of_carcasses'))['total'] or 0,
            "allocated_total_weight_of_carcasses":
                kill_house_ware_houses.aggregate(total=Sum('allocated_total_weight_of_carcasses'))['total'] or 0,
            "remain_total_number_of_carcasses":
                kill_house_ware_houses.aggregate(total=Sum('remain_total_number_of_carcasses'))['total'] or 0,
            "remain_total_weight_of_carcasses":
                kill_house_ware_houses.aggregate(total=Sum('remain_total_weight_of_carcasses'))['total'] or 0,
            "freezing_quantity": kill_house_ware_houses.aggregate(total=Sum('freezing_quantity'))['total'] or 0,
            "freezing_weight": kill_house_ware_houses.aggregate(total=Sum('freezing_weight'))['total'] or 0,
            "free_sale_quantity": kill_house_ware_houses.aggregate(total=Sum('free_sale_quantity'))['total'] or 0,
            "free_sale_weight": kill_house_ware_houses.aggregate(total=Sum('free_sale_weight'))['total'] or 0
        }

        return Response(result, status=status.HTTP_200_OK)


class PreColdKillHouseWareHouseViewSet(viewsets.ModelViewSet):
    queryset = KillHouseWareHouse.objects.all()
    serializer_class = KillHouseWareHouseSerializer
    permission_classes = [TokenHasReadWriteScope]

    def create(self, request, *args, **kwargs):
        now = datetime.now().date()
        kill_house_ware_house = KillHouseWareHouse.objects.get(key=request.data['ware_house_key'])
        if kill_house_ware_house.date.date() != now:
            return Response({"result": "به علت مغایرت تاریخ امکان پیش سرد وجود ندارد!"},
                            status=status.HTTP_403_FORBIDDEN)

        tomorrow = kill_house_ware_house.date + timedelta(days=1)
        kill_house_ware_house.pre_cold_number_of_carcasses_self_ware_house = kill_house_ware_house.remain_total_number_of_carcasses
        kill_house_ware_house.pre_cold_weight_of_carcasses_self_ware_house = kill_house_ware_house.remain_total_weight_of_carcasses
        kill_house_ware_house.remain_total_number_of_carcasses = 0
        kill_house_ware_house.remain_total_weight_of_carcasses = 0
        kill_house_ware_house.save()
        tomorrow_kill_house_ware_house = KillHouseWareHouse.objects.filter(kill_house=kill_house_ware_house.kill_house,
                                                                           date__date=tomorrow.date()).first()
        if not tomorrow_kill_house_ware_house:
            tomorrow_kill_house_ware_house = KillHouseWareHouse(
                kill_house=kill_house_ware_house.kill_house,
                date=kill_house_ware_house.date + timedelta(days=1)
            )
        tomorrow_kill_house_ware_house.save()
        tomorrow_kill_house_ware_house.final_total_number_of_carcasses += kill_house_ware_house.pre_cold_number_of_carcasses_self_ware_house
        tomorrow_kill_house_ware_house.total_number_of_carcasses += kill_house_ware_house.pre_cold_number_of_carcasses_self_ware_house
        tomorrow_kill_house_ware_house.final_total_weight_of_carcasses += kill_house_ware_house.pre_cold_weight_of_carcasses_self_ware_house
        tomorrow_kill_house_ware_house.total_weight_of_carcasses += kill_house_ware_house.pre_cold_weight_of_carcasses_self_ware_house
        tomorrow_kill_house_ware_house.remain_total_number_of_carcasses += kill_house_ware_house.pre_cold_number_of_carcasses_self_ware_house
        tomorrow_kill_house_ware_house.remain_total_weight_of_carcasses += kill_house_ware_house.pre_cold_weight_of_carcasses_self_ware_house
        tomorrow_kill_house_ware_house.pre_cold_number_of_carcasses_to_ware_house = kill_house_ware_house.pre_cold_number_of_carcasses_self_ware_house
        tomorrow_kill_house_ware_house.pre_cold_weight_of_carcasses_to_ware_house = kill_house_ware_house.pre_cold_weight_of_carcasses_self_ware_house
        tomorrow_kill_house_ware_house.save()
        return Response({"result": "با موفقیت انجام شد!"}, status=status.HTTP_201_CREATED)


class KillHouseFreeSaleBarInformationViewSet(viewsets.ModelViewSet):
    queryset = KillHouseFreeSaleBarInformation.objects.all()
    serializer_class = KillHouseFreeSaleBarInformationSerializer
    permission_classes = [TokenHasReadWriteScope]
    pagination_class = CustomPagination
    filter_backends = [DjangoFilterBackend]
    filterset_class = KillHouseFreeSaleBarInformationFilterSet
    filterset_fields = [
        'type_car',
        'pelak',
        'clearance_code',
        'kill_house__name',
        'kill_house__kill_house_operator__user__fullname',
        'kill_house__kill_house_operator__user__first_name',
        'kill_house__kill_house_operator__user__last_name',
        'kill_house__kill_house_operator__user__mobile',
        'buyer__fullname',
        'buyer__first_name',
        'buyer__last_name',
        'buyer__mobile',
        'buyer__unit_name',
        'buyer_name',
        'buyer_mobile',
        'province',
        'city',

    ]

    def create(self, request, *args, **kwargs):
        user = SystemUserProfile.objects.get(user=request.user, trash=False)
        now = datetime.now().date()
        now_time = datetime.now().time()
        quota = request.data['quota']
        buyer = None
        dispenser = request.data.pop('dispenser',None)
        representative = request.data.pop('representative',None)
        if 'kill_house_key' in request.data.keys():
            kill_house = KillHouse.objects.get(key=request.data['kill_house_key'])
            request.data.pop('kill_house_key')
        elif 'buyer_key' in request.data.keys():
            kill_house = KillHouse.objects.filter(kill_house_operator__user=user).first()
            buyer = OutProvinceCarcassesBuyer.objects.get(key=request.data['buyer_key'])
            request.data.pop('buyer_key')
        product = RolesProducts.objects.get(key=request.data['product_key'])
        request.data.pop('product_key')
        date = datetime.strptime(str(request.data['date']), '%Y-%m-%d').date()
        production_date = datetime.strptime(str(request.data['production_date']), '%Y-%m-%d').date()
        date = datetime(year=date.year, month=date.month, day=date.day, hour=now_time.hour,
                        minute=now_time.minute,
                        second=now_time.second)
        production_date = datetime(year=production_date.year, month=production_date.month, day=production_date.day,
                                   hour=now_time.hour,
                                   minute=now_time.minute,
                                   second=now_time.second)
        request.data.pop('date')
        request.data.pop('production_date')
        if OperationLimitation.objects.all().first().kill_house_free_sale_limitation == True:

            if now != date.date():
                return Response({"result": "به علت مغایرت تاریخ امکان فروش بار وجود ندارد!"},
                                status=status.HTTP_403_FORBIDDEN)
        carcass_distribution = RestrictionCarcassDistribution.objects.filter(trash=False,
                                                                             distribution_type='KillHouse',
                                                                             allow=True,
                                                                             out=True).first()
        if carcass_distribution and datetime.now().time() > carcass_distribution.time:
            return Response({"result": "لطفا در ساعات مجاز اقدام نمایید!"},
                            status=status.HTTP_403_FORBIDDEN)
        # ware_house = KillHouseWareHouse.objects.get(kill_house=kill_house, date__date=date)
        # if request.data['weight_of_carcasses'] > ware_house.remain_total_weight_of_carcasses:
        #     return Response({"result": "تعداد یا مقدار وارد شده از موجودی انبار بیشتر است !"},
        #                     status=status.HTTP_403_FORBIDDEN)
        kill_house_total_input_warehouse_governmental_weight = kill_house.total_input_warehouse_governmental_weight
        kill_house_total_input_warehouse_free_weight = kill_house.total_input_warehouse_free_weight

        if request.data['sale_type'] == 'free':
            quota = request.data['quota']
            if quota == 'governmental':
                if not kill_house.free_sale_form_governmental_quota:
                    return Response({"result": "مجاز به فروش آزاد از انبار دولتی نمیباشید!"},
                                    status=status.HTTP_403_FORBIDDEN)

        if quota == 'governmental':
            if kill_house.total_input_warehouse_governmental_weight < (
                    kill_house.total_selling_warehouse_governmental_weight + request.data['weight_of_carcasses']):
                return Response({"result": "مجاز به فروش دولتی بیشتر از ورودی دولتی انبار نمیباشید!"},
                                status=status.HTTP_403_FORBIDDEN)
        else:
            if kill_house.total_input_warehouse_free_weight < (
                    kill_house.total_selling_warehouse_free_weight + request.data['weight_of_carcasses']):
                return Response({"result": "مجاز به فروش آزاد بیشتر از ورودی آزاد انبار نمیباشید!"},
                                status=status.HTTP_403_FORBIDDEN)

        if quota == 'governmental':
            free_sale_type = request.data['sale_type']
            if kill_house.governmental_selling_permission:
                if free_sale_type == 'free':
                    if not kill_house.free_sale_form_governmental_quota:
                        if kill_house.total_commitment_selling_in_province_governmental_weight > kill_house.total_selling_in_province_governmental_weight:
                            return Response({"result": "ابتدا تعهد داخل استان رو تکمیل کنید!"},
                                            status=status.HTTP_403_FORBIDDEN)
                else:
                    if kill_house.total_commitment_selling_in_province_governmental_weight > kill_house.total_selling_in_province_governmental_weight:
                        return Response({"result": "ابتدا تعهد داخل استان رو تکمیل کنید!"},
                                        status=status.HTTP_403_FORBIDDEN)
            else:
                return Response({"result": "مجاز به فروش دولتی نمیباشید!"}, status=status.HTTP_403_FORBIDDEN)
            if kill_house.total_commitment_selling_out_province_governmental_weight > 0:
                if kill_house.total_selling_out_province_governmental_weight + request.data[
                    'weight_of_carcasses'] > kill_house.total_commitment_selling_out_province_governmental_weight:
                    return Response({"result": "به دلیل بیشتر از وزن تعهد مجاز به فروش دولتی نمیباشید!"},
                                    status=status.HTTP_403_FORBIDDEN)

        else:
            if kill_house.free_selling_permission:
                if kill_house.total_commitment_selling_in_province_free_weight > kill_house.total_selling_in_province_free_weight:
                    return Response({"result": "ابتدا تعهد داخل استان رو تکمیل کنید!"},
                                    status=status.HTTP_403_FORBIDDEN)
            else:
                return Response({"result": "مجاز به فروش آزاد نمیباشید!"}, status=status.HTTP_403_FORBIDDEN)

            if kill_house.total_commitment_selling_out_province_free_weight > 0:
                if kill_house.total_selling_out_province_free_weight + request.data[
                    'weight_of_carcasses'] > kill_house.total_commitment_selling_out_province_free_weight:
                    return Response({"result": "به دلیل بیشتر از وزن تعهد مجاز به فروش دولتی نمیباشید!"},
                                    status=status.HTTP_403_FORBIDDEN)

        ware_house_remain_weight = product.total_remain_weight
        allocations_weight = StewardAllocation.objects.filter(trash=False, receiver_state__in=('pending', 'accepted'),
                                                              kill_house=kill_house, date__date=now).aggregate(
            total=Sum('real_weight_of_carcasses'))['total'] or 0
        free_sales_weight = \
            KillHouseFreeSaleBarInformation.objects.filter(trash=False, kill_house=kill_house,
                                                           date__date=now).aggregate(
                total=Sum('real_weight_of_carcasses'))['total'] or 0
        total_weight = ware_house_remain_weight + allocations_weight + free_sales_weight
        free_sales_weight += request.data['weight_of_carcasses']

        # if kill_house.in_province_selling_limitation and kill_house.in_province_selling_limitation_percent > 0:
        #     in_province_limitation_weight = int(
        #         total_weight * (kill_house.in_province_selling_limitation_percent / 100))
        #     if allocations_weight < in_province_limitation_weight:
        #         return Response(
        #             {"result": "به دلیل عدم رعایت حداقل فروش/توزیع داخل استان امکان فروش به خارج استان وجود ندارد!"},
        #             status=status.HTTP_403_FORBIDDEN)
        #
        # if kill_house.out_province_selling_limitation and kill_house.out_province_selling_limitation_percent > 0:
        #     max_out_province_limitation_weight = int(
        #         total_weight * (kill_house.out_province_selling_limitation_percent / 100))
        #     if free_sales_weight > max_out_province_limitation_weight:
        #         return Response({"result": "سقف فروش به خارج استان امروز شما پر شده است!"},
        #                         status=status.HTTP_403_FORBIDDEN)
        if KillHouseFreeSaleBarInformation.objects.filter(trash=False, clearance_code=request.data['clearance_code'],
                                                          quarantine_weight_of_carcasses__gt=0).exists():
            return Response({"result": "کد قرنطینه در سامانه ثبت شده است!"},
                            status=status.HTTP_403_FORBIDDEN)
        serializer = self.serializer_class(data=request.data)
        if serializer.is_valid():
            kill_house_free_sale_bar_info = serializer.create(validated_data=request.data)
            kill_house_free_sale_bar_info.kill_house = kill_house
            if buyer is not None:
                kill_house_free_sale_bar_info.buyer = buyer
                kill_house_free_sale_bar_info.buyer_name = buyer.fullname
                kill_house_free_sale_bar_info.buyer_mobile = buyer.mobile
                kill_house_free_sale_bar_info.city = buyer.city
                kill_house_free_sale_bar_info.province = buyer.province

            kill_house_free_sale_bar_info.date = date
            kill_house_free_sale_bar_info.production_date = production_date
            kill_house_free_sale_bar_info.product = product
            kill_house_free_sale_bar_info.dispenser = dispenser if dispenser else None
            kill_house_free_sale_bar_info.representative = representative if representative else None
            kill_house_free_sale_bar_info.real_number_of_carcasses = kill_house_free_sale_bar_info.number_of_carcasses
            kill_house_free_sale_bar_info.real_weight_of_carcasses = kill_house_free_sale_bar_info.weight_of_carcasses
            # ware_house.allocated_total_number_of_carcasses += kill_house_free_sale_bar_info.number_of_carcasses
            # ware_house.allocated_total_weight_of_carcasses += kill_house_free_sale_bar_info.weight_of_carcasses
            # ware_house.save()

            wage = 0
            wage_type = WageType.objects.filter(en_name='carcasse-sell', trash=False).first()
            if wage_type.status == True:
                wage = wage_type.amount
            kill_house_free_sale_bar_info.wage = wage
            kill_house_free_sale_bar_info.total_wage_amount = wage * kill_house_free_sale_bar_info.real_weight_of_carcasses

            percentages_wage_type = PercentageOfWageType.objects.filter(wage_type=wage_type, percent__gt=0, trash=False)

            if wage_type and wage_type.status == True and percentages_wage_type:
                for percentage_wage_type in percentages_wage_type:
                    if percentage_wage_type.share_type.en_name == 'union':
                        kill_house_free_sale_bar_info.union_share = int(
                            (percentage_wage_type.percent / 100) * kill_house_free_sale_bar_info.total_wage_amount)
                        kill_house_free_sale_bar_info.union_share_percent = percentage_wage_type.percent
                    elif percentage_wage_type.share_type.en_name == 'company':
                        kill_house_free_sale_bar_info.company_share = int(
                            (percentage_wage_type.percent / 100) * kill_house_free_sale_bar_info.total_wage_amount)
                        kill_house_free_sale_bar_info.company_share_percent = percentage_wage_type.percent

                    elif percentage_wage_type.share_type.en_name == 'guilds':
                        kill_house_free_sale_bar_info.guilds_share = int(
                            (percentage_wage_type.percent / 100) * kill_house_free_sale_bar_info.total_wage_amount)
                        kill_house_free_sale_bar_info.guilds_share_percent = percentage_wage_type.percent
                    elif percentage_wage_type.share_type.en_name == 'city':
                        kill_house_free_sale_bar_info.city_share = int(
                            (percentage_wage_type.percent / 100) * kill_house_free_sale_bar_info.total_wage_amount)
                        kill_house_free_sale_bar_info.city_share_percent = percentage_wage_type.percent

                    elif percentage_wage_type.share_type.en_name == 'wallet':
                        kill_house_free_sale_bar_info.wallet_share = int(
                            (percentage_wage_type.percent / 100) * kill_house_free_sale_bar_info.total_wage_amount)
                        kill_house_free_sale_bar_info.wallet_share_percent = percentage_wage_type.percent

                    else:
                        kill_house_free_sale_bar_info.other_share = int(
                            (percentage_wage_type.percent / 100) * kill_house_free_sale_bar_info.total_wage_amount)
                        kill_house_free_sale_bar_info.other_share_percent = percentage_wage_type.percent
            kill_house_free_sale_bar_info.save()
            allow_register_code = AllowRegisterCodeForKillHouseFreeSaleBarInformation.objects.filter(trash=False,
                                                                                                     active=True).first()
            if allow_register_code:
                number = random.randint(10000, 99000)
                kill_house_free_sale_bar_info.registration_code = number
                kill_house_free_sale_bar_info.system_registration_code = True
                if int(allow_register_code.time) > 0:
                    kill_house_free_sale_bar_info.active_expire_date_time = True
                    kill_house_free_sale_bar_info.expire_date_time_registration_code = datetime.now() + timedelta(
                        minutes=int(allow_register_code.time))
                kill_house_free_sale_bar_info.save()
                send_sms_for_sale_bar(kill_house_free_sale_bar_info)
            get_gid_out_province(kill_house_free_sale_bar_info.id)
            kill_house_free_sale_product_warehousing(product)
            return Response(serializer.data, status=status.HTTP_201_CREATED)
        # return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

    def list(self, request, *args, **kwargs):
        user = SystemUserProfile.objects.get(user=request.user, trash=False)
        date1 = request.GET.get('date1')
        date2 = request.GET.get('date2')
        kill_house_key = request.GET.get('kill_house_key')
        if 'type' in request.GET:
            role = request.GET['role']
            if date1:
                date1 = datetime.strptime(str(date1), '%Y-%m-%d').date()
                date2 = datetime.strptime(str(date2), '%Y-%m-%d').date()

                if role in ['ProvinceOperator', 'Commerce', 'ProvinceSupervisor''GuildRoom', 'SuperAdmin',
                            'ImprovingLivestock', 'AdminX', 'Supporter']:
                    if kill_house_key and kill_house_key != 'all':
                        kill_house_free_sale_bar_info = KillHouseFreeSaleBarInformation.objects.filter(
                            date__date__gte=date1,
                            date__date__lte=date2,
                            kill_house__key=kill_house_key,
                            trash=False)
                    else:
                        kill_house_free_sale_bar_info = KillHouseFreeSaleBarInformation.objects.filter(
                            date__date__gte=date1,
                            date__date__lte=date2,
                            trash=False)


                elif role in ['CityJahad', 'CityPoultry', 'CityOperator']:

                    if kill_house_key and kill_house_key != 'all':

                        kill_house_free_sale_bar_info = KillHouseFreeSaleBarInformation.objects.filter(
                            kill_house__system_address__city=user.city,
                            date__date__gte=date1,
                            date__date__lte=date2,
                            kill_house__key=kill_house_key,
                            trash=False)

                    else:

                        kill_house_free_sale_bar_info = KillHouseFreeSaleBarInformation.objects.filter(
                            kill_house__system_address__city=user.city,
                            date__date__gte=date1,
                            date__date__lte=date2,
                            trash=False)




                else:
                    kill_house = KillHouse.objects.filter(kill_house_operator__user=user, trash=False).first()
                    kill_house_free_sale_bar_info = KillHouseFreeSaleBarInformation.objects.filter(
                        kill_house=kill_house,
                        date__date__gte=date1,
                        date__date__lte=date2,
                        trash=False)

            else:
                if role in ['ProvinceOperator', 'Commerce', 'ProvinceSupervisor''GuildRoom', 'SuperAdmin',
                            'ImprovingLivestock', 'AdminX', 'Supporter']:

                    if kill_house_key and kill_house_key != 'all':

                        kill_house_free_sale_bar_info = KillHouseFreeSaleBarInformation.objects.filter(
                            trash=False, kill_house__key=kill_house_key)
                    else:
                        kill_house_free_sale_bar_info = KillHouseFreeSaleBarInformation.objects.filter(
                            trash=False)


                elif role in ['CityJahad', 'CityPoultry', 'CityOperator']:
                    if kill_house_key and kill_house_key != 'all':
                        kill_house_free_sale_bar_info = KillHouseFreeSaleBarInformation.objects.filter(
                            kill_house__system_address__city=user.city,
                            trash=False, kill_house__key=kill_house_key)
                    else:
                        kill_house_free_sale_bar_info = KillHouseFreeSaleBarInformation.objects.filter(
                            kill_house__system_address__city=user.city,
                            trash=False)



                else:
                    kill_house = KillHouse.objects.filter(kill_house_operator__user=user, trash=False).first()
                    kill_house_free_sale_bar_info = KillHouseFreeSaleBarInformation.objects.filter(
                        kill_house=kill_house,
                        trash=False)

            if 'search' in request.GET:
                kill_house_free_sale_bar_info_list = []
                if request.GET['search'] == 'filter':
                    if request.GET['value'] != "" and request.GET['value'] != 'undefined':
                        for item in self.filterset_fields:
                            query = QueryDict('{0}__contains={1}'.format(item, request.GET['value']))
                            if (self.filterset_class(
                                    data=query,
                                    queryset=kill_house_free_sale_bar_info
                            )
                            ).filter():
                                ps = self.filterset_class(data=query, queryset=kill_house_free_sale_bar_info)
                                kill_house_free_sale_bar_info_list = ps.filter()
                        kill_house_free_sale_bar_info = [] if len(
                            kill_house_free_sale_bar_info_list) == 0 else kill_house_free_sale_bar_info_list

            page_size = request.query_params.get('page_size', None)
            if page_size:
                self.pagination_class.page_size = int(page_size)

            page = self.paginate_queryset(kill_house_free_sale_bar_info)
            if page is not None:
                serializer = self.serializer_class(page, many=True)
                return self.get_paginated_response(serializer.data)

        else:
            now = datetime.now().date()
            date = datetime.strptime(str(request.GET['date']),
                                     '%Y-%m-%d').date() if 'date' in request.GET else now
            kill_house = KillHouse.objects.get(key=request.GET['kill_house_key'])
            kill_house_free_sale_bar_info = KillHouseFreeSaleBarInformation.objects.filter(kill_house=kill_house,
                                                                                           date__year=date.year,
                                                                                           date__month=date.month,
                                                                                           date__day=date.day,
                                                                                           trash=False)

        serializer = self.serializer_class(kill_house_free_sale_bar_info, many=True)
        return Response(serializer.data, status=status.HTTP_200_OK)

    def update(self, request, pk=None, *args, **kwargs):
        free_sale_bar = KillHouseFreeSaleBarInformation.objects.get(key=request.data['key'])
        product = free_sale_bar.product
        kill_house = free_sale_bar.kill_house
        if KillHouseFreeSaleBarInformation.objects.filter(trash=False,
                                                          clearance_code=request.data.get('clearance_code'),
                                                          quarantine_weight_of_carcasses__gt=0).exists() and 'register_code' not in request.data.keys():
            return Response({"result": "کد قرنطینه در سامانه ثبت شده است!"},
                            status=status.HTTP_403_FORBIDDEN)
        now = datetime.now().date()
        if free_sale_bar.quota == 'governmental':
            if free_sale_bar.kill_house.total_input_warehouse_governmental_weight < (
                    (
                            free_sale_bar.kill_house.total_selling_warehouse_governmental_weight - free_sale_bar.weight_of_carcasses) +
                    request.data[
                        'weight_of_carcasses']):
                return Response({"result": "وزن وارد شده بیشتر از باقی مانده دولتی می باشد!"},
                                status=status.HTTP_403_FORBIDDEN)
        else:
            if free_sale_bar.kill_house.total_input_warehouse_free_weight < (
                    (free_sale_bar.kill_house.total_selling_warehouse_free_weight - free_sale_bar.weight_of_carcasses) +
                    request.data[
                        'weight_of_carcasses']):
                return Response({"result": "وزن وارد شده بیشتر از باقی مانده آزاد می باشد!"},
                                status=status.HTTP_403_FORBIDDEN)
        allow_register_code = AllowRegisterCodeForKillHouseFreeSaleBarInformation.objects.filter(trash=False,
                                                                                                 active=True).first()
        if allow_register_code:
            if 'register_code' in request.data.keys():
                code = request.data['register_code']
                if code != free_sale_bar.registration_code:
                    return Response({"result": "کد وارد شده صحیح نیست"}, status=status.HTTP_403_FORBIDDEN)
                free_sale_bar.logged_registration_code = code
                request.data.pop('register_code')
            free_sale_bar.save()
        serializer = self.serializer_class(free_sale_bar)

        serializer.update(instance=free_sale_bar, validated_data=request.data)
        kill_house_free_sale_product_warehousing(product)
        free_sale_bar.real_number_of_carcasses = free_sale_bar.number_of_carcasses
        free_sale_bar.real_weight_of_carcasses = free_sale_bar.weight_of_carcasses
        free_sale_bar.total_wage_amount = free_sale_bar.wage * free_sale_bar.real_weight_of_carcasses
        free_sale_bar.save()
        kill_house_free_sale_product_warehousing(product)

        union_percent = free_sale_bar.union_share_percent / 100 if free_sale_bar.union_share_percent > 0 else 0
        company_percent = free_sale_bar.company_share_percent / 100 if free_sale_bar.company_share_percent > 0 else 0
        guilds_percent = free_sale_bar.guilds_share_percent / 100 if free_sale_bar.guilds_share_percent > 0 else 0
        city_share_percent = free_sale_bar.city_share_percent / 100 if free_sale_bar.city_share_percent > 0 else 0
        wallet_share_percent = free_sale_bar.wallet_share_percent / 100 if free_sale_bar.wallet_share_percent > 0 else 0
        other_share_percent = free_sale_bar.other_share_percent / 100 if free_sale_bar.other_share_percent > 0 else 0
        free_sale_bar.union_share = int(union_percent * free_sale_bar.total_wage_amount)
        free_sale_bar.company_share = int(company_percent * free_sale_bar.total_wage_amount)
        free_sale_bar.guilds_share = int(guilds_percent * free_sale_bar.total_wage_amount)
        free_sale_bar.city_share = int(city_share_percent * free_sale_bar.total_wage_amount)
        free_sale_bar.wallet_share = int(wallet_share_percent * free_sale_bar.total_wage_amount)
        free_sale_bar.other_share = int(other_share_percent * free_sale_bar.total_wage_amount)

        get_gid_out_province(free_sale_bar.id)
        return Response(serializer.data, status=status.HTTP_200_OK)

    def destroy(self, request, pk=None, *args, **kwargs):
        free_sale_bar = KillHouseFreeSaleBarInformation.objects.get(key=request.GET['key'])
        product = free_sale_bar.product

        # ware_house = KillHouseWareHouse.objects.get(kill_house=free_sale_bar.kill_house,
        #                                             date__date=free_sale_bar.date.date(), trash=False)
        #
        # if ware_house.allocated_total_number_of_carcasses != free_sale_bar.real_number_of_carcasses or ware_house.allocated_total_weight_of_carcasses != free_sale_bar.real_weight_of_carcasses:
        #     if ware_house.remain_total_number_of_carcasses < free_sale_bar.real_number_of_carcasses or ware_house.remain_total_weight_of_carcasses < free_sale_bar.real_weight_of_carcasses:
        #         return Response({"result": "به علت تخصیص بار به مباشرین و صنف ها امکان حذف بار وجود ندارد!"},
        #                         status=status.HTTP_403_FORBIDDEN)
        free_sale_bar.trash = True
        free_sale_bar.save()
        kill_house_free_sale_product_warehousing(product)

        #
        # ware_house.allocated_total_number_of_carcasses -= free_sale_bar.real_number_of_carcasses
        # ware_house.allocated_total_weight_of_carcasses -= free_sale_bar.real_weight_of_carcasses
        # ware_house.save()

        return Response({"result": "بار با موفقیت حذف شد !"}, status=status.HTTP_200_OK)


class PosKillHouseFreeSaleBarInformationViewSet(viewsets.ModelViewSet):
    queryset = KillHouseFreeSaleBarInformation.objects.all()
    serializer_class = KillHouseFreeSaleBarInformationSerializer
    permission_classes = [AllowAny]
    pagination_class = CustomPagination
    filter_backends = [DjangoFilterBackend]
    filterset_class = KillHouseFreeSaleBarInformationFilterSet
    filterset_fields = [
        'type_car',
        'pelak',
        'clearance_code',
        'kill_house__name',
        'kill_house__kill_house_operator__user__fullname',
        'kill_house__kill_house_operator__user__first_name',
        'kill_house__kill_house_operator__user__last_name',
        'kill_house__kill_house_operator__user__mobile',
        'buyer__fullname',
        'buyer__first_name',
        'buyer__last_name',
        'buyer__mobile',
        'buyer__unit_name',
        'buyer_name',
        'buyer_mobile',
        'province',
        'city',

    ]

    def create(self, request, *args, **kwargs):
        # user = SystemUserProfile.objects.get(user=request.user, trash=False)
        now = datetime.now().date()
        now_time = datetime.now().time()
        quota = request.data['quota']
        pos = POSMachine.objects.get(pos_id=request.data['pos-id'], trash=False)
        kill_house = pos.kill_house
        buyer = OutProvinceCarcassesBuyer.objects.get(key=request.data['buyer_key'])
        request.data.pop('buyer_key')
        product = RolesProducts.objects.get(key=request.data['product_key'])
        request.data.pop('product_key')
        request.data.pop('pos-id')
        date = datetime.now()
        # date = datetime.strptime(str(request.data['date']), '%Y-%m-%d').date()
        production_date = datetime.strptime(str(request.data['production_date']), '%Y-%m-%d').date()
        # date = datetime(year=date.year, month=date.month, day=date.day, hour=now_time.hour,
        #                 minute=now_time.minute,
        #                 second=now_time.second)
        production_date = datetime(year=production_date.year, month=production_date.month, day=production_date.day,
                                   hour=now_time.hour,
                                   minute=now_time.minute,
                                   second=now_time.second)
        # request.data.pop('date')
        request.data.pop('production_date')
        if OperationLimitation.objects.all().first().kill_house_free_sale_limitation == True:

            if now != date.date():
                return Response({"result": "به علت مغایرت تاریخ امکان فروش بار وجود ندارد!"},
                                status=status.HTTP_403_FORBIDDEN)
        carcass_distribution = RestrictionCarcassDistribution.objects.filter(trash=False,
                                                                             distribution_type='KillHouse',
                                                                             allow=True,
                                                                             out=True).first()
        if carcass_distribution and datetime.now().time() > carcass_distribution.time:
            return Response({"result": "لطفا در ساعات مجاز اقدام نمایید!"},
                            status=status.HTTP_403_FORBIDDEN)

        if request.data['sale_type'] == 'free':
            quota = request.data['quota']
            if quota == 'governmental':
                if not kill_house.free_sale_form_governmental_quota:
                    return Response({"result": "مجاز به فروش آزاد از انبار دولتی نمیباشید!"},
                                    status=status.HTTP_403_FORBIDDEN)

        if quota == 'governmental':
            if kill_house.total_input_warehouse_governmental_weight < (
                    kill_house.total_selling_warehouse_governmental_weight + request.data['weight_of_carcasses']):
                return Response({"result": "مجاز به فروش دولتی بیشتر از ورودی دولتی انبار نمیباشید!"},
                                status=status.HTTP_403_FORBIDDEN)
        else:
            if kill_house.total_input_warehouse_free_weight < (
                    kill_house.total_selling_warehouse_free_weight + request.data['weight_of_carcasses']):
                return Response({"result": "مجاز به فروش آزاد بیشتر از ورودی آزاد انبار نمیباشید!"},
                                status=status.HTTP_403_FORBIDDEN)

        if quota == 'governmental':
            free_sale_type = request.data['sale_type']
            if kill_house.governmental_selling_permission:
                if free_sale_type == 'free':
                    if not kill_house.free_sale_form_governmental_quota:
                        if kill_house.total_commitment_selling_in_province_governmental_weight > kill_house.total_selling_in_province_governmental_weight:
                            return Response({"result": "ابتدا تعهد داخل استان رو تکمیل کنید!"},
                                            status=status.HTTP_403_FORBIDDEN)
                else:
                    if kill_house.total_commitment_selling_in_province_governmental_weight > kill_house.total_selling_in_province_governmental_weight:
                        return Response({"result": "ابتدا تعهد داخل استان رو تکمیل کنید!"},
                                        status=status.HTTP_403_FORBIDDEN)
            else:
                return Response({"result": "مجاز به فروش دولتی نمیباشید!"}, status=status.HTTP_403_FORBIDDEN)
            if kill_house.total_commitment_selling_out_province_governmental_weight > 0:
                if kill_house.total_selling_out_province_governmental_weight + request.data[
                    'weight_of_carcasses'] > kill_house.total_commitment_selling_out_province_governmental_weight:
                    return Response({"result": "به دلیل بیشتر از وزن تعهد مجاز به فروش دولتی نمیباشید!"},
                                    status=status.HTTP_403_FORBIDDEN)

        else:
            if kill_house.free_selling_permission:
                if kill_house.total_commitment_selling_in_province_free_weight > kill_house.total_selling_in_province_free_weight:
                    return Response({"result": "ابتدا تعهد داخل استان رو تکمیل کنید!"},
                                    status=status.HTTP_403_FORBIDDEN)
            else:
                return Response({"result": "مجاز به فروش آزاد نمیباشید!"}, status=status.HTTP_403_FORBIDDEN)

            if kill_house.total_commitment_selling_out_province_free_weight > 0:
                if kill_house.total_selling_out_province_free_weight + request.data[
                    'weight_of_carcasses'] > kill_house.total_commitment_selling_out_province_free_weight:
                    return Response({"result": "به دلیل بیشتر از وزن تعهد مجاز به فروش دولتی نمیباشید!"},
                                    status=status.HTTP_403_FORBIDDEN)

        ware_house_remain_weight = product.total_remain_weight
        allocations_weight = StewardAllocation.objects.filter(trash=False, receiver_state__in=('pending', 'accepted'),
                                                              kill_house=kill_house, date__date=now).aggregate(
            total=Sum('real_weight_of_carcasses'))['total'] or 0
        free_sales_weight = \
            KillHouseFreeSaleBarInformation.objects.filter(trash=False, kill_house=kill_house,
                                                           date__date=now).aggregate(
                total=Sum('real_weight_of_carcasses'))['total'] or 0
        total_weight = ware_house_remain_weight + allocations_weight + free_sales_weight
        free_sales_weight += request.data['weight_of_carcasses']

        if KillHouseFreeSaleBarInformation.objects.filter(trash=False, clearance_code=request.data['clearance_code'],
                                                          quarantine_weight_of_carcasses__gt=0).exists():
            return Response({"result": "کد قرنطینه در سامانه ثبت شده است!"},
                            status=status.HTTP_403_FORBIDDEN)
        serializer = self.serializer_class(data=request.data)
        if serializer.is_valid():
            kill_house_free_sale_bar_info = serializer.create(validated_data=request.data)
            kill_house_free_sale_bar_info.kill_house = kill_house
            if buyer is not None:
                kill_house_free_sale_bar_info.buyer = buyer
                kill_house_free_sale_bar_info.buyer_name = buyer.fullname
                kill_house_free_sale_bar_info.buyer_mobile = buyer.mobile
                kill_house_free_sale_bar_info.city = buyer.city
                kill_house_free_sale_bar_info.province = buyer.province

            kill_house_free_sale_bar_info.date = date
            kill_house_free_sale_bar_info.production_date = production_date
            kill_house_free_sale_bar_info.product = product
            kill_house_free_sale_bar_info.real_number_of_carcasses = kill_house_free_sale_bar_info.number_of_carcasses
            kill_house_free_sale_bar_info.real_weight_of_carcasses = kill_house_free_sale_bar_info.weight_of_carcasses

            wage = 0
            wage_type = WageType.objects.filter(en_name='carcasse-sell', trash=False).first()
            if wage_type.status == True:
                wage = wage_type.amount
            kill_house_free_sale_bar_info.wage = wage
            kill_house_free_sale_bar_info.total_wage_amount = wage * kill_house_free_sale_bar_info.real_weight_of_carcasses

            percentages_wage_type = PercentageOfWageType.objects.filter(wage_type=wage_type, percent__gt=0, trash=False)

            if wage_type and wage_type.status == True and percentages_wage_type:
                for percentage_wage_type in percentages_wage_type:
                    if percentage_wage_type.share_type.en_name == 'union':
                        kill_house_free_sale_bar_info.union_share = int(
                            (percentage_wage_type.percent / 100) * kill_house_free_sale_bar_info.total_wage_amount)
                        kill_house_free_sale_bar_info.union_share_percent = percentage_wage_type.percent
                    elif percentage_wage_type.share_type.en_name == 'company':
                        kill_house_free_sale_bar_info.company_share = int(
                            (percentage_wage_type.percent / 100) * kill_house_free_sale_bar_info.total_wage_amount)
                        kill_house_free_sale_bar_info.company_share_percent = percentage_wage_type.percent

                    elif percentage_wage_type.share_type.en_name == 'guilds':
                        kill_house_free_sale_bar_info.guilds_share = int(
                            (percentage_wage_type.percent / 100) * kill_house_free_sale_bar_info.total_wage_amount)
                        kill_house_free_sale_bar_info.guilds_share_percent = percentage_wage_type.percent
                    elif percentage_wage_type.share_type.en_name == 'city':
                        kill_house_free_sale_bar_info.city_share = int(
                            (percentage_wage_type.percent / 100) * kill_house_free_sale_bar_info.total_wage_amount)
                        kill_house_free_sale_bar_info.city_share_percent = percentage_wage_type.percent

                    elif percentage_wage_type.share_type.en_name == 'wallet':
                        kill_house_free_sale_bar_info.wallet_share = int(
                            (percentage_wage_type.percent / 100) * kill_house_free_sale_bar_info.total_wage_amount)
                        kill_house_free_sale_bar_info.wallet_share_percent = percentage_wage_type.percent

                    else:
                        kill_house_free_sale_bar_info.other_share = int(
                            (percentage_wage_type.percent / 100) * kill_house_free_sale_bar_info.total_wage_amount)
                        kill_house_free_sale_bar_info.other_share_percent = percentage_wage_type.percent
            kill_house_free_sale_bar_info.save()
            allow_register_code = AllowRegisterCodeForKillHouseFreeSaleBarInformation.objects.filter(trash=False,
                                                                                                     active=True).first()
            if allow_register_code:
                number = random.randint(10000, 99000)
                kill_house_free_sale_bar_info.registration_code = number
                kill_house_free_sale_bar_info.system_registration_code = True
                if int(allow_register_code.time) > 0:
                    kill_house_free_sale_bar_info.active_expire_date_time = True
                    kill_house_free_sale_bar_info.expire_date_time_registration_code = datetime.now() + timedelta(
                        minutes=int(allow_register_code.time))
                kill_house_free_sale_bar_info.save()
                send_sms_for_sale_bar(kill_house_free_sale_bar_info)
            get_gid_out_province(kill_house_free_sale_bar_info.id)
            kill_house_free_sale_product_warehousing(product)
            return Response(serializer.data, status=status.HTTP_201_CREATED)

    def list(self, request, *args, **kwargs):
        pos = POSMachine.objects.get(pos_id=request.GET['pos-id'], trash=False)
        date1 = request.GET.get('date1')
        date2 = request.GET.get('date2')
        role = request.GET['role']
        if date1:
            date1 = datetime.strptime(str(date1), '%Y-%m-%d').date()
            date2 = datetime.strptime(str(date2), '%Y-%m-%d').date()

            kill_house_free_sale_bar_info = KillHouseFreeSaleBarInformation.objects.filter(
                kill_house=pos.kill_house,
                date__date__gte=date1,
                date__date__lte=date2,
                trash=False)
        else:

            kill_house_free_sale_bar_info = KillHouseFreeSaleBarInformation.objects.filter(
                kill_house=pos.kill_house,
                trash=False)

        if 'search' in request.GET:
            kill_house_free_sale_bar_info_list = []
            if request.GET['search'] == 'filter':
                if request.GET['value'] != "" and request.GET['value'] != 'undefined':
                    for item in self.filterset_fields:
                        query = QueryDict('{0}__contains={1}'.format(item, request.GET['value']))
                        if (self.filterset_class(
                                data=query,
                                queryset=kill_house_free_sale_bar_info
                        )
                        ).filter():
                            ps = self.filterset_class(data=query, queryset=kill_house_free_sale_bar_info)
                            kill_house_free_sale_bar_info_list = ps.filter()
                    kill_house_free_sale_bar_info = [] if len(
                        kill_house_free_sale_bar_info_list) == 0 else kill_house_free_sale_bar_info_list

            page_size = request.query_params.get('page_size', None)
            if page_size:
                self.pagination_class.page_size = int(page_size)

            page = self.paginate_queryset(kill_house_free_sale_bar_info)
            if page is not None:
                serializer = self.serializer_class(page, many=True)
                return self.get_paginated_response(serializer.data)
        serializer = self.serializer_class(kill_house_free_sale_bar_info, many=True)
        return Response(serializer.data, status=status.HTTP_200_OK)

    def update(self, request, pk=None, *args, **kwargs):
        free_sale_bar = KillHouseFreeSaleBarInformation.objects.get(key=request.data['key'])
        product = free_sale_bar.product
        kill_house = free_sale_bar.kill_house
        if KillHouseFreeSaleBarInformation.objects.filter(trash=False,
                                                          clearance_code=request.data.get('clearance_code'),
                                                          quarantine_weight_of_carcasses__gt=0).exists():
            return Response({"result": "کد قرنطینه در سامانه ثبت شده است!"},
                            status=status.HTTP_403_FORBIDDEN)
        now = datetime.now().date()

        if free_sale_bar.quota == 'governmental':
            if free_sale_bar.kill_house.total_input_warehouse_governmental_weight < (
                    (
                            free_sale_bar.kill_house.total_selling_warehouse_governmental_weight - free_sale_bar.weight_of_carcasses) +
                    request.data[
                        'weight_of_carcasses']):
                return Response({"result": "وزن وارد شده بیشتر از باقی مانده دولتی می باشد!"},
                                status=status.HTTP_403_FORBIDDEN)
        else:
            if free_sale_bar.kill_house.total_input_warehouse_free_weight < (
                    (free_sale_bar.kill_house.total_selling_warehouse_free_weight - free_sale_bar.weight_of_carcasses) +
                    request.data[
                        'weight_of_carcasses']):
                return Response({"result": "وزن وارد شده بیشتر از باقی مانده آزاد می باشد!"},
                                status=status.HTTP_403_FORBIDDEN)
        allow_register_code = AllowRegisterCodeForKillHouseFreeSaleBarInformation.objects.filter(trash=False,
                                                                                                 active=True).first()
        if allow_register_code:
            if 'register_code' in request.data.keys():
                code = request.data['register_code']
                if code != free_sale_bar.registration_code:
                    return Response({"result": "کد وارد شده صحیح نیست"}, status=status.HTTP_403_FORBIDDEN)
                free_sale_bar.logged_registration_code = code
                request.data.pop('register_code')
            free_sale_bar.save()
        serializer = self.serializer_class(free_sale_bar)

        serializer.update(instance=free_sale_bar, validated_data=request.data)
        kill_house_free_sale_product_warehousing(product)
        free_sale_bar.real_number_of_carcasses = free_sale_bar.number_of_carcasses
        free_sale_bar.real_weight_of_carcasses = free_sale_bar.weight_of_carcasses
        free_sale_bar.total_wage_amount = free_sale_bar.wage * free_sale_bar.real_weight_of_carcasses
        free_sale_bar.save()
        kill_house_free_sale_product_warehousing(product)

        union_percent = free_sale_bar.union_share_percent / 100 if free_sale_bar.union_share_percent > 0 else 0
        company_percent = free_sale_bar.company_share_percent / 100 if free_sale_bar.company_share_percent > 0 else 0
        guilds_percent = free_sale_bar.guilds_share_percent / 100 if free_sale_bar.guilds_share_percent > 0 else 0
        city_share_percent = free_sale_bar.city_share_percent / 100 if free_sale_bar.city_share_percent > 0 else 0
        wallet_share_percent = free_sale_bar.wallet_share_percent / 100 if free_sale_bar.wallet_share_percent > 0 else 0
        other_share_percent = free_sale_bar.other_share_percent / 100 if free_sale_bar.other_share_percent > 0 else 0
        free_sale_bar.union_share = int(union_percent * free_sale_bar.total_wage_amount)
        free_sale_bar.company_share = int(company_percent * free_sale_bar.total_wage_amount)
        free_sale_bar.guilds_share = int(guilds_percent * free_sale_bar.total_wage_amount)
        free_sale_bar.city_share = int(city_share_percent * free_sale_bar.total_wage_amount)
        free_sale_bar.wallet_share = int(wallet_share_percent * free_sale_bar.total_wage_amount)
        free_sale_bar.other_share = int(other_share_percent * free_sale_bar.total_wage_amount)

        get_gid_out_province(free_sale_bar.id)
        return Response(serializer.data, status=status.HTTP_200_OK)

    def destroy(self, request, pk=None, *args, **kwargs):
        free_sale_bar = KillHouseFreeSaleBarInformation.objects.get(key=request.GET['key'])
        product = free_sale_bar.product
        free_sale_bar.trash = True
        free_sale_bar.save()
        kill_house_free_sale_product_warehousing(product)
        return Response({"result": "بار با موفقیت حذف شد !"}, status=status.HTTP_200_OK)


class KillHouseFreeSaleBarInformationDashboardViewSet(viewsets.ModelViewSet):
    queryset = KillHouseFreeSaleBarInformation.objects.all()
    serializer_class = KillHouseFreeSaleBarInformationSerializer
    permission_classes = [TokenHasReadWriteScope]
    filter_backends = [DjangoFilterBackend]
    filterset_class = KillHouseFreeSaleBarInformationFilterSet
    filterset_fields = [
        'type_car',
        'pelak',
        'clearance_code',
        'kill_house__name',
        'kill_house__kill_house_operator__user__fullname',
        'kill_house__kill_house_operator__user__first_name',
        'kill_house__kill_house_operator__user__last_name',
        'kill_house__kill_house_operator__user__mobile',
        'buyer__fullname',
        'buyer__first_name',
        'buyer__last_name',
        'buyer__mobile',
        'buyer__unit_name',
        'buyer_name',
        'buyer_mobile',
        'province',
        'city',

    ]

    def list(self, request, *args, **kwargs):
        user = SystemUserProfile.objects.get(user=request.user, trash=False)
        role = request.GET['role']
        kill_house_key = request.GET.get('kill_house_key')
        date1 = request.GET['date1']
        date2 = request.GET['date2']
        if date1:
            date1 = datetime.strptime(str(date1), '%Y-%m-%d').date()
            date2 = datetime.strptime(str(date2), '%Y-%m-%d').date()
        if role in ['ProvinceOperator', 'Commerce', 'ProvinceSupervisor''GuildRoom', 'SuperAdmin',
                    'ImprovingLivestock', 'AdminX', 'Supporter']:
            if date1:
                ware_houses = KillHouseWareHouse.objects.filter(date__date__gte=date1,
                                                                date__date__lte=date2)
                if kill_house_key and kill_house_key != 'all':
                    kill_house_free_sale_bar_info = KillHouseFreeSaleBarInformation.objects.filter(
                        date__date__gte=date1,
                        date__date__lte=date2,
                        calculate_status=True,
                        temporary_trash=False,
                        temporary_deleted=False,
                        kill_house__key=kill_house_key,
                        trash=False)
                else:
                    kill_house_free_sale_bar_info = KillHouseFreeSaleBarInformation.objects.filter(
                        date__date__gte=date1,
                        date__date__lte=date2,
                        calculate_status=True,
                        temporary_trash=False,
                        temporary_deleted=False,
                        trash=False)
            else:
                ware_houses = KillHouseWareHouse.objects.filter(trash=False)

                if kill_house_key and kill_house_key != 'all':

                    kill_house_free_sale_bar_info = KillHouseFreeSaleBarInformation.objects.filter(
                        calculate_status=True,
                        temporary_trash=False,
                        temporary_deleted=False,
                        kill_house__key=kill_house_key,
                        trash=False)
                else:
                    kill_house_free_sale_bar_info = KillHouseFreeSaleBarInformation.objects.filter(
                        calculate_status=True,
                        temporary_trash=False,
                        temporary_deleted=False,
                        trash=False)
            kill_houses = KillHouse.objects.filter(trash=False,
                                                   pk__in=kill_house_free_sale_bar_info.values_list('kill_house',
                                                                                                    flat=True))
            buyers = len(kill_house_free_sale_bar_info.values_list('buyer', flat=True).distinct())




        elif role in ['CityJahad', 'CityPoultry', 'CityOperator']:
            if date1:

                ware_houses = KillHouseWareHouse.objects.filter(kill_house__system_address__city=user.city,
                                                                date__date__gte=date1,
                                                                date__date__lte=date2)

                if kill_house_key and kill_house_key != 'all':

                    kill_house_free_sale_bar_info = KillHouseFreeSaleBarInformation.objects.filter(
                        kill_house__system_address__city=user.city,
                        date__date__gte=date1,
                        date__date__lte=date2,
                        calculate_status=True,
                        temporary_trash=False,
                        temporary_deleted=False,
                        kill_house__key=kill_house_key,
                        trash=False)
                else:
                    kill_house_free_sale_bar_info = KillHouseFreeSaleBarInformation.objects.filter(
                        kill_house__system_address__city=user.city,
                        date__date__gte=date1,
                        date__date__lte=date2,
                        calculate_status=True,
                        temporary_trash=False,
                        temporary_deleted=False,
                        trash=False)
            else:
                ware_houses = KillHouseWareHouse.objects.filter(kill_house__system_address__city=user.city, trash=False)
                if kill_house_key and kill_house_key != 'all':

                    kill_house_free_sale_bar_info = KillHouseFreeSaleBarInformation.objects.filter(
                        kill_house__system_address__city=user.city,
                        calculate_status=True,
                        temporary_trash=False,
                        temporary_deleted=False,
                        kill_house__key=kill_house_key,
                        trash=False)
                else:
                    kill_house_free_sale_bar_info = KillHouseFreeSaleBarInformation.objects.filter(
                        kill_house__system_address__city=user.city,
                        calculate_status=True,
                        temporary_trash=False,
                        temporary_deleted=False,
                        trash=False)
            kill_houses = KillHouse.objects.filter(trash=False,
                                                   pk__in=kill_house_free_sale_bar_info.values_list('kill_house',
                                                                                                    flat=True))
            buyers = len(kill_house_free_sale_bar_info.values_list('buyer', flat=True).distinct())




        else:
            kill_houses = KillHouse.objects.filter(kill_house_operator__user=user, trash=False).first()
            if date1:
                kill_house_free_sale_bar_info = KillHouseFreeSaleBarInformation.objects.filter(
                    kill_house=kill_houses,
                    date__date__gte=date1,
                    date__date__lte=date2,
                    calculate_status=True,
                    temporary_trash=False,
                    temporary_deleted=False,
                    trash=False)
            else:
                kill_house_free_sale_bar_info = KillHouseFreeSaleBarInformation.objects.filter(
                    kill_house=kill_houses,
                    calculate_status=True,
                    temporary_trash=False,
                    temporary_deleted=False,
                    trash=False)

            buyers = len(kill_house_free_sale_bar_info.values_list('buyer', flat=True).distinct())

        if 'search' in request.GET:
            kill_house_free_sale_bar_info_list = []
            if request.GET['search'] == 'filter':
                if request.GET['value'] != "" and request.GET['value'] != 'undefined':
                    for item in self.filterset_fields:
                        query = QueryDict('{0}__contains={1}'.format(item, request.GET['value']))
                        if (self.filterset_class(
                                data=query,
                                queryset=kill_house_free_sale_bar_info
                        )
                        ).filter():
                            ps = self.filterset_class(data=query, queryset=kill_house_free_sale_bar_info)
                            kill_house_free_sale_bar_info_list = ps.filter()
                    kill_house_free_sale_bar_info = [] if len(
                        kill_house_free_sale_bar_info_list) == 0 else kill_house_free_sale_bar_info_list

        if role == 'KillHouse':
            result = {
                "number_of_allocations": len(kill_house_free_sale_bar_info),
                "number_of_buyers": buyers,
                "total_number_of_allocation_carcasses":
                    kill_house_free_sale_bar_info.aggregate(total=Sum('number_of_carcasses'))['total'] or 0,
                "total_weight_of_allocation_carcasses":
                    kill_house_free_sale_bar_info.aggregate(total=Sum('weight_of_carcasses'))['total'] or 0,

            }

        else:
            result = {
                "number_of_kill_houses": len(kill_houses),
                "number_of_allocations": len(kill_house_free_sale_bar_info),
                "number_of_buyers": buyers,
                "total_number_of_allocation_carcasses":
                    kill_house_free_sale_bar_info.aggregate(total=Sum('number_of_carcasses'))['total'] or 0,
                "total_weight_of_allocation_carcasses": int(
                    kill_house_free_sale_bar_info.aggregate(total=Sum('weight_of_carcasses'))['total'] or 0),
                "remain_total_number_of_carcasses":
                    ware_houses.aggregate(total=Sum('remain_total_number_of_carcasses'))[
                        'total'] or 0,
                "remain_total_weight_of_carcasses":
                    ware_houses.aggregate(total=Sum('remain_total_weight_of_carcasses'))[
                        'total'] or 0,

            }

        return Response(result, status=status.HTTP_200_OK)


class KillHousebuyersDashboarForFreeSaleBarInformationdViewSet(viewsets.ModelViewSet):
    queryset = KillHouse.objects.all()
    serializer_class = KillHouseForKillHouseVetKillHouseSerializer
    permission_classes = [TokenHasReadWriteScope]

    def list(self, request, *args, **kwargs):
        role = request.GET['role']
        user = SystemUserProfile.objects.get(user=request.user, trash=False)
        if role == 'KillHouse':
            kill_house = KillHouse.objects.filter(kill_house_operator__user=user, trash=False).first()
        else:
            kill_house = KillHouse.objects.filter(key=request.GET['kill_house_key'], kill_house_operator__user=user,
                                                  trash=False).first()

        buyers = OutProvinceCarcassesBuyer.objects.filter(Kill_house=kill_house, trash=False)
        free_sales = KillHouseFreeSaleBarInformation.objects.filter(trash=False, kill_house=kill_house)

        total_quantity = free_sales.aggregate(total=Sum('number_of_carcasses'))[
                             'total'] or 0
        total_weight = free_sales.aggregate(total=Sum('weight_of_carcasses'))[
                           'total'] or 0
        result = {
            "buyers": len(buyers),
            "number_of_requests": len(free_sales),
            "total_quantity": total_quantity,
            "total_weight": total_weight,
        }
        return Response({"result": result}, status=status.HTTP_200_OK)


class KillHouseFreeBarInformationforWageTotalViewSet(viewsets.ModelViewSet):
    queryset = KillHouseFreeBarInformation.objects.all()
    serializer_class = KillHouseFreeBarInformationForWageTotalSerializer
    permission_classes = [TokenHasReadWriteScope]
    pagination_class = CustomPagination
    filter_backends = [DjangoFilterBackend]
    filterset_class = KillHouseFreeBarInformationFilterSet
    filterset_fields = [
        'kill_house__name',
        'kill_house__kill_house_operator__user__mobile',
        'kill_house__kill_house_operator__user__fullname',
        'kill_house__kill_house_operator__user__mobile',

    ]

    def list(self, request, *args, **kwargs):
        user = SystemUserProfile.objects.get(user=request.user, trash=False)
        type = request.GET['type']
        if request.GET['role'] == 'KillHouse':
            kill_house = KillHouse.objects.filter(kill_house_operator__user=user, trash=False).first()
        else:
            kill_house = KillHouse.objects.get(key=request.GET['kill_house_key'])

        if 'date1' in request.GET:
            date1 = datetime.strptime(str(request.GET['date1']), '%Y-%m-%d').date()
            date2 = datetime.strptime(str(request.GET['date2']), '%Y-%m-%d').date()

            if request.GET['role'] == 'ProvinceOperator':
                kill_house_free_bar_info = KillHouseFreeBarInformation.objects.filter(kill_house=kill_house,
                                                                                      buy_type=type,
                                                                                      date__date__gte=date1,
                                                                                      date__date__lte=date2,
                                                                                      union_share__gt=0,
                                                                                      archive_wage=False,
                                                                                      trash=False).order_by('id')
            elif request.GET['role'] == 'Company':
                kill_house_free_bar_info = KillHouseFreeBarInformation.objects.filter(kill_house=kill_house,
                                                                                      buy_type=type,
                                                                                      date__date__gte=date1,
                                                                                      date__date__lte=date2,
                                                                                      company_share__gt=0,
                                                                                      archive_wage=False,
                                                                                      trash=False).order_by('id')
            elif request.GET['role'] == 'Guilds':
                kill_house_free_bar_info = KillHouseFreeBarInformation.objects.filter(kill_house=kill_house,
                                                                                      buy_type=type,
                                                                                      date__date__gte=date1,
                                                                                      date__date__lte=date2,
                                                                                      guilds_share__gt=0,
                                                                                      archive_wage=False,
                                                                                      trash=False).order_by('id')
            else:

                kill_house_free_bar_info = KillHouseFreeBarInformation.objects.filter(kill_house=kill_house,
                                                                                      buy_type=type,
                                                                                      date__date__gte=date1,
                                                                                      date__date__lte=date2,
                                                                                      archive_wage=False,
                                                                                      trash=False).order_by('id')

        else:
            if request.GET['role'] == 'ProvinceOperator':
                kill_house_free_bar_info = KillHouseFreeBarInformation.objects.filter(kill_house=kill_house,
                                                                                      buy_type=type,
                                                                                      union_share__gt=0,
                                                                                      trash=False).order_by('id')
            elif request.GET['role'] == 'Company':
                kill_house_free_bar_info = KillHouseFreeBarInformation.objects.filter(kill_house=kill_house,
                                                                                      buy_type=type,
                                                                                      company_share__gt=0,
                                                                                      archive_wage=False,
                                                                                      trash=False).order_by('id')
            elif request.GET['role'] == 'Guilds':
                kill_house_free_bar_info = KillHouseFreeBarInformation.objects.filter(kill_house=kill_house,
                                                                                      buy_type=type,
                                                                                      guilds_share__gt=0,
                                                                                      archive_wage=False,
                                                                                      trash=False).order_by('id')
            else:

                kill_house_free_bar_info = KillHouseFreeBarInformation.objects.filter(kill_house=kill_house,
                                                                                      buy_type=type,
                                                                                      archive_wage=False,
                                                                                      trash=False).order_by('id')

        if 'search' in request.GET:
            kill_house_free_bar_info_list = []
            if request.GET['search'] == 'filter':
                if request.GET['value'] != "" and request.GET['value'] != 'undefined':
                    for item in self.filterset_fields:
                        query = QueryDict('{0}__contains={1}'.format(item, request.GET['value']))
                        if (self.filterset_class(
                                data=query,
                                queryset=kill_house_free_bar_info
                        )
                        ).filter():
                            ps = self.filterset_class(data=query, queryset=kill_house_free_bar_info)
                            kill_house_free_bar_info_list = ps.filter()
                    kill_house_free_bar_info = [] if len(
                        kill_house_free_bar_info_list) == 0 else kill_house_free_bar_info_list

        page_size = request.query_params.get('page_size', None)
        if page_size:
            self.pagination_class.page_size = int(page_size)

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

        serializer = self.get_serializer(kill_house_free_bar_info, many=True)
        return Response(serializer.data, status=status.HTTP_200_OK)


class KillHouseFreeBarInformationViewSet(viewsets.ModelViewSet):
    queryset = KillHouseFreeBarInformation.objects.all()
    serializer_class = KillHouseFreeBarInformationSerializer
    permission_classes = [TokenHasReadWriteScope]
    pagination_class = CustomPagination
    filter_backends = [DjangoFilterBackend]
    filterset_class = KillHouseFreeBarInformationFilterSet
    filterset_fields = [
        'kill_house__name',
        'poultry_name',
        'poultry_mobile',
        'province',
        'bar_code',
        'city',
        'driver_name',
        'driver_mobile',
        'bar_clearance_code',
        'kill_house__kill_house_operator__user__mobile',
        'kill_house__kill_house_operator__user__fullname',

    ]

    def create(self, request, *args, **kwargs):
        killer = None
        now_time = datetime.now().time()
        dispenser = request.data.pop('dispenser',None)
        representative = request.data.pop('representative',None)
        user = SystemUserProfile.objects.get(user=request.user, trash=False)
        kill_house = KillHouse.objects.filter(kill_house_operator__user=user, trash=False).first()
        free_commitment_percent = kill_house.out_province_free_buying_commitment_percent
        if 'bar_clearance_code' in request.data.keys():
            if KillHouseFreeBarInformation.objects.filter(trash=False, bar_clearance_code=request.data[
                'bar_clearance_code']).exists():
                return Response({'result': 'کد قرنطینه قبلا در سامانه ثبت شده است!'}, status=status.HTTP_403_FORBIDDEN)
        if 'product_key' not in request.data.keys():
            return Response({'result': 'لطفا محصول را انتخاب کنید!'}, status=status.HTTP_403_FORBIDDEN)
        product = RolesProducts.objects.get(key=request.data['product_key'])
        request.data.pop('product_key')
        if 'killer_key' in request.data.keys() and request.data['killer_key'] != None:
            killer = KillHouse.objects.get(key=request.data['killer_key'])
        request.data.pop('killer_key')

        try:
            image = request.data['bar_image']
            request.data.pop('bar_image')
        except:
            image = None
        date = datetime.strptime(str(request.data['date']), '%Y-%m-%d').date()
        date = datetime(year=date.year, month=date.month, day=date.day, hour=now_time.hour,
                        minute=now_time.minute,
                        second=now_time.second)
        request.data.pop('date')
        serializer = self.serializer_class(data=request.data)
        if serializer.is_valid():
            kill_house_free_bar_info = serializer.create(validated_data=request.data)
            if image != None:
                kill_house_free_bar_info.bar_image = send_image_to_server(image)
            kill_house_free_bar_info.kill_house = kill_house
            kill_house_free_bar_info.date = date
            if kill_house_free_bar_info.buy_type == 'carcass':
                kill_house_free_bar_info.warehouse_commitment_weight = int(
                    (free_commitment_percent / 100) * int(kill_house_free_bar_info.weight_of_carcasses))

                kill_house_free_bar_info.ware_house = True
            if killer:
                if killer.killer and killer.type == 'public':
                    kill_house_free_bar_info.kill_house = killer
                    kill_house_free_bar_info.public_killer = kill_house
                    kill_house_free_bar_info.input_warehouse = killer
                    product = RolesProducts.objects.get(kill_house=killer, trash=False)
                else:
                    kill_house_free_bar_info.exclusive_killer = killer
                    kill_house_free_bar_info.input_warehouse = killer
                    product = RolesProducts.objects.get(kill_house=killer, trash=False)

            else:
                kill_house_free_bar_info.input_warehouse = kill_house
            kill_house_free_bar_info.product = product
            kill_house_free_bar_info.dispenser = dispenser if dispenser else None
            kill_house_free_bar_info.representative = representative if representative else None
            kill_house_free_bar_info.bar_code = generate_unique_bar_code()
            kill_house_free_bar_info.save()
            wage = 0
            type = 'live-buy' if kill_house_free_bar_info.buy_type == 'live' else 'carcasse-buy'
            wage_type = WageType.objects.filter(en_name=type, trash=False).first()
            if wage_type.status == True:
                wage = wage_type.amount
            kill_house_free_bar_info.wage = wage
            kill_house_free_bar_info.total_wage_amount = wage * int(
                kill_house_free_bar_info.live_weight) if kill_house_free_bar_info.buy_type == 'live' else wage * int(
                kill_house_free_bar_info.weight_of_carcasses)
            kill_house_free_bar_info.register_date = datetime.now()
            kill_house_free_bar_info.save()
            kill_house_free_buying_product_warehousing(product)

            percentages_wage_type = PercentageOfWageType.objects.filter(wage_type=wage_type, percent__gt=0, trash=False)

            if wage_type and wage_type.status == True and percentages_wage_type:
                for percentage_wage_type in percentages_wage_type:
                    if percentage_wage_type.share_type.en_name == 'union':
                        kill_house_free_bar_info.union_share = int(
                            (percentage_wage_type.percent / 100) * kill_house_free_bar_info.total_wage_amount)
                        kill_house_free_bar_info.union_share_percent = percentage_wage_type.percent
                        kill_house_free_bar_info.save()
                    elif percentage_wage_type.share_type.en_name == 'company':
                        kill_house_free_bar_info.company_share = int(
                            (percentage_wage_type.percent / 100) * kill_house_free_bar_info.total_wage_amount)
                        kill_house_free_bar_info.company_share_percent = percentage_wage_type.percent
                        kill_house_free_bar_info.save()

                    elif percentage_wage_type.share_type.en_name == 'guilds':
                        kill_house_free_bar_info.guilds_share = int(
                            (percentage_wage_type.percent / 100) * kill_house_free_bar_info.total_wage_amount)
                        kill_house_free_bar_info.guilds_share_percent = percentage_wage_type.percent
                        kill_house_free_bar_info.save()
                    elif percentage_wage_type.share_type.en_name == 'city':
                        kill_house_free_bar_info.city_share = int(
                            (percentage_wage_type.percent / 100) * kill_house_free_bar_info.total_wage_amount)
                        kill_house_free_bar_info.city_share_percent = percentage_wage_type.percent
                        kill_house_free_bar_info.save()

                    elif percentage_wage_type.share_type.en_name == 'wallet':
                        kill_house_free_bar_info.wallet_share = int(
                            (percentage_wage_type.percent / 100) * kill_house_free_bar_info.total_wage_amount)
                        kill_house_free_bar_info.wallet_share_percent = percentage_wage_type.percent
                        kill_house_free_bar_info.save()

                    else:
                        kill_house_free_bar_info.other_share = int(
                            (percentage_wage_type.percent / 100) * kill_house_free_bar_info.total_wage_amount)
                        kill_house_free_bar_info.other_share_percent = percentage_wage_type.percent
                        kill_house_free_bar_info.save()
            return Response(serializer.data, status=status.HTTP_201_CREATED)
        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

    def list(self, request, *args, **kwargs):
        user = SystemUserProfile.objects.get(user=request.user, trash=False)
        type = request.GET.get('type')
        date_type = request.GET.get('date_type')
        bar_state = request.GET.get('bar_state')
        kill_house_free_bar_info_list = []
        role = request.GET.get('role')
        kill_houses = None
        order_by_type = '-date'

        if role in ['KillHouse', 'KillHouseVet']:
            if role == 'KillHouse':
                kill_houses = KillHouse.objects.filter(kill_house_operator__user=user, trash=False)
            else:
                kill_house_ids = KillHouseVet.objects.filter(vet__user=user, trash=False).values_list('kill_house',
                                                                                                      flat=True)
                kill_houses = KillHouse.objects.filter(id__in=kill_house_ids, trash=False)
        if 'date1' in request.GET:
            date1 = datetime.strptime(str(request.GET['date1']), '%Y-%m-%d').date()
            date2 = datetime.strptime(str(request.GET['date2']), '%Y-%m-%d').date()
            if date_type:
                if date_type == 'buy':

                    filters = {
                        'register_date__date__gte': date1,
                        'register_date__date__lte': date2,
                        'trash': False,
                        'temporary_trash': False,
                        'temporary_deleted': False,
                        'calculate_status': True
                    }
                else:
                    order_by_type = '-date'
                    filters = {
                        'date__date__gte': date1,
                        'date__date__lte': date2,
                        'trash': False,
                        'temporary_trash': False,
                        'temporary_deleted': False,
                        'calculate_status': True
                    }
            else:
                filters = {
                    'register_date__date__gte': date1,
                    'register_date__date__lte': date2,
                    'trash': False,
                    'temporary_trash': False,
                    'temporary_deleted': False,
                    'calculate_status': True
                }
        else:
            filters = {
                'trash': False,
                'temporary_trash': False,
                'temporary_deleted': False,
                'calculate_status': True
            }

        if type:
            filters['buy_type'] = type
            if type == 'live':
                if bar_state:
                    if bar_state == 'entered':
                        filters['weight_of_carcasses__gt'] = 0
                    else:
                        filters['weight_of_carcasses'] = 0
        if kill_houses is not None:
            kill_house_free_bar_info = KillHouseFreeBarInformation.objects.filter(
                Q(kill_house__in=kill_houses) | Q(exclusive_killer__in=kill_houses) | Q(public_killer__in=kill_houses),
                **filters).order_by(order_by_type)
        else:

            kill_house_free_bar_info = KillHouseFreeBarInformation.objects.filter(**filters).order_by(order_by_type)

        if 'search' in request.GET:
            if request.GET['search'] == 'filter':
                if request.GET['value'] != "" and request.GET['value'] != 'undefined':
                    for item in self.filterset_fields:
                        query = QueryDict('{0}__contains={1}'.format(item, request.GET['value']))
                        if (self.filterset_class(
                                data=query,
                                queryset=kill_house_free_bar_info
                        )
                        ).filter():
                            ps = self.filterset_class(data=query, queryset=kill_house_free_bar_info)
                            kill_house_free_bar_info_list = ps.filter()
                    kill_house_free_bar_info = [] if len(
                        kill_house_free_bar_info_list) == 0 else kill_house_free_bar_info_list

        page_size = request.query_params.get('page_size', None)
        if page_size:
            self.pagination_class.page_size = int(page_size)

        page = self.paginate_queryset(kill_house_free_bar_info)
        if page is not None:
            serializer = self.serializer_class(page, many=True)
            return self.get_paginated_response(serializer.data)

        serializer = self.serializer_class(kill_house_free_bar_info, many=True)
        return Response(serializer.data, status=status.HTTP_200_OK)

    def update(self, request, pk=None, *args, **kwargs):
        user = SystemUserProfile.objects.get(user=request.user, trash=False)
        free_bar = KillHouseFreeBarInformation.objects.get(key=request.data['key'])
        # product = free_bar.product

        if 'live_weight' in request.data.keys():
            if int(request.data['live_weight']) < free_bar.weight_of_carcasses:
                return Response(
                    {"result": "مقدار وارد شده کمتر از وزن لاشه است! "},
                    status=status.HTTP_403_FORBIDDEN)

        if 'bar_clearance_code' in request.data.keys():
            existing_bar = KillHouseFreeBarInformation.objects.filter(trash=False, bar_clearance_code=request.data[
                'bar_clearance_code']).exclude(id=free_bar.id).first()
            if existing_bar:
                if existing_bar.register_type == 'automatic':
                    existing_bar.trash = True
                    existing_bar.save()
                else:
                    return Response({'result': 'کد قرنطینه قبلا در سامانه ثبت شده است!'},
                                    status=status.HTTP_403_FORBIDDEN)
        if 'number_of_carcasses' in request.data.keys():
            now = datetime.now().date()
            if OperationLimitation.objects.all().first().kill_house_input_bar_limitation == True and \
                    free_bar.register_type != 'automatic':
                if now != free_bar.date.date():
                    return Response({"result": "به علت وجود مفایرت در تاریخ ثبت امکان ویرایش وجود ندارد! "},
                                    status=status.HTTP_403_FORBIDDEN)

            # ware_house = KillHouseWareHouse.objects.filter(kill_house=free_bar.kill_house,
            #                                                date__date=free_bar.date.date(), trash=False).first()
            # allocation = StewardAllocation.objects.filter(ware_house=ware_house, trash=False)
            #
            # if len(allocation) > 0:
            #     if OperationLimitation.objects.all().first().kill_house_input_bar_limitation == True:
            #         return Response(
            #             {"result": "به علت وجود تخصیص به مباشر یا صنف برای امروز امکان ویرایش وجود ندارد! "},
            #             status=status.HTTP_403_FORBIDDEN)
        if 'return_entered_bar' in request.data.keys():
            free_bar.weight_of_carcasses = 0
            free_bar.number_of_carcasses = 0
            free_bar.entered_message = None
            free_bar.ware_house = False
        if 'bar_image' in request.data.keys():
            if request.data['bar_image'] != " ":
                free_bar.bar_image = send_image_to_server(request.data['bar_image'])
                free_bar.save()
            request.data.pop('bar_image')
        if 'kill_house_vet_state' in request.data.keys():
            free_bar.date_of_accept_reject = datetime.now()
            free_bar.acceptor_rejector = user.fullname
        if 'killer_key' in request.data.keys() and request.data['killer_key'] != None and request.data[
            'killer_key'] != '':
            exclusive_killer = KillHouse.objects.filter(trash=False, key=request.data['killer_key']).first()
            if exclusive_killer.killer and exclusive_killer.type == 'public':
                if not free_bar.public_killer:
                    free_bar.public_killer = free_bar.kill_house
                free_bar.kill_house = exclusive_killer
                free_bar.input_warehouse = exclusive_killer
                product = RolesProducts.objects.filter(kill_house=exclusive_killer, trash=False, name='مرغ گرم').first()
                free_bar.product = product
                if free_bar.exclusive_killer:
                    free_bar.exclusive_killer = None
            else:
                free_bar.exclusive_killer = exclusive_killer
                free_bar.input_warehouse = exclusive_killer
                product = RolesProducts.objects.filter(kill_house=exclusive_killer, trash=False, name='مرغ گرم').first()
                free_bar.product = product
                if free_bar.public_killer:
                    free_bar.kill_house = free_bar.public_killer
                    free_bar.public_killer = None
            request.data.pop('killer_key')
        serializer = self.serializer_class(free_bar)
        serializer.update(instance=free_bar, validated_data=request.data)
        free_commitment_percent = free_bar.kill_house.out_province_free_buying_commitment_percent
        free_bar.total_wage_amount = free_bar.wage * int(
            free_bar.live_weight) if free_bar.buy_type == 'live' else free_bar.wage * int(free_bar.weight_of_carcasses)
        free_bar.warehouse_commitment_weight = int((free_commitment_percent / 100) * int(free_bar.weight_of_carcasses))
        if free_bar.exclusive_killer:
            product = RolesProducts.objects.get(kill_house=free_bar.exclusive_killer, trash=False)
            free_bar.product = product
        free_bar.save()
        union_percent = free_bar.union_share_percent / 100 if free_bar.union_share_percent > 0 else 0
        company_percent = free_bar.company_share_percent / 100 if free_bar.company_share_percent > 0 else 0
        guilds_percent = free_bar.guilds_share_percent / 100 if free_bar.guilds_share_percent > 0 else 0
        city_share_percent = free_bar.city_share_percent / 100 if free_bar.city_share_percent > 0 else 0
        wallet_share_percent = free_bar.wallet_share_percent / 100 if free_bar.wallet_share_percent > 0 else 0
        other_share_percent = free_bar.other_share_percent / 100 if free_bar.other_share_percent > 0 else 0
        free_bar.union_share = int(union_percent * free_bar.total_wage_amount)
        free_bar.company_share = int(company_percent * free_bar.total_wage_amount)
        free_bar.guilds_share = int(guilds_percent * free_bar.total_wage_amount)
        free_bar.city_share = int(city_share_percent * free_bar.total_wage_amount)
        free_bar.wallet_share = int(wallet_share_percent * free_bar.total_wage_amount)
        free_bar.other_share = int(other_share_percent * free_bar.total_wage_amount)
        free_bar.save()
        kill_house_free_buying_product_warehousing(free_bar.product)
        return Response(serializer.data, status=status.HTTP_200_OK)

    def destroy(self, request, pk=None, *args, **kwargs):
        free_bar = KillHouseFreeBarInformation.objects.get(trash=False, key=request.GET['key'])
        free_bar.trash = True
        free_bar.save()
        product = free_bar.product
        kill_house_free_buying_product_warehousing(product)

        return Response({"result": "بار با موفقیت حذف شد !"}, status=status.HTTP_200_OK)


class ParentCompanyKillHouseFreeBarInformationViewSet(viewsets.ModelViewSet):
    queryset = KillHouseFreeBarInformation.objects.all()
    serializer_class = KillHouseFreeBarInformationSerializer
    permission_classes = [AllowAny]
    pagination_class = CustomPagination
    filter_backends = [DjangoFilterBackend]
    filterset_class = KillHouseFreeBarInformationFilterSet
    filterset_fields = [
        'kill_house__name',
        'poultry_name',
        'poultry_mobile',
        'province',
        'city',
        'driver_name',
        'driver_mobile',
        'bar_clearance_code',
        'kill_house__kill_house_operator__user__mobile',
        'kill_house__kill_house_operator__user__fullname',

    ]

    def list(self, request, *args, **kwargs):
        type = request.GET.get('type')
        date_type = request.GET.get('date_type')
        bar_state = request.GET.get('bar_state')
        kill_house_free_bar_info_list = []
        role = request.GET.get('role')
        kill_houses = None
        order_by_type = '-create_date'

        if 'date1' in request.GET:
            date1 = datetime.strptime(str(request.GET['date1']), '%Y-%m-%d').date()
            date2 = datetime.strptime(str(request.GET['date2']), '%Y-%m-%d').date()
            if date_type:
                if date_type == 'buy':

                    filters = {
                        'create_date__date__gte': date1,
                        'create_date__date__lte': date2,
                        'trash': False,
                    }
                else:
                    order_by_type = '-date'
                    filters = {
                        'date__date__gte': date1,
                        'date__date__lte': date2,
                        'trash': False,
                    }
            else:
                filters = {
                    'create_date__date__gte': date1,
                    'create_date__date__lte': date2,
                    'trash': False,
                }
        else:
            filters = {
                'trash': False
            }

        if kill_houses is not None:
            filters['kill_house__in'] = kill_houses

        if type:
            filters['buy_type'] = type
            if type == 'live':
                if bar_state:
                    if bar_state == 'entered':
                        filters['weight_of_carcasses__gt'] = 0
                    else:
                        filters['weight_of_carcasses'] = 0

        kill_house_free_bar_info = KillHouseFreeBarInformation.objects.filter(**filters).order_by(order_by_type)

        if 'search' in request.GET:
            if request.GET['search'] == 'filter':
                if request.GET['value'] != "" and request.GET['value'] != 'undefined':
                    for item in self.filterset_fields:
                        query = QueryDict('{0}__contains={1}'.format(item, request.GET['value']))
                        if (self.filterset_class(
                                data=query,
                                queryset=kill_house_free_bar_info
                        )
                        ).filter():
                            ps = self.filterset_class(data=query, queryset=kill_house_free_bar_info)
                            kill_house_free_bar_info_list = ps.filter()
                    kill_house_free_bar_info = [] if len(
                        kill_house_free_bar_info_list) == 0 else kill_house_free_bar_info_list

        page_size = request.query_params.get('page_size', None)
        if page_size:
            self.pagination_class.page_size = int(page_size)

        page = self.paginate_queryset(kill_house_free_bar_info)
        if page is not None:
            serializer = self.serializer_class(page, many=True)
            return self.get_paginated_response(serializer.data)

        serializer = self.serializer_class(kill_house_free_bar_info, many=True)
        return Response(serializer.data, status=status.HTTP_200_OK)


class KillHouseRequestForBarManagementViewSet(viewsets.ModelViewSet):
    queryset = KillHouseRequest.objects.all()
    serializer_class = KillHouseRequestForBarManagementSerializer
    pagination_class = CustomPagination
    permission_classes = [TokenHasReadWriteScope]
    filter_backends = [DjangoFilterBackend]
    filterset_class = KillHouseRequestFilterSet
    filterset_fields = [
        'killhouse_user__kill_house_operator__user__fullname',
        'killhouse_user__kill_house_operator__user__mobile',
        'province_request__poultry_request__poultry__user__fullname',
        'province_request__poultry_request__poultry__user__mobile',
        'province_request__poultry_request__order_code',
        'bar_code',
        'traffic_code',
        'clearance_code'
    ]

    def list(self, request, *args, **kwargs):
        # refresh(request.user.id)
        breed_list = []
        city_list = []
        quantity_list = []
        total_list = []

        user = SystemUserProfile.objects.get(user=request.user, trash=False)
        if 'role' in request.GET:
            if request.GET['role'] == 'Poultry':
                if 'waiting' in request.GET:
                    queryset = PoultryRequest.objects.filter(poultry__user=user, awaiting_payment=True,
                                                             trash=False, out=False).order_by('-send_date')
                elif 'inspector' in request.GET:
                    queryset = PoultryRequest.objects.filter(poultry__user=user, inspector='pending',
                                                             trash=False, out=False).order_by('-send_date')
                else:
                    now = datetime.now().date()

                    date1 = datetime.strptime(str(request.GET['date1']),
                                              '%Y-%m-%d').date() if 'date1' in request.GET else now
                    date2 = datetime.strptime(str(request.GET['date2']),
                                              '%Y-%m-%d').date() if 'date2' in request.GET else now

                    queryset_lists = PoultryRequest.objects.filter(poultry__user=user,
                                                                   final_state__in=('pending', 'archive'),
                                                                   trash=False, out=False).order_by('-send_date')
                    queryset = [
                        queryset_list for queryset_list in queryset_lists
                        if date1 <= queryset_list.send_date.date() <= date2
                    ]
            elif request.GET['role'] == 'VetSupervisor':

                if 'check' in request.GET:
                    if 'date1' in request.GET and 'date2' in request.GET:
                        date1 = datetime.strptime(str(request.GET['date1']), '%Y-%m-%d').date()
                        date2 = datetime.strptime(str(request.GET['date2']), '%Y-%m-%d').date()

                        if 'search' in request.GET:
                            if 'deleted_requests' in request.GET:

                                kill_house_requests_list = KillHouseRequest.objects.filter(
                                    kill_request__recive_date__date__gte=date1,
                                    kill_request__recive_date__date__lte=date2,
                                    province_request__poultry_request__poultry__address__province=user.province,
                                    trash=True, temporary_trash=False, temporary_deleted=False,
                                    message__isnull=False
                                ).select_related('kill_request')
                            else:
                                kill_house_requests_list = KillHouseRequest.objects.filter(
                                    kill_request__recive_date__date__gte=date1,
                                    kill_request__recive_date__date__lte=date2,
                                    province_request__poultry_request__poultry__address__province=user.province,
                                    non_receipt=False,
                                    trash=False
                                ).select_related('kill_request')

                            if request.GET['search'] == 'filter':
                                if request.GET['value'] != "":
                                    for item in self.filterset_fields:
                                        query = QueryDict('{0}__contains={1}'.format(item, request.GET['value']))
                                        if (self.filterset_class(
                                                data=query,
                                                queryset=kill_house_requests_list

                                        )
                                        ).filter():
                                            ps = self.filterset_class(data=query, queryset=kill_house_requests_list)
                                            kill_house_requests = ps.filter()
                                else:
                                    kill_house_requests = kill_house_requests_list
                        else:

                            if 'deleted_requests' in request.GET:

                                kill_house_requests = KillHouseRequest.objects.filter(
                                    kill_request__recive_date__date__gte=date1,
                                    kill_request__recive_date__date__lte=date2,
                                    province_request__poultry_request__poultry__address__province=user.province,
                                    trash=True,
                                    message__isnull=False, temporary_trash=False, temporary_deleted=False
                                ).select_related('kill_request')
                            else:
                                kill_house_requests = KillHouseRequest.objects.filter(
                                    kill_request__recive_date__date__gte=date1,
                                    kill_request__recive_date__date__lte=date2,
                                    province_request__poultry_request__poultry__address__province=user.province,
                                    non_receipt=False,
                                    trash=False
                                ).select_related('kill_request')

                        page_size = request.query_params.get('page_size', None)
                        if page_size:
                            self.pagination_class.page_size = int(page_size)

                        page = self.paginate_queryset(kill_house_requests)
                        if page is not None:
                            serializer = KillHouseRequestForBarManagementSerializer(page, many=True)
                            return self.get_paginated_response(serializer.data)

                        serializer = KillHouseRequestForBarManagementSerializer(kill_house_requests, many=True)
                        return Response(serializer.data, status=status.HTTP_200_OK)
            elif request.GET['role'] == 'VetFarm':
                vet = Vet.objects.filter(user=user, trash=False)
                poultries = []
                if vet.count() > 0:
                    vet = vet.last()
                    vet_farms = VetFarm.objects.filter(vet=vet, trash=False)
                    if vet_farms.count() > 0:
                        for vet_farm in vet_farms:
                            if vet_farm.poultry in poultries:
                                pass
                            else:
                                poultries.append(vet_farm.poultry)
                        if 'check' in request.GET:
                            kill_house_requests = []
                            date1 = datetime.strptime(str(request.GET['date1']), '%Y-%m-%d').date()
                            date2 = datetime.strptime(str(request.GET['date2']), '%Y-%m-%d').date()
                            if 'search' in request.GET:
                                if 'deleted_requests' in request.GET:
                                    aggregate_permission = VetFarmAggregatePermission.objects.filter(
                                        trash=False).first()
                                    if aggregate_permission and aggregate_permission.allow == True:
                                        kill_house_requests_list = KillHouseRequest.objects.filter(
                                            kill_request__recive_date__date__gte=date1,
                                            kill_request__recive_date__date__lte=date2,
                                            province_request__poultry_request__poultry__in=poultries,
                                            trash=True,
                                            message__isnull=False, temporary_trash=False, temporary_deleted=False
                                        ).select_related('kill_request')
                                    else:

                                        kill_house_requests_list = KillHouseRequest.objects.filter(
                                            kill_request__recive_date__date__gte=date1,
                                            kill_request__recive_date__date__lte=date2,
                                            province_request__poultry_request__poultry__in=poultries,
                                            trash=True,
                                            message__isnull=False, temporary_trash=False, temporary_deleted=False
                                        ).select_related('kill_request')
                                else:
                                    aggregate_permission = VetFarmAggregatePermission.objects.filter(
                                        trash=False).first()
                                    if aggregate_permission and aggregate_permission.allow == True:
                                        kill_house_requests_list = KillHouseRequest.objects.filter(
                                            kill_request__recive_date__date__gte=date1,
                                            kill_request__recive_date__date__lte=date2,
                                            province_request__poultry_request__poultry__in=poultries,
                                            non_receipt=False,
                                            trash=False
                                        ).select_related('kill_request').order_by(
                                            'province_request__poultry_request__poultry', 'killhouse_user')
                                    else:
                                        kill_house_requests_list = KillHouseRequest.objects.filter(
                                            kill_request__recive_date__date__gte=date1,
                                            kill_request__recive_date__date__lte=date2,
                                            province_request__poultry_request__poultry__in=poultries,
                                            non_receipt=False,
                                            trash=False
                                        ).select_related('kill_request')

                                if request.GET['search'] == 'filter':
                                    if request.GET['value'] != "":
                                        for item in self.filterset_fields:
                                            query = QueryDict('{0}__contains={1}'.format(item, request.GET['value']))
                                            if (self.filterset_class(
                                                    data=query,
                                                    queryset=kill_house_requests_list

                                            )
                                            ).filter():
                                                ps = self.filterset_class(data=query, queryset=kill_house_requests_list)
                                                kill_house_requests = ps.filter()
                                    else:
                                        kill_house_requests = kill_house_requests_list
                            else:

                                if 'deleted_requests' in request.GET:

                                    kill_house_requests = KillHouseRequest.objects.filter(
                                        kill_request__recive_date__date__gte=date1,
                                        kill_request__recive_date__date__lte=date2,
                                        province_request__poultry_request__poultry__in=poultries,
                                        trash=True,
                                        message__isnull=False, temporary_trash=False, temporary_deleted=False
                                    ).select_related('kill_request')
                                else:
                                    kill_house_requests = KillHouseRequest.objects.filter(
                                        kill_request__recive_date__date__gte=date1,
                                        kill_request__recive_date__date__lte=date2,
                                        province_request__poultry_request__poultry__in=poultries,
                                        non_receipt=False,
                                        trash=False
                                    ).select_related('kill_request')

                            page_size = request.query_params.get('page_size', None)
                            if page_size:
                                self.pagination_class.page_size = int(page_size)

                            page = self.paginate_queryset(kill_house_requests)
                            if page is not None:
                                serializer = KillHouseRequestForBarManagementSerializer(page, many=True)
                                return self.get_paginated_response(serializer.data)

                            serializer = KillHouseRequestForBarManagementSerializer(kill_house_requests, many=True)
                            return Response(serializer.data, status=status.HTTP_200_OK)



                        elif 'waiting' in request.GET:
                            queryset = PoultryRequest.objects.filter(poultry__in=poultries,
                                                                     poultry__address__province=user.province,
                                                                     awaiting_payment=True,
                                                                     trash=False, out=False).order_by('send_date')
                        elif 'inspector' in request.GET:
                            queryset = PoultryRequest.objects.filter(poultry__in=poultries,
                                                                     poultry__address__province=user.province,
                                                                     inspector='pending',
                                                                     trash=False, out=False).order_by('send_date')
                        else:
                            queryset = PoultryRequest.objects.filter(poultry__in=poultries,
                                                                     poultry__address__province=user.province,
                                                                     final_state__in=('pending', 'archive'),
                                                                     trash=False, out=False).order_by('send_date')
                    else:
                        queryset = []

            elif request.GET['role'] == 'ProvinceInspector':
                if 'waiting' in request.GET:
                    queryset = PoultryRequest.objects.filter(poultry__address__province=user.province,
                                                             awaiting_payment=True,
                                                             trash=False, out=False).order_by('send_date')
                elif 'inspector' in request.GET:
                    queryset = PoultryRequest.objects.filter(poultry__address__province=user.province,
                                                             inspector='pending',
                                                             trash=False, out=False).order_by('send_date')
                # elif 'out' in request.GET:

                else:

                    if 'date' in request.GET:
                        date = datetime.strptime(request.GET['date'], '%Y-%m-%d')
                    else:
                        date = datetime.now()

                    queryset = PoultryRequest.objects.filter(poultry__address__province=user.province,
                                                             state_process__in=('pending', 'accepted'),
                                                             province_state__in=('pending', 'accepted'),
                                                             trash=False, out=False,
                                                             send_date__year=date.year, send_date__month=date.month,
                                                             send_date__day=date.day
                                                             ).order_by('-send_date')
            elif request.GET['role'] == 'CityOperator':
                city_operator = CityOperator.objects.get(user=user)

                if 'check' in request.GET:
                    kill_house_requests = []
                    date1 = datetime.strptime(str(request.GET['date1']), '%Y-%m-%d').date()
                    date2 = datetime.strptime(str(request.GET['date2']), '%Y-%m-%d').date()

                    if 'search' in request.GET:
                        if 'deleted_requests' in request.GET:

                            kill_house_requests_list = KillHouseRequest.objects.filter(
                                kill_request__recive_date__date__gte=date1,
                                kill_request__recive_date__date__lte=date2,
                                province_request__poultry_request__poultry__city_operator=city_operator.unit_name,
                                trash=True,
                                message__isnull=False, temporary_trash=False, temporary_deleted=False
                            ).select_related('kill_request')
                        else:
                            kill_house_requests_list = KillHouseRequest.objects.filter(
                                kill_request__recive_date__date__gte=date1,
                                kill_request__recive_date__date__lte=date2,
                                province_request__poultry_request__poultry__city_operator=city_operator.unit_name,
                                non_receipt=False,
                                trash=False
                            ).select_related('kill_request')

                        if request.GET['search'] == 'filter':
                            if request.GET['value'] != "":
                                for item in self.filterset_fields:
                                    query = QueryDict('{0}__contains={1}'.format(item, request.GET['value']))
                                    if (self.filterset_class(
                                            data=query,
                                            queryset=kill_house_requests_list

                                    )
                                    ).filter():
                                        ps = self.filterset_class(data=query, queryset=kill_house_requests_list)
                                        kill_house_requests = ps.filter()
                            else:
                                kill_house_requests = kill_house_requests_list
                    else:

                        if 'deleted_requests' in request.GET:

                            kill_house_requests = KillHouseRequest.objects.filter(
                                kill_request__recive_date__date__gte=date1,
                                kill_request__recive_date__date__lte=date2,
                                province_request__poultry_request__poultry__city_operator=city_operator.unit_name,
                                trash=True,
                                message__isnull=False, temporary_trash=False, temporary_deleted=False
                            ).select_related('kill_request')
                        else:
                            kill_house_requests = KillHouseRequest.objects.filter(
                                kill_request__recive_date__date__gte=date1,
                                kill_request__recive_date__date__lte=date2,
                                province_request__poultry_request__poultry__city_operator=city_operator.unit_name,
                                non_receipt=False,
                                trash=False
                            ).select_related('kill_request')

                    page_size = request.query_params.get('page_size', None)
                    if page_size:
                        self.pagination_class.page_size = int(page_size)

                    page = self.paginate_queryset(kill_house_requests)
                    if page is not None:
                        serializer = KillHouseRequestForBarManagementSerializer(page, many=True)
                        return self.get_paginated_response(serializer.data)

                    serializer = KillHouseRequestForBarManagementSerializer(kill_house_requests, many=True)
                    return Response(serializer.data, status=status.HTTP_200_OK)



                # list1 = []
                # for c in CityUnit.objects.filter(city__name=user.city.name, trash=False):
                #     list1.append(c.name)
                elif 'waiting' in request.GET:
                    # queryset = PoultryRequest.objects.filter(poultry__address__city__name__in=list1,
                    #                                          awaiting_payment=True,
                    #                                          trash=False).order_by('send_date')

                    queryset = PoultryRequest.objects.filter(city_operator=city_operator,
                                                             awaiting_payment=True,
                                                             trash=False, out=False).order_by('send_date')
                elif 'inspector' in request.GET:
                    # queryset = PoultryRequest.objects.filter(poultry__address__city__name__in=list1,
                    #                                          inspector='pending',
                    #                                          trash=False).order_by('send_date')
                    queryset = PoultryRequest.objects.filter(city_operator=city_operator,
                                                             inspector='pending',
                                                             trash=False, out=False).order_by('send_date')
                else:
                    # queryset = PoultryRequest.objects.filter(poultry__address__city__name__in=list1,
                    #                                          trash=False).order_by(
                    #     'send_date')
                    if 'date1' in request.GET and 'date2' in request.GET:
                        date1 = datetime.strptime(str(request.GET['date1']), '%Y-%m-%d').date()
                        date2 = datetime.strptime(str(request.GET['date2']), '%Y-%m-%d').date()
                    queryset_list = PoultryRequest.objects.filter(poultry__city_operator=city_operator.unit_name,
                                                                  trash=False, out=False, final_state='pending',
                                                                  ).order_by('send_date')
                    queryset = [
                        poultry_req for poultry_req in queryset_list
                        if date1 <= poultry_req.send_date.date() <= date2
                    ]

            elif request.GET['role'] in ['CityCommerce', 'CityVet', 'CityJahad', 'CityPoultry']:
                if 'check' in request.GET:
                    kill_house_requests = []
                    if 'date1' in request.GET and 'date2' in request.GET:
                        date1 = datetime.strptime(str(request.GET['date1']), '%Y-%m-%d').date()
                        date2 = datetime.strptime(str(request.GET['date2']), '%Y-%m-%d').date()
                        if 'search' in request.GET:

                            if 'deleted_requests' in request.GET:

                                kill_house_requests_list = KillHouseRequest.objects.filter(
                                    kill_request__recive_date__date__gte=date1,
                                    kill_request__recive_date__date__lte=date2,
                                    province_request__poultry_request__poultry__address__city=user.city,
                                    trash=True,
                                    message__isnull=False, temporary_trash=False, temporary_deleted=False
                                ).select_related('kill_request')
                            else:
                                kill_house_requests_list = KillHouseRequest.objects.filter(
                                    kill_request__recive_date__date__gte=date1,
                                    kill_request__recive_date__date__lte=date2,
                                    province_request__poultry_request__poultry__address__city=user.city,
                                    non_receipt=False,
                                    trash=False
                                ).select_related('kill_request')

                            if request.GET['search'] == 'filter':
                                if request.GET['value'] != "":
                                    for item in self.filterset_fields:
                                        query = QueryDict('{0}__contains={1}'.format(item, request.GET['value']))
                                        if (self.filterset_class(
                                                data=query,
                                                queryset=kill_house_requests_list

                                        )
                                        ).filter():
                                            ps = self.filterset_class(data=query, queryset=kill_house_requests_list)
                                            kill_house_requests = ps.filter()
                                else:
                                    kill_house_requests = kill_house_requests_list
                        else:

                            if 'deleted_requests' in request.GET:

                                kill_house_requests = KillHouseRequest.objects.filter(
                                    kill_request__recive_date__date__gte=date1,
                                    kill_request__recive_date__date__lte=date2,
                                    province_request__poultry_request__poultry__address__city=user.city,
                                    trash=True,
                                    message__isnull=False, temporary_trash=False, temporary_deleted=False
                                ).select_related('kill_request')
                            else:
                                kill_house_requests = KillHouseRequest.objects.filter(
                                    kill_request__recive_date__date__gte=date1,
                                    kill_request__recive_date__date__lte=date2,
                                    province_request__poultry_request__poultry__address__city=user.city,
                                    non_receipt=False,
                                    trash=False
                                ).select_related('kill_request')

                        page_size = request.query_params.get('page_size', None)
                        if page_size:
                            self.pagination_class.page_size = int(page_size)

                        page = self.paginate_queryset(kill_house_requests)
                        if page is not None:
                            serializer = KillHouseRequestForBarManagementSerializer(page, many=True)
                            return self.get_paginated_response(serializer.data)

                        serializer = KillHouseRequestForBarManagementSerializer(kill_house_requests, many=True)
                        return Response(serializer.data, status=status.HTTP_200_OK)
            elif request.GET['role'] == 'LiveStockSupport':
                if 'check' in request.GET:
                    kill_house_requests = []
                    if 'date1' in request.GET and 'date2' in request.GET:
                        date1 = datetime.strptime(str(request.GET['date1']), '%Y-%m-%d').date()
                        date2 = datetime.strptime(str(request.GET['date2']), '%Y-%m-%d').date()
                        if 'search' in request.GET:

                            if 'deleted_requests' in request.GET:

                                kill_house_requests_list = KillHouseRequest.objects.filter(
                                    kill_request__recive_date__date__gte=date1,
                                    kill_request__recive_date__date__lte=date2,
                                    province_request__poultry_request__freezing=True,
                                    trash=True,
                                    message__isnull=False, temporary_trash=False, temporary_deleted=False
                                ).select_related('kill_request')
                            else:
                                kill_house_requests_list = KillHouseRequest.objects.filter(
                                    kill_request__recive_date__date__gte=date1,
                                    kill_request__recive_date__date__lte=date2,
                                    province_request__poultry_request__freezing=True,
                                    non_receipt=False,
                                    trash=False
                                ).select_related('kill_request')

                            if request.GET['search'] == 'filter':
                                if request.GET['value'] != "":
                                    for item in self.filterset_fields:
                                        query = QueryDict('{0}__contains={1}'.format(item, request.GET['value']))
                                        if (self.filterset_class(
                                                data=query,
                                                queryset=kill_house_requests_list

                                        )
                                        ).filter():
                                            ps = self.filterset_class(data=query, queryset=kill_house_requests_list)
                                            kill_house_requests = ps.filter()
                                else:
                                    kill_house_requests = kill_house_requests_list
                        else:

                            if 'deleted_requests' in request.GET:

                                kill_house_requests = KillHouseRequest.objects.filter(
                                    kill_request__recive_date__date__gte=date1,
                                    kill_request__recive_date__date__lte=date2,
                                    province_request__poultry_request__freezing=True,
                                    trash=True,
                                    message__isnull=False, temporary_trash=False, temporary_deleted=False
                                ).select_related('kill_request')
                            else:
                                kill_house_requests = KillHouseRequest.objects.filter(
                                    kill_request__recive_date__date__gte=date1,
                                    kill_request__recive_date__date__lte=date2,
                                    province_request__poultry_request__freezing=True,
                                    non_receipt=False,
                                    trash=False
                                ).select_related('kill_request')

                        page_size = request.query_params.get('page_size', None)
                        if page_size:
                            self.pagination_class.page_size = int(page_size)

                        page = self.paginate_queryset(kill_house_requests)
                        if page is not None:
                            serializer = KillHouseRequestForBarManagementSerializer(page, many=True)
                            return self.get_paginated_response(serializer.data)

                        serializer = KillHouseRequestForBarManagementSerializer(kill_house_requests, many=True)
                        return Response(serializer.data, status=status.HTTP_200_OK)


            elif request.GET['role'] == 'ProvinceFinancial':
                if 'waiting' in request.GET:
                    queryset = PoultryRequest.objects.filter(poultry__address__province=user.province,
                                                             awaiting_payment=True,
                                                             trash=False, out=False).order_by('send_date')
                elif 'inspector' in request.GET:
                    queryset = PoultryRequest.objects.filter(poultry__address__province=user.province,
                                                             inspector='pending',
                                                             trash=False, out=False).order_by('send_date')
                elif 'all' in request.GET:
                    queryset = PoultryRequest.objects.filter(poultry__address__province=user.province,
                                                             assignment=True,
                                                             final_state='pending',
                                                             trash=False, out=False).order_by('send_date')
                else:
                    if 'date' in request.GET:
                        date = datetime.strptime(request.GET['date'], '%Y-%m-%d')
                    else:
                        date = datetime.now()

                    queryset = PoultryRequest.objects.filter(poultry__address__province=user.province,
                                                             state_process__in=('pending', 'accepted'),
                                                             province_state__in=('pending', 'accepted'),
                                                             trash=False, out=False,
                                                             send_date__year=date.year, send_date__month=date.month,
                                                             send_date__day=date.day
                                                             ).order_by('-send_date')
            elif request.GET['role'] in ['ProvinceOperator', 'Commerce', 'ProvinceSupervisor', 'SuperAdmin', 'AdminX',
                                         'ImprovingLivestock', 'Supporter']:
                if 'waiting' in request.GET:
                    queryset = PoultryRequest.objects.filter(poultry__address__province=user.province,
                                                             awaiting_payment=True,
                                                             trash=False, out=False).order_by('send_date')
                elif 'inspector' in request.GET:
                    queryset = PoultryRequest.objects.filter(poultry__address__province=user.province,
                                                             inspector='pending',
                                                             trash=False, out=False).order_by('send_date')
                elif 'out' in request.GET:
                    if 'date' in request.GET:
                        date = datetime.strptime(request.GET['date'], '%Y-%m-%d')
                    else:
                        date = datetime.now()
                    queryset = PoultryRequest.objects.filter(poultry__address__province=user.province,
                                                             send_date__year=date.year, send_date__month=date.month,
                                                             send_date__day=date.day,
                                                             trash=False, out=True).order_by('-send_date')
                elif 'check' in request.GET:
                    kill_house_requests = []
                    if 'date1' in request.GET and 'date2' in request.GET:
                        date1 = datetime.strptime(str(request.GET['date1']), '%Y-%m-%d').date()
                        date2 = datetime.strptime(str(request.GET['date2']), '%Y-%m-%d').date()
                        if 'search' in request.GET:

                            if 'deleted_requests' in request.GET:

                                kill_house_requests = KillHouseRequest.objects.filter(
                                    kill_request__recive_date__date__gte=date1,
                                    kill_request__recive_date__date__lte=date2,
                                    province_request__poultry_request__poultry__address__province=user.province,
                                    trash=True, temporary_trash=False, temporary_deleted=False
                                    # message__isnull=False
                                ).select_related('kill_request')
                            else:
                                if 'without_quarantine_code_state' in request.GET and request.GET[
                                    'without_quarantine_code_state'] == 'true':
                                    kill_house_requests = KillHouseRequest.objects.filter(
                                        clearance_code__isnull=False,
                                        kill_request__recive_date__date__gte=date1,
                                        kill_request__recive_date__date__lte=date2,
                                        quarantine_quantity__isnull=True,
                                        quarantine_code_state__isnull=True,
                                        non_receipt=False,
                                        province_request__poultry_request__poultry__address__province=user.province,
                                        trash=False
                                    ).select_related('kill_request')
                                else:
                                    kill_house_requests = KillHouseRequest.objects.filter(
                                        # (Q(trash=False) | Q(trash=True, clearance_code__isnull=False,
                                        #                     temporary_trash=False, temporary_deleted=False)),
                                        kill_request__recive_date__date__gte=date1,
                                        kill_request__recive_date__date__lte=date2,
                                        non_receipt=False,
                                        province_request__poultry_request__poultry__address__province=user.province,

                                        trash=False
                                    ).select_related('kill_request')
                            value = request.GET.get('value')
                            search = request.GET.get('search')
                            if value and search == 'filter':
                                if value != 'undefined' and value.strip():
                                    kill_house_requests = kill_house_requests.filter(
                                        build_query(DashboardEnterLoadInformationFilterSet, value)
                                    )
                        else:

                            if 'deleted_requests' in request.GET:

                                kill_house_requests = KillHouseRequest.objects.filter(
                                    kill_request__recive_date__date__gte=date1,
                                    kill_request__recive_date__date__lte=date2,
                                    province_request__poultry_request__poultry__address__province=user.province,
                                    trash=True,
                                    # message__isnull=False
                                ).select_related('kill_request')
                            else:
                                if 'without_quarantine_code_state' in request.GET and request.GET[
                                    'without_quarantine_code_state'] == 'true':
                                    kill_house_requests = KillHouseRequest.objects.filter(
                                        clearance_code__isnull=False,
                                        kill_request__recive_date__date__gte=date1,
                                        kill_request__recive_date__date__lte=date2,
                                        quarantine_quantity__isnull=True,
                                        quarantine_code_state__isnull=True,
                                        non_receipt=False,
                                        province_request__poultry_request__poultry__address__province=user.province,
                                        trash=False
                                    ).select_related('kill_request')
                                else:
                                    kill_house_requests = KillHouseRequest.objects.filter(
                                        # (Q(trash=False) | Q(trash=True, clearance_code__isnull=False)),
                                        kill_request__recive_date__date__gte=date1,
                                        kill_request__recive_date__date__lte=date2,
                                        non_receipt=False,
                                        province_request__poultry_request__poultry__address__province=user.province,
                                        trash=False
                                    ).select_related('kill_request')
                        page_size = request.query_params.get('page_size', None)
                        if page_size:
                            self.pagination_class.page_size = int(page_size)

                        page = self.paginate_queryset(kill_house_requests)
                        if page is not None:
                            serializer = KillHouseRequestForBarManagementSerializer(page, many=True)
                            return self.get_paginated_response(serializer.data)

                        serializer = KillHouseRequestForBarManagementSerializer(kill_house_requests, many=True)
                        return Response(serializer.data, status=status.HTTP_200_OK)

                elif 'date1' in request.GET and 'date2' in request.GET:

                    now = datetime.now().date()
                    date1 = datetime.strptime(str(request.GET['date1']),
                                              '%Y-%m-%d').date() if 'date1' in request.GET else now
                    date2 = datetime.strptime(str(request.GET['date2']),
                                              '%Y-%m-%d').date() if 'date2' in request.GET else now
                    queryset_lists = PoultryRequest.objects.filter(poultry__address__province=user.province,
                                                                   trash=False, out=False,
                                                                   ).order_by('-send_date')

                    queryset = [
                        queryset_list for queryset_list in queryset_lists
                        if date1 <= queryset_list.send_date.date() <= date2
                    ]

                    # date1 = datetime.datetime.strptime(str(request.GET['date1']), '%Y-%m-%d').date()
                    # date2 = datetime.datetime.strptime(str(request.GET['date2']), '%Y-%m-%d').date()
                    # queryset_list = PoultryRequest.objects.filter(poultry__address__province=user.province,
                    #                                               trash=False, out=False,
                    #                                               ).order_by('-send_date')
                    #
                    # queryset = []
                    # queryset = [
                    #     poultry_req for poultry_req in queryset_list
                    #     if date1 <= poultry_req.send_date.date() <= date2
                    # ]
                else:
                    if 'date' in request.GET:
                        date = datetime.strptime(request.GET['date'], '%Y-%m-%d')
                    else:
                        date = datetime.now() - timedelta(days=2)

                    queryset = PoultryRequest.objects.filter(poultry__address__province=user.province,
                                                             state_process__in=('pending', 'accepted'),
                                                             province_state__in=('pending', 'accepted'),
                                                             trash=False, out=False,
                                                             send_date__year__gte=date.year,
                                                             send_date__month__gte=date.month,
                                                             send_date__day__gte=date.day
                                                             ).order_by('-send_date')

            elif request.GET['role'] == 'KillHouse':
                kill_house = KillHouse.objects.filter(kill_house_operator__user=user, trash=False)

                if 'check' in request.GET:
                    kill_house_requests = []
                    if 'date1' in request.GET and 'date2' in request.GET:
                        date1 = datetime.strptime(str(request.GET['date1']), '%Y-%m-%d').date()
                        date2 = datetime.strptime(str(request.GET['date2']), '%Y-%m-%d').date()
                        if 'search' in request.GET:

                            if 'deleted_requests' in request.GET:

                                kill_house_requests_list = KillHouseRequest.objects.filter(
                                    (Q(killhouse_user__in=kill_house) | Q(
                                        kill_request__slaughter_house__in=kill_house) | Q(killer__in=kill_house)),
                                    kill_request__recive_date__date__gte=date1,
                                    kill_request__recive_date__date__lte=date2,
                                    province_request__poultry_request__poultry__address__province=user.province,
                                    trash=True, temporary_trash=False, temporary_deleted=False
                                    # message__isnull=False
                                ).select_related('kill_request')
                            else:
                                kill_house_requests_list = KillHouseRequest.objects.filter(
                                    (Q(killhouse_user__in=kill_house) | Q(
                                        kill_request__slaughter_house__in=kill_house) | Q(killer__in=kill_house)),
                                    # (Q(trash=False) | Q(trash=True, clearance_code__isnull=False, temporary_trash=False,
                                    #                     temporary_deleted=False)),
                                    kill_request__recive_date__date__gte=date1,
                                    kill_request__recive_date__date__lte=date2,
                                    non_receipt=False,
                                    province_request__poultry_request__poultry__address__province=user.province,
                                    trash=False
                                ).select_related('kill_request')

                            if request.GET['search'] == 'filter':
                                if request.GET['value'] != "":
                                    for item in self.filterset_fields:
                                        query = QueryDict('{0}__contains={1}'.format(item, request.GET['value']))
                                        if (self.filterset_class(
                                                data=query,
                                                queryset=kill_house_requests_list

                                        )
                                        ).filter():
                                            ps = self.filterset_class(data=query, queryset=kill_house_requests_list)
                                            kill_house_requests = ps.filter()
                                else:
                                    kill_house_requests = kill_house_requests_list
                        else:

                            if 'deleted_requests' in request.GET:

                                kill_house_requests = KillHouseRequest.objects.filter(
                                    (Q(killhouse_user__in=kill_house) | Q(
                                        kill_request__slaughter_house__in=kill_house) | Q(killer__in=kill_house)),
                                    kill_request__recive_date__date__gte=date1,
                                    kill_request__recive_date__date__lte=date2,
                                    province_request__poultry_request__poultry__address__province=user.province,
                                    trash=True, temporary_trash=False, temporary_deleted=False
                                    # message__isnull=False
                                ).select_related('kill_request')
                            else:
                                kill_house_requests = KillHouseRequest.objects.filter(
                                    (Q(killhouse_user__in=kill_house) | Q(
                                        kill_request__slaughter_house__in=kill_house) | Q(killer__in=kill_house)),
                                    # (Q(trash=False) | Q(trash=True, clearance_code__isnull=False, temporary_trash=False,
                                    #                     temporary_deleted=False)),

                                    kill_request__recive_date__date__gte=date1,
                                    kill_request__recive_date__date__lte=date2,
                                    non_receipt=False,
                                    province_request__poultry_request__poultry__address__province=user.province,
                                    trash=False
                                ).select_related('kill_request')
                        page_size = request.query_params.get('page_size', None)
                        if page_size:
                            self.pagination_class.page_size = int(page_size)

                        page = self.paginate_queryset(kill_house_requests)
                        if page is not None:
                            serializer = KillHouseRequestForBarManagementSerializer(page, many=True)
                            return self.get_paginated_response(serializer.data)

                        serializer = KillHouseRequestForBarManagementSerializer(kill_house_requests, many=True)
                        return Response(serializer.data, status=status.HTTP_200_OK)
            else:
                if 'date' in request.GET:
                    date = datetime.strptime(request.GET['date'], '%Y-%m-%d')
                else:
                    date = datetime.now()

                queryset = PoultryRequest.objects.filter(poultry__address__province=user.province,
                                                         state_process__in=('pending', 'accepted'),
                                                         province_state__in=('pending', 'accepted'),
                                                         trash=False, out=False,
                                                         send_date__year=date.year, send_date__month=date.month,
                                                         send_date__day=date.day
                                                         ).order_by('-send_date')

        else:

            if 'type' in request.GET:
                if request.GET['type'] == 'auction':
                    queryset = []
                    poultry_req_auctions = PoultryRequestAuction.objects.filter(state='active',
                                                                                trash=False).order_by(
                        'fee').order_by(
                        'create_date')
                    for poultry_req_auction in poultry_req_auctions:
                        queryset.append(
                            PoultryRequest.objects.get(id=poultry_req_auction.poultry_request.id, auction=True))

        serializer = PoultryRequestSerializer(queryset, many=True)
        return Response(serializer.data, status=status.HTTP_200_OK)


class ParentCompanyKillHouseRequestForBarManagementViewSet(viewsets.ModelViewSet):
    queryset = KillHouseRequest.objects.all()
    serializer_class = KillHouseRequestForBarManagementSerializer
    pagination_class = CustomPagination
    permission_classes = [AllowAny]
    filter_backends = [DjangoFilterBackend]
    filterset_class = KillHouseRequestFilterSet
    filterset_fields = [
        'killhouse_user__kill_house_operator__user__fullname',
        'killhouse_user__kill_house_operator__user__mobile',
        'province_request__poultry_request__poultry__user__fullname',
        'province_request__poultry_request__poultry__user__mobile',
        'province_request__poultry_request__order_code',
        'bar_code',
        'traffic_code',
        'clearance_code'
    ]

    def list(self, request, *args, **kwargs):

        kill_house_requests = []
        if 'date1' in request.GET and 'date2' in request.GET:
            date1 = datetime.strptime(str(request.GET['date1']), '%Y-%m-%d').date()
            date2 = datetime.strptime(str(request.GET['date2']), '%Y-%m-%d').date()
            if 'search' in request.GET:

                if 'deleted_requests' in request.GET:

                    kill_house_requests_list = KillHouseRequest.objects.filter(
                        kill_request__recive_date__date__gte=date1,
                        kill_request__recive_date__date__lte=date2,
                        trash=True, temporary_trash=False, temporary_deleted=False
                    ).select_related('kill_request')
                else:
                    if 'without_quarantine_code_state' in request.GET and request.GET[
                        'without_quarantine_code_state'] == 'true':
                        kill_house_requests_list = KillHouseRequest.objects.filter(
                            clearance_code__isnull=False,
                            kill_request__recive_date__date__gte=date1,
                            kill_request__recive_date__date__lte=date2,
                            quarantine_quantity__isnull=True,
                            quarantine_code_state__isnull=True,

                        ).select_related('kill_request')
                    else:
                        kill_house_requests_list = KillHouseRequest.objects.filter(
                            (Q(trash=False) | Q(trash=True, clearance_code__isnull=False, temporary_trash=False,
                                                temporary_deleted=False)),
                            kill_request__recive_date__date__gte=date1,
                            kill_request__recive_date__date__lte=date2,
                        ).select_related('kill_request')

                if request.GET['search'] == 'filter':
                    if request.GET['value'] != "":
                        for item in self.filterset_fields:
                            query = QueryDict('{0}__contains={1}'.format(item, request.GET['value']))
                            if (self.filterset_class(
                                    data=query,
                                    queryset=kill_house_requests_list

                            )
                            ).filter():
                                ps = self.filterset_class(data=query, queryset=kill_house_requests_list)
                                kill_house_requests = ps.filter()
                    else:
                        kill_house_requests = kill_house_requests_list
            else:

                if 'deleted_requests' in request.GET:

                    kill_house_requests = KillHouseRequest.objects.filter(
                        kill_request__recive_date__date__gte=date1,
                        kill_request__recive_date__date__lte=date2,
                        trash=True,
                    ).select_related('kill_request')
                else:
                    if 'without_quarantine_code_state' in request.GET and request.GET[
                        'without_quarantine_code_state'] == 'true':
                        kill_house_requests = KillHouseRequest.objects.filter(
                            clearance_code__isnull=False,
                            kill_request__recive_date__date__gte=date1,
                            kill_request__recive_date__date__lte=date2,
                            quarantine_quantity__isnull=True,
                            quarantine_code_state__isnull=True,
                        ).select_related('kill_request')
                    else:
                        kill_house_requests = KillHouseRequest.objects.filter(
                            (Q(trash=False) | Q(trash=True, clearance_code__isnull=False)),
                            kill_request__recive_date__date__gte=date1,
                            kill_request__recive_date__date__lte=date2,
                        ).select_related('kill_request')
        page_size = request.query_params.get('page_size', None)
        if page_size:
            self.pagination_class.page_size = int(page_size)

        page = self.paginate_queryset(kill_house_requests)
        if page is not None:
            serializer = KillHouseRequestForBarManagementSerializer(page, many=True)
            return self.get_paginated_response(serializer.data)

        serializer = KillHouseRequestForBarManagementSerializer(kill_house_requests, many=True)
        return Response(serializer.data, status=status.HTTP_200_OK)


class KillHouseRequestForBarManagementWageViewSet(viewsets.ModelViewSet):
    queryset = KillHouseRequest.objects.all()
    serializer_class = KillHouseRequestForBarManagementSerializer
    pagination_class = CustomPagination
    permission_classes = [TokenHasReadWriteScope]
    filter_backends = [DjangoFilterBackend]
    filterset_class = KillHouseRequestFilterSet
    filterset_fields = [
        'killhouse_user__kill_house_operator__user__fullname',
        'killhouse_user__kill_house_operator__user__mobile',
        'province_request__poultry_request__poultry__user__fullname',
        'province_request__poultry_request__poultry__user__mobile',
        'province_request__poultry_request__order_code',
        'province_request__poultry_request__order_code',
        'bar_code',
    ]

    def list(self, request, *args, **kwargs):
        if request.GET['role'] == 'KillHouse':
            user = SystemUserProfile.objects.get(user=request.user)
            kill_house = KillHouse.objects.filter(kill_house_operator__user=user, trash=False).first()
            if 'date1' in request.GET and 'date2' in request.GET:
                date1 = datetime.strptime(str(request.GET['date1']), '%Y-%m-%d').date()
                date2 = datetime.strptime(str(request.GET['date2']), '%Y-%m-%d').date()
                kill_house_requests = KillHouseRequest.objects.filter(
                    Q(killhouse_user=kill_house) | Q(killer=kill_house),
                    kill_request__recive_date__date__gte=date1,
                    kill_request__recive_date__date__lte=date2,
                    trash=False)

            else:
                kill_house_requests = KillHouseRequest.objects.filter(
                    Q(killhouse_user=kill_house) | Q(killer=kill_house),
                    trash=False)

        else:

            kill_house = KillHouse.objects.get(key=request.GET['kill_house_key'], trash=False)
            if 'date1' in request.GET and 'date2' in request.GET:
                date1 = datetime.strptime(str(request.GET['date1']), '%Y-%m-%d').date()
                date2 = datetime.strptime(str(request.GET['date2']), '%Y-%m-%d').date()
                if request.GET['role'] == 'ProvinceOperator':
                    kill_house_requests = KillHouseRequest.objects.filter(
                        Q(killhouse_user=kill_house) | Q(killer=kill_house),
                        kill_request__recive_date__date__gte=date1,
                        kill_request__recive_date__date__lte=date2,
                        province_kill_request__union_share__gt=0,
                        trash=False)
                elif request.GET['role'] == 'Company':
                    kill_house_requests = KillHouseRequest.objects.filter(
                        Q(killhouse_user=kill_house) | Q(killer=kill_house),
                        kill_request__recive_date__date__gte=date1,
                        kill_request__recive_date__date__lte=date2,
                        province_kill_request__company_share__gt=0,
                        trash=False)

                elif request.GET['role'] == 'Guilds':
                    kill_house_requests = KillHouseRequest.objects.filter(
                        Q(killhouse_user=kill_house) | Q(killer=kill_house),
                        kill_request__recive_date__date__gte=date1,
                        kill_request__recive_date__date__lte=date2,
                        province_kill_request__guilds_share__gt=0,
                        trash=False)
                else:
                    kill_house_requests = KillHouseRequest.objects.filter(
                        Q(killhouse_user=kill_house) | Q(killer=kill_house),
                        kill_request__recive_date__date__gte=date1,
                        kill_request__recive_date__date__lte=date2,
                        trash=False)

            else:
                if request.GET['role'] == 'ProvinceOperator':
                    kill_house_requests = KillHouseRequest.objects.filter(
                        Q(killhouse_user=kill_house) | Q(killer=kill_house),
                        province_kill_request__union_share__gt=0,
                        trash=False)
                elif request.GET['role'] == 'Company':
                    kill_house_requests = KillHouseRequest.objects.filter(
                        Q(killhouse_user=kill_house) | Q(killer=kill_house),
                        province_kill_request__company_share__gt=0,
                        trash=False)

                elif request.GET['role'] == 'Guilds':
                    kill_house_requests = KillHouseRequest.objects.filter(
                        Q(killhouse_user=kill_house) | Q(killer=kill_house),
                        province_kill_request__guilds_share__gt=0,
                        trash=False)
                else:
                    kill_house_requests = KillHouseRequest.objects.filter(
                        Q(killhouse_user=kill_house) | Q(killer=kill_house),
                        trash=False)

        if 'search' in request.GET:
            kill_house_request_list = []
            if request.GET['search'] == 'filter':
                if request.GET['value'] != "" and request.GET['value'] != 'undefined':
                    for item in self.filterset_fields:
                        query = QueryDict('{0}__contains={1}'.format(item, request.GET['value']))
                        if (self.filterset_class(
                                data=query,
                                queryset=kill_house_requests
                        )
                        ).filter():
                            ps = self.filterset_class(data=query, queryset=kill_house_requests)
                            kill_house_request_list = ps.filter()
                    kill_house_requests = [] if len(kill_house_request_list) == 0 else kill_house_request_list

        page_size = request.query_params.get('page_size', None)
        if page_size:
            self.pagination_class.page_size = int(page_size)

        page = self.paginate_queryset(kill_house_requests)
        if page is not None:
            serializer = KillHouseRequestForBarManagementSerializer(page, many=True)
            return self.get_paginated_response(serializer.data)

        serializer = KillHouseRequestForBarManagementSerializer(kill_house_requests, many=True)
        return Response(serializer.data, status=status.HTTP_200_OK)


class KillHouseRequestForAggregateLoadsViewSet(viewsets.ModelViewSet):
    queryset = KillHouseRequest.objects.all()
    serializer_class = KillHouseRequestForBarManagementSerializer
    pagination_class = CustomPagination
    filter_backends = [DjangoFilterBackend]
    filterset_class = KillHouseRequestFilterSet
    filterset_fields = [
        'killhouse_user__kill_house_operator__user__fullname',
        'killhouse_user__kill_house_operator__user__mobile',
        'province_request__poultry_request__poultry__user__fullname',
        'province_request__poultry_request__poultry__user__mobile',
        'province_request__poultry_request__order_code',
        'province_request__poultry_request__order_code',
        'bar_code',
    ]

    def list(self, request, *args, **kwargs):
        user = SystemUserProfile.objects.get(user=request.user)
        # user = SystemUserProfile.objects.get(user=request.user)
        date1 = datetime.strptime(str(request.GET['date1']), '%Y-%m-%d').date()
        date2 = datetime.strptime(str(request.GET['date2']), '%Y-%m-%d').date()
        kill_house = []
        kill_house_requests_list = []
        if request.GET['role'] == 'KillHouse':
            kill_house = KillHouse.objects.filter(kill_house_operator__user=user, trash=False)

        elif request.GET['role'] == 'KillHouseVet':
            kill_house_vets = KillHouseVet.objects.filter(vet__user=user, trash=False).select_related('kill_house')
            for kill_house_vet in kill_house_vets:
                kill_house.append(kill_house_vet.kill_house)

        else:
            kill_house = KillHouse.objects.filter(system_address__province=user.province, trash=False)

        if request.GET['role'] in ['CityOperator', 'CityJahad', 'CityPoultry']:
            if request.GET['role'] == 'CityOperator':
                city_operator = CityOperator.objects.get(user=user, trash=False)
                kill_house_requests = KillHouseRequest.objects.filter(
                    (Q(killhouse_user__in=kill_house) | Q(kill_request__slaughter_house__in=kill_house)),
                    kill_request__recive_date__date__gte=date1,
                    kill_request__recive_date__date__lte=date2,
                    assignment_state_archive='pending',
                    non_receipt=False,
                    trash=False, province_request__poultry_request__poultry__city_operator=city_operator.unit_name,

                ).order_by('-kill_request__recive_date')
            else:
                kill_house_requests = KillHouseRequest.objects.filter(
                    (Q(killhouse_user__in=kill_house) | Q(kill_request__slaughter_house__in=kill_house)),
                    kill_request__recive_date__date__gte=date1,
                    kill_request__recive_date__date__lte=date2,
                    assignment_state_archive='pending',
                    non_receipt=False,
                    trash=False, province_request__poultry_request__poultry__address__city=user.city

                ).order_by('-kill_request__recive_date')

        else:

            kill_house_requests = KillHouseRequest.objects.filter(
                (Q(killhouse_user__in=kill_house) | Q(kill_request__slaughter_house__in=kill_house) | Q(
                    killer__in=kill_house)),
                kill_request__recive_date__date__gte=date1,
                kill_request__recive_date__date__lte=date2,
                assignment_state_archive='pending',
                non_receipt=False,
                trash=False,

            ).order_by('-kill_request__recive_date')

        if 'search' in request.GET:
            if request.GET['search'] == 'filter':
                if request.GET['value'] != "" and request.GET['value'] != 'undefined':
                    for item in self.filterset_fields:
                        query = QueryDict('{0}__contains={1}'.format(item, request.GET['value']))
                        if (self.filterset_class(
                                data=query,
                                queryset=kill_house_requests
                        )
                        ).filter():
                            ps = self.filterset_class(data=query, queryset=kill_house_requests)
                            kill_house_requests_list = ps.filter()
                    kill_house_requests = [] if len(kill_house_requests_list) == 0 else kill_house_requests_list

        page_size = request.query_params.get('page_size', None)
        if page_size:
            self.pagination_class.page_size = int(page_size)

        page = self.paginate_queryset(kill_house_requests)
        if page is not None:
            serializer = self.serializer_class(page, many=True)
            return self.get_paginated_response(serializer.data)

        serializer = self.serializer_class(kill_house_requests, many=True)
        return Response(serializer.data, status=status.HTTP_200_OK)


class KillingInformationDiscrepancyReportViewSet(viewsets.ModelViewSet):
    queryset = PoultryRequest.objects.all()
    serializer_class = PoultryRequestLetterForProvinceVetSerializer
    permission_classes = [TokenHasReadWriteScope]

    def list(self, request, *args, **kwargs):
        user = SystemUserProfile.objects.get(user=request.user, trash=False)
        date1 = datetime.strptime(str(request.GET['date1']), '%Y-%m-%d').date()
        date2 = datetime.strptime(str(request.GET['date2']), '%Y-%m-%d').date()
        province_operator = ProvinceOperator.objects.filter(
            user=SystemUserProfile.objects.get(role__name='ProvinceOperator', province=user.province),
            trash=False).select_related(
            'user').first()
        if request.GET['role'] == 'CityOperator':
            city_operator = CityOperator.objects.get(user=user, trash=False)
            poultry_requests = PoultryRequest.objects.filter(poultry__address__province=user.province,
                                                             poultry__city_operator=city_operator.unit_name,
                                                             state_process__in=('pending', 'accepted'),
                                                             province_state__in=('pending', 'accepted'),
                                                             final_state='pending',
                                                             trash=False,
                                                             out=False,
                                                             send_date__date__gte=date1,
                                                             send_date__date__lte=date2,
                                                             ).order_by('-send_date').annotate(
                total_quantity=Sum('quantity'),
                total_weight=Sum(F('quantity') * F('Index_weight')),
                total_remain_quantity=Sum('remain_quantity'),
                total_remain_weight=Sum(F('remain_quantity') * F('Index_weight')),

            )
        elif request.GET['role'] in ['CityJahad', 'CityPoultry']:
            poultry_requests = PoultryRequest.objects.filter(poultry__address__province=user.province,
                                                             poultry__address__city=user.city,
                                                             state_process__in=('pending', 'accepted'),
                                                             province_state__in=('pending', 'accepted'),
                                                             final_state='pending',
                                                             trash=False,
                                                             out=False,
                                                             send_date__date__gte=date1,
                                                             send_date__date__lte=date2,
                                                             ).order_by('-send_date').annotate(
                total_quantity=Sum('quantity'),
                total_weight=Sum(F('quantity') * F('Index_weight')),
                total_remain_quantity=Sum('remain_quantity'),
                total_remain_weight=Sum(F('remain_quantity') * F('Index_weight')),

            )
        else:
            poultry_requests = PoultryRequest.objects.filter(poultry__address__province=user.province,
                                                             state_process__in=('pending', 'accepted'),
                                                             province_state__in=('pending', 'accepted'),
                                                             final_state='pending',
                                                             trash=False,
                                                             out=False,
                                                             send_date__date__gte=date1,
                                                             send_date__date__lte=date2,
                                                             ).order_by('-send_date').annotate(
                total_quantity=Sum('quantity'),
                total_weight=Sum(F('quantity') * F('Index_weight')),
                total_remain_quantity=Sum('remain_quantity'),
                total_remain_weight=Sum(F('remain_quantity') * F('Index_weight')),

            )
        poultry_request_total_quantity = poultry_requests.aggregate(total=Sum('total_quantity'))['total']
        poultry_request_total_weight = poultry_requests.aggregate(total=Sum('total_weight'))['total']
        poultry_request_total_remain_quantity = poultry_requests.aggregate(total=Sum('total_remain_quantity'))['total']
        poultry_request_remain_weight = poultry_requests.aggregate(total=Sum('total_remain_weight'))['total']

        province_kill_requests = ProvinceKillRequest.objects.filter(
            province_request__poultry_request__in=poultry_requests, trash=False,
            state__in=('pending', 'accepted')).annotate(
            total_quantity=Sum('main_quantity'),
            total_weight=Sum(F('main_quantity') * F('province_request__poultry_request__Index_weight')),
        )

        province_kill_requests_total_quantity = province_kill_requests.aggregate(total=Sum('total_quantity'))['total']
        province_kill_requests_total_weight = province_kill_requests.aggregate(total=Sum('total_weight'))['total']

        province_kill_requests_with_left_over = ProvinceKillRequest.objects.filter(
            province_request__poultry_request__in=poultry_requests, trash=False,
            state__in=('pending', 'accepted'), quantity__gt=0)
        province_kill_requests_serializer = ProvinceKillRequestForKillingInformationDiscrepancyReportSerializer(
            province_kill_requests_with_left_over, many=True)
        # if 'role' in request.GET:
        # if request.GET['role'] == 'ProvinceSupervisor':
        #     last_date = datetime(2024, 4, 14, 7, 33).date()
        #     if date2 > last_date and date1 <= last_date:
        #         kill_house_request_without_clearance_code = KillHouseRequest.objects.filter(
        #             province_kill_request__in=province_kill_requests, kill_request__recive_date__date__gte=date1,
        #             kill_request__recive_date__date__lte=last_date, clearance_code__isnull=True, trash=False)
        #
        #         kill_house_request_diffrent_quarantine_quantity = KillHouseRequest.objects.filter(
        #             Q(quantity__gt=F('quarantine_quantity')) | Q(quantity__lt=F('quarantine_quantity')),
        #             province_kill_request__in=province_kill_requests, clearance_code__isnull=False,
        #             quarantine_quantity__isnull=False, trash=False)
        #         kill_house_request_without_vet_check = KillHouseRequest.objects.filter(
        #             province_kill_request__in=province_kill_requests, kill_request__recive_date__date__gte=date1,
        #             kill_request__recive_date__date__lte=last_date, vet_state='pending', trash=False)
        #         kill_house_request_without_bar_info = KillHouseRequest.objects.filter(
        #             province_kill_request__in=province_kill_requests, kill_request__recive_date__date__gte=date1,
        #             kill_request__recive_date__date__lte=last_date, vet_state='accepted',
        #             assignment_state_archive='pending',
        #             trash=False)
        #         kill_house_request_diffrent_bar_info = KillHouseRequest.objects.filter(
        #             Q(quantity__gt=F('vet_accepted_real_quantity')) | Q(
        #                 quantity__lt=F('vet_accepted_real_quantity')) | Q(
        #                 quantity__gt=F('accepted_real_quantity')) | Q(quantity__lt=F('accepted_real_quantity')) | Q(
        #                 vet_accepted_real_quantity__gt=F('accepted_real_quantity')) | Q(
        #                 vet_accepted_real_quantity__lt=F('accepted_real_quantity')),
        #             # kill_request__recive_date__date__gte=date1,
        #             # kill_request__recive_date__date__lte=last_date,
        #             province_kill_request__in=province_kill_requests, vet_state='accepted',
        #             assignment_state_archive='True',
        #             trash=False)
        #     elif date2 > last_date and date1 > last_date:
        #         kill_house_request_without_clearance_code = []
        #         kill_house_request_without_vet_check = []
        #         kill_house_request_without_bar_info = []
        #         kill_house_request_diffrent_quarantine_quantity = KillHouseRequest.objects.filter(
        #             Q(quantity__gt=F('quarantine_quantity')) | Q(quantity__lt=F('quarantine_quantity')),
        #             province_kill_request__in=province_kill_requests, clearance_code__isnull=False,
        #             quarantine_quantity__isnull=False, trash=False)
        #         kill_house_request_diffrent_bar_info = KillHouseRequest.objects.filter(
        #             Q(quantity__gt=F('vet_accepted_real_quantity')) | Q(
        #                 quantity__lt=F('vet_accepted_real_quantity')) | Q(
        #                 quantity__gt=F('accepted_real_quantity')) | Q(quantity__lt=F('accepted_real_quantity')) | Q(
        #                 vet_accepted_real_quantity__gt=F('accepted_real_quantity')) | Q(
        #                 vet_accepted_real_quantity__lt=F('accepted_real_quantity')),
        #             province_kill_request__in=province_kill_requests, vet_state='accepted',
        #             assignment_state_archive='True',
        #             trash=False)
        #     else:
        #
        #         kill_house_request_without_clearance_code = KillHouseRequest.objects.filter(
        #             province_kill_request__in=province_kill_requests, clearance_code__isnull=True, trash=False)
        #
        #         kill_house_request_diffrent_quarantine_quantity = KillHouseRequest.objects.filter(
        #             Q(quantity__gt=F('quarantine_quantity')) | Q(quantity__lt=F('quarantine_quantity')),
        #             province_kill_request__in=province_kill_requests, clearance_code__isnull=False,
        #             quarantine_quantity__isnull=False, trash=False)
        #         kill_house_request_without_vet_check = KillHouseRequest.objects.filter(
        #             province_kill_request__in=province_kill_requests, vet_state='pending', trash=False)
        #         kill_house_request_without_bar_info = KillHouseRequest.objects.filter(
        #             province_kill_request__in=province_kill_requests, vet_state='accepted',
        #             assignment_state_archive='pending',
        #             trash=False)
        #         kill_house_request_diffrent_bar_info = KillHouseRequest.objects.filter(
        #             Q(quantity__gt=F('vet_accepted_real_quantity')) | Q(
        #                 quantity__lt=F('vet_accepted_real_quantity')) | Q(
        #                 quantity__gt=F('accepted_real_quantity')) | Q(quantity__lt=F('accepted_real_quantity')) | Q(
        #                 vet_accepted_real_quantity__gt=F('accepted_real_quantity')) | Q(
        #                 vet_accepted_real_quantity__lt=F('accepted_real_quantity')),
        #             province_kill_request__in=province_kill_requests, vet_state='accepted',
        #             assignment_state_archive='True',
        #             trash=False)
        # else:
        kill_house_request_without_clearance_code = KillHouseRequest.objects.filter(
            province_kill_request__in=province_kill_requests, clearance_code__isnull=True, trash=False)

        kill_house_request_diffrent_quarantine_quantity = KillHouseRequest.objects.filter(
            Q(quantity__gt=F('quarantine_quantity')) | Q(quantity__lt=F('quarantine_quantity')),
            province_kill_request__in=province_kill_requests, clearance_code__isnull=False,
            quarantine_quantity__isnull=False, trash=False)
        kill_house_request_without_vet_check = KillHouseRequest.objects.filter(
            province_kill_request__in=province_kill_requests, vet_state='pending', trash=False)
        kill_house_request_without_bar_info = KillHouseRequest.objects.filter(
            province_kill_request__in=province_kill_requests,
            assignment_state_archive='pending',
            trash=False)

        kill_house_request_diffrent_bar_info = KillHouseRequest.objects.filter(
            Q(quantity__gt=F('accepted_real_quantity')) | Q(quantity__lt=F('accepted_real_quantity')),
            province_kill_request__in=province_kill_requests,
            assignment_state_archive='True',
            trash=False)

        # kill_house_request_diffrent_bar_info = KillHouseRequest.objects.filter(
        #     Q(quantity__gt=F('vet_accepted_real_quantity')) | Q(quantity__lt=F('vet_accepted_real_quantity')) | Q(
        #         quantity__gt=F('accepted_real_quantity')) | Q(quantity__lt=F('accepted_real_quantity')) | Q(
        #         vet_accepted_real_quantity__gt=F('accepted_real_quantity') | Q(vet_accepted_real_quantity__lt=F('accepted_real_quantity'))),
        #     province_kill_request__in=province_kill_requests, vet_state='accepted', assignment_state_archive='True',
        #     trash=False)

        # kill_house_request_diffrent_bar_info = KillHouseRequest.objects.filter(
        #     Q(quantity__gt=F('vet_accepted_real_quantity')) | Q(quantity__lt=F('vet_accepted_real_quantity')) | Q(
        #         quantity__gt=F('accepted_real_quantity')) | Q(quantity__lt=F('accepted_real_quantity')) | Q(
        #         vet_accepted_real_quantity__gt=F('accepted_real_quantity')) | Q(
        #         vet_accepted_real_quantity__lt=F('accepted_real_quantity')),
        #     province_kill_request__in=province_kill_requests, vet_state='accepted', assignment_state_archive='True',
        #     trash=False)

        kill_house_request_without_clearance_code_serializer = KillHouseRequestForBarManagementSerializer(
            kill_house_request_without_clearance_code, many=True)
        kill_house_request_diffrent_quarantine_quantitye_serializer = KillHouseRequestForBarManagementSerializer(
            kill_house_request_diffrent_quarantine_quantity, many=True)
        kill_house_request_without_vet_check_serializer = KillHouseRequestForBarManagementSerializer(
            kill_house_request_without_vet_check, many=True)
        kill_house_request_without_bar_info_serializer = KillHouseRequestForBarManagementSerializer(
            kill_house_request_without_bar_info, many=True)
        kill_house_request_diffrent_bar_info_serializer = KillHouseRequestForDiffrentBarInfoSerializer(
            kill_house_request_diffrent_bar_info, many=True)

        return Response({
            "part_one": {
                "total_requests": poultry_requests.count(),
                "poultry_request_total_quantity": poultry_request_total_quantity if poultry_request_total_quantity != None else 0,
                "poultry_request_total_weight": poultry_request_total_weight if poultry_request_total_weight != None else 0,
                "province_kill_requests_total_quantity": province_kill_requests_total_quantity if province_kill_requests_total_quantity != None else 0,
                "province_kill_requests_total_weight": province_kill_requests_total_weight if province_kill_requests_total_weight != None else 0,
                "poultry_request_total_remain_quantity": poultry_request_total_remain_quantity if poultry_request_total_remain_quantity != None else 0,
                "poultry_request_remain_weight": poultry_request_remain_weight if poultry_request_remain_weight != None else 0,
                "operator_fullname": province_operator.user.fullname,
                "operator_mobile": province_operator.user.mobile,
                "role": "ProvinceOperator",
            },
            "part_two": province_kill_requests_serializer.data,
            "part_three": kill_house_request_without_clearance_code_serializer.data,
            "part_seven": kill_house_request_diffrent_quarantine_quantitye_serializer.data,
            "part_four": kill_house_request_without_vet_check_serializer.data,
            "part_five": kill_house_request_without_bar_info_serializer.data,
            "part_six": kill_house_request_diffrent_bar_info_serializer.data,
        })


class PoultryRequestForTotalInformationInTableViewSet(viewsets.ModelViewSet):
    queryset = PoultryRequest.objects.all()
    kill_house_requests_queryset = KillHouseRequest.objects.all()
    serializer_class = PoultryRequestForTotalInformationInTableSerializer
    pagination_class = CustomPagination
    permission_classes = [TokenHasReadWriteScope]
    filter_backends = [DjangoFilterBackend]
    filterset_class = PoultryRequestFilterSet
    filterset_fields = poultry_request_new_fields
    kill_house_requests_filter_class = KillHouseRequestFilterSet
    kill_house_requests_filterset_fields = kill_house_request_filterset_fields

    def list(self, request, *args, **kwargs):
        poultry_requests_for_search = []
        kill_house_request_for_search = []

        user = SystemUserProfile.objects.get(user=request.user, trash=False)
        date1 = datetime.strptime(str(request.GET['date1']), '%Y-%m-%d').date()
        date2 = datetime.strptime(str(request.GET['date2']), '%Y-%m-%d').date()

        if 'clearance_code' in request.GET:

            kill_house_requests = KillHouseRequest.objects.filter(kill_request__recive_date__date__gte=date1,
                                                                  kill_request__recive_date__date__lte=date2,
                                                                  clearance_code__isnull=request.GET[
                                                                      'clearance_code']).select_related(
                'province_request__poultry_request')

            poultry_requests = PoultryRequest.objects.filter(
                pk__in=kill_house_requests.values('province_request__poultry_request'),
                poultry__address__province=user.province,
                state_process__in=('pending', 'accepted'),
                province_state__in=('pending', 'accepted'),
                final_state='pending',
                trash=False, out=False,
                send_date__date__gte=date1,
                send_date__date__lte=date2,
            ).order_by('-send_date')
        elif 'assignment' in request.GET:
            kill_house_requests = KillHouseRequest.objects.filter(kill_request__recive_date__date__gte=date1,
                                                                  kill_request__recive_date__date__lte=date2,
                                                                  assignment_state_archive=request.GET[
                                                                      'assignment']).select_related(
                'province_request__poultry_request')

            poultry_requests = PoultryRequest.objects.filter(
                pk__in=kill_house_requests.values('province_request__poultry_request'),
                poultry__address__province=user.province,
                state_process__in=('pending', 'accepted'),
                province_state__in=('pending', 'accepted'),
                final_state='pending',
                trash=False, out=False,
                send_date__date__gte=date1,
                send_date__date__lte=date2,
            ).order_by('-send_date')


        elif 'discharge' in request.GET:
            if request.GET['discharge'] == 'pending':
                kill_house_requests = KillHouseRequest.objects.filter(kill_request__recive_date__date__gte=date1,
                                                                      kill_request__recive_date__date__lte=date2,
                                                                      vet_state='pending',
                                                                      assignment_state_archive='pending').select_related(
                    'province_request__poultry_request')
            else:
                kill_house_requests = KillHouseRequest.objects.filter(
                    (Q(vet_state='pending') | Q(vet_state='pending', assignment_state_archive='True')),
                    kill_request__recive_date__date__gte=date1,
                    kill_request__recive_date__date__lte=date2, ).select_related(
                    'province_request__poultry_request')

            poultry_requests = PoultryRequest.objects.filter(
                pk__in=kill_house_requests.values('province_request__poultry_request'),
                poultry__address__province=user.province,
                state_process__in=('pending', 'accepted'),
                province_state__in=('pending', 'accepted'),
                final_state='pending',
                trash=False, out=False,
                send_date__date__gte=date1,
                send_date__date__lte=date2,
            ).order_by('-send_date')

        else:
            poultry_requests = PoultryRequest.objects.filter(
                poultry__address__province=user.province,
                # state_process__in=('pending', 'accepted'),
                # province_state__in=('pending', 'accepted'),
                final_state='pending',
                trash=False, out=False,
                send_date__date__gte=date1,
                send_date__date__lte=date2,
            ).order_by('-send_date')
            kill_house_requests = KillHouseRequest.objects.filter(kill_request__recive_date__date__gte=date1,
                                                                  kill_request__recive_date__date__lte=date2,
                                                                  province_request__poultry_request__in=poultry_requests)

        if request.GET['search'] == 'filter':
            if request.GET['value'] != "":
                for item in self.filterset_fields:
                    query = QueryDict('{0}__contains={1}'.format(item, request.GET['value']))
                    if (self.filterset_class(
                            data=query,
                            queryset=poultry_requests

                    )
                    ).filter():
                        ps = self.filterset_class(data=query, queryset=poultry_requests)
                        poultry_requests_for_search = ps.filter()

                poultry_requests = [] if len(poultry_requests_for_search) == 0 else poultry_requests_for_search

                for item in self.kill_house_requests_filterset_fields:
                    kill_house_request_query = QueryDict('{0}={1}'.format(item, request.GET['value']))
                    if (self.kill_house_requests_filter_class(
                            data=kill_house_request_query,
                            queryset=kill_house_requests

                    )
                    ).filter():
                        ks = self.kill_house_requests_filter_class(data=kill_house_request_query,
                                                                   queryset=kill_house_requests)
                        kill_house_request_for_search = ks.filter()
                kill_house_requests = [] if len(kill_house_request_for_search) == 0 else kill_house_request_for_search
                if len(kill_house_requests) > 0:
                    for kill_house_request in kill_house_requests:
                        if kill_house_request.province_request.poultry_request not in poultry_requests:
                            poultry_requests.append(kill_house_request.province_request.poultry_request)

        page_size = request.query_params.get('page_size', None)
        if page_size:
            self.pagination_class.page_size = int(page_size)

        page = self.paginate_queryset(poultry_requests)
        if page is not None:
            serializer = PoultryRequestForTotalInformationInTableSerializer(page, many=True)
            return self.get_paginated_response(serializer.data)

        serializer = PoultryRequestForTotalInformationInTableSerializer(poultry_requests, many=True)
        return Response(serializer.data, status=status.HTTP_200_OK)


class PoultryRequestForTotalInformationViewSet(viewsets.ModelViewSet):
    queryset = PoultryRequest.objects.all()
    kill_house_requests_queryset = KillHouseRequest.objects.all()
    serializer_class = PoultryRequestForTotalInformationSerializer
    pagination_class = CustomPagination
    permission_classes = [TokenHasReadWriteScope]
    filter_backends = [DjangoFilterBackend]
    filterset_class = PoultryRequestFilterSet
    filterset_fields = poultry_request_new_fields
    kill_house_requests_filter_class = KillHouseRequestFilterSet
    kill_house_requests_filterset_fields = kill_house_request_filterset_fields

    def list(self, request, *args, **kwargs):
        poultry_requests_for_search = []
        kill_house_request_for_search = []

        user = SystemUserProfile.objects.get(user=request.user, trash=False)
        date1 = datetime.strptime(str(request.GET['date1']), '%Y-%m-%d').date()
        date2 = datetime.strptime(str(request.GET['date2']), '%Y-%m-%d').date()

        if 'clearance_code' in request.GET:

            kill_house_requests = KillHouseRequest.objects.filter(kill_request__recive_date__date__gte=date1,
                                                                  kill_request__recive_date__date__lte=date2,
                                                                  clearance_code__isnull=request.GET[
                                                                      'clearance_code']).select_related(
                'province_request__poultry_request')

            poultry_requests = PoultryRequest.objects.filter(
                pk__in=kill_house_requests.values('province_request__poultry_request'),
                poultry__address__province=user.province,
                state_process__in=('pending', 'accepted'),
                province_state__in=('pending', 'accepted'),
                final_state='pending',
                trash=False, out=False,
                send_date__date__gte=date1,
                send_date__date__lte=date2,
            ).order_by('-send_date')
        elif 'assignment' in request.GET:
            kill_house_requests = KillHouseRequest.objects.filter(kill_request__recive_date__date__gte=date1,
                                                                  kill_request__recive_date__date__lte=date2,
                                                                  assignment_state_archive=request.GET[
                                                                      'assignment']).select_related(
                'province_request__poultry_request')

            poultry_requests = PoultryRequest.objects.filter(
                pk__in=kill_house_requests.values('province_request__poultry_request'),
                poultry__address__province=user.province,
                state_process__in=('pending', 'accepted'),
                province_state__in=('pending', 'accepted'),
                final_state='pending',
                trash=False, out=False,
                send_date__date__gte=date1,
                send_date__date__lte=date2,
            ).order_by('-send_date')


        elif 'discharge' in request.GET:
            if request.GET['discharge'] == 'pending':
                kill_house_requests = KillHouseRequest.objects.filter(kill_request__recive_date__date__gte=date1,
                                                                      kill_request__recive_date__date__lte=date2,
                                                                      vet_state='pending',
                                                                      assignment_state_archive='pending').select_related(
                    'province_request__poultry_request')
            else:
                kill_house_requests = KillHouseRequest.objects.filter(
                    (Q(vet_state='pending') | Q(vet_state='pending', assignment_state_archive='True')),
                    kill_request__recive_date__date__gte=date1,
                    kill_request__recive_date__date__lte=date2, ).select_related(
                    'province_request__poultry_request')

            poultry_requests = PoultryRequest.objects.filter(
                pk__in=kill_house_requests.values('province_request__poultry_request'),
                poultry__address__province=user.province,
                state_process__in=('pending', 'accepted'),
                province_state__in=('pending', 'accepted'),
                final_state='pending',
                trash=False, out=False,
                send_date__date__gte=date1,
                send_date__date__lte=date2,
            ).order_by('-send_date')

        else:
            if request.GET['role'] == 'CityOperator':
                city_operator = CityOperator.objects.get(user=user, trash=False)
                poultry_requests = PoultryRequest.objects.filter(
                    poultry__address__province=user.province,
                    poultry__city_operator=city_operator.unit_name,
                    # final_state='pending',
                    trash=False,
                    # out=False,
                    send_date__date__gte=date1,
                    send_date__date__lte=date2,
                ).order_by('-send_date')
            elif request.GET['role'] in ['CityJahad', 'CityPoultry']:
                poultry_requests = PoultryRequest.objects.filter(
                    poultry__address__city=user.city,
                    # final_state='pending',
                    trash=False,
                    # out=False,
                    send_date__date__gte=date1,
                    send_date__date__lte=date2,
                ).order_by('-send_date')
            elif request.GET['role'] == 'LiveStockSupport':
                poultry_requests = PoultryRequest.objects.filter(
                    poultry__address__province=user.province,
                    freezing=True,
                    final_state='pending',
                    trash=False, out=False,
                    send_date__date__gte=date1,
                    send_date__date__lte=date2,
                ).order_by('-send_date')
            else:
                poultry_requests = PoultryRequest.objects.filter(
                    poultry__address__province=user.province,
                    # final_state='pending',
                    trash=False,
                    # out=False,
                    send_date__date__gte=date1,
                    send_date__date__lte=date2,
                ).order_by('-send_date')
            kill_house_requests = KillHouseRequest.objects.filter(kill_request__recive_date__date__gte=date1,
                                                                  kill_request__recive_date__date__lte=date2,
                                                                  province_request__poultry_request__in=poultry_requests)

        if request.GET['search'] == 'filter':
            if request.GET['value'] != "":
                for item in self.filterset_fields:
                    query = QueryDict('{0}__contains={1}'.format(item, request.GET['value']))
                    if (self.filterset_class(
                            data=query,
                            queryset=poultry_requests

                    )
                    ).filter():
                        ps = self.filterset_class(data=query, queryset=poultry_requests)
                        poultry_requests_for_search = ps.filter()

                poultry_requests = [] if len(poultry_requests_for_search) == 0 else poultry_requests_for_search

                for item in self.kill_house_requests_filterset_fields:
                    kill_house_request_query = QueryDict('{0}={1}'.format(item, request.GET['value']))
                    if (self.kill_house_requests_filter_class(
                            data=kill_house_request_query,
                            queryset=kill_house_requests

                    )
                    ).filter():
                        ks = self.kill_house_requests_filter_class(data=kill_house_request_query,
                                                                   queryset=kill_house_requests)
                        kill_house_request_for_search = ks.filter()
                kill_house_requests = [] if len(kill_house_request_for_search) == 0 else kill_house_request_for_search
                if len(kill_house_requests) > 0:
                    for kill_house_request in kill_house_requests:
                        if kill_house_request.province_request.poultry_request not in poultry_requests:
                            poultry_requests.append(kill_house_request.province_request.poultry_request)

        page_size = request.query_params.get('page_size', None)
        if page_size:
            self.pagination_class.page_size = int(page_size)

        page = self.paginate_queryset(poultry_requests)
        if page is not None:
            serializer = PoultryRequestForTotalInformationSerializer(page, many=True)
            return self.get_paginated_response(serializer.data)

        serializer = PoultryRequestForTotalInformationSerializer(poultry_requests, many=True)
        return Response(serializer.data, status=status.HTTP_200_OK)


class GeneralPoultryRequestLetterReportViewSet(viewsets.ModelViewSet):
    queryset = PoultryRequest.objects.all()
    serializer_class = PoultryRequestLetterForProvinceVetSerializer
    permission_classes = [TokenHasReadWriteScope]

    def list(self, request, *args, **kwargs):
        user = SystemUserProfile.objects.get(user=request.user, trash=False)
        date = datetime.strptime(str(request.GET['date']), '%Y-%m-%d').date()
        if request.GET['type'] == 'broadcast':
            date_one_day_ago = date - timedelta(days=1)
        else:
            date_one_day_ago = date

        poultry_requests_first_letter = PoultryRequest.objects.filter(poultry__address__province=user.province,
                                                                      state_process__in=('pending', 'accepted'),
                                                                      province_state__in=('pending', 'accepted'),
                                                                      final_state='pending',
                                                                      trash=False, out=False,
                                                                      send_date__date=date_one_day_ago
                                                                      ).order_by('-send_date')
        serializer_poultry_requests_first_letter = PoultryRequestForKillingInformationSerializer(
            poultry_requests_first_letter, many=True)
        poultry_requests_seconde_letter = PoultryRequest.objects.filter(send_date__date=date_one_day_ago,
                                                                        quantity__gt=F('remain_quantity'),
                                                                        trash=False)
        serializer_poultry_requests_seconde_letter = PoultryRequestLetterForProvinceVetSerializer(
            poultry_requests_seconde_letter, many=True)

        kill_house_requests_third_letter_part_two = KillHouseRequest.objects.filter(
            Q(vet_state='accepted') | Q(assignment_state_archive='True'),
            kill_request__recive_date__date=date_one_day_ago,
            province_request__poultry_request__poultry__address__province=user.province,
            trash=False
        ).only('accepted_real_quantity', 'accepted_real_weight')
        kill_house_requests_third_letter_part_two_quantity = \
            kill_house_requests_third_letter_part_two.aggregate(total=Sum('accepted_real_quantity'))[
                'total']
        kill_house_requests_third_letter_part_two_weight = \
            kill_house_requests_third_letter_part_two.aggregate(total=Sum('accepted_real_weight'))[
                'total']
        kill_house_requests_third_letter_part_three = KillHouseRequest.objects.filter(
            clearance_code__isnull=False,
            kill_request__recive_date__date=date_one_day_ago,
            province_request__poultry_request__poultry__address__province=user.province,
            trash=False
        ).only('accepted_real_quantity', 'accepted_real_weight')

        # total_weight = kill_house_requests_third_letter.aggregate(total=Sum('accepted_real_weight'))[
        #     'total']
        # total_quantity = kill_house_requests_third_letter.aggregate(total=Sum('accepted_real_quantity'))[
        #     'total']

        kill_house_requests_third_letter = KillHouseRequest.objects.filter(
            kill_request__recive_date__date=date_one_day_ago,
            province_request__poultry_request__poultry__address__province=user.province,
            trash=False
        ).select_related('kill_request')
        kill_house_requests_third_letter_quantity = kill_house_requests_third_letter.aggregate(total=Sum('quantity'))[
            'total']
        kill_house_requests_third_letter_weight = kill_house_requests_third_letter.aggregate(
            total=Sum(F('accepted_real_weight') * F('province_request__poultry_request__Index_weight')))[
            'total']
        serializer_kill_house_requests_third_letter = KillHouseRequestForBarManagementSerializer(
            kill_house_requests_third_letter, many=True)

        province_kill_requests = ProvinceKillRequest.objects.filter(state__in=('pending', 'accepted'),
                                                                    kill_request__recive_date__date=date_one_day_ago).select_related(
            'killhouse_user')
        kill_houses = KillHouse.objects.filter(
            pk__in=province_kill_requests.values('killhouse_user')
        )
        kill_house_ware_houses = KillHouseWareHouse.objects.filter(kill_house__in=kill_houses, date__date=date)
        steward_allocations = StewardAllocation.objects.filter(
            system_registration_code=True,
            ware_house__in=kill_house_ware_houses, trash=False,
            date__date=date).order_by('id')

        total_number_of_carcasses = kill_house_ware_houses.aggregate(total=Sum('final_total_number_of_carcasses'))[
            'total']
        total_weight_of_carcasses = kill_house_ware_houses.aggregate(total=Sum('final_total_weight_of_carcasses'))[
            'total']
        allocated_total_number_of_carcasses = \
            kill_house_ware_houses.aggregate(total=Sum('allocated_total_number_of_carcasses'))['total']
        allocated_total_weight_of_carcasses = \
            kill_house_ware_houses.aggregate(total=Sum('allocated_total_weight_of_carcasses'))['total']
        remain_total_number_of_carcasses = \
            kill_house_ware_houses.aggregate(total=Sum('remain_total_number_of_carcasses'))['total']
        remain_total_weight_of_carcasses = \
            kill_house_ware_houses.aggregate(total=Sum('remain_total_weight_of_carcasses'))['total']

        province_kill_requests = ProvinceKillRequest.objects.filter(state__in=('pending', 'accepted'),
                                                                    kill_request__recive_date__date=date_one_day_ago).select_related(
            'killhouse_user')
        kill_houses = KillHouse.objects.filter(
            pk__in=province_kill_requests.values('killhouse_user')
        )

        serializer_kill_house_requests_fourth_part_two = KillHouseForAutomaticStewardAllocationSerializer(kill_houses,
                                                                                                          context={
                                                                                                              'request': request},
                                                                                                          many=True)

        allocations = StewardAllocation.objects.filter(trash=False, system_registration_code=True,
                                                       date__date=date).order_by('id')
        real_number_of_carcasses = \
            allocations.aggregate(total=Sum('real_number_of_carcasses'))['total']
        real_weight_of_carcasses = \
            allocations.aggregate(total=Sum('real_weight_of_carcasses'))['total']
        serializer_kill_house_requests_fourth_part_three = StewardAllocationSerializer(allocations, many=True)

        return Response({
            "serializer_poultry_requests_first_letter": serializer_poultry_requests_first_letter.data,
            "serializer_poultry_requests_seconde_letter": serializer_poultry_requests_seconde_letter.data,
            "serializer_kill_house_requests_third_letter": serializer_kill_house_requests_third_letter.data,
            "kill_house_requests_third_letter_quantity": kill_house_requests_third_letter_quantity if kill_house_requests_third_letter_quantity != None else 0,
            "kill_house_requests_third_letter_weight": int(
                kill_house_requests_third_letter_weight) if kill_house_requests_third_letter_weight != None else 0,
            "serializer_kill_house_requests_third_letter_part_two": len(kill_house_requests_third_letter_part_two),
            "kill_house_requests_third_letter_part_two_quantity": kill_house_requests_third_letter_part_two_quantity if kill_house_requests_third_letter_part_two_quantity != None else 0,
            "kill_house_requests_third_letter_part_two_weight": kill_house_requests_third_letter_part_two_weight if kill_house_requests_third_letter_part_two_weight != None else 0,
            "serializer_kill_house_requests_third_letter_part_three": len(kill_house_requests_third_letter_part_three),
            "serializer_kill_house_requests_fourth_part_one": {
                "buyers": len(kill_house_ware_houses),
                "allocations": len(steward_allocations),
                "total_number_of_carcasses": total_number_of_carcasses if total_number_of_carcasses != None else 0,
                "total_weight_of_carcasses": total_weight_of_carcasses if total_weight_of_carcasses != None else 0,
                "allocated_total_number_of_carcasses": allocated_total_number_of_carcasses if allocated_total_number_of_carcasses != None else 0,
                "allocated_total_weight_of_carcasses": allocated_total_weight_of_carcasses if allocated_total_weight_of_carcasses != None else 0,
                "remain_total_number_of_carcasses": remain_total_number_of_carcasses if remain_total_number_of_carcasses != None else 0,
                "remain_total_weight_of_carcasses": remain_total_weight_of_carcasses if remain_total_weight_of_carcasses != None else 0,
            },
            "serializer_kill_house_requests_fourth_part_two": serializer_kill_house_requests_fourth_part_two.data,
            "serializer_kill_house_requests_fourth_part_three": serializer_kill_house_requests_fourth_part_three.data,
            "serializer_kill_house_requests_fourth_part_fourth": real_number_of_carcasses if real_number_of_carcasses != None else 0,
            "serializer_kill_house_requests_fourth_part_fifth": real_weight_of_carcasses if real_weight_of_carcasses != None else 0,
            "serializer_kill_house_requests_fourth_part_sixth": len(allocations),
        })


class StewardGuildsAllocationsForStatisticalProfileViewSet(viewsets.ModelViewSet):
    queryset = StewardAllocation.objects.all()
    serializer_class = StewardAllocationSerializer
    permission_classes = [AllowAny]

    def list(self, request, *args, **kwargs):
        date = datetime.strptime(str(request.GET['date']), '%Y-%m-%d').date()
        allocations = StewardAllocation.objects.filter(trash=False, system_registration_code=True,
                                                       date__date=date).order_by('id')
        real_number_of_carcasses = \
            allocations.aggregate(total=Sum('real_number_of_carcasses'))['total']
        real_weight_of_carcasses = \
            allocations.aggregate(total=Sum('real_weight_of_carcasses'))['total']
        serializer_kill_house_requests_fourth_part_three = StewardAllocationSerializer(allocations, many=True)

        return Response({
            "real_number_of_carcasses": real_number_of_carcasses if real_number_of_carcasses != None else 0,
            "real_weight_of_carcasses": real_weight_of_carcasses if real_weight_of_carcasses != None else 0,
            "allocations": len(allocations),
        })


# kill_house_requests=KillHouseRequest.objects.filter(killhouse_user__id=5,trash=True,clearance_code__isnull=False,message__isnull=True)
# for kill_house_request in kill_house_requests:
#     kill_house_request.message='عدم ارسال راننده توسط کشتارگاه'
#     kill_house_request.bar_remover={
#         "date": str(kill_house_request.create_date.date()),
#         "role":"KillHouse",
#         "mobile": "09143488339",
#         "full_name": "حامد صمدی"
#     }
#     kill_house_request.save()


class DetailOfKillingViewSet(viewsets.ViewSet):
    permission_classes = [TokenHasReadWriteScope]

    def hatching_55_90_data(self, request):
        if 'role' in request.GET:
            if request.GET['role'] == 'CityOperator':
                city_operator = CityOperator.objects.get(trash=False, user__user=request.user)
                hatching_between_50_70 = PoultryHatching.objects.filter(trash=False, left_over__gt=F('quantity') * 0.1,
                                                                        chicken_age__range=(55, 90),
                                                                        poultry__city_operator=city_operator.unit_name, ).order_by(
                    'id')
            elif request.GET['role'] in ['CityJahad', 'CityPoultry']:
                user = SystemUserProfile.objects.get(user=request.user)
                hatching_between_50_70 = PoultryHatching.objects.filter(trash=False, left_over__gt=F('quantity') * 0.1,
                                                                        chicken_age__range=(55, 90),
                                                                        poultry__user__city=user.city).order_by('id')
            else:
                hatching_between_50_70 = PoultryHatching.objects.filter(trash=False, left_over__gt=F('quantity') * 0.1,
                                                                        chicken_age__range=(55, 90)).order_by('id')
        else:
            hatching_between_50_70 = PoultryHatching.objects.filter(trash=False, left_over__gt=F('quantity') * 0.1,
                                                                    chicken_age__range=(55, 90)).order_by('id')
        min_list = []

        all_poultry_hatching_quantity = hatching_between_50_70.aggregate(total=Sum('quantity'))['total']
        all_poultry_hatching_killed_quantity = hatching_between_50_70.aggregate(total=Sum('killed_quantity'))['total']
        all_poultry_hatching_left_over = hatching_between_50_70.aggregate(total=Sum('left_over'))['total']
        all_left_over_ninty_percent = \
            hatching_between_50_70.aggregate(total=Sum(F('quantity') * 90 / 100) - Sum(F('killed_quantity')))['total']
        archive_hatch = hatching_between_50_70.filter(archive=True, allow_hatching='True')
        active_hatch = hatching_between_50_70.filter(archive=False, allow_hatching='pending')
        archive_hatching_quantity = \
            archive_hatch.aggregate(total=Sum('quantity'))['total']
        left_over_active_hatch = \
            active_hatch.aggregate(total=Sum('quantity'))['total'] or 0
        for poultry_hatching in hatching_between_50_70:
            if poultry_hatching.chicken_age not in min_list:
                min_list.append(poultry_hatching.chicken_age)

        min_list = sorted(min_list)
        all_total_commitment = hatching_between_50_70.aggregate(total_quantity=Sum('total_commitment')).get(
            'total_quantity', 0)
        all_governmental_killed_quantity = hatching_between_50_70.aggregate(
            total_quantity=Sum('governmental_killed_quantity')).get(
            'total_quantity', 0)
        all_free_killed_quantity = hatching_between_50_70.aggregate(
            total_quantity=Sum('free_killed_quantity')).get(
            'total_quantity', 0)
        all_total_killed_weight = hatching_between_50_70.aggregate(
            total_quantity=Sum('total_killed_weight')).get(
            'total_quantity', 0)
        all_governmental_quantity = hatching_between_50_70.aggregate(
            total_quantity=Sum('governmental_quantity')).get(
            'total_quantity', 0)
        all_free_quantity = hatching_between_50_70.aggregate(
            total_quantity=Sum('free_quantity')).get(
            'total_quantity', 0)
        all_out_province_killed_quantity = hatching_between_50_70.aggregate(
            total_quantity=Sum('out_province_killed_quantity')).get(
            'total_quantity', 0)
        all_out_province_killed_weight = hatching_between_50_70.aggregate(
            total_quantity=Sum('out_province_killed_weight')).get(
            'total_quantity', 0)

        return {
            'poultry': len(hatching_between_50_70),
            'hatching_quantity': all_poultry_hatching_quantity,
            'len_archive_hatching': len(archive_hatch),
            'archive_hatching_quantity': archive_hatching_quantity,
            'len_active_hatching': len(active_hatch),
            'active_hatching_quantity': left_over_active_hatch,
            'hatching_killed_quantity': all_poultry_hatching_killed_quantity,
            'hatching_killed_weight': int(all_total_killed_weight),
            'hatching_left_over': all_poultry_hatching_left_over,
            'hatching_left_over_ninty_percent': all_left_over_ninty_percent,
            'min_age': min_list[0] if len(min_list) > 0 else None,
            'max_age': min_list[len(min_list) - 1] if len(min_list) > 0 else None,
            'total_commitment': all_total_commitment,
            'governmental_quantity': all_governmental_quantity,
            'governmental_weight': int(all_governmental_killed_quantity),
            'free_quantity': all_free_quantity,
            'free_weight': all_free_killed_quantity,
            'out_province_killed_quantity': all_out_province_killed_quantity,
            'out_province_killed_weight': all_out_province_killed_weight
        }

    def get_kill_house_for_detail(self, kill_req):
        poultry_request = (PoultryRequest.objects.filter(trash=False, pk__in=kill_req.values(
            'province_request__poultry_request'))
                           .only('quantity', 'Index_weight')).annotate(
            total_quantity=Sum('quantity'),
            total_weight=Sum(F('quantity') * F('Index_weight'))
        )
        total_requests_quantity = poultry_request.aggregate(total=Sum('total_quantity'))['total']
        total_requests_weight = poultry_request.aggregate(total=Sum('total_weight'))['total']
        all_quantity = kill_req.aggregate(total=Sum('accepted_real_quantity'))[
                           'total'] or 0
        all_weighte = kill_req.aggregate(total=Sum('accepted_real_weight'))[
                          'total'] or 0
        all_governmental_quantity = \
            kill_req.filter(province_request__poultry_request__free_sale_in_province=False).aggregate(
                total=Sum('accepted_real_quantity'))[
                'total'] or 0
        all_governmental_weight = \
            kill_req.filter(province_request__poultry_request__free_sale_in_province=False).aggregate(
                total=Sum('accepted_real_weight'))[
                'total'] or 0
        all_free_quantity = kill_req.filter(province_request__poultry_request__free_sale_in_province=True).aggregate(
            total=Sum('accepted_real_quantity'))[
                                'total'] or 0
        all_free_weight = kill_req.filter(province_request__poultry_request__free_sale_in_province=True).aggregate(
            total=Sum('accepted_real_weight'))[
                              'total'] or 0

        all_age = []

        if kill_req:
            for kill in kill_req:
                # weight = kill.get('quantity') * kill.get(
                #     'province_kill_request__province_request__poultry_request__Index_weight')
                # all_weighte += weight
                age = (kill.get('province_request__poultry_request__send_date').date() -
                       kill.get('province_request__poultry_request__hatching__date').date()).days + 1
                if age not in all_age:
                    all_age.append(age)
        # difference_bars = kill_req.filter(
        #     Q(quantity__gt=F('quarantine_quantity')) | Q(quantity__lt=F('quarantine_quantity')),quarantine_quantity__gt=0)
        #
        #
        # final_real_quantity=-0
        # difference_bar = len(difference_bars)
        # greater_bars_quantity = difference_bars.filter(quantity__gt=F('quarantine_quantity'))
        # real_greater_bars_quantity = (greater_bars_quantity.aggregate(total=Sum('quarantine_quantity'))['total'] or 0 )  - (greater_bars_quantity.aggregate(total=Sum('quantity'))['total'] or 0 )
        # less_bars_quantity = difference_bars.filter(quantity__lt=F('quarantine_quantity'))
        # real_less_bars_quantity = (less_bars_quantity.aggregate(total=Sum('quarantine_quantity'))['total'] or 0 )  - (less_bars_quantity.aggregate(total=Sum('quantity'))['total'] or 0 )
        #
        # final_real_quantity = real_greater_bars_quantity +  real_less_bars_quantity if real_greater_bars_quantity > 0 else (-1 * real_greater_bars_quantity) +  real_less_bars_quantity

        difference_bars = kill_req.filter(
            Q(accepted_real_quantity__gt=F('quarantine_quantity')) | Q(
                accepted_real_quantity__lt=F('quarantine_quantity')), quarantine_quantity__gt=0)

        final_real_quantity = -0
        difference_bar = len(difference_bars)
        greater_bars_quantity = difference_bars.filter(accepted_real_quantity__gt=F('quarantine_quantity'))
        real_greater_bars_quantity = (greater_bars_quantity.aggregate(total=Sum('quarantine_quantity'))[
                                          'total'] or 0) - (
                                             greater_bars_quantity.aggregate(total=Sum('accepted_real_quantity'))[
                                                 'total'] or 0)
        less_bars_quantity = difference_bars.filter(accepted_real_quantity__lt=F('quarantine_quantity'))
        real_less_bars_quantity = (less_bars_quantity.aggregate(total=Sum('quarantine_quantity'))['total'] or 0) - (
                less_bars_quantity.aggregate(total=Sum('accepted_real_quantity'))['total'] or 0)

        final_real_quantity = real_greater_bars_quantity + real_less_bars_quantity if real_greater_bars_quantity > 0 else (
                                                                                                                                  -1 * real_greater_bars_quantity) + real_less_bars_quantity

        hasnt_code = kill_req.filter(clearance_code__isnull=True)
        all_quarantine_quantity_hasnt_code = hasnt_code.aggregate(total_quantity=Sum('quantity')).get(
            'total_quantity', 0)
        has_code = kill_req.filter(clearance_code__isnull=False)
        all_quarantine_quantity_has_code = has_code.aggregate(total_quantity=Sum('quantity')).get(
            'total_quantity', 0)
        has_qarantine = kill_req.filter(quarantine_quantity__isnull=False)
        all_has_qarantine = has_qarantine.aggregate(total_quantity=Sum('quarantine_quantity')).get(
            'total_quantity', 0)
        all_age1 = sorted(all_age)

        return {
            'poultry_request': len(poultry_request),
            'poultry_request_quantity': total_requests_quantity if total_requests_quantity != None else 0,
            'poultry_request_weight': int(total_requests_weight) if total_requests_weight != None else 0,
            'min_age': all_age1[0] if len(all_age1) > 0 else '-',
            'max_age': all_age1[len(all_age1) - 1] if len(all_age1) > 0 else '-',
            'avg_age': int((sum(all_age1)) / len(all_age1)) if len(all_age1) > 0 else '-',
            'len_kill_request': len(kill_req),
            'kill_request_quantity': all_quantity if all_quantity != None else 0,
            'kill_request_weight': int(all_weighte),
            'avg_weight': round(all_weighte / all_quantity, 1) if all_weighte > 0 and all_quantity > 0 else 0,
            'len_kill_request_has_code': len(has_code),
            'quantity_of_kill_request_has_code': all_quarantine_quantity_has_code if all_quarantine_quantity_has_code != None else 0,
            'len_kill_request_has_quarantine': len(has_qarantine),
            'quantity_of_kill_request_has_quarantine': all_has_qarantine if all_has_qarantine != None else 0,
            'len_kill_request_has_not_code': len(hasnt_code),
            'quantity_of_kill_request_has_not_code': all_quarantine_quantity_hasnt_code if all_quarantine_quantity_hasnt_code != None else 0,
            'difference_bar': difference_bar,
            'final_real_quantity': final_real_quantity,
            'all_governmental_quantity': all_governmental_quantity,
            'all_governmental_weight': all_governmental_weight,
            'all_free_quantity': all_free_quantity,
            'all_free_weight': all_free_weight,

        }

    def steward_ware_house_total_report_daily_broad_cast(self, steward):
        number_of_steward1 = Steward.objects.filter(
            pk__in=steward.values('steward')
        )

        steward_allocations = StewardAllocation.objects.filter(
            Q(type='manual') | Q(type='auto', system_registration_code=True),
            steward_ware_house__in=steward, receiver_state__in=('pending', 'accepted'),
            trash=False).order_by(
            'id')

        guild_allocations1 = steward_allocations.filter(guilds__isnull=False, trash=False)
        number_of_guild1 = guild_allocations1.values('guilds').distinct().count() if guild_allocations1 else 0

        total_number_of_free_carcasses1 = steward.aggregate(total=Sum('number_of_free_carcasses'))[
                                              'total'] or 0
        total_free_weight_of_carcasses1 = steward.aggregate(total=Sum('weight_of_free_carcasses'))[
                                              'total'] or 0
        total_number_of_carcasses1 = steward.aggregate(total=Sum('number_of_carcasses'))[
                                         'total'] or 0
        total_weight_of_carcasses1 = steward.aggregate(total=Sum('weight_of_carcasses'))[
                                         'total'] or 0

        final_total_number_of_carcasses1 = \
            steward.aggregate(total=Sum('real_number_of_carcasses'))[
                'total'] or 0
        final_total_weight_of_carcasses1 = \
            steward.aggregate(total=Sum('real_weight_of_carcasses'))[
                'total'] or 0

        total_remain_quantity1 = \
            steward.aggregate(total=Sum('remain_total_number_of_carcasses'))[
                'total'] or 0

        total_remain_weight1 = \
            steward.aggregate(total=Sum('remain_total_weight_of_carcasses'))[
                'total'] or 0

        total_allocated_quantity1 = \
            steward_allocations.aggregate(total=Sum('real_number_of_carcasses'))[
                'total'] or 0

        total_allocated_weight1 = \
            steward_allocations.aggregate(total=Sum('real_weight_of_carcasses'))[
                'total'] or 0

        total_accepted_allocated_quantity1 = \
            steward_allocations.aggregate(total=Sum('receiver_real_number_of_carcasses'))[
                'total'] or 0

        total_accepted_allocated_weight1 = \
            steward_allocations.aggregate(total=Sum('receiver_real_weight_of_carcasses'))[
                'total'] or 0

        return {
            "buyers": len(number_of_steward1),
            "incoming_quantity_of_cold_house": 0,
            "incoming_weight_of_cold_house": 0,
            "total_pre_cold_quantity": 0,
            "total_pre_cold_weight": 0,
            "total_number_of_free_carcasses": total_number_of_free_carcasses1,
            "total_free_weight_of_carcasses": total_free_weight_of_carcasses1,
            "total_number_of_carcasses": total_number_of_carcasses1,
            "total_weight_of_carcasses": int(total_weight_of_carcasses1),
            "final_total_number_of_carcasses": final_total_number_of_carcasses1,
            "final_total_weight_of_carcasses": int(final_total_weight_of_carcasses1),
            "total_allocated_quantity": total_allocated_quantity1,
            "total_allocated_weight": int(total_allocated_weight1),
            "total_accepted_allocated_quantity": total_accepted_allocated_quantity1,
            "total_accepted_allocated_weight": int(total_accepted_allocated_weight1),
            "total_remain_quantity": total_remain_quantity1,
            "total_remain_weight": int(total_remain_weight1),
            "number_of_guild": number_of_guild1,
        }

    def kill_house_ware_house_total_report_daily_broad_cast(self, kill):
        number_of_kill_houses = KillHouse.objects.filter(
            pk__in=kill.values('kill_house')
        )

        steward_allocations = StewardAllocation.objects.filter(
            Q(type='manual') | Q(type='auto', system_registration_code=True),
            ware_house__in=kill, receiver_state__in=('pending', 'accepted'), trash=False).order_by(
            'id')

        guild_allocations = steward_allocations.filter(guilds__isnull=False, trash=False)
        number_of_guild = guild_allocations.values('guilds').distinct().count() if guild_allocations else 0

        steward_allocations_for_number_of_steward = steward_allocations.filter(steward__isnull=False, trash=False)
        number_of_steward = steward_allocations_for_number_of_steward.values(
            'steward').distinct().count() if steward_allocations_for_number_of_steward else 0

        total_pre_cold_quantity = \
            kill.aggregate(total=Sum('pre_cold_number_of_carcasses_to_ware_house'))[
                'total'] or 0
        total_pre_cold_weight = \
            kill.aggregate(total=Sum('pre_cold_weight_of_carcasses_to_ware_house'))[
                'total'] or 0
        total_number_of_free_carcasses = kill.aggregate(total=Sum('number_of_free_carcasses'))[
                                             'total'] or 0
        total_free_weight_of_carcasses = kill.aggregate(total=Sum('free_weight_of_carcasses'))[
                                             'total'] or 0
        total_number_of_carcasses = kill.aggregate(total=Sum('number_of_carcasses'))[
                                        'total'] or 0
        total_weight_of_carcasses = kill.aggregate(total=Sum('weight_of_carcasses'))[
                                        'total'] or 0

        final_total_number_of_carcasses = \
            kill.aggregate(total=Sum('final_total_number_of_carcasses'))[
                'total'] or 0
        final_total_weight_of_carcasses = \
            kill.aggregate(total=Sum('final_total_weight_of_carcasses'))[
                'total'] or 0

        total_remain_quantity = \
            kill.aggregate(total=Sum('remain_total_number_of_carcasses'))[
                'total'] or 0

        total_remain_weight = \
            kill.aggregate(total=Sum('remain_total_weight_of_carcasses'))[
                'total'] or 0

        total_allocated_quantity = \
            steward_allocations.aggregate(total=Sum('real_number_of_carcasses'))[
                'total'] or 0

        total_allocated_weight = \
            steward_allocations.aggregate(total=Sum('real_weight_of_carcasses'))[
                'total'] or 0

        total_accepted_allocated_quantity = \
            steward_allocations.aggregate(total=Sum('receiver_real_number_of_carcasses'))[
                'total'] or 0

        total_accepted_allocated_weight = \
            steward_allocations.aggregate(total=Sum('receiver_real_weight_of_carcasses'))[
                'total'] or 0

        return {
            "buyers": len(number_of_kill_houses),
            "incoming_quantity_of_cold_house": 0,
            "incoming_weight_of_cold_house": 0,
            "total_pre_cold_quantity": total_pre_cold_quantity,
            "total_pre_cold_weight": int(total_pre_cold_weight),
            "total_number_of_free_carcasses": total_number_of_free_carcasses,
            "total_free_weight_of_carcasses": int(total_free_weight_of_carcasses),
            "total_number_of_carcasses": total_number_of_carcasses,
            "total_weight_of_carcasses": int(total_weight_of_carcasses),
            "final_total_number_of_carcasses": final_total_number_of_carcasses,
            "final_total_weight_of_carcasses": int(final_total_weight_of_carcasses),
            "total_allocated_quantity": total_allocated_quantity,
            "total_allocated_weight": int(total_allocated_weight),
            "total_accepted_allocated_quantity": total_accepted_allocated_quantity,
            "total_accepted_allocated_weight": int(total_accepted_allocated_weight),
            "total_remain_quantity": total_remain_quantity,
            "total_remain_weight": int(total_remain_weight),
            "number_of_guild": number_of_guild,
            "number_of_steward": number_of_steward,
        }

    def list(self, request, *args, **kwargs):
        now = datetime.now().date()

        date1 = datetime.strptime(request.GET['date1'],
                                  '%Y-%m-%d').date() if 'date1' in request.GET else now
        date2 = datetime.strptime(request.GET['date2'],
                                  '%Y-%m-%d').date() if 'date2' in request.GET else now
        if 'role' in request.GET:

            if request.GET['role'] == 'CityOperator':
                city_operator = CityOperator.objects.get(trash=False, user__user=request.user)
                filtered_kill_reqs = KillHouseRequest.objects.filter(
                    Q(trash=False) | Q(trash=True, clearance_code__isnull=False),
                    province_request__poultry_request__poultry__city_operator=city_operator.unit_name,
                    kill_request__recive_date__date__gte=date1,
                    kill_request__recive_date__date__lte=date2).order_by(
                    '-create_date').select_related(

                    'province_request__poultry_request',
                    'add_car__driver',
                ).only('province_request', 'province_request__poultry_request',

                       'province_request__poultry_request__send_date',
                       'province_kill_request__province_request__poultry_request__Index_weight',
                       'clearance_code',
                       'quantity',
                       'accepted_real_weight',
                       'accepted_real_quantity',
                       'vet_state', 'vet_accepted_real_quantity',
                       'vet_accepted_real_weight', 'quarantine_quantity',
                       'province_request__poultry_request__hatching__date',
                       'province_request__poultry_request__send_date').values(
                    'province_request',
                    'province_request__poultry_request',

                    'province_request__poultry_request__send_date',
                    'province_kill_request__province_request__poultry_request__Index_weight',
                    'clearance_code',
                    'quantity',
                    'accepted_real_weight',
                    'accepted_real_quantity',
                    'vet_state',
                    'vet_accepted_real_quantity',
                    'vet_accepted_real_weight',
                    'quarantine_quantity',
                    'province_request__poultry_request__hatching__date',
                    'province_request__poultry_request__send_date'
                )

                out_true_poultry_request = PoultryRequest.objects.filter(trash=False, out=True,
                                                                         out_province_request_cancel=False,
                                                                         province_state='accepted',
                                                                         poultry__city_operator=city_operator.unit_name,
                                                                         send_date__date__gte=date1,
                                                                         send_date__date__lte=date2)

            elif request.GET['role'] in ['CityJahad', 'CityPoultry']:
                user = SystemUserProfile.objects.get(user=request.user)
                filtered_kill_reqs = KillHouseRequest.objects.filter(
                    Q(trash=False) | Q(trash=True, clearance_code__isnull=False),
                    province_request__poultry_request__poultry__user__city=user.city,
                    kill_request__recive_date__date__gte=date1,
                    kill_request__recive_date__date__lte=date2).order_by(
                    '-create_date').select_related(

                    'province_request__poultry_request',
                    'add_car__driver',
                ).only('province_request', 'province_request__poultry_request',

                       'province_request__poultry_request__send_date',
                       'province_kill_request__province_request__poultry_request__Index_weight',
                       'clearance_code',
                       'quantity',
                       'accepted_real_weight',
                       'accepted_real_quantity',
                       'vet_state', 'vet_accepted_real_quantity',
                       'vet_accepted_real_weight', 'quarantine_quantity',
                       'province_request__poultry_request__hatching__date',
                       'province_request__poultry_request__send_date').values(
                    'province_request',
                    'province_request__poultry_request',

                    'province_request__poultry_request__send_date',
                    'province_kill_request__province_request__poultry_request__Index_weight',
                    'clearance_code',
                    'quantity',
                    'accepted_real_weight',
                    'accepted_real_quantity',
                    'vet_state',
                    'vet_accepted_real_quantity',
                    'vet_accepted_real_weight',
                    'quarantine_quantity',
                    'province_request__poultry_request__hatching__date',
                    'province_request__poultry_request__send_date'
                )

                out_true_poultry_request = PoultryRequest.objects.filter(trash=False, out=True,
                                                                         out_province_request_cancel=False,
                                                                         poultry__user__city=user.city,
                                                                         province_state='accepted',
                                                                         send_date__date__gte=date1,
                                                                         send_date__date__lte=date2)
            else:
                filtered_kill_reqs = KillHouseRequest.objects.filter(
                    Q(trash=False) | Q(trash=True, clearance_code__isnull=False),
                    kill_request__recive_date__date__gte=date1,
                    kill_request__recive_date__date__lte=date2).order_by(
                    '-create_date').select_related(

                    'province_request__poultry_request',
                    'add_car__driver',
                ).only('province_request', 'province_request__poultry_request',

                       'province_request__poultry_request__send_date',
                       'province_kill_request__province_request__poultry_request__Index_weight',
                       'clearance_code',
                       'quantity',
                       'accepted_real_weight',
                       'accepted_real_quantity',
                       'vet_state', 'vet_accepted_real_quantity',
                       'vet_accepted_real_weight', 'quarantine_quantity',
                       'province_request__poultry_request__hatching__date',
                       'province_request__poultry_request__send_date').values(
                    'province_request',
                    'province_request__poultry_request',

                    'province_request__poultry_request__send_date',
                    'province_kill_request__province_request__poultry_request__Index_weight',
                    'clearance_code',
                    'quantity',
                    'accepted_real_weight',
                    'accepted_real_quantity',
                    'vet_state',
                    'vet_accepted_real_quantity',
                    'vet_accepted_real_weight',
                    'quarantine_quantity',
                    'province_request__poultry_request__hatching__date',
                    'province_request__poultry_request__send_date'
                )

                out_true_poultry_request = PoultryRequest.objects.filter(trash=False, out=True,
                                                                         out_province_request_cancel=False,
                                                                         province_state='accepted',
                                                                         send_date__date__gte=date1,
                                                                         send_date__date__lte=date2)
        else:
            filtered_kill_reqs = KillHouseRequest.objects.filter(
                Q(trash=False) | Q(trash=True, clearance_code__isnull=False),
                kill_request__recive_date__date__gte=date1,
                kill_request__recive_date__date__lte=date2).order_by(
                '-create_date').select_related(

                'province_request__poultry_request',
                'add_car__driver',
            ).only('province_request', 'province_request__poultry_request',

                   'province_request__poultry_request__send_date',
                   'province_kill_request__province_request__poultry_request__Index_weight',
                   'clearance_code',
                   'quantity',
                   'accepted_real_weight',
                   'accepted_real_quantity',
                   'vet_state', 'vet_accepted_real_quantity',
                   'vet_accepted_real_weight', 'quarantine_quantity',
                   'province_request__poultry_request__hatching__date',
                   'province_request__poultry_request__send_date').values(
                'province_request',
                'province_request__poultry_request',

                'province_request__poultry_request__send_date',
                'province_kill_request__province_request__poultry_request__Index_weight',
                'clearance_code',
                'quantity',
                'accepted_real_weight',
                'accepted_real_quantity',
                'vet_state',
                'vet_accepted_real_quantity',
                'vet_accepted_real_weight',
                'quarantine_quantity',
                'province_request__poultry_request__hatching__date',
                'province_request__poultry_request__send_date'
            )

            out_true_poultry_request = PoultryRequest.objects.filter(trash=False, out=True,
                                                                     out_province_request_cancel=False,
                                                                     province_state='accepted',
                                                                     send_date__date__gte=date1,
                                                                     send_date__date__lte=date2)

        kill_req = self.get_kill_house_for_detail(filtered_kill_reqs)

        filtered_kill_reqs_not_code_but_have_assigment = filtered_kill_reqs.filter(
            Q(assignment_state_archive='True', vet_state='pending')
            | Q(vet_state='accepted'), clearance_code__isnull=True)

        bar_government = filtered_kill_reqs.filter(
            province_request__poultry_request__free_sale_in_province=False)

        accepted_real_quantity_bar_government = bar_government.aggregate(
            total_quantity=Sum('accepted_real_quantity')).get(
            'total_quantity', 0) or 0
        accepted_real_wight_bar_government = bar_government.aggregate(
            total_quantity=Sum('accepted_real_weight')).get(
            'total_quantity', 0) or 0

        bar_government_quarantine_quantity = bar_government.filter(quarantine_quantity__isnull=False)

        accepted_real_quantity_bar_government_quarantine_quantity = bar_government_quarantine_quantity.aggregate(
            total_quantity=Sum('accepted_real_quantity')).get(
            'total_quantity') or 0

        bar_free = filtered_kill_reqs.filter(province_request__poultry_request__free_sale_in_province=True)
        accepted_real_quantity_bar_free = bar_free.aggregate(
            total_quantity=Sum('accepted_real_quantity')).get(
            'total_quantity') or 0
        accepted_real_wight_bar_free = bar_free.aggregate(
            total_quantity=Sum('accepted_real_weight')).get(
            'total_quantity') or 0

        bar_free_quarantine_quantity = bar_free.filter(quarantine_quantity__isnull=False)

        accepted_real_quantity_bar_free_quarantine_quantity = bar_free_quarantine_quantity.aggregate(
            total_quantity=Sum('accepted_real_quantity')).get(
            'total_quantity') or 0

        bar_free_has_code = len(bar_free.filter(clearance_code__isnull=False))

        quantity_out_true_poultry_request = out_true_poultry_request.aggregate(
            total_quantity=Sum('quantity')).get(
            'total_quantity') or 0

        bar_complete_with_kill_house_and_vet = filtered_kill_reqs.filter(
            trash=False)
        bar_complete_with_vet = filtered_kill_reqs.filter(
            vet_state='accepted')
        accepted_real_quantity_with_kill_house_and_vet = bar_complete_with_kill_house_and_vet.aggregate(
            total_quantity=Sum('accepted_real_quantity')).get(
            'total_quantity') or 0
        accepted_real_wight_with_kill_house_and_vet = bar_complete_with_kill_house_and_vet.aggregate(
            total_quantity=Sum('accepted_real_weight')).get(
            'total_quantity') or 0
        all_vet_accepted_real_quantity_with_kill_house_and_vet = bar_complete_with_vet.aggregate(
            total_quantity=Sum('vet_accepted_real_quantity')).get(
            'total_quantity') or 0
        all_vet_accepted_real_weight_with_kill_house_and_vet = bar_complete_with_vet.aggregate(
            total_quantity=Sum('vet_accepted_real_weight')).get(
            'total_quantity') or 0
        bar_complete_with_kill_house = filtered_kill_reqs.filter(
            assignment_state_archive='True')

        accepted_real_wight_final = bar_complete_with_kill_house.aggregate(
            total_quantity=Sum('accepted_real_weight')).get(
            'total_quantity') or 0

        accepted_real_quantity_no_code = filtered_kill_reqs_not_code_but_have_assigment.aggregate(
            total_quantity=Sum('accepted_real_quantity')).get(
            'total_quantity') or 0
        accepted_real_wight_no_code = filtered_kill_reqs_not_code_but_have_assigment.aggregate(
            total_quantity=Sum('accepted_real_weight')).get(
            'total_quantity') or 0

        if accepted_real_wight_with_kill_house_and_vet != None:
            less_25 = (accepted_real_wight_with_kill_house_and_vet * 75) / 100
        else:
            less_25 = 0

        filtered_kill_reqs_not_assigment_all = filtered_kill_reqs.filter(
            assignment_state_archive='pending', vet_state='pending')

        accepted_real_quantity_not_assigment_all = filtered_kill_reqs_not_assigment_all.aggregate(
            total_quantity=Sum('accepted_real_quantity')).get(
            'total_quantity', 0) or 0
        accepted_real_wight_not_assigment_all = filtered_kill_reqs_not_assigment_all.aggregate(
            total_quantity=Sum('accepted_real_weight')).get(
            'total_quantity', 0) or 0

        filtered_kill_reqs_havent_kill_house = filtered_kill_reqs.filter(
            assignment_state_archive='pending'
            , vet_state='accepted')

        accepted_real_quantity_havent_kill_house = filtered_kill_reqs_havent_kill_house.aggregate(
            total_quantity=Sum('accepted_real_quantity')).get(
            'total_quantity') or 0
        accepted_real_wight_havent_kill_house = filtered_kill_reqs_havent_kill_house.aggregate(
            total_quantity=Sum('accepted_real_weight')).get(
            'total_quantity') or 0

        accepted_real_quantity_final = bar_complete_with_kill_house.aggregate(
            total_quantity=Sum('accepted_real_quantity')).get(
            'total_quantity', 0) or 0
        accepted_real_weight_final = bar_complete_with_kill_house.aggregate(
            total_quantity=Sum('accepted_real_weight')).get(
            'total_quantity', 0) or 0
        accepted_real_quantity_final1 = filtered_kill_reqs.aggregate(
            total_quantity=Sum('accepted_real_quantity')).get(
            'total_quantity', 0) or 0
        accepted_real_weight_final1 = filtered_kill_reqs.aggregate(
            total_quantity=Sum('accepted_real_weight')).get(
            'total_quantity', 0) or 0
        kill_house_ware_houses = KillHouseWareHouse.objects.filter(
            Q(weight_of_carcasses__gt=0) | Q(free_weight_of_carcasses__gt=0) | Q(
                pre_cold_weight_of_carcasses_to_ware_house__gt=0), date__date__gte=date1,
            date__date__lte=date2, trash=False)

        kill_house_data = self.kill_house_ware_house_total_report_daily_broad_cast(kill_house_ware_houses)

        steward_ware_houses = StewardWareHouse.objects.filter(
            Q(weight_of_carcasses__gt=0) | Q(weight_of_free_carcasses__gt=0), date__date__gte=date1,
            date__date__lte=date2, trash=False)

        steward = self.steward_ware_house_total_report_daily_broad_cast(steward_ware_houses)
        return Response({
            'age55_age90': self.hatching_55_90_data(request),
            'kill_request': kill_req,
            'free_and_government_kill_request': {
                'len_government': len(bar_government),
                'quantity_government': accepted_real_quantity_bar_government,
                'weight_government': int(accepted_real_wight_bar_government),
                'len_government_quarantine_quantity': len(bar_government_quarantine_quantity),
                'real_quantity_bar_government_quarantine_quantity': accepted_real_quantity_bar_government_quarantine_quantity,
                'len_free': len(bar_free),
                'quantity_free': accepted_real_quantity_bar_free,
                'weight_free': accepted_real_wight_bar_free,
                'len_free_quarantine_quantity': len(bar_free_quarantine_quantity),
                'real_quantity_bar_free_quarantine_quantity': accepted_real_quantity_bar_free_quarantine_quantity,
                'len_free_has_code': bar_free_has_code,
                'len_out_kill_request': len(out_true_poultry_request),
                'quantity_out_kill_request': quantity_out_true_poultry_request,
            },
            'complete_kill_request': {
                'len_complete_with_kill_house_and_vet': len(bar_complete_with_kill_house_and_vet),
                'quantity_with_kill_house_and_vet': accepted_real_quantity_with_kill_house_and_vet,
                'weight_with_kill_house_and_vet': int(accepted_real_wight_with_kill_house_and_vet),
                "avg_weight": round(
                    accepted_real_wight_with_kill_house_and_vet / accepted_real_quantity_with_kill_house_and_vet,
                    1) if accepted_real_wight_with_kill_house_and_vet > 0 else 0,
                'less_25': int(less_25),
                'len_complete_with_vet': len(bar_complete_with_vet),
                'quantity_complete_with_vet': all_vet_accepted_real_quantity_with_kill_house_and_vet,
                'weight_complete_with_vet': int(all_vet_accepted_real_weight_with_kill_house_and_vet),
                'len_complete_with_kill_house': len(bar_complete_with_kill_house),
                'quantity_final_kill_house': accepted_real_quantity_final,
                'weight_final_kill_house': int(accepted_real_wight_final),
                'len_kill_reqs_has_not_code': len(filtered_kill_reqs_not_code_but_have_assigment),
                'quantity_kill_reqs_has_not_code': accepted_real_quantity_no_code,
                'weight_kill_reqs_has_not_code': int(accepted_real_wight_no_code),
            },
            'kill_request_has_not_assigment': {
                'len_kill_reqs_not_assigment': len(filtered_kill_reqs_not_assigment_all),
                'quantity_kill_reqs_not_assigment': accepted_real_quantity_not_assigment_all,
                'weight_kill_reqs_not_assigment': int(accepted_real_wight_not_assigment_all),
                'len_kill_request_has_not_complete': len(filtered_kill_reqs_havent_kill_house),
                'quantity_kill_request_has_not_complete': accepted_real_quantity_havent_kill_house,
                'weight_kill_request_has_not_complete': int(accepted_real_wight_havent_kill_house),
            },
            'final_quantity_and_weight': {
                'final_quantity': accepted_real_quantity_final1,
                'final_weight': int(accepted_real_weight_final1),
            },
            'kill_house_ware_house_total_report_daily_broad_cast': kill_house_data,
            'steward_ware_house_total_report_daily_broad_cast': steward

        })


class ComprehensiveReportOfTheSlaughterhouseViewSet(viewsets.ViewSet):
    permission_classes = [AllowAny]

    def all_kill_request(self, date1, date2):
        filtered_kill_reqs = KillHouseRequest.objects.filter(trash=False,
                                                             kill_request__recive_date__date__gte=date1,
                                                             kill_request__recive_date__date__lte=date2,
                                                             ).order_by(
            '-create_date').select_related(
            'province_request__poultry_request__hatching', 'province_request__poultry_request').only(
            'province_kill_request__province_request__poultry_request__Index_weight',
            'quantity',
            'accepted_real_weight',
            'accepted_real_quantity',
            'ware_house_accepted_real_weight',
            'ware_house_accepted_real_quantity')

        all_kill_req_quantity = filtered_kill_reqs.aggregate(
            total_quantity=Sum('quantity')).get(
            'total_quantity') or 0

        weight = filtered_kill_reqs.aggregate(
            total_quantity=Sum(
                F('quantity') * F('province_kill_request__province_request__poultry_request__Index_weight')))[
                     'total_quantity'] or 0

        all_kill_req_quantity_reciver = filtered_kill_reqs.aggregate(
            total_quantity=Sum('accepted_real_quantity')).get(
            'total_quantity') or 0
        all_kill_req_weight_reciver = filtered_kill_reqs.aggregate(
            total_quantity=Sum('accepted_real_weight')).get(
            'total_quantity') or 0
        all_ware_house_accepted_real_quantity = filtered_kill_reqs.aggregate(
            total_quantity=Sum('ware_house_accepted_real_quantity')).get(
            'total_quantity') or 0
        all_ware_house_accepted_real_weight = filtered_kill_reqs.aggregate(
            total_quantity=Sum('ware_house_accepted_real_weight')).get(
            'total_quantity') or 0

        return {
            "quantity_of_create_bar": all_kill_req_quantity,
            "weight_of_create_bar": int(weight),
            "quantity_of_receive_bar": all_kill_req_quantity_reciver,
            "weight_of_receive_bar": int(all_kill_req_weight_reciver),
            "weight_with_twenty_five_percent_receive": int(
                (all_kill_req_weight_reciver * 75) / 100) if all_kill_req_weight_reciver > 0 else 0,
            "quantity_warehouse": all_ware_house_accepted_real_quantity,
            "weight_warehouse": int(all_ware_house_accepted_real_weight),
            "quantity_percent_warehouse": int(
                all_ware_house_accepted_real_quantity * 100 / all_kill_req_quantity_reciver) if all_ware_house_accepted_real_quantity > 0 else 0,
            "weight_percent_warehouse": int(
                all_ware_house_accepted_real_weight * 100 / all_kill_req_weight_reciver) if all_ware_house_accepted_real_weight > 0 else 0,
            "quantity_percent_receive": int(
                all_kill_req_quantity_reciver * 100 / all_kill_req_quantity) if all_kill_req_quantity_reciver > 0 else 0,
            "weight_percent_receive": int(
                (all_kill_req_weight_reciver * 100) / weight) if all_kill_req_weight_reciver > 0 else 0
        }

    def general_broadcast_information(self, tomorrow_date1, tomorrow_date2, filtered_kill_reqs, kill_free_info):

        number_of_kill_house = filtered_kill_reqs.values(
            'killhouse_user').distinct().count() if filtered_kill_reqs else 0

        all_quantity_out_false = filtered_kill_reqs.aggregate(
            total_quantity=Sum('quantity')).get(
            'total_quantity') or 0

        weight = filtered_kill_reqs.aggregate(
            total_quantity=Sum(
                F('quantity') * F('province_kill_request__province_request__poultry_request__Index_weight')))[
                     'total_quantity'] or 0
        all_quantity_out_true = kill_free_info.aggregate(
            total_quantity=Sum('number_of_carcasses')).get(
            'total_quantity') or 0
        all_weight_out_true = kill_free_info.aggregate(
            total_quantity=Sum('weight_of_carcasses')).get(
            'total_quantity') or 0

        kill_house_ware_houses = KillHouseWareHouse.objects.filter(
            Q(weight_of_carcasses__gt=0) | Q(free_weight_of_carcasses__gt=0) | Q(
                pre_cold_weight_of_carcasses_to_ware_house__gt=0), date__date__gte=tomorrow_date1,
            date__date__lte=tomorrow_date2, trash=False)
        final_total_number_of_carcasses = \
            kill_house_ware_houses.aggregate(total=Sum('final_total_number_of_carcasses'))[
                'total'] or 0
        final_total_weight_of_carcasses = \
            kill_house_ware_houses.aggregate(total=Sum('final_total_weight_of_carcasses'))[
                'total'] or 0
        steward_allocations = StewardAllocation.objects.filter(
            Q(type='manual') | Q(type='auto', system_registration_code=True),
            ware_house__in=kill_house_ware_houses, receiver_state__in=('pending', 'accepted'),
            trash=False).order_by(
            'id')
        total_allocated_quantity = \
            steward_allocations.aggregate(total=Sum('real_number_of_carcasses'))[
                'total'] or 0

        total_allocated_weight = \
            steward_allocations.aggregate(total=Sum('real_weight_of_carcasses'))[
                'total'] or 0

        total_accepted_allocated_quantity = \
            steward_allocations.aggregate(total=Sum('receiver_real_number_of_carcasses'))[
                'total'] or 0

        total_accepted_allocated_weight = \
            steward_allocations.aggregate(total=Sum('receiver_real_weight_of_carcasses'))[
                'total'] or 0

        total_remain_quantity = \
            kill_house_ware_houses.aggregate(total=Sum('remain_total_number_of_carcasses'))[
                'total'] or 0

        total_remain_weight = \
            kill_house_ware_houses.aggregate(total=Sum('remain_total_weight_of_carcasses'))[
                'total'] or 0
        steward_allocations_for_number_of_steward = steward_allocations.filter(steward__isnull=False,
                                                                               trash=False)
        number_of_steward = steward_allocations_for_number_of_steward.values(
            'steward').distinct().count() if steward_allocations_for_number_of_steward else 0

        guild_allocations = steward_allocations.filter(guilds__isnull=False, trash=False)
        number_of_guild = guild_allocations.values('guilds').distinct().count() if guild_allocations else 0

        return {
            "number_of_buyer": number_of_kill_house,
            "quantity_of_kill_request_in_province": all_quantity_out_false,
            "weight_of_kill_request_in_province": int(weight),
            "quantity_of_kill_request_out_province": all_quantity_out_true,
            "weight_of_kill_request_out_province": int(all_weight_out_true),
            "quantity_carcasses": final_total_number_of_carcasses,
            "weight_carcasses": int(final_total_weight_of_carcasses),
            "allocated_quantity": total_allocated_quantity,
            "allocated_weight": int(total_allocated_weight),
            "accepted_allocated_quantity": total_accepted_allocated_quantity,
            "accepted_allocated_weight": int(total_accepted_allocated_weight),
            "remain_quantity": total_remain_quantity,
            "remain_weight": int(total_remain_weight),
            "percent_warehouse": int((
                                             total_allocated_quantity * 100) / final_total_number_of_carcasses) if total_allocated_quantity and final_total_number_of_carcasses > 0 else 0,
            "number_of_stewards": number_of_steward,
            "number_of_giulds": number_of_guild,
            "date1": tomorrow_date1,
            "date2": tomorrow_date2,

        }

    def kill_request_and_broadcast(self, tomorrow_date1, tomorrow_date2, filtered_kill_reqs, kill_free_info):
        list1 = []
        kill_houses = KillHouse.objects.filter(trash=False).select_related('kill_house_operator__user__city').exclude(
            out_province=True)
        for kill_house in kill_houses:
            kill_free_information = kill_free_info.filter(kill_house=kill_house)
            tomorrow_kill_request = filtered_kill_reqs.filter(killhouse_user=kill_house)
            if tomorrow_kill_request:
                tomorrow_kill_request_not_assigment = tomorrow_kill_request.filter(assignment_state_archive='pending',
                                                                                   vet_state='accepted')
                all_kill_req_quantity = tomorrow_kill_request.aggregate(
                    total_quantity=Sum('quantity')).get(
                    'total_quantity') or 0

                all_kill_req_quantity_reciver = tomorrow_kill_request.aggregate(
                    total_quantity=Sum('accepted_real_quantity')).get(
                    'total_quantity') or 0
                all_kill_req_weight_reciver = tomorrow_kill_request.aggregate(
                    total_quantity=Sum('accepted_real_weight')).get(
                    'total_quantity') or 0
                all_ware_house_accepted_real_quantity = tomorrow_kill_request.aggregate(
                    total_quantity=Sum('ware_house_accepted_real_quantity')).get(
                    'total_quantity') or 0

                weight = tomorrow_kill_request.aggregate(
                    total_quantity=Sum(
                        F('quantity') * F('province_kill_request__province_request__poultry_request__Index_weight')))[
                             'total_quantity'] or 0
                kill_house_ware_houses = KillHouseWareHouse.objects.filter(
                    Q(weight_of_carcasses__gt=0) | Q(free_weight_of_carcasses__gt=0) | Q(
                        pre_cold_weight_of_carcasses_to_ware_house__gt=0), date__date__gte=tomorrow_date1,
                    date__date__lte=tomorrow_date2, kill_house=kill_house, trash=False)

                steward_allocations = StewardAllocation.objects.filter(
                    Q(type='manual') | Q(type='auto', system_registration_code=True),
                    ware_house__in=kill_house_ware_houses, receiver_state__in=('pending', 'accepted'),
                    trash=False).order_by(
                    'id')
                total_allocated_quantity = \
                    steward_allocations.aggregate(total=Sum('real_number_of_carcasses'))[
                        'total'] or 0
                total_allocated_weight = \
                    steward_allocations.aggregate(total=Sum('real_weight_of_carcasses'))[
                        'total'] or 0
                total_accepted_allocated_quantity = \
                    steward_allocations.aggregate(total=Sum('receiver_real_number_of_carcasses'))[
                        'total'] or 0
                total_accepted_allocated_weight = \
                    steward_allocations.aggregate(total=Sum('receiver_real_weight_of_carcasses'))[
                        'total'] or 0

                total_remain_quantity = \
                    kill_house_ware_houses.aggregate(total=Sum('remain_total_number_of_carcasses'))[
                        'total'] or 0
                total_remain_weight = \
                    kill_house_ware_houses.aggregate(total=Sum('remain_total_weight_of_carcasses'))[
                        'total'] or 0
                final_total_number_of_carcasses = \
                    kill_house_ware_houses.aggregate(total=Sum('final_total_number_of_carcasses'))[
                        'total'] or 0

                final_total_weight_of_carcasses = \
                    kill_house_ware_houses.aggregate(total=Sum('final_total_weight_of_carcasses'))[
                        'total'] or 0
                steward_allocations_for_number_of_steward = steward_allocations.filter(steward__isnull=False,
                                                                                       trash=False)
                number_of_steward = steward_allocations_for_number_of_steward.values(
                    'steward').distinct().count() if steward_allocations_for_number_of_steward else 0

                guild_allocations = steward_allocations.filter(guilds__isnull=False, trash=False)
                number_of_guild = guild_allocations.values('guilds').distinct().count() if guild_allocations else 0

                all_kill_req_quantity_not_assigment = tomorrow_kill_request_not_assigment.aggregate(
                    total_quantity=Sum('accepted_real_quantity')).get(
                    'total_quantity') or 0
                all_kill_req_weight_not_assigment = tomorrow_kill_request_not_assigment.aggregate(
                    total_quantity=Sum('accepted_real_weight')).get(
                    'total_quantity') or 0
                all_quantity_out_true = kill_free_information.aggregate(
                    total_quantity=Sum('number_of_carcasses')).get(
                    'total_quantity') or 0
                all_weight_out_true = kill_free_information.aggregate(
                    total_quantity=Sum('weight_of_carcasses')).get(
                    'total_quantity') or 0
                twenty_five_percent = (int(all_kill_req_weight_reciver) * 75) / 100
                reciver_percent = int(
                    int(all_kill_req_quantity_reciver) * 100) / all_kill_req_quantity if all_kill_req_quantity_reciver > 0 else 0
                lashe_25_percent = int(
                    final_total_number_of_carcasses * 100 / all_kill_req_quantity_reciver) if final_total_number_of_carcasses > 0 else 0
                weight_lashe_25_percent = int(
                    final_total_weight_of_carcasses * 100 / all_kill_req_weight_reciver) if final_total_weight_of_carcasses > 0 else 0
                remain_percent = int((
                                             total_remain_quantity * 100) / all_ware_house_accepted_real_quantity) if total_remain_quantity and all_ware_house_accepted_real_quantity > 0 else 0
                all_num = number_of_steward + number_of_guild
                hasnt_code = len(
                    tomorrow_kill_request.filter(assignment_state_archive='True', clearance_code__isnull=True))
                percent_hasnt_code = round(hasnt_code * 100 / len(tomorrow_kill_request)) if len(
                    tomorrow_kill_request) > 0 else 0
                has_code = len(
                    tomorrow_kill_request.filter(assignment_state_archive='pending', clearance_code__isnull=False))
                percent_has_code = round(has_code * 100 / len(tomorrow_kill_request)) if len(
                    tomorrow_kill_request) > 0 else 0

                has_assignment = len(
                    tomorrow_kill_request.filter(assignment_state_archive='True'))
                percent_has_assignment = round(has_assignment * 100 / len(tomorrow_kill_request)) if len(
                    tomorrow_kill_request) > 0 else 0
                hasnt_assignment = len(
                    tomorrow_kill_request.filter(assignment_state_archive='pending'))
                percent_hasnt_assignment = round(hasnt_assignment * 100 / len(tomorrow_kill_request)) if len(
                    tomorrow_kill_request) > 0 else 0
                accepeted_bar = len(
                    tomorrow_kill_request.filter(bar_document_status__title='بدون مشکل'))
                percent_accepeted_bar = round(accepeted_bar * 100 / has_assignment) if has_assignment > 0 else 0
                diffrent_bar = len(
                    tomorrow_kill_request.filter(bar_document_status__title='مغایرت دارد'))
                percent_diffrent_bar = round(diffrent_bar * 100 / has_assignment) if has_assignment > 0 else 0
                no_quality = len(
                    tomorrow_kill_request.filter(bar_document_status__title='فاقد کیفیت'))
                percent_no_quality = round(no_quality * 100 / has_assignment) if has_assignment > 0 else 0
                low_quality = len(
                    tomorrow_kill_request.filter(bar_document_status__title='کیفیت پایین'))
                percent_low_quality = round(low_quality * 100 / has_assignment) if has_assignment > 0 else 0
                dict_1 = {
                    "name": kill_house.name,
                    "city": kill_house.kill_house_operator.user.city.name,
                    "kill_req_quantity": all_kill_req_quantity,
                    "kill_req_weight": int(weight),
                    "quantity_receiver": all_kill_req_quantity_reciver,
                    "weight_receiver": int(all_kill_req_weight_reciver),
                    "twenty_five_percent_weight": int(twenty_five_percent),
                    "receiver_percent": reciver_percent,
                    "quantity_of_carcasses": final_total_number_of_carcasses,
                    "weight_of_carcasses": int(final_total_weight_of_carcasses),
                    "quantity_of_lashe_percent": lashe_25_percent,
                    "weight_of_lashe_percent": int(weight_lashe_25_percent),
                    "quantity_out_province": all_quantity_out_true,
                    "weight_out_province": int(all_weight_out_true),
                    "total_number_of_carcasses": final_total_number_of_carcasses,
                    "total_weight_of_carcasses": int(final_total_weight_of_carcasses),
                    "allocated_quantity": total_allocated_quantity,
                    "allocated_weight": int(total_allocated_weight),
                    "accepted_allocated_quantity": total_accepted_allocated_quantity,
                    "accepted_allocated_weight": int(total_accepted_allocated_weight),
                    "remain_quantity": total_remain_quantity,
                    "remain_weight": int(total_remain_weight),
                    "remain_percent": remain_percent,
                    "steward_and_guild": all_num,
                    "len_kill_req_not_complete": len(tomorrow_kill_request_not_assigment),
                    "quantity_kill_req_not_complete": all_kill_req_quantity_not_assigment,
                    "weight_kill_req_not_complete": int(all_kill_req_weight_not_assigment),
                    "len_hasnt_code": hasnt_code,
                    "percent_hasnt_code": percent_hasnt_code,
                    "len_has_code": has_code,
                    "percent_has_code": percent_has_code,
                    "has_assignment": has_assignment,
                    "percent_has_assignment": percent_has_assignment,
                    "accepeted_bar": accepeted_bar,
                    "percent_accepeted_bar": percent_accepeted_bar,
                    "diffrent_bar": diffrent_bar,
                    "percent_diffrent_bar": percent_diffrent_bar,
                    "no_quality": no_quality,
                    "percent_no_quality": percent_no_quality,
                    "low_quality": low_quality,
                    "percent_low_quality": percent_low_quality,
                    "hasnt_assignment": hasnt_assignment,
                    "percent_hasnt_assignment": percent_hasnt_assignment,

                }
                list1.append(dict_1)
        return list1

    def list(self, request):
        now = datetime.now().date()
        date1 = datetime.strptime(str(request.GET['date1']),
                                  '%Y-%m-%d').date() if 'date1' in request.GET else now
        date2 = datetime.strptime(str(request.GET['date2']),
                                  '%Y-%m-%d').date() if 'date2' in request.GET else now

        tomorrow_date1 = date1 + timedelta(days=1)
        tomorrow_date2 = date2 + timedelta(days=1)

        filtered_kill_reqs = KillHouseRequest.objects.filter(trash=False,
                                                             kill_request__recive_date__date__gte=date1,
                                                             kill_request__recive_date__date__lte=date2,
                                                             ).order_by(
            '-create_date').select_related(
            'killhouse_user', 'province_request__poultry_request',
            'province_request__poultry_request__poultry').only(
            'killhouse_user',
            'kill_request__slaughter_house',
            'kill_request__slaughter_house__name',
            'province_request__poultry_request__poultry',
            'province_request__poultry_request__send_date',
            'province_kill_request__province_request__poultry_request__Index_weight',
            'quantity',
            'accepted_real_weight',
            'accepted_real_quantity',
            'province_request__poultry_request__send_date',
            'province_request__poultry_request__hatching__date',
            'ware_house_accepted_real_weight',
            'ware_house_accepted_real_quantity',
            'killhouse_user__kill_house_operator__user__city__name')

        kill_free_info = KillHouseFreeBarInformation.objects.filter(trash=False, date__date__gte=tomorrow_date1,
                                                                    date__date__lte=tomorrow_date2).only(
            'weight_of_carcasses', 'number_of_carcasses')
        kill_request = self.all_kill_request(date1, date2)
        general_broadcast_informations = self.general_broadcast_information(tomorrow_date1, tomorrow_date2,
                                                                            filtered_kill_reqs, kill_free_info)
        kill_request_and_broadcasts = self.kill_request_and_broadcast(tomorrow_date1, tomorrow_date2,
                                                                      filtered_kill_reqs, kill_free_info)

        return Response({
            "all_kill_request": kill_request,
            "general_broadcast_informations": general_broadcast_informations,
            "kill_request_and_broadcast": kill_request_and_broadcasts
        }
        )


class DetailOfKillingDashboardView(viewsets.ViewSet):
    permission_classes = [TokenHasReadWriteScope]
    filter_backends = [DjangoFilterBackend]
    filterset_class = DashboardEnterLoadInformationFilterSet

    def list(self, request, *args, **kwargs):
        now = datetime.now().date()

        date1 = datetime.strptime(request.GET['date1'],
                                  '%Y-%m-%d').date() if 'date1' in request.GET else now
        date2 = datetime.strptime(request.GET['date2'],
                                  '%Y-%m-%d').date() if 'date2' in request.GET else now
        value = request.GET.get('value')
        search = request.GET.get('search')
        if request.GET.get('type') == 'assignment':
            filtered_kill_request = KillHouseRequest.objects.filter(
                trash=False,
                calculate_status=True,
                non_receipt=False,
                kill_request__recive_date__date__gte=date1,
                kill_request__recive_date__date__lte=date2, assignment_state_archive='True').order_by(
                '-create_date').select_related(
                'killhouse_user',
                'province_request__poultry_request',
                'add_car__driver',
            ).only('province_request', 'province_request__poultry_request',

                   'province_request__poultry_request__send_date',
                   'province_kill_request__province_request__poultry_request__Index_weight',
                   'clearance_code',
                   'quantity',
                   'accepted_real_weight',
                   'accepted_real_quantity',
                   'vet_state', 'vet_accepted_real_quantity',
                   'vet_accepted_real_weight', 'quarantine_quantity',
                   'province_request__poultry_request__hatching__date',
                   'province_request__poultry_request__send_date').values(
                'province_request',
                'province_request__poultry_request',

                'province_request__poultry_request__send_date',
                'province_kill_request__province_request__poultry_request__Index_weight',
                'clearance_code',
                'quantity',
                'accepted_real_weight',
                'accepted_real_quantity',
                'vet_state',
                'vet_accepted_real_quantity',
                'vet_accepted_real_weight',
                'quarantine_quantity',
                'province_request__poultry_request__hatching__date',
                'province_request__poultry_request__send_date'
            )
        else:

            filtered_kill_request = KillHouseRequest.objects.filter(
                trash=False,
                calculate_status=True,
                non_receipt=False,
                kill_request__recive_date__date__gte=date1,
                kill_request__recive_date__date__lte=date2).order_by(
                '-create_date').select_related(
                'killhouse_user',
                'province_request__poultry_request',
                'add_car__driver',
            ).only('province_request', 'province_request__poultry_request',

                   'province_request__poultry_request__send_date',
                   'province_kill_request__province_request__poultry_request__Index_weight',
                   'clearance_code',
                   'quantity',
                   'accepted_real_weight',
                   'accepted_real_quantity',
                   'vet_state', 'vet_accepted_real_quantity',
                   'vet_accepted_real_weight', 'quarantine_quantity',
                   'province_request__poultry_request__hatching__date',
                   'province_request__poultry_request__send_date').values(
                'province_request',
                'province_request__poultry_request',

                'province_request__poultry_request__send_date',
                'province_kill_request__province_request__poultry_request__Index_weight',
                'clearance_code',
                'quantity',
                'accepted_real_weight',
                'accepted_real_quantity',
                'vet_state',
                'vet_accepted_real_quantity',
                'vet_accepted_real_weight',
                'quarantine_quantity',
                'province_request__poultry_request__hatching__date',
                'province_request__poultry_request__send_date'
            )

        user = SystemUserProfile.objects.get(user=request.user)
        if request.GET['role'] == 'CityOperator':
            city_operator = CityOperator.objects.get(trash=False, user=user)
            filtered_kill_request = filtered_kill_request.filter(
                province_request__poultry_request__poultry__city_operator=city_operator.unit_name)
        elif request.GET['role'] == 'VetFarm':
            vet = Vet.objects.filter(user=user, trash=False).last()
            if vet:
                poultry_set = set()
                vet_farms = VetFarm.objects.filter(vet=vet, trash=False)
                for vet_farm in vet_farms:
                    poultry_set.add(vet_farm.poultry)
                poultries = list(poultry_set)
                filtered_kill_request = filtered_kill_request.filter(
                    province_request__poultry_request__poultry__in=poultries
                )


        elif request.GET['role'] in ['CityJahad', 'CityPoultry']:
            filtered_kill_request = filtered_kill_request.filter(
                province_request__poultry_request__poultry__address__city=user.city)
        elif request.GET['role'] == 'KillHouse':
            kill_house = KillHouse.objects.filter(kill_house_operator__user=user, trash=False).first()

            filtered_kill_request = filtered_kill_request.filter(
                killhouse_user=kill_house)
        elif request.GET['role'] == 'KillHouseVet':
            kill_house = KillHouseVet.objects.filter(vet__user=user, trash=False).values_list('kill_house')
            filtered_kill_request = filtered_kill_request.filter(
                (Q(killhouse_user__id__in=kill_house) | Q(kill_request__slaughter_house__id__in=kill_house)))
        else:
            if request.GET.get('without_quarantine_code_state') == 'true':
                filtered_kill_request = filtered_kill_request.filter(
                    clearance_code__isnull=False,
                    quarantine_quantity__isnull=True,
                    quarantine_code_state__isnull=True,
                )
            elif request.GET.get('without_bar_document') == "true":
                filtered_kill_request = filtered_kill_request.filter(
                    assignment_state_archive='True',
                    bar_document_status__isnull=True,
                )
            else:
                filtered_kill_request = filtered_kill_request

        if value and search == 'filter':
            if value != 'undefined' and value.strip():
                filtered_kill_request = filtered_kill_request.filter(
                    build_query(self.filterset_class, value)
                )

        ware_house_bars = filtered_kill_request.filter(ware_house_confirmation=True)
        ware_house_bars_quantity = ware_house_bars.aggregate(total=Sum('ware_house_accepted_real_quantity'))[
                                       'total'] or 0
        ware_house_bars_weight = ware_house_bars.aggregate(total=Sum('ware_house_accepted_real_weight'))[
                                     'total'] or 0

        ware_house_bars_weight_lose = ware_house_bars.aggregate(total=Sum('weight_loss'))[
                                          'total'] or 0
        bar_complete_with_kill_house = filtered_kill_request.filter(
            assignment_state_archive='True')

        accepted_real_wight_final = bar_complete_with_kill_house.aggregate(
            total_quantity=Sum('accepted_real_weight')).get(
            'total_quantity') or 0

        accepted_real_quantity_final = bar_complete_with_kill_house.aggregate(
            total_quantity=Sum('accepted_real_quantity')).get(
            'total_quantity', 0) or 0
        detail_of_killing = DetailOfKillingViewSet()
        bars = dict(list(detail_of_killing.get_kill_house_for_detail(filtered_kill_request).items())[3:])
        dict1 = {**bars,
                 'len_complete_with_vet': 0,
                 'quantity_complete_with_vet': 0,
                 'weight_complete_with_vet': 0,
                 'ware_house_bars': len(ware_house_bars),
                 'ware_house_bars_quantity': ware_house_bars_quantity,
                 'ware_house_bars_weight': ware_house_bars_weight,
                 'ware_house_bars_weight_lose': ware_house_bars_weight_lose / len(
                     ware_house_bars) if ware_house_bars else 0,
                 'len_complete_with_kill_house': len(bar_complete_with_kill_house),
                 'quantity_final_kill_house': accepted_real_quantity_final,
                 'weight_final_kill_house': int(accepted_real_wight_final),

                 }
        return Response(dict1)


class ParentCompanyDetailOfKillingDashboardView(viewsets.ViewSet):
    permission_classes = [AllowAny]
    filter_backends = [DjangoFilterBackend]
    filterset_class = DashboardEnterLoadInformationFilterSet

    def list(self, request, *args, **kwargs):
        now = datetime.now().date()

        date1 = datetime.strptime(request.GET['date1'],
                                  '%Y-%m-%d').date() if 'date1' in request.GET else now
        date2 = datetime.strptime(request.GET['date2'],
                                  '%Y-%m-%d').date() if 'date2' in request.GET else now
        value = request.GET.get('value')
        search = request.GET.get('search')
        if request.GET.get('type') == 'assignment':
            filtered_kill_request = KillHouseRequest.objects.filter(
                trash=False,
                kill_request__recive_date__date__gte=date1,
                kill_request__recive_date__date__lte=date2, assignment_state_archive='True').order_by(
                '-create_date').select_related(
                'killhouse_user',
                'province_request__poultry_request',
                'add_car__driver',
            ).only('province_request', 'province_request__poultry_request',

                   'province_request__poultry_request__send_date',
                   'province_kill_request__province_request__poultry_request__Index_weight',
                   'clearance_code',
                   'quantity',
                   'accepted_real_weight',
                   'accepted_real_quantity',
                   'vet_state', 'vet_accepted_real_quantity',
                   'vet_accepted_real_weight', 'quarantine_quantity',
                   'province_request__poultry_request__hatching__date',
                   'province_request__poultry_request__send_date').values(
                'province_request',
                'province_request__poultry_request',

                'province_request__poultry_request__send_date',
                'province_kill_request__province_request__poultry_request__Index_weight',
                'clearance_code',
                'quantity',
                'accepted_real_weight',
                'accepted_real_quantity',
                'vet_state',
                'vet_accepted_real_quantity',
                'vet_accepted_real_weight',
                'quarantine_quantity',
                'province_request__poultry_request__hatching__date',
                'province_request__poultry_request__send_date'
            )
        else:

            filtered_kill_request = KillHouseRequest.objects.filter(
                trash=False,
                kill_request__recive_date__date__gte=date1,
                kill_request__recive_date__date__lte=date2).order_by(
                '-create_date').select_related(
                'killhouse_user',
                'province_request__poultry_request',
                'add_car__driver',
            ).only('province_request', 'province_request__poultry_request',

                   'province_request__poultry_request__send_date',
                   'province_kill_request__province_request__poultry_request__Index_weight',
                   'clearance_code',
                   'quantity',
                   'accepted_real_weight',
                   'accepted_real_quantity',
                   'vet_state', 'vet_accepted_real_quantity',
                   'vet_accepted_real_weight', 'quarantine_quantity',
                   'province_request__poultry_request__hatching__date',
                   'province_request__poultry_request__send_date').values(
                'province_request',
                'province_request__poultry_request',

                'province_request__poultry_request__send_date',
                'province_kill_request__province_request__poultry_request__Index_weight',
                'clearance_code',
                'quantity',
                'accepted_real_weight',
                'accepted_real_quantity',
                'vet_state',
                'vet_accepted_real_quantity',
                'vet_accepted_real_weight',
                'quarantine_quantity',
                'province_request__poultry_request__hatching__date',
                'province_request__poultry_request__send_date'
            )

        if request.GET.get('without_quarantine_code_state') == 'true':
            filtered_kill_request = filtered_kill_request.filter(
                clearance_code__isnull=False,
                quarantine_quantity__isnull=True,
                quarantine_code_state__isnull=True,
            )
        elif request.GET.get('without_bar_document') == "true":
            filtered_kill_request = filtered_kill_request.filter(
                assignment_state_archive='True',
                bar_document_status__isnull=True,
            )
        else:
            filtered_kill_request = filtered_kill_request

        if value and search == 'filter':
            if value != 'undefined' and value.strip():
                filtered_kill_request = filtered_kill_request.filter(
                    build_query(self.filterset_class, value)
                )

        ware_house_bars = filtered_kill_request.filter(ware_house_confirmation=True)
        ware_house_bars_quantity = ware_house_bars.aggregate(total=Sum('ware_house_accepted_real_quantity'))[
                                       'total'] or 0
        ware_house_bars_weight = ware_house_bars.aggregate(total=Sum('ware_house_accepted_real_weight'))[
                                     'total'] or 0

        ware_house_bars_weight_lose = ware_house_bars.aggregate(total=Sum('weight_loss'))[
                                          'total'] or 0
        bar_complete_with_kill_house = filtered_kill_request.filter(
            assignment_state_archive='True')

        accepted_real_wight_final = bar_complete_with_kill_house.aggregate(
            total_quantity=Sum('accepted_real_weight')).get(
            'total_quantity') or 0

        accepted_real_quantity_final = bar_complete_with_kill_house.aggregate(
            total_quantity=Sum('accepted_real_quantity')).get(
            'total_quantity', 0) or 0

        detail_of_killing = DetailOfKillingViewSet()
        bars = dict(list(detail_of_killing.get_kill_house_for_detail(filtered_kill_request).items())[3:])
        dict1 = {**bars,
                 'len_complete_with_vet': 0,
                 'quantity_complete_with_vet': 0,
                 'weight_complete_with_vet': 0,
                 'ware_house_bars': len(ware_house_bars),
                 'ware_house_bars_quantity': ware_house_bars_quantity,
                 'ware_house_bars_weight': ware_house_bars_weight,
                 'ware_house_bars_weight_lose': ware_house_bars_weight_lose / len(
                     ware_house_bars) if ware_house_bars else 0,
                 'len_complete_with_kill_house': len(bar_complete_with_kill_house),
                 'quantity_final_kill_house': accepted_real_quantity_final,
                 'weight_final_kill_house': int(accepted_real_wight_final),

                 }
        return Response(dict1)


class SlaughterHouseTransactionViewSet(viewsets.ModelViewSet):
    queryset = SlaughterHouseTransaction.objects.all()
    serializer_class = SlaughterHouseTransactionSerializer
    permission_classes = [TokenHasReadWriteScope]


class KillHouseWageDashbordInWeightViewSet(viewsets.ModelViewSet):
    queryset = KillHouse.objects.all()
    serializer_class = KillHouseWageSerializer
    permission_classes = [TokenHasReadWriteScope]

    def list(self, request, *args, **kwargs):
        user = SystemUserProfile.objects.get(user=request.user, trash=False)
        if request.GET['role'] == 'KillHouse':
            kill_house_operator = KillHouseOperator.objects.get(user=user)
            kill_houses = KillHouse.objects.filter(kill_house_operator=kill_house_operator, out_province=False,
                                                   trash=False)
            # kill_house = KillHouse.objects.filter(kill_house_operator=kill_house_operator,out_province=False,trash=False).first()
            # serializer = self.serializer_class(kill_house)

        else:
            kill_houses = KillHouse.objects.filter(out_province=False, trash=False)
        serializer = self.serializer_class(kill_houses, many=True)

        return Response(serializer.data, status=status.HTTP_200_OK)


class TotalWageInformationExclusiveKillerViewset(viewsets.ModelViewSet):
    queryset = KillRequest.objects.all()
    permission_classes = [TokenHasReadWriteScope]
    serializer_class = TotalWageInformationKillHouseExclusiveKillerSerializer

    def list(self, request, *args, **kwargs):
        user = SystemUserProfile.objects.get(user=request.user)
        kill_house_key = request.GET.get('kill_house_key')
        if kill_house_key:
            kill_house = KillHouse.objects.filter(key=kill_house_key, trash=False).first()
        else:

            kill_house = KillHouse.objects.filter(kill_house_operator__user=user, trash=False).first()
        serializer = self.serializer_class(kill_house).data
        return Response(serializer, status=status.HTTP_200_OK)


class PoultryRequestLetterForProvinceVetViewSet(viewsets.ModelViewSet):
    queryset = PoultryRequest.objects.all()
    serializer_class = PoultryRequestLetterForProvinceVetSerializer
    permission_classes = [AllowAny]

    def list(self, request, *args, **kwargs):

        if 'order_code' in request.GET:
            poultry_request = PoultryRequest.objects.get(order_code=int(request.GET['order_code']), trash=False)
            serializer = PoultryRequestLetterForProvinceVetSerializer(poultry_request)
        else:
            date = datetime.strptime(str(request.GET['date']), '%Y-%m-%d').date()
            poultry_requests = PoultryRequest.objects.filter(send_date__date=date,
                                                             quantity__gt=F('remain_quantity'),
                                                             trash=False)
            serializer = PoultryRequestLetterForProvinceVetSerializer(poultry_requests, many=True)
        return Response(serializer.data, status=status.HTTP_200_OK)


class ProvinceRequestLetterForProvinceViewSet(viewsets.ModelViewSet):
    queryset = KillHouse.objects.all()
    serializer_class = KillHouseLetterForProvinceSerializer
    permission_classes = [AllowAny]

    def list(self, request, *args, **kwargs):
        # user=SystemUserProfile.objects.get(user=request.user,trash=False)
        date = datetime.strptime(str(request.GET['date']), '%Y-%m-%d').date()

        province_kill_requests = ProvinceKillRequest.objects.filter(kill_request__recive_date__date=date, trash=False,
                                                                    state__in=('pending', 'accepted'),
                                                                    return_to_province=False)
        kill_houses = KillHouse.objects.filter(pk__in=province_kill_requests.values_list('killhouse_user', flat=True))
        serializer = self.serializer_class(kill_houses, many=True, context={'date': date})
        if WageType.objects.filter(en_name='poultry-sell-out-province', status=True).exists():
            poultry_requests = PoultryRequest.objects.filter(send_date__date=date, out=True,
                                                             out_province_request_cancel=False,
                                                             trash=False, state_process='accepted',
                                                             province_state='accepted', wage_pay=True) \
                .select_related('hatching', 'poultry', 'poultry__address__city', 'poultry__address__province',
                                'poultry__user') \
                .order_by('-send_date')
        else:
            poultry_requests = PoultryRequest.objects.filter(send_date__date=date, out=True,
                                                             out_province_request_cancel=False,
                                                             trash=False, state_process='accepted',
                                                             province_state='accepted') \
                .select_related('hatching', 'poultry', 'poultry__address__city', 'poultry__address__province',
                                'poultry__user') \
                .order_by('-send_date')

        poultry_out = PoultryRequestoutProvinceSerializer(poultry_requests, many=True)
        dict1 = {
            'allocation': serializer.data,
            'out_province': poultry_out.data,
        }
        return Response(dict1, status=status.HTTP_200_OK)


class KillHousetestSerializer:
    pass


class KillHouseFortestViewSet(viewsets.ModelViewSet):
    queryset = KillHouse.objects.all()
    serializer_class = KillHousetestSerializer
    permission_classes = [AllowAny]

    def list(self, request, *args, **kwargs):
        kill_houses = KillHouse.objects.filter(trash=False, out_province=False)
        serializer = self.get_serializer(kill_houses, many=True)
        return Response(serializer.data, status=status.HTTP_200_OK)


class DeleteKillHouseRequest(viewsets.ModelViewSet):
    queryset = KillHouseRequest.objects.filter(trash=False)
    serializer_class = KillHouseRequestSerializer
    permission_classes = [TokenHasReadWriteScope]

    def destroy(self, request, *args, **kwargs):
        kill_house_request = KillHouseRequest.objects.get(trash=False, bar_code=request.GET['bar_code'])
        if kill_house_request.assignment_state_archive == 'True':
            kill_house_assignment = KillHouseAssignmentInformation.objects.get(kill_house_request=kill_house_request)
            kill_house_assignment.trash = True
            kill_house_assignment.save()

        kill_house_request.trash = True
        kill_house_request.save()
        update_kill_house_requests(kill_house_request.province_kill_request,
                                   kill_house_request.province_request.poultry_request)
        update_province_kill_requests(kill_house_request.province_request.poultry_request.hatching)
        poultry_prediction(kill_house_request.province_request.poultry_request.hatching)

        if kill_house_request.ware_house_confirmation == True:
            product = RolesProducts.objects.filter(trash=False, kill_house=kill_house_request.killhouse_user).first()
            kill_house_requests_product_warehousing(product)

        return Response({'result': 'Success'}, status=status.HTTP_200_OK)


class DashboardEnterLoadInformationView(viewsets.ViewSet):
    permission_classes = [TokenHasReadWriteScope]
    filter_backends = [DjangoFilterBackend]
    filterset_class = DashboardEnterLoadInformationFilterSet

    def list(self, request, *args, **kwargs):
        now = datetime.now().date()
        date1 = datetime.strptime(request.GET['date1'],
                                  '%Y-%m-%d').date() if 'date1' in request.GET else now
        date2 = datetime.strptime(request.GET['date2'],
                                  '%Y-%m-%d').date() if 'date2' in request.GET else now
        value = request.GET.get('value')
        search = request.GET.get('search')
        user = SystemUserProfile.objects.get(user=request.user)
        kill_house = []
        if request.GET['role'] == 'KillHouse':
            kill_house = KillHouse.objects.filter(kill_house_operator__user=user, trash=False)

        elif request.GET['role'] == 'KillHouseVet':
            kill_house_vets = KillHouseVet.objects.filter(vet__user=user, trash=False).select_related('kill_house')
            for kill_house_vet in kill_house_vets:
                kill_house.append(kill_house_vet.kill_house)

        else:
            kill_house = KillHouse.objects.filter(system_address__province=user.province, trash=False)

        if request.GET['role'] in ['CityOperator', 'CityJahad', 'CityPoultry']:
            if request.GET['role'] == 'CityOperator':
                city_operator = CityOperator.objects.get(user=user, trash=False)
                kill_house_requests = KillHouseRequest.objects.filter(
                    (Q(killhouse_user__in=kill_house) | Q(kill_request__slaughter_house__in=kill_house)),
                    kill_request__recive_date__date__gte=date1,
                    kill_request__recive_date__date__lte=date2,
                    assignment_state_archive='pending',
                    non_receipt=False,
                    trash=False, province_request__poultry_request__poultry__city_operator=city_operator.unit_name,

                ).order_by('-kill_request__recive_date')
            else:
                kill_house_requests = KillHouseRequest.objects.filter(
                    (Q(killhouse_user__in=kill_house) | Q(kill_request__slaughter_house__in=kill_house)),
                    kill_request__recive_date__date__gte=date1,
                    kill_request__recive_date__date__lte=date2,
                    assignment_state_archive='pending',
                    non_receipt=False,
                    trash=False, province_request__poultry_request__poultry__address__city=user.city

                ).order_by('-kill_request__recive_date')

        else:

            kill_house_requests = KillHouseRequest.objects.filter(
                (Q(killhouse_user__in=kill_house) | Q(kill_request__slaughter_house__in=kill_house) | Q(
                    killer__in=kill_house)),
                kill_request__recive_date__date__gte=date1,
                kill_request__recive_date__date__lte=date2,
                assignment_state_archive='pending',
                non_receipt=False,
                trash=False,

            ).order_by('-kill_request__recive_date')

        if value and search == 'filter':
            if value != 'undefined' and value.strip():
                kill_house_requests = kill_house_requests.filter(
                    build_query(self.filterset_class, value)
                )

        first_quantity = kill_house_requests.aggregate(
            total_quantity=Sum('quantity')).get(
            'total_quantity') or 0

        first_weight = kill_house_requests.aggregate(
            total_quantity=Sum(F('province_request__poultry_request__Index_weight') * F('quantity'))).get(
            'total_quantity') or 0
        vet_accepted_real_quantity = kill_house_requests.aggregate(
            total_quantity=Sum('vet_accepted_real_quantity')).get(
            'total_quantity') or 0
        vet_accepted_real_weight = kill_house_requests.aggregate(
            total_quantity=Sum('vet_accepted_real_weight')).get(
            'total_quantity') or 0

        dict1 = {
            "lenKillHouseRequest": len(kill_house_requests),
            'firstQuantity': first_quantity,
            'firstWeight': int(first_weight),
            'vetAcceptedRealQuantity': vet_accepted_real_quantity,
            'vetAcceptedRealWeight': vet_accepted_real_weight,
        }
        return Response(dict1)


class DashboardDeleteBarView(viewsets.ViewSet):
    permission_classes = [TokenHasReadWriteScope]
    filter_backends = [DjangoFilterBackend]
    filterset_class = DashboardEnterLoadInformationFilterSet

    def list(self, request, *args, **kwargs):
        now = datetime.now().date()
        date1 = datetime.strptime(request.GET['date1'],
                                  '%Y-%m-%d').date() if 'date1' in request.GET else now
        date2 = datetime.strptime(request.GET['date2'],
                                  '%Y-%m-%d').date() if 'date2' in request.GET else now
        value = request.GET.get('value')
        search = request.GET.get('search')
        user = SystemUserProfile.objects.get(user=request.user)
        kill_house_requests_list = KillHouseRequest.objects.filter(
            kill_request__recive_date__date__gte=date1,
            kill_request__recive_date__date__lte=date2, trash=True, temporary_trash=False,
            temporary_deleted=False).select_related('kill_request')
        if request.GET['role'] == 'VetSupervisor':
            kill_house_requests_list = kill_house_requests_list.filter(
                province_request__poultry_request__poultry__address__province=user.province,

            )

        elif request.GET['role'] == 'VetFarm':
            vet = Vet.objects.filter(user=user, trash=False)
            poultries = []
            if vet.count() > 0:
                vet = vet.last()
                vet_farms = VetFarm.objects.filter(vet=vet, trash=False)
                if vet_farms.count() > 0:
                    for vet_farm in vet_farms:
                        if vet_farm.poultry in poultries:
                            pass
                        else:
                            poultries.append(vet_farm.poultry)

                kill_house_requests_list = kill_house_requests_list.filter(
                    province_request__poultry_request__poultry__in=poultries,
                ).select_related('kill_request')

        elif request.GET['role'] == 'CityOperator':
            city_operator = CityOperator.objects.get(user=user)
            kill_house_requests_list = kill_house_requests_list.filter(
                province_request__poultry_request__poultry__city_operator=city_operator.unit_name,

            ).select_related('kill_request')

        elif request.GET['role'] in ['CityCommerce', 'CityVet', 'CityJahad', 'CityPoultry']:
            kill_house_requests_list = kill_house_requests_list.filter(

                province_request__poultry_request__poultry__address__city=user.city,

            ).select_related('kill_request')

        elif request.GET['role'] == 'LiveStockSupport':
            kill_house_requests_list = kill_house_requests_list.filter(

                province_request__poultry_request__freezing=True,

            ).select_related('kill_request')

        elif request.GET['role'] == 'KillHouse':
            kill_house = KillHouse.objects.filter(kill_house_operator__user=user, trash=False)

            kill_house_requests_list = kill_house_requests_list.filter(
                (Q(killhouse_user__in=kill_house) | Q(
                    kill_request__slaughter_house__in=kill_house) | Q(killer__in=kill_house)),

                province_request__poultry_request__poultry__address__province=user.province,
            ).select_related('kill_request')

        else:
            kill_house_requests_list = kill_house_requests_list.filter(

                province_request__poultry_request__poultry__address__province=user.province,
            ).select_related('kill_request')

        if value and search == 'filter':
            if value != 'undefined' and value.strip():
                kill_house_requests_list = kill_house_requests_list.filter(
                    build_query(self.filterset_class, value)
                )

        first_quantity = kill_house_requests_list.aggregate(
            total_quantity=Sum('quantity')).get(
            'total_quantity') or 0

        first_weight = kill_house_requests_list.aggregate(
            total_quantity=Sum(F('province_request__poultry_request__Index_weight') * F('quantity'))).get(
            'total_quantity') or 0
        len_has_code = len(kill_house_requests_list.filter(clearance_code__isnull=False))
        len_hasnt_code = len(kill_house_requests_list.filter(clearance_code__isnull=True))
        kill_house = kill_house_requests_list.values_list('kill_request__kill_house', flat=True).distinct()

        dict1 = {
            "lenKillHouseRequest": len(kill_house_requests_list),
            'firstQuantity': first_quantity,
            'firstWeight': int(first_weight),
            'lenHasCode': len_has_code,
            'lenHasntCode': len_hasnt_code,
            'lenKillHouse': len(kill_house),
        }
        return Response(dict1)


class DahsnoardProvinceKillRequestViewSet(viewsets.ModelViewSet):
    queryset = ProvinceKillRequest.objects.all()
    serializer_class = ProvinceKillRequestSerializer
    permission_classes = [TokenHasReadWriteScope]
    filterset_class = ProvinceKillRequestNewFilterSet

    # تابع مربوط به نمایش  تخصیصات به کشتارگاها توسط استان
    def list(self, request, *args, **kwargs):
        now = datetime.now().date()
        user = SystemUserProfile.objects.get(user=request.user, trash=False)

        date1 = datetime.strptime(str(request.GET['date1']),
                                  '%Y-%m-%d').date() if 'date1' in request.GET else now
        date2 = datetime.strptime(str(request.GET['date2']),
                                  '%Y-%m-%d').date() if 'date2' in request.GET else now
        if request.GET['role'] == 'KillHouse':

            kill_house = KillHouse.objects.filter(kill_house_operator__user=user,
                                                  trash=False)

            trash = True if 'deleted_object' in request.GET else False
            province_kill_requests = ProvinceKillRequest.objects.filter(Q(killhouse_user__in=kill_house) | Q(
                kill_request__slaughter_house__in=kill_house),
                                                                        trash=trash,
                                                                        delete_message__isnull=False if trash else True,
                                                                        kill_request__recive_date__date__gte=date1,
                                                                        kill_request__recive_date__date__lte=date2,
                                                                        temporary_trash=False, temporary_deleted=False,
                                                                        ).select_related(
                'province_request__poultry_request').order_by(
                'province_request__city_request_Poultry__poultry_request__send_date')
        else:
            trash = True if 'deleted_object' in request.GET else False
            province_kill_requests = ProvinceKillRequest.objects.filter(
                province_request__city_request_Poultry__poultry_request__poultry__user__province=user.province,
                trash=trash,
                delete_message__isnull=False if trash else True,
                kill_request__recive_date__date__gte=date1,
                kill_request__recive_date__date__lte=date2, temporary_trash=False, temporary_deleted=False,
            ).select_related(
                'province_request__poultry_request__poultry',
                'province_request__city_request_Poultry__poultry_request__poultry__user',
                'province_request__city_request_Poultry__poultry_request__poultry__user__city',
                'kill_request__kill_house',
                'kill_request__kill_house__kill_house_operator__user',
                'kill_request__kill_house__system_address__city'
            ).order_by('province_request__poultry_request__send_date')
        if 'allocated_car_state' in request.GET:
            province_kill_requests = province_kill_requests.filter(first_car_allocated_quantity=0)
        value = request.GET.get('value')
        search = request.GET.get('filter')
        if value and search == 'search':
            if value != 'undefined' and value.strip():
                province_kill_requests = province_kill_requests.filter(
                    build_query(self.filterset_class, value)
                )
        kill_requests = KillHouseRequest.objects.filter(province_kill_request__in=province_kill_requests, trash=False)
        accepted_province_kill_requests = province_kill_requests.filter(state='accepted')
        pending_province_kill_requests = province_kill_requests.filter(state='pending')
        rejected_province_kill_requests = province_kill_requests.filter(state='rejected')

        quantity = province_kill_requests.aggregate(
            total_quantity=Sum('total_killed_quantity')).get(
            'total_quantity') or 0
        weight = province_kill_requests.aggregate(
            total_quantity=Sum('total_killed_weight')).get(
            'total_quantity') or 0

        accepted_quantity = accepted_province_kill_requests.aggregate(
            total_quantity=Sum('total_killed_quantity')).get(
            'total_quantity') or 0
        pending_quantity = pending_province_kill_requests.aggregate(
            total_quantity=Sum('total_killed_quantity')).get(
            'total_quantity') or 0
        rejected_quantity = rejected_province_kill_requests.aggregate(
            total_quantity=Sum('total_killed_quantity')).get(
            'total_quantity') or 0
        has_car = province_kill_requests.filter(first_car_allocated_quantity__gt=0)
        has_car_quantity = has_car.aggregate(
            total_quantity=Sum('total_killed_quantity')).get(
            'total_quantity') or 0
        has_car_weight = has_car.aggregate(
            total_quantity=Sum('total_killed_weight')).get(
            'total_quantity') or 0
        hasnt_car = province_kill_requests.filter(first_car_allocated_quantity=0)
        hasnt_car_quantity = hasnt_car.aggregate(
            total_quantity=Sum('total_killed_quantity')).get(
            'total_quantity') or 0
        hasnt_car_weight = hasnt_car.aggregate(
            total_quantity=Sum('total_killed_weight')).get(
            'total_quantity') or 0
        real_quantity = kill_requests.aggregate(
            total_quantity=Sum('accepted_real_quantity')).get(
            'total_quantity') or 0
        real_weight = kill_requests.aggregate(
            total_quantity=Sum('accepted_real_weight')).get(
            'total_quantity') or 0

        internal_dict_infos = {
            "lenProvinceRequest": len(province_kill_requests),
            "quantity": quantity,
            "weight": int(weight),
            "acceptedProvinceKillRequests": len(accepted_province_kill_requests),
            "acceptedProvinceKillRequestsQuantity": accepted_quantity,
            "pendingProvinceKillRequests": len(pending_province_kill_requests),
            "pendingProvinceKillRequestsQuantity": pending_quantity,
            "rejectedProvinceKillRequests": len(rejected_province_kill_requests),
            "rejectedProvinceKillRequestsQuantity": rejected_quantity,
            "lenHasCar": len(has_car),
            "hasCarQuantity": has_car_quantity,
            "hasCarWeight": has_car_weight,
            "lenKillRequests": len(kill_requests),
            "realQuantity": real_quantity,
            "realWeight": real_weight,
            "lenHasntCar": len(hasnt_car),
            "hasntCarQuantity": hasnt_car_quantity,
            "hasntCarWeight": hasnt_car_weight,
        }

        return Response(internal_dict_infos, status=status.HTTP_200_OK)

    def update(self, request, pk=None, *args, **kwargs):
        user = SystemUserProfile.objects.get(user=request.user, trash=False)
        role = request.data['role']
        request.data.pop('role')
        if 'type' in request.data.keys():
            if request.data['type'] == 'archive':
                user_fullname = user.fullname
                date = str(datetime.now())
                archive_province_kill_request_wage_threading = threading.Thread(
                    target=provincearchiveprovincekillrequestforwage,
                    args=(
                        request.data['province_kill_request_list'], request.data['message'], role, user_fullname, date
                    ))
                archive_province_kill_request_wage_threading.start()
                return Response({"result": "با موفقیت انجام شد"}, status=status.HTTP_200_OK)


            elif request.data['type'] == 'return_archive':
                user_fullname = user.fullname
                date = str(datetime.now().date())
                province_kill_request = ProvinceKillRequest.objects.get(key=request.data['province_kill_request_key'])
                province_kill_request.archive_by_province = False
                if 'return_archive_message' in request.data.keys():
                    province_kill_request.return_archive_message = request.data['return_archive_message']
                province_kill_request.returner = {
                    "fullname": user_fullname,
                    "date": date,
                    "role": role
                }
                province_kill_request.save()
                return Response({"result": "با موفقیت انجام شد"}, status=status.HTTP_200_OK)


        else:

            province_kill_request = ProvinceKillRequest.objects.get(key=request.data['province_kill_request_key'])
            if province_kill_request.prev_total_amount == None:
                province_kill_request.prev_total_amount = province_kill_request.total_amount
            province_kill_request.total_amount_editor = {
                "role": role,
                "fullname": user.fullname,
                "mobile": user.mobile,
                "date": str(datetime.now())
            }
            province_kill_request.save()
            serializer = self.serializer_class(province_kill_request)
            serializer.update(instance=province_kill_request, validated_data=request.data)
            return Response(serializer.data, status=status.HTTP_200_OK)

    def destroy(self, request, pk=None, *args, **kwargs):
        # refresh(request.user.id)

        if 'delete_allocation' in request.GET:
            province_kill_request = ProvinceKillRequest.objects.get(key=request.GET['province_kill_request_key'],
                                                                    trash=False)
            if province_kill_request.quantity != province_kill_request.main_quantity:
                return Response({"result": "برای تخصیص ماشین ثبت شده امکان حذف وجود ندارد!"},
                                status=status.HTTP_403_FORBIDDEN)

            poultry_request = PoultryRequest.objects.get(key=province_kill_request.province_request.poultry_request.key,
                                                         trash=False)
            province_check = ProvinceCheckOperatorRequest.objects.get(poultry_request=poultry_request)

            hatching = PoultryHatching.objects.get(key=poultry_request.hatching.key, trash=False)
            if poultry_request.export == True:
                hatching.export_killed_weight -= int(int(request.data['quantity']) * poultry_request.Index_weight)
                hatching.export_killed_quantity -= int(request.data['quantity'])
            elif poultry_request.free_sale_in_province == True:
                hatching.free_killed_quantity -= province_kill_request.total_killed_weight
                # hatching.free_killed_quantity -= int(province_kill_request.main_quantity * poultry_request.Index_weight)
                hatching.free_quantity -= province_kill_request.total_killed_quantity
                # hatching.free_quantity -= province_kill_request.main_quantity
            else:
                hatching.governmental_killed_quantity -= province_kill_request.total_killed_weight
                # hatching.governmental_killed_quantity -= int(
                #     province_kill_request.main_quantity * poultry_request.Index_weight)

                hatching.governmental_quantity -= province_kill_request.total_killed_quantity
                # hatching.governmental_quantity -= province_kill_request.main_quantity
            # hatching.killed_quantity -= province_kill_request.main_quantity
            hatching.save()

            if poultry_request.remain_quantity > 0:
                # province_check = ProvinceCheckOperatorRequest.objects.get(poultry_request=poultry_request)
                province_check.quantity += province_kill_request.main_quantity
                province_check.save()
                poultry_request.remain_quantity += province_kill_request.main_quantity
                poultry_request.save()
            else:

                # province_check = ProvinceCheckOperatorRequest.objects.get(poultry_request=poultry_request)
                province_check.quantity += province_kill_request.main_quantity
                province_check.save()
                poultry_request.remain_quantity += province_kill_request.main_quantity
                poultry_request.save()
                # poultry_request.quantity -= province_kill_request.quantity
                # poultry_request.first_quantity -= province_kill_request.quantity
                # poultry_request.previous_quantity -= province_kill_request.quantity
                # poultry_request.save()
                # if poultry_request.quantity == 0:
                # poultry_request.trash = True
                # poultry_request.save()
                # hatching.left_over += province_kill_request.quantity
                # hatching.state = 'pending'
                # hatching.allow_hatching = 'pending'
                # hatching.save()
            kill_request = KillRequest.objects.get(key=province_kill_request.kill_request.key)
            kill_request.remain_quantity += province_kill_request.main_quantity
            kill_request.save()
            province_kill_request.delete_message = request.GET['message']
            province_kill_request.trash = True
            province_kill_request.save()
            return Response({"result": "با موفقیت حذف شد"}, status=status.HTTP_200_OK)
        elif 'return_allocation_quantity' in request.GET:

            province_kill_request = ProvinceKillRequest.objects.get(key=request.GET['province_kill_request_key'],
                                                                    trash=False)
            if province_kill_request.quantity == 0:
                return Response({"result": "باقی مانده تخصیص صفر است امکان بازگشت تعداد وجود ندارد"},
                                status=status.HTTP_403_FORBIDDEN)
            amount = province_kill_request.quantity

            poultry_request = PoultryRequest.objects.get(key=province_kill_request.province_request.poultry_request.key,
                                                         trash=False)
            hatching = PoultryHatching.objects.get(key=poultry_request.hatching.key, trash=False)

            if province_kill_request.main_quantity - province_kill_request.quantity == 0:
                province_check = ProvinceCheckOperatorRequest.objects.get(poultry_request=poultry_request)
                province_check.quantity += province_kill_request.main_quantity
                province_check.save()
                poultry_request.remain_quantity += province_kill_request.main_quantity
                poultry_request.save()
                # kill_request = KillRequest.objects.get(key=province_kill_request.kill_request.key)
                # kill_request.remain_quantity += province_kill_request.main_quantity
                # kill_request.save()
                if poultry_request.export == True:
                    hatching.export_killed_weight -= int(int(request.data['quantity']) * poultry_request.Index_weight)
                    hatching.export_killed_quantity -= int(request.data['quantity'])
                elif poultry_request.free_sale_in_province == True:
                    hatching.free_killed_quantity -= province_kill_request.total_killed_weight
                    # hatching.free_killed_quantity -= int(amount * poultry_request.Index_weight)
                    hatching.free_quantity -= province_kill_request.total_killed_quantity
                    # hatching.free_quantity -= amount
                else:
                    hatching.governmental_killed_quantity -= province_kill_request.total_killed_weight
                    # hatching.governmental_killed_quantity -= int(amount * poultry_request.Index_weight)
                    hatching.governmental_quantity -= province_kill_request.total_killed_quantity
                    # hatching.governmental_quantity -= amount
                # hatching.killed_quantity -= amount
                hatching.save()
                # province_kill_request.trash = True
                province_kill_request.quantity = 0
                province_kill_request.total_killed_quantity = 0
                province_kill_request.total_killed_weight = 0
                province_kill_request.return_to_province = True
                province_kill_request.save()
            else:

                province_check = ProvinceCheckOperatorRequest.objects.get(poultry_request=poultry_request)
                province_check.quantity += province_kill_request.main_quantity - province_kill_request.quantity
                province_check.save()
                poultry_request.remain_quantity += province_kill_request.main_quantity - province_kill_request.quantity
                poultry_request.save()
                # kill_request = KillRequest.objects.get(key=province_kill_request.kill_request.key)
                # kill_request.remain_quantity += province_kill_request.main_quantity - province_kill_request.quantity
                # kill_request.save()
                if poultry_request.export == True:
                    hatching.export_killed_weight -= int(int(request.data['quantity']) * poultry_request.Index_weight)
                    hatching.export_killed_quantity -= int(request.data['quantity'])
                elif poultry_request.free_sale_in_province == True:
                    hatching.free_killed_quantity -= int((
                                                                 province_kill_request.main_quantity - province_kill_request.quantity) * poultry_request.Index_weight)
                    # hatching.free_killed_quantity -= int(amount * poultry_request.Index_weight)
                    hatching.free_quantity -= province_kill_request.total_killed_quantity
                    # hatching.free_quantity -= amount
                else:
                    hatching.governmental_killed_quantity -= int((
                                                                         province_kill_request.main_quantity - province_kill_request.quantity) * poultry_request.Index_weight)
                    # hatching.governmental_killed_quantity -= int(amount * poultry_request.Index_weight)
                    hatching.governmental_quantity -= province_kill_request.main_quantity - province_kill_request.quantity
                    # hatching.governmental_quantity -= amount
                # hatching.killed_quantity -= amount
                hatching.save()
                province_kill_request.main_quantity = province_kill_request.main_quantity - province_kill_request.quantity
                province_kill_request.quantity = 0
                province_kill_request.save()
            return Response({"result": "با موفقیت انجام شد"}, status=status.HTTP_200_OK)
        queryset = ProvinceKillRequest.objects.get(key=request.GET['key'])
        poultry_request = PoultryRequest.objects.get(key=queryset.province_request.poultry_request.key)
        hatching = PoultryHatching.objects.get(key=poultry_request.hatching.key, trash=False)
        check = KillHouseCheckRequest.objects.filter(province_kill_request=queryset, state='accepted')
        if check.count() > 0:
            return Response({"result": "can not delete"}, status=status.HTTP_403_FORBIDDEN)
        province = ProvinceCheckOperatorRequest.objects.get(key=queryset.province_request.key)
        province.quantity += queryset.quantity
        province.save()
        kill_request = KillRequest.objects.get(key=queryset.kill_request.key)
        kill_request.remain_quantity += queryset.quantity
        kill_request.save()
        # queryset.delete()
        poultry_request.remain_quantity += queryset.quantity
        poultry_request.save()
        if poultry_request.export == True:
            hatching.export_killed_weight -= int(int(request.data['quantity']) * poultry_request.Index_weight)
            hatching.export_killed_quantity -= int(request.data['quantity'])
        elif poultry_request.free_sale_in_province == True:
            hatching.free_killed_quantity -= queryset.total_killed_weight
            # hatching.free_killed_quantity -= int(queryset.quantity * poultry_request.Index_weight)
            hatching.free_quantity -= queryset.total_killed_quantity
        else:
            hatching.governmental_killed_quantity -= queryset.total_killed_weight
            # hatching.governmental_killed_quantity -= int(
            #     queryset.quantity * poultry_request.Index_weight)
            hatching.governmental_quantity -= queryset.total_killed_quantity
        # hatching.killed_quantity -= queryset.total_killed_quantity
        hatching.save()
        queryset.delete()

        return Response(status=status.HTTP_200_OK)


class DashboardKillHouseFreeBarInformationViewSet(viewsets.ModelViewSet):
    queryset = KillHouseFreeBarInformation.objects.all()
    serializer_class = KillHouseFreeBarInformationSerializer
    permission_classes = [TokenHasReadWriteScope]
    pagination_class = CustomPagination
    filter_backends = [DjangoFilterBackend]
    filterset_class = DashboardKillHouseFreeBarInformationFilterSet

    def list(self, request, *args, **kwargs):
        value = request.GET.get('value')
        search = request.GET.get('search')
        date1 = request.GET.get('date1')
        date2 = request.GET.get('date2')
        if date1:
            date1 = datetime.strptime(str(request.GET['date1']), '%Y-%m-%d').date()
            date2 = datetime.strptime(str(request.GET['date2']), '%Y-%m-%d').date()
        user = SystemUserProfile.objects.get(user=request.user, trash=False)
        type = request.GET['type']
        if request.GET['role'] in ['KillHouse', 'KillHouseVet']:
            if request.GET['role'] == 'KillHouse':
                kill_houses = KillHouse.objects.filter(kill_house_operator__user=user, trash=False)
            else:
                kill_house_ids = KillHouseVet.objects.filter(vet__user=user, trash=False).values_list('kill_house',
                                                                                                      flat=True)
                kill_houses = KillHouse.objects.filter(id__in=kill_house_ids, trash=False)

            kill_house_free_bar_info = KillHouseFreeBarInformation.objects.filter(
                Q(kill_house__in=kill_houses) | Q(exclusive_killer__in=kill_houses) | Q(public_killer__in=kill_houses),
                buy_type=type,
                calculate_status=True,
                temporary_trash=False,
                temporary_deleted=False,
                trash=False).order_by('-date')
        else:
            kill_house_free_bar_info = KillHouseFreeBarInformation.objects.filter(
                buy_type=type,
                calculate_status=True,
                temporary_trash=False,
                temporary_deleted=False,
                trash=False).order_by('-date')

        if date1:
            kill_house_free_bar_info = kill_house_free_bar_info.filter(register_date__date__gte=date1,
                                                                       register_date__date__lte=date2)

        if value and search == 'filter':
            if value != 'undefined' and value.strip():
                kill_house_free_bar_info = kill_house_free_bar_info.filter(
                    build_query(self.filterset_class, value)
                )
        quantity = kill_house_free_bar_info.aggregate(
            total_quantity=Sum('quantity')).get(
            'total_quantity') or 0
        live_weight = kill_house_free_bar_info.aggregate(
            total_quantity=Sum('live_weight')).get(
            'total_quantity') or 0
        number_of_carcasses = kill_house_free_bar_info.aggregate(
            total_quantity=Sum('number_of_carcasses')).get(
            'total_quantity') or 0
        weight_of_carcasses = kill_house_free_bar_info.aggregate(
            total_quantity=Sum('weight_of_carcasses')).get(
            'total_quantity') or 0
        if type == 'live':
            quantity = kill_house_free_bar_info.aggregate(
                total_quantity=Sum('quantity')).get(
                'total_quantity') or 0
            live_weight = kill_house_free_bar_info.aggregate(
                total_quantity=Sum('live_weight')).get(
                'total_quantity') or 0
            number_of_carcasses = kill_house_free_bar_info.aggregate(
                total_quantity=Sum('number_of_carcasses')).get(
                'total_quantity') or 0
            weight_of_carcasses = kill_house_free_bar_info.aggregate(
                total_quantity=Sum('weight_of_carcasses')).get(
                'total_quantity') or 0

            entered_bars = kill_house_free_bar_info.filter(weight_of_carcasses__gt=0)

            entered_quantity = entered_bars.aggregate(
                total_quantity=Sum('quantity')).get(
                'total_quantity') or 0
            entered_live_weight = entered_bars.aggregate(
                total_quantity=Sum('live_weight')).get(
                'total_quantity') or 0
            entered_number_of_carcasses = entered_bars.aggregate(
                total_quantity=Sum('number_of_carcasses')).get(
                'total_quantity') or 0
            entered_weight_of_carcasses = entered_bars.aggregate(
                total_quantity=Sum('weight_of_carcasses')).get(
                'total_quantity') or 0

            not_entered_bars = kill_house_free_bar_info.filter(weight_of_carcasses=0)

            not_entered_quantity = not_entered_bars.aggregate(
                total_quantity=Sum('quantity')).get(
                'total_quantity') or 0
            not_entered_live_weight = not_entered_bars.aggregate(
                total_quantity=Sum('live_weight')).get(
                'total_quantity') or 0
            not_entered_number_of_carcasses = not_entered_bars.aggregate(
                total_quantity=Sum('number_of_carcasses')).get(
                'total_quantity') or 0
            not_entered_weight_of_carcasses = not_entered_bars.aggregate(
                total_quantity=Sum('weight_of_carcasses')).get(
                'total_quantity') or 0

            result = {
                'total_bars': len(kill_house_free_bar_info),
                'total_bars_quantity': quantity,
                'total_bars_live_Weight': live_weight,
                'total_bars_numberOfCarcasses': number_of_carcasses,
                'total_bars_weightOfCarcasses': weight_of_carcasses,

                'entered_total_bars': len(entered_bars),
                'entered_total_bars_quantity': entered_quantity,
                'entered_total_bars_live_Weight': entered_live_weight,
                'entered_total_bars_numberOfCarcasses': entered_number_of_carcasses,
                'entered_total_bars_weightOfCarcasses': entered_weight_of_carcasses,

                'not_entered_total_bars': len(not_entered_bars),
                'not_entered_total_bars_quantity': not_entered_quantity,
                'not_entered_total_bars_live_Weight': not_entered_live_weight,
                'not_entered_total_bars_numberOfCarcasses': not_entered_number_of_carcasses,
                'not_entered_total_bars_weightOfCarcasses': not_entered_weight_of_carcasses,

            }
        else:
            result = {
                'total_bars': len(kill_house_free_bar_info),
                'total_bars_quantity': quantity,
                'total_bars_live_Weight': live_weight,
                'total_bars_numberOfCarcasses': number_of_carcasses,
                'total_bars_weightOfCarcasses': weight_of_carcasses,
            }
        return Response(result, status=status.HTTP_200_OK)


class ParentCopmanyDashboardKillHouseFreeBarInformationViewSet(viewsets.ModelViewSet):
    queryset = KillHouseFreeBarInformation.objects.all()
    serializer_class = KillHouseFreeBarInformationSerializer
    permission_classes = [AllowAny]
    pagination_class = CustomPagination
    filter_backends = [DjangoFilterBackend]
    filterset_class = DashboardKillHouseFreeBarInformationFilterSet

    def list(self, request, *args, **kwargs):

        type = request.GET['type']

        kill_house_free_bar_info = KillHouseFreeBarInformation.objects.filter(
            buy_type=type,
            trash=False).order_by('-date')
        quantity = kill_house_free_bar_info.aggregate(
            total_quantity=Sum('quantity')).get(
            'total_quantity') or 0
        live_weight = kill_house_free_bar_info.aggregate(
            total_quantity=Sum('live_weight')).get(
            'total_quantity') or 0
        number_of_carcasses = kill_house_free_bar_info.aggregate(
            total_quantity=Sum('number_of_carcasses')).get(
            'total_quantity') or 0
        weight_of_carcasses = kill_house_free_bar_info.aggregate(
            total_quantity=Sum('weight_of_carcasses')).get(
            'total_quantity') or 0
        if type == 'live':
            quantity = kill_house_free_bar_info.aggregate(
                total_quantity=Sum('quantity')).get(
                'total_quantity') or 0
            live_weight = kill_house_free_bar_info.aggregate(
                total_quantity=Sum('live_weight')).get(
                'total_quantity') or 0
            number_of_carcasses = kill_house_free_bar_info.aggregate(
                total_quantity=Sum('number_of_carcasses')).get(
                'total_quantity') or 0
            weight_of_carcasses = kill_house_free_bar_info.aggregate(
                total_quantity=Sum('weight_of_carcasses')).get(
                'total_quantity') or 0

            entered_bars = kill_house_free_bar_info.filter(weight_of_carcasses__gt=0)

            entered_quantity = entered_bars.aggregate(
                total_quantity=Sum('quantity')).get(
                'total_quantity') or 0
            entered_live_weight = entered_bars.aggregate(
                total_quantity=Sum('live_weight')).get(
                'total_quantity') or 0
            entered_number_of_carcasses = entered_bars.aggregate(
                total_quantity=Sum('number_of_carcasses')).get(
                'total_quantity') or 0
            entered_weight_of_carcasses = entered_bars.aggregate(
                total_quantity=Sum('weight_of_carcasses')).get(
                'total_quantity') or 0

            not_entered_bars = kill_house_free_bar_info.filter(weight_of_carcasses=0)

            not_entered_quantity = not_entered_bars.aggregate(
                total_quantity=Sum('quantity')).get(
                'total_quantity') or 0
            not_entered_live_weight = not_entered_bars.aggregate(
                total_quantity=Sum('live_weight')).get(
                'total_quantity') or 0
            not_entered_number_of_carcasses = not_entered_bars.aggregate(
                total_quantity=Sum('number_of_carcasses')).get(
                'total_quantity') or 0
            not_entered_weight_of_carcasses = not_entered_bars.aggregate(
                total_quantity=Sum('weight_of_carcasses')).get(
                'total_quantity') or 0

            result = {
                'total_bars': len(kill_house_free_bar_info),
                'total_bars_quantity': quantity,
                'total_bars_live_Weight': live_weight,
                'total_bars_numberOfCarcasses': number_of_carcasses,
                'total_bars_weightOfCarcasses': weight_of_carcasses,

                'entered_total_bars': len(entered_bars),
                'entered_total_bars_quantity': entered_quantity,
                'entered_total_bars_live_Weight': entered_live_weight,
                'entered_total_bars_numberOfCarcasses': entered_number_of_carcasses,
                'entered_total_bars_weightOfCarcasses': entered_weight_of_carcasses,

                'not_entered_total_bars': len(not_entered_bars),
                'not_entered_total_bars_quantity': not_entered_quantity,
                'not_entered_total_bars_live_Weight': not_entered_live_weight,
                'not_entered_total_bars_numberOfCarcasses': not_entered_number_of_carcasses,
                'not_entered_total_bars_weightOfCarcasses': not_entered_weight_of_carcasses,

            }
        else:
            result = {
                'total_bars': len(kill_house_free_bar_info),
                'total_bars_quantity': quantity,
                'total_bars_live_Weight': live_weight,
                'total_bars_numberOfCarcasses': number_of_carcasses,
                'total_bars_weightOfCarcasses': weight_of_carcasses,
            }
        return Response(result, status=status.HTTP_200_OK)


class DashboardKillRequestViewSet(viewsets.ModelViewSet):
    queryset = KillRequest.objects.all()
    serializer_class = KillHouseFreeBarInformationSerializer
    permission_classes = [TokenHasReadWriteScope]
    filter_backends = [DjangoFilterBackend]
    filterset_class = DashboardKillRequestFilterSet

    def list(self, request, *args, **kwargs):
        value = request.GET.get('value')
        search = request.GET.get('search')
        date1 = datetime.strptime(str(request.GET['date1']), '%Y-%m-%d').date()
        date2 = datetime.strptime(str(request.GET['date2']), '%Y-%m-%d').date()
        user = SystemUserProfile.objects.get(user=request.user, trash=False)
        querysets = KillRequest.objects.filter(
            recive_date__date__gte=date1,
            recive_date__date__lte=date2, poultry__isnull=False,
            trash=False).order_by(
            'recive_date')
        if request.GET['role'] == 'KillHouse':
            kill_house_operator = KillHouseOperator.objects.get(user=user, trash=False)
            kill_house = KillHouse.objects.filter(kill_house_operator=kill_house_operator, trash=False)
            querysets = querysets.filter(kill_house__in=kill_house).order_by('recive_date')
        elif request.GET['role'] in ['ProvinceOperator', 'SuperAdmin', 'AdminX']:
            if 'direct_buying' in request.GET:
                querysets = querysets.filter(market=False,
                                             final_accept=True,
                                             direct_buying_state__in=(
                                                 'accepted', 'rejected', 'deleted', 'pending'),
                                             export_status=False, trash=False
                                             )
            if 'export' in request.GET:
                if request.GET['type'] == 'pending':
                    querysets = querysets.filter(export_status=True,
                                                 export_state='pending'
                                                 )
                else:
                    querysets = querysets.filter(export_status=True,
                                                 export_state__in=(
                                                     'accepted', 'rejected', 'deleted'),
                                                 )

        if value and search == 'filter':
            if value != 'undefined' and value.strip():
                querysets = querysets.filter(
                    build_query(self.filterset_class, value)
                )
        quantity = querysets.aggregate(
            total_quantity=Sum('kill_capacity')).get(
            'total_quantity') or 0
        free_direct_buying_true_quantity = querysets.aggregate(
            total_quantity=Sum('kill_capacity', filter=Q(free_direct_buying=True))).get(
            'total_quantity') or 0
        free_direct_buying_false_quantity = querysets.aggregate(
            total_quantity=Sum('kill_capacity', filter=Q(free_direct_buying=False))).get(
            'total_quantity') or 0
        left_over = querysets.aggregate(
            total_quantity=Sum('remain_quantity')).get(
            'total_quantity') or 0
        amount = querysets.aggregate(
            total_quantity=Avg('amount')).get(
            'total_quantity') or 0
        index_wight = querysets.aggregate(
            total_quantity=Avg('Index_weight')).get(
            'total_quantity') or 0
        dict1 = {
            'lenKillRequest': querysets.count(),
            'lenKillRequestHasFreeDirectBuying': querysets.filter(free_direct_buying=True).count(),
            'lenKillRequestHasntFreeDirectBuying': querysets.filter(free_direct_buying=False).count(),
            'quantity': quantity,
            'leftOver': left_over,
            'remainQuantity': quantity - left_over,
            'amount': amount,
            'indexWight': index_wight,
            'freeDirectBuyingTrueQuantity': free_direct_buying_true_quantity,
            'freeDirectBuyingFalseQuantity': free_direct_buying_false_quantity,

        }
        return Response(dict1, status=status.HTTP_200_OK)


class InputBarsForKillHouseViewSet(viewsets.ModelViewSet):
    queryset = KillHouseRequest.objects.all()
    serializer_class = KillHouseRequestForInputBarsSerializer
    permission_classes = [TokenHasReadWriteScope]
    pagination_class = CustomPagination
    filter_backends = [DjangoFilterBackend]
    filterset_class = KillHouseRequestFilterSet
    filterset_fields = [
        'killhouse_user__kill_house_operator__user__fullname',
        'killhouse_user__kill_house_operator__user__mobile',
        'province_request__poultry_request__poultry__user__fullname',
        'province_request__poultry_request__poultry__user__mobile',
        'province_request__poultry_request__order_code',
        'province_request__poultry_request__order_code',
        'bar_code',
    ]

    def list(self, request, *args, **kwargs):
        quota = request.GET.get('quota')
        if quota == 'governmental':
            quota_filter = {'province_request__poultry_request__free_sale_in_province': False}
        elif quota == 'free':
            quota_filter = {'province_request__poultry_request__free_sale_in_province': True}
        else:
            quota_filter = None
        user = SystemUserProfile.objects.get(user=request.user, trash=False)
        kill_house = KillHouse.objects.filter(kill_house_operator__user=user, trash=False).select_related(
            'system_address__province').first()

        if 'date1' in request.GET and request.GET['date1']:

            date1 = datetime.strptime(str(request.GET['date1']), '%Y-%m-%d').date()

            date2 = datetime.strptime(str(request.GET['date2']), '%Y-%m-%d').date()

            if request.GET['type'] == 'entered':

                kill_house_requests = KillHouseRequest.objects.filter(
                    Q(killhouse_user=kill_house) | Q(killer=kill_house),
                    kill_request__recive_date__date__gte=date1,
                    kill_request__recive_date__date__lte=date2,
                    ware_house_confirmation=True, trash=False, calculate_status=True).order_by(
                    '-kill_request__recive_date')
            else:

                kill_house_requests = KillHouseRequest.objects.filter(
                    Q(killhouse_user=kill_house) | Q(killer=kill_house),
                    kill_request__recive_date__date__gte=date1,
                    kill_request__recive_date__date__lte=date2,
                    ware_house_confirmation=False, non_receipt=False, trash=False, calculate_status=True).order_by(
                    '-kill_request__recive_date')
        else:

            if request.GET['type'] == 'entered':
                kill_house_requests = KillHouseRequest.objects.filter(
                    Q(killhouse_user=kill_house) | Q(killer=kill_house),
                    ware_house_confirmation=True, trash=False, calculate_status=True).order_by(
                    '-kill_request__recive_date')
            else:

                kill_house_requests = KillHouseRequest.objects.filter(
                    Q(killhouse_user=kill_house) | Q(killer=kill_house),
                    ware_house_confirmation=False, non_receipt=False, trash=False, calculate_status=True).order_by(
                    '-kill_request__recive_date')

        if quota_filter:
            kill_house_requests = kill_house_requests.filter(**quota_filter)

        if 'search' in request.GET:
            kill_house_requests_list = []
            if request.GET['search'] == 'filter':
                if request.GET['value'] != "" and request.GET['value'] != 'undefined':
                    for item in self.filterset_fields:
                        query = QueryDict('{0}__contains={1}'.format(item, request.GET['value']))
                        if (self.filterset_class(
                                data=query,
                                queryset=kill_house_requests
                        )
                        ).filter():
                            ps = self.filterset_class(data=query, queryset=kill_house_requests)
                            kill_house_requests_list = ps.filter()
                    kill_house_requests = [] if len(kill_house_requests_list) == 0 else kill_house_requests_list

        page_size = request.query_params.get('page_size', None)
        if page_size:
            self.pagination_class.page_size = int(page_size)

        page = self.paginate_queryset(kill_house_requests)
        if page is not None:
            serializer = self.serializer_class(page, many=True)
            return self.get_paginated_response(serializer.data)

        serializer = self.serializer_class(kill_house_requests, many=True)
        return Response(serializer.data, status=status.HTTP_200_OK)


class InputBarsForKillHouseDashboardViewSet(viewsets.ModelViewSet):
    queryset = KillHouseRequest.objects.all()
    serializer_class = KillHouseRequestForInputBarsSerializer
    permission_classes = [TokenHasReadWriteScope]

    def list(self, request, *args, **kwargs):
        role = request.GET.get('role')
        user = SystemUserProfile.objects.get(user=request.user, trash=False)
        if role in ('Steward', 'Guild'):
            guild = Guilds.objects.get(user=user, active=True, trash=False)
            if 'date1' in request.GET:
                date1 = datetime.strptime(str(request.GET['date1']), '%Y-%m-%d').date()
                date2 = datetime.strptime(str(request.GET['date2']), '%Y-%m-%d').date()
                allocations = StewardAllocation.objects.filter(
                    Q(to_steward=guild) | Q(to_guilds=guild), date__date__gte=date1, date__date__lte=date2,
                    trash=False, calculate_status=True, system_registration_code=True)
            else:
                allocations = StewardAllocation.objects.filter(
                    Q(to_steward=guild) | Q(to_guilds=guild),
                    trash=False, calculate_status=True, system_registration_code=True)
            entered_allocations = allocations.filter(receiver_state='accepted')
            not_entered_allocations = allocations.filter(receiver_state='pending')
            rejected_allocations = allocations.filter(receiver_state='rejected')
            total_allocations_quantity = allocations.filter(receiver_state__in=('pending', 'accepted')).aggregate(
                total=Sum('real_number_of_carcasses'))[
                                             'total'] or 0
            total_allocations_weight = allocations.filter(receiver_state__in=('pending', 'accepted')).aggregate(
                total=Sum('real_weight_of_carcasses'))[
                                           'total'] or 0
            total_entered_allocations_quantity = \
                entered_allocations.aggregate(total=Sum('real_number_of_carcasses'))['total'] or 0
            total_entered_allocations_weight = \
                entered_allocations.aggregate(total=Sum('real_weight_of_carcasses'))['total'] or 0
            total_not_entered_allocations_quantity = \
                not_entered_allocations.aggregate(total=Sum('real_number_of_carcasses'))['total'] or 0
            total_not_entered_allocations_weight = \
                not_entered_allocations.aggregate(total=Sum('real_weight_of_carcasses'))['total'] or 0

            total_rejected_allocations_quantity = \
                rejected_allocations.aggregate(total=Sum('real_number_of_carcasses'))['total'] or 0
            total_rejected_allocations_weight = \
                rejected_allocations.aggregate(total=Sum('real_weight_of_carcasses'))['total'] or 0

            result = {
                "total_bars": len(allocations),
                "total_bars_quantity": total_allocations_quantity,
                "total_bars_weight": total_allocations_weight,
                "total_entered_bars": len(entered_allocations),
                "total_entered_bars_quantity": total_entered_allocations_quantity,
                "total_entered_bars_weight": total_entered_allocations_weight,
                "total_not_entered_bars": len(not_entered_allocations),
                "total_not_entered_bars_quantity": total_not_entered_allocations_quantity,
                "total_not_entered_kill_house_requests_weight": total_not_entered_allocations_weight,
                "total_rejected_bars": len(rejected_allocations),
                "total_rejected_bars_quantity": total_rejected_allocations_quantity,
                "total_rejected_bars_weight": total_rejected_allocations_weight,
            }

        else:
            kill_house = KillHouse.objects.filter(kill_house_operator__user=user, trash=False).select_related(
                'system_address__province').first()

            kill_house_requests = KillHouseRequest.objects.filter(
                Q(killhouse_user=kill_house) | Q(killer=kill_house),
                trash=False, calculate_status=True).order_by('-kill_request__recive_date')
            entered_kill_house_requests = kill_house_requests.filter(ware_house_confirmation=True)
            not_entered_kill_house_requests = kill_house_requests.filter(ware_house_confirmation=False)
            total_kill_house_requests_quantity = kill_house_requests.aggregate(total=Sum('accepted_real_quantity'))[
                                                     'total'] or 0
            total_kill_house_requests_weight = kill_house_requests.aggregate(total=Sum('accepted_real_weight'))[
                                                   'total'] or 0
            total_entered_kill_house_requests_quantity = \
                entered_kill_house_requests.aggregate(total=Sum('accepted_real_quantity'))['total'] or 0
            total_entered_kill_house_requests_weight = \
                entered_kill_house_requests.aggregate(total=Sum('accepted_real_weight'))['total'] or 0
            total_entered_kill_house_requests_carcasses = \
                entered_kill_house_requests.aggregate(total=Sum('ware_house_accepted_real_quantity'))['total'] or 0
            total_entered_kill_house_requests_carcasses_weight = \
                entered_kill_house_requests.aggregate(total=Sum('ware_house_accepted_real_weight'))['total'] or 0
            total_not_entered_kill_house_requests_quantity = \
                not_entered_kill_house_requests.aggregate(total=Sum('accepted_real_quantity'))['total'] or 0
            total_not_entered_kill_house_requests_weight = \
                not_entered_kill_house_requests.aggregate(total=Sum('accepted_real_weight'))['total'] or 0

            result = {
                "total_bars": len(kill_house_requests),
                "total_bars_quantity": total_kill_house_requests_quantity,
                "total_bars_weight": total_kill_house_requests_weight,
                "total_entered_bars": len(entered_kill_house_requests),
                "total_entered_bars_quantity": total_entered_kill_house_requests_quantity,
                "total_entered_bars_weight": total_entered_kill_house_requests_weight,
                "total_entered_bars_carcasses": total_entered_kill_house_requests_carcasses,
                "total_entered_bars_carcasses_weight": total_entered_kill_house_requests_carcasses_weight,
                "total_not_entered_bars": len(not_entered_kill_house_requests),
                "total_not_entered_bars_quantity": total_not_entered_kill_house_requests_quantity,
                "total_not_entered_kill_house_requests_weight": total_not_entered_kill_house_requests_weight,
            }

        return Response(result, status=status.HTTP_200_OK)


class BarDifferenceRequestViewSet(viewsets.ModelViewSet):
    queryset = BarDifferenceRequest.objects.all()
    serializer_class = BarDifferenceRequestSerializer
    permission_classes = [TokenHasReadWriteScope]
    pagination_class = CustomPagination
    filter_backends = [DjangoFilterBackend]
    filterset_class = BarDifferenceRequestFilterSet
    filterset_fields = [
        'kill_house__kill_house_operator__user__fullname',
        'kill_house__kill_house_operator__user__mobile',
        'hatching__poultry__user__fullname',
        'hatching__poultry__user__mobile'
    ]

    def list(self, request, *args, **kwargs):
        user = SystemUserProfile.objects.get(user=request.user, trash=False)
        role = request.GET.get('role')
        state = request.GET.get('state')
        date1 = request.GET.get('date1')
        date2 = request.GET.get('date2')
        filters = {
            'trash': False,
        }
        if role == 'KillHouse':
            kill_house = KillHouse.objects.filter(kill_house_operator__user=user, trash=False).select_related(
                'system_address__province').first()
            filters['kill_house'] = kill_house
        if state == 'pending':
            filters['state'] = 'pending'
        else:
            filters['state__in'] = ('accepted', 'rejected')

        if date1:
            filters['create_date__date__gte'] = date1
            filters['create_date__date__lte'] = date2

        bar_requests = BarDifferenceRequest.objects.filter(**filters).order_by('-id')

        if 'search' in request.GET:
            bar_requests_list = []
            if request.GET['search'] == 'filter':
                if request.GET['value'] != "" and request.GET['value'] != 'undefined':
                    for item in self.filterset_fields:
                        query = QueryDict('{0}__contains={1}'.format(item, request.GET['value']))
                        if (self.filterset_class(
                                data=query,
                                queryset=bar_requests
                        )
                        ).filter():
                            ps = self.filterset_class(data=query, queryset=bar_requests)
                            bar_requests_list = ps.filter()
                    bar_requests = [] if len(bar_requests_list) == 0 else bar_requests_list

        page_size = request.query_params.get('page_size', None)
        if page_size:
            self.pagination_class.page_size = int(page_size)

        page = self.paginate_queryset(bar_requests)
        if page is not None:
            serializer = self.serializer_class(page, many=True)
            return self.get_paginated_response(serializer.data)

        serializer = self.serializer_class(bar_requests, many=True)
        return Response(serializer.data, status=status.HTTP_200_OK)

    def create(self, request, *args, **kwargs):
        user = SystemUserProfile.objects.get(user=request.user, trash=False)
        hatching = PoultryHatching.objects.get(key=request.data['hatching_key'], trash=False)
        kill_house = KillHouse.objects.get(key=request.data['kill_house_key'], trash=False)
        images = None
        acceptor_images = None
        request.data.pop('hatching_key')
        request.data.pop('kill_house_key')
        if 'images' in request.data.keys():
            images = request.data['images']
            request.data.pop('images')

        if 'acceptor_images' in request.data.keys():
            acceptor_images = request.data['acceptor_images']
            request.data.pop('acceptor_images')
        image_list = []
        acceptor_image_list = []
        serializer = self.serializer_class(data=request.data)
        if serializer.is_valid():
            bar_request = serializer.create(validated_data=request.data)
            bar_request.hatching = hatching
            bar_request.kill_house = kill_house
            bar_request.register_fullname = user.fullname
            bar_request.register_mobile = user.mobile
            bar_request.weight = int(bar_request.quantity) * bar_request.hatching.poultry.real_killing_ave_weight

            if images != None:
                for image in images:
                    image_list.append(send_image_to_server(image))

                bar_request.violation_image = image_list

            if acceptor_images != None:
                for acceptor_image in acceptor_images:
                    acceptor_image_list.append(send_image_to_server(acceptor_image))

                bar_request.acceptor_image = acceptor_image_list

            bar_request.save()
            send_sms_for_bar_difference_request(kill_house.kill_house_operator.user.mobile, request.data['quantity'],
                                                hatching.poultry.unit_name)
            send_ticket_for_bar_difference_request(user, kill_house.kill_house_operator.user, request.data['quantity'],
                                                   hatching.poultry.unit_name)
            serializer_request = self.serializer_class(bar_request)
            return Response(serializer_request.data, status=status.HTTP_201_CREATED)
        return Response(serializer.errors)

    def update(self, request, pk=None, *args, **kwargs):
        bar_request = BarDifferenceRequest.objects.get(key=request.data['bar_key'])
        request.data.pop('bar_key')
        if 'kill_house_check' in request.data.keys():
            request.data.pop('kill_house_check')
            if request.data['state'] == 'accepted':
                user = SystemUserProfile.objects.get(user=request.user, trash=False)
                bar_request.acceptor_fullname = user.fullname
                bar_request.acceptor_mobile = user.mobile
                bar_request.acceptor_date = datetime.now()
                # bar_request.weight = bar_request.quantity * bar_request.hatching.poultry.real_killing_ave_weight
                bar_request.hatching.bar_difference_request_quantity += bar_request.quantity
                bar_request.hatching.bar_difference_request_weight += bar_request.weight
                bar_request.hatching.save()
                bar_request.save()

        if 'images' in request.data.keys():
            images = request.data['images']
            request.data.pop('images')
            image_list = []
            if images != None:
                for image in images:
                    image_list.append(send_image_to_server(image))

                bar_request.violation_image = image_list
        if 'acceptor_images' in request.data.keys():
            acceptor_images = request.data['acceptor_images']
            request.data.pop('acceptor_images')
            acceptor_images_list = []
            if acceptor_images != None:
                for acceptor_image in acceptor_images:
                    acceptor_images_list.append(send_image_to_server(acceptor_image))

                bar_request.acceptor_image = acceptor_images_list
        serializer = self.serializer_class(bar_request)
        serializer.update(instance=bar_request, validated_data=request.data)
        return Response(serializer.data, status=status.HTTP_200_OK)

    def destroy(self, request, pk=None, *args, **kwargs):
        bar_request = BarDifferenceRequest.objects.get(key=request.GET['bar_key'], trash=False)
        if bar_request.state == 'accepted':
            bar_request.hatching.bar_difference_request_quantity -= bar_request.quantity
            bar_request.hatching.bar_difference_request_weight -= bar_request.weight
            bar_request.hatching.save()
        bar_request.trash = True
        bar_request.save()
        return Response({"result": "با موفقیت حذف شد."},
                        status=status.HTTP_200_OK)


@api_view(["GET"])
@csrf_exempt
@permission_classes([AllowAny])
def get_hatching_kill_ingo(request):
    hatching = PoultryHatching.objects.get(key=request.GET['hatching_key'])
    kill_house = KillHouse.objects.get(key=request.GET['kill_house_key'])

    total_quantity = 0
    total_weight = 0
    Province_kill_requests = ProvinceKillRequest.objects.filter(killhouse_user=kill_house, trash=False,
                                                                state__in=('pending', 'accepted'),
                                                                return_to_province=False,
                                                                province_request__poultry_request__hatching=hatching)
    first_total_quantity = \
        Province_kill_requests.aggregate(total=Sum('main_quantity'))[
            'total'] or 0

    total_quantity = \
        Province_kill_requests.aggregate(total=Sum('total_killed_quantity'))[
            'total'] or 0
    total_weight = \
        Province_kill_requests.aggregate(total=Sum('total_killed_weight'))[
            'total'] or 0

    difference_quantity = first_total_quantity - total_quantity
    # kill_house_requests = KillHouseRequest.objects.filter(Q(killhouse_user=obj.kill_house) | Q(killer=obj.kill_house),trash=False,
    #                                                       province_request__poultry_request__hatching=obj.hatching)
    #
    #
    # total_quantity +=\
    # kill_house_requests.aggregate(total=Sum('accepted_real_quantity'))[
    #     'total'] or 0
    # total_weight +=\
    # kill_house_requests.aggregate(total=Sum('accepted_real_weight'))[
    #     'total'] or 0

    result = {
        "first_total_quantity": first_total_quantity,
        "total_quantity": total_quantity,
        "difference_quantity": difference_quantity,
        "total_weight": total_weight,
    }

    return Response(result,
                    status=status.HTTP_200_OK)


@api_view(["GET"])
@csrf_exempt
@permission_classes([TokenHasReadWriteScope])
def dashboard_monitoring_bar_and_killing(request):
    now = datetime.now().date()
    date1 = datetime.strptime(str(request.GET['date1']), '%Y-%m-%d').date() if 'date1' in request.GET else now
    date2 = datetime.strptime(str(request.GET['date2']), '%Y-%m-%d').date() if 'date1' in request.GET else now
    kill_house_free_bar = KillHouseFreeBarInformation.objects.filter(Q(date__date__gte=date1,
                                                                       date__date__lte=date2,
                                                                       buy_type='carcass') | Q(
        create_date__date__gte=date1, create_date__date__lte=date2, buy_type='live'),
                                                                     trash=False,
                                                                     archive_wage=False,
                                                                     ).only(
        'quantity',
        'live_weight',
        'number_of_carcasses',
        'weight_of_carcasses',
        'send_date',
        'type',
        'out'
    )

    kill_house_free_bar_aggregates = kill_house_free_bar.aggregate(
        total_quantity_live=Sum('quantity', filter=Q(buy_type='live')),
        total_weight_live=Sum('live_weight', filter=Q(buy_type='live')),
        total_count=Count('id', filter=Q(buy_type='live')),
        total_weight=Sum('weight_of_carcasses', filter=Q(buy_type='live')),
        total_count_carcass=Count('id', filter=Q(buy_type='carcass')),
        total_weight_carcass=Sum('weight_of_carcasses', filter=Q(buy_type='carcass')),
        total_quantity_carcass=Sum('number_of_carcasses', filter=Q(buy_type='carcass')),

    )

    if kill_house_free_bar_aggregates['total_quantity_live'] != 0:
        ratio = round(
            ((kill_house_free_bar_aggregates['total_weight_live'] or 0) / (
                    kill_house_free_bar_aggregates['total_quantity_live']
                    or 0))
            , 1) if (kill_house_free_bar_aggregates['total_quantity_live'] or 0) > 0 else 0
    else:
        ratio = 0

    province_kill_request = ProvinceKillRequest.objects.filter(state__in=('pending', 'accepted'),
                                                               wage_pay=False,
                                                               archive_wage=False,
                                                               return_to_province=False,
                                                               trash=False,
                                                               kill_request__recive_date__date__gte=date1,
                                                               kill_request__recive_date__date__lte=date2). \
        select_related('province_request__poultry_request').only(
        'total_killed_quantity',
        'province_request__poultry_request__Index_weight',
    )

    province_kill_request_aggregates = province_kill_request.aggregate(
        total_count=Count('id', filter=Q(first_car_allocated_quantity=0)),
        total_quantity=Sum('total_killed_quantity', filter=Q(first_car_allocated_quantity=0)),
        total_index_weight=Avg('province_request__poultry_request__Index_weight',
                               filter=Q(first_car_allocated_quantity=0)),
        total_count_new=Count('id'),
        total_quantity_new=Sum('total_killed_quantity'),
        total_weight_new=Sum('total_killed_weight'),
        total_index_weight_new=Avg('province_request__poultry_request__Index_weight'),

    )

    poultry_request = PoultryRequest.objects.filter(
        trash=False,
        state_process__in=('pending', 'accepted'),
        province_state__in=('pending', 'accepted'),
        out_province_request_cancel=False,
        temporary_trash=False,
        temporary_deleted=False, send_date__date__gte=date1,
        send_date__date__lte=date2
    ).only(
        'quantity',
        'Index_weight',
    ).annotate(
        item_weight=F('Index_weight') * F('quantity')
    )

    poultry_request_aggregates = poultry_request.aggregate(
        total_count=Count('id', filter=Q(out=True)),
        total_quantity=Sum('quantity', filter=Q(out=True)),
        total_ave_weight=Avg('Index_weight', filter=Q(out=True)),
        total_weight=Sum('item_weight', filter=Q(out=True)),
        total_count_killing=Count('id'),
        total_quantity_killing=Sum('quantity'),
        total_ave_weight_killing=Avg('Index_weight'),
        total_weight_killing=Sum('item_weight')
    )

    kill_house_request = KillHouseRequest.objects.filter(
        trash=False,
        temporary_trash=False,
        temporary_deleted=False, kill_request__recive_date__date__gte=date1,
        kill_request__recive_date__date__lte=date2
    ).select_related('province_kill_request__province_request__poultry_request__Index_weight').only(
        'quantity',
        'province_kill_request__province_request__poultry_request__Index_weight',
        'accepted_real_weight',
        'accepted_real_quantity',
    )

    kill_house_request_aggregates = kill_house_request.aggregate(
        total_count=Count('id'),
        total_quantity=Sum('accepted_real_quantity'),
        total_quantity_has_quarantine=Sum('accepted_real_quantity', filter=Q(quarantine_quantity__gt=0)),
        total_count_has_quarantine=Count('id', filter=Q(quarantine_quantity__gt=0)),
        total_weight=Sum('accepted_real_weight'),
        total_ave_weight=Avg('province_kill_request__province_request__poultry_request__Index_weight'),
        total_ave_age=Avg('province_kill_request__province_request__poultry_request__hatching__chicken_age'),
        total_quarantine=Count('id', filter=Q(quarantine_quantity__gt=0)),
        total_quarantine_quantity=Sum('quarantine_quantity', filter=Q(quarantine_quantity__gt=0)),
        total_quarantine_discharge_confirmation=Count('id', filter=Q(quarantine_quantity__gt=0,
                                                                     assignment_state_archive='True')),
        total_quarantine_discharge_confirmation_quantity=Sum('accepted_real_quantity',
                                                             filter=Q(quarantine_quantity__gt=0,
                                                                      assignment_state_archive='True')),

    )

    province_request_count = province_kill_request_aggregates['total_count_new'] or 0
    province_request_quantity = province_kill_request_aggregates['total_quantity_new'] or 0
    province_request_weight = province_kill_request_aggregates['total_weight_new'] or 0
    total_free_sell_count = kill_house_free_bar_aggregates['total_count'] or 0
    total_free_sell_quantity = kill_house_free_bar_aggregates['total_quantity_live'] or 0
    total_free_sell_weight = kill_house_free_bar_aggregates['total_weight_live'] or 0
    avgWeight = round(
        (province_request_weight + total_free_sell_weight) / (province_request_quantity + total_free_sell_quantity),
        1) if (province_request_quantity + total_free_sell_quantity) > 0 else 0

    result_dict = {
        'freeLiveBar': {
            'count': kill_house_free_bar_aggregates['total_count'] or 0,
            'quantity': kill_house_free_bar_aggregates['total_quantity_live'] or 0,
            'weight': kill_house_free_bar_aggregates['total_weight_live'] or 0,
            'weightCarcass': kill_house_free_bar_aggregates['total_weight_carcass'] or 0,
            'avgWeight': ratio,
        },
        'provinceKillRequestWithoutBar': {
            'count': province_kill_request_aggregates['total_count'] or 0,
            'quantity': province_kill_request_aggregates['total_quantity'] or 0,
            'indexWeight': round((province_kill_request_aggregates['total_index_weight'] or 0), 1),
        },
        'outLiveBar': {
            'count': poultry_request_aggregates['total_count'] or 0,
            'quantity': poultry_request_aggregates['total_quantity'] or 0,
            'weight': poultry_request_aggregates['total_weight'] or 0,
            'avgWeight': round((poultry_request_aggregates['total_ave_weight'] or 0), 1),

        },
        'bar': {
            'count': kill_house_request_aggregates['total_count'] or 0,
            'count_has_quarantine': kill_house_request_aggregates['total_count_has_quarantine'] or 0,
            'quantity': kill_house_request_aggregates['total_quantity'] or 0,
            'quantity_has_quarantine': kill_house_request_aggregates['total_quantity_has_quarantine'] or 0,
            'weight': kill_house_request_aggregates['total_weight'] or 0,
            'avgWeight': round((kill_house_request_aggregates['total_ave_weight'] or 0), 1),
            'avgAge': int(kill_house_request_aggregates['total_ave_age'] or 0),

            'total_quarantine': kill_house_request_aggregates['total_quarantine'] or 0,
            'total_quarantine_quantity': kill_house_request_aggregates['total_quarantine_quantity'] or 0,
            'total_quarantine_discharge_confirmation': kill_house_request_aggregates[
                                                           'total_quarantine_discharge_confirmation'] or 0,
            'total_quarantine_discharge_confirmation_quantity': kill_house_request_aggregates[
                                                                    'total_quarantine_discharge_confirmation_quantity'] or 0,

        },
        'killingInfo': {
            'count': province_request_count + total_free_sell_count,
            'quantity': province_request_quantity + total_free_sell_quantity,
            'weight': province_request_weight + total_free_sell_weight,
            'avgWeight': avgWeight,
        },
        'buyFreeCarcasses': {
            'count': kill_house_free_bar_aggregates['total_count_carcass'] or 0,
            'quantity': kill_house_free_bar_aggregates['total_quantity_carcass'] or 0,
            'weight': kill_house_free_bar_aggregates['total_weight_carcass'] or 0,
        }

    }
    return Response(result_dict, status=status.HTTP_200_OK)


@api_view(["GET"])
@csrf_exempt
@permission_classes([TokenHasReadWriteScope])
def dashboarad_bar_for_kill_house(request):
    filterset_class = KillHouseRequestFilterSet
    filterset_fields = [
        'killhouse_user__kill_house_operator__user__fullname',
        'killhouse_user__kill_house_operator__user__mobile',
        'province_request__poultry_request__poultry__user__fullname',
        'province_request__poultry_request__poultry__user__mobile',
        'province_request__poultry_request__order_code',
        'province_request__poultry_request__order_code',
        'bar_code',
    ]
    user = SystemUserProfile.objects.get(user=request.user)
    kill_house = KillHouse.objects.filter(kill_house_operator__user=user, trash=False).first()
    kill_house_requests = KillHouseRequest.objects.filter(
        (Q(killhouse_user=kill_house) | Q(
            kill_request__slaughter_house=kill_house) | Q(killer=kill_house)),
        (Q(trash=False) | Q(trash=True, clearance_code__isnull=False, temporary_trash=False,
                            temporary_deleted=False)),

        province_request__poultry_request__poultry__address__province=user.province,
    ).select_related('kill_request')
    if 'date1' in request.GET and 'date2' in request.GET:
        date1 = datetime.strptime(str(request.GET['date1']), '%Y-%m-%d').date()
        date2 = datetime.strptime(str(request.GET['date2']), '%Y-%m-%d').date()
        kill_house_requests = kill_house_requests.filter(
            kill_request__recive_date__date__gte=date1,
            kill_request__recive_date__date__lte=date2)

    if 'search' in request.GET:
        kill_house_request_list = []
        if request.GET['search'] == 'filter':
            if request.GET['value'] != "" and request.GET['value'] != 'undefined':
                for item in filterset_fields:
                    query = QueryDict('{0}__contains={1}'.format(item, request.GET['value']))
                    if (filterset_class(
                            data=query,
                            queryset=kill_house_requests
                    )
                    ).filter():
                        ps = filterset_class(data=query, queryset=kill_house_requests)
                        kill_house_request_list = ps.filter()
                kill_house_requests = [] if len(kill_house_request_list) == 0 else kill_house_request_list
    kill_house_requests_aggregate = kill_house_requests.aggregate(
        first_quantity=Sum('quantity'),
        first_weight=Sum('quantity') * Avg('province_request__poultry_request__Index_weight'),
        first_index_weight=Avg('province_request__poultry_request__Index_weight'),
        accepted_real_quantity=Sum('accepted_real_quantity'),
        accepted_real_weight=Sum('accepted_real_weight'),
        assignment_state_archive_pending=Count('id', filter=Q(assignment_state_archive='pending')),
        assignment_state_archive_accepted=Count('id', filter=Q(assignment_state_archive='accepted')),
        clearance_code_count=Count('id', filter=Q(clearance_code__isnull=False)),

    )

    result_dict = {
        'count': kill_house_requests.count(),
        'firstQuantity': kill_house_requests_aggregate['first_quantity'] or 0,
        'firstWeight': int(kill_house_requests_aggregate['first_weight'] or 0),
        'firstIndexWeight': round((kill_house_requests_aggregate['first_index_weight'] or 0), 1),
        'acceptedRealQuantity': kill_house_requests_aggregate['accepted_real_quantity'] or 0,
        'acceptedRealWeight': int(kill_house_requests_aggregate['accepted_real_weight'] or 0),
        'finalIndexWeight': round((kill_house_requests_aggregate['accepted_real_weight'] or 0) /
                                  (kill_house_requests_aggregate['accepted_real_quantity'] or 0), 1)
        if (kill_house_requests_aggregate['accepted_real_quantity'] or 0) > 0 else 0,
        'assignmentStateArchivePending': kill_house_requests_aggregate['assignment_state_archive_pending'] or 0,
        'assignmentStateArchiveAccepted': kill_house_requests_aggregate['assignment_state_archive_accepted'] or 0,
        'clearanceCodeCount': kill_house_requests_aggregate['clearance_code_count'] or 0,

    }
    return Response(result_dict, status=status.HTTP_200_OK)


@api_view(["GET"])
@csrf_exempt
@permission_classes([TokenHasReadWriteScope])
def dashboard_bar_difference_request(request):
    filterset_class = BarDifferenceRequestFilterSet
    filterset_fields = [
        'kill_house__kill_house_operator__user__fullname',
        'kill_house__kill_house_operator__user__mobile',
        'hatching__poultry__user__fullname',
        'hatching__poultry__user__mobile'
    ]
    user = SystemUserProfile.objects.get(user=request.user, trash=False)
    # if request.GET['role'] == 'KillHouse':
    #     kill_house = KillHouse.objects.filter(kill_house_operator__user=user, trash=False).select_related(
    #         'system_address__province').first()
    #     if request.GET['state'] == 'pending':
    #         bar_requests = BarDifferenceRequest.objects.filter(kill_house=kill_house, trash=False,
    #                                                            state='pending').order_by('id')
    #     else:
    #         bar_requests = BarDifferenceRequest.objects.filter(kill_house=kill_house, trash=False,
    #                                                            state__in=('accepted', 'rejected')).order_by('id')
    # else:
    #     if request.GET['state'] == 'pending':
    #         bar_requests = BarDifferenceRequest.objects.filter(trash=False, state='pending').order_by('id')
    #     else:
    #         bar_requests = BarDifferenceRequest.objects.filter(trash=False,
    #                                                            state__in=('accepted', 'rejected')).order_by('id')

    role = request.GET.get('role')
    state = request.GET.get('state')
    date1 = request.GET.get('date1')
    date2 = request.GET.get('date2')
    filters = {
        'trash': False,
    }
    if role == 'KillHouse':
        kill_house = KillHouse.objects.filter(kill_house_operator__user=user, trash=False).select_related(
            'system_address__province').first()
        filters['kill_house'] = kill_house
    if state == 'pending':
        filters['state'] = 'pending'
    else:
        filters['state__in'] = ('accepted', 'rejected')

    if date1:
        filters['create_date__date__gte'] = date1
        filters['create_date__date__lte'] = date2

    bar_requests = BarDifferenceRequest.objects.filter(**filters).order_by('-id')

    if 'search' in request.GET:
        bar_requests_list = []
        if request.GET['search'] == 'filter':
            if request.GET['value'] != "" and request.GET['value'] != 'undefined':
                for item in filterset_fields:
                    query = QueryDict('{0}__contains={1}'.format(item, request.GET['value']))
                    if (filterset_class(
                            data=query,
                            queryset=bar_requests
                    )
                    ).filter():
                        ps = filterset_class(data=query, queryset=bar_requests)
                        bar_requests_list = ps.filter()
                bar_requests = [] if len(bar_requests_list) == 0 else bar_requests_list

    serializer = BarDifferenceRequestSerializer(bar_requests, many=True)

    bar_info_list = [item['bar_info'] for item in serializer.data]

    difference_quantity = sum(item["first_total_quantity"] for item in bar_info_list) - \
                          sum(item["total_quantity"] for item in bar_info_list)

    bar_requests_aggregate = bar_requests.aggregate(
        count=Count('id'),
        weight=Sum('weight'),
        quantity=Sum('quantity'),
    )

    result_dict = {
        'count': bar_requests_aggregate['count'] or 0,
        'weight': bar_requests_aggregate['weight'] or 0,
        'quantity': bar_requests_aggregate['quantity'] or 0,
        "firstTotalQuantity": sum(item["first_total_quantity"] for item in bar_info_list),
        "totalQuantity": sum(item["total_quantity"] for item in bar_info_list),
        "differenceQuantity": difference_quantity,
        "totalWeight": sum(item["total_weight"] for item in bar_info_list),
    }

    return Response(result_dict, status=status.HTTP_200_OK)


class KillHousePerformanceDashboardViewSet(APIView):
    permission_classes = [TokenHasReadWriteScope]

    def get(self, request):
        date1 = request.GET.get('date1')
        date2 = request.GET.get('date2')
        kill_house_ids = KillHousePercentage.objects.filter(kill_house__type='exclusive', trash=False).values_list(
            'kill_house', flat=True)
        kill_houses = KillHouse.objects.filter(out_province=False, trash=False).exclude(id__in=kill_house_ids).order_by(
            'id')

        serializer = KillHouseForPerformanceDashboardSerializer(kill_houses, many=True,
                                                                context={'date1': date1, 'date2': date2, })
        return Response(serializer.data, status=status.HTTP_200_OK)


class NonReceiptKillHouseRequestViewSet(viewsets.ModelViewSet):
    queryset = KillHouseRequest.objects.all()
    permission_classes = [TokenHasReadWriteScope]
    serializer_class = KillHouseRequestForBarManagementSerializer
    pagination_class = CustomPagination
    filter_backends = [DjangoFilterBackend]
    filterset_class = KillHouseRequestFilterSet
    filterset_fields = [
        'killhouse_user__kill_house_operator__user__fullname',
        'killhouse_user__kill_house_operator__user__mobile',
        'province_request__poultry_request__poultry__user__fullname',
        'province_request__poultry_request__poultry__user__mobile',
        'province_request__poultry_request__order_code',
        'province_request__poultry_request__order_code',
        'bar_code',
    ]

    def list(self, request, *args, **kwargs):
        user = SystemUserProfile.objects.get(user=request.user)
        date1 = datetime.strptime(str(request.GET['date1']), '%Y-%m-%d').date()
        date2 = datetime.strptime(str(request.GET['date2']), '%Y-%m-%d').date()
        kill_house = []
        kill_house_requests_list = []
        if request.GET['role'] == 'KillHouse':
            kill_house = KillHouse.objects.filter(kill_house_operator__user=user, trash=False)

        elif request.GET['role'] == 'KillHouseVet':
            kill_house_vets = KillHouseVet.objects.filter(vet__user=user, trash=False).select_related('kill_house')
            for kill_house_vet in kill_house_vets:
                kill_house.append(kill_house_vet.kill_house)

        else:
            kill_house = KillHouse.objects.filter(system_address__province=user.province, trash=False)

        if request.GET['role'] in ['CityOperator', 'CityJahad', 'CityPoultry']:
            if request.GET['role'] == 'CityOperator':
                city_operator = CityOperator.objects.get(user=user, trash=False)
                kill_house_requests = KillHouseRequest.objects.filter(
                    (Q(killhouse_user__in=kill_house) | Q(kill_request__slaughter_house__in=kill_house)),
                    kill_request__recive_date__date__gte=date1,
                    kill_request__recive_date__date__lte=date2,
                    main_non_receipt=True,
                    non_receipt=True,
                    province_request__poultry_request__poultry__city_operator=city_operator.unit_name,

                ).order_by('-kill_request__recive_date')
            else:
                kill_house_requests = KillHouseRequest.objects.filter(
                    (Q(killhouse_user__in=kill_house) | Q(kill_request__slaughter_house__in=kill_house)),
                    kill_request__recive_date__date__gte=date1,
                    kill_request__recive_date__date__lte=date2,
                    main_non_receipt=True,
                    non_receipt=True,
                    province_request__poultry_request__poultry__address__city=user.city

                ).order_by('-kill_request__recive_date')

        else:

            kill_house_requests = KillHouseRequest.objects.filter(
                (Q(killhouse_user__in=kill_house) | Q(kill_request__slaughter_house__in=kill_house) | Q(
                    killer__in=kill_house)),
                kill_request__recive_date__date__gte=date1,
                kill_request__recive_date__date__lte=date2,
                main_non_receipt=True,
                non_receipt=True

            ).order_by('-kill_request__recive_date')

        if 'search' in request.GET:
            if request.GET['search'] == 'filter':
                if request.GET['value'] != "" and request.GET['value'] != 'undefined':
                    for item in self.filterset_fields:
                        query = QueryDict('{0}__contains={1}'.format(item, request.GET['value']))
                        if (self.filterset_class(
                                data=query,
                                queryset=kill_house_requests
                        )
                        ).filter():
                            ps = self.filterset_class(data=query, queryset=kill_house_requests)
                            kill_house_requests_list = ps.filter()
                    kill_house_requests = [] if len(kill_house_requests_list) == 0 else kill_house_requests_list

        page_size = request.query_params.get('page_size', None)
        if page_size:
            self.pagination_class.page_size = int(page_size)

        page = self.paginate_queryset(kill_house_requests)
        if page is not None:
            serializer = self.serializer_class(page, many=True)
            return self.get_paginated_response(serializer.data)

        serializer = self.serializer_class(kill_house_requests, many=True)
        return Response(serializer.data, status=status.HTTP_200_OK)

    def update(self, request, *args, **kwargs):
        user = SystemUserProfile.objects.get(user=request.user, trash=False)
        now = datetime.now()
        role = request.data.get('role')
        message = request.data.get('message')
        state = request.data.get('state')
        key = request.data.get('key')
        kill_house_request = KillHouseRequest.objects.get(key=key)
        if kill_house_request.assignment_state_archive == 'True':
            return Response({"result": "به دلیل وارد کردن اطلاعات بار امکان ثبت عدم وصول وجود ندارد!"},
                            status=status.HTTP_403_FORBIDDEN)

        kill_house_request.non_receipt_state = state
        kill_house_request.message = message
        kill_house_request.bar_remover = {
            "full_name": user.fullname,
            "role": role,
            "mobile": user.mobile,
            "date": str(now)
        }
        kill_house_request.trash = True if state == 'accepted' else False
        kill_house_request.save()
        if state == 'accepted':
            update_kill_house_requests(kill_house_request.province_kill_request,
                                       kill_house_request.province_request.poultry_request)
            update_province_kill_requests(kill_house_request.province_request.poultry_request.hatching)

        return Response({"result": "با موفقیت انجام شد."}, status=status.HTTP_200_OK)


class ReturnNonReceiptKillHouseRequestViewSet(viewsets.ModelViewSet):
    queryset = KillHouseRequest.objects.all()
    permission_classes = [TokenHasReadWriteScope]
    serializer_class = KillHouseRequestForBarManagementSerializer

    def update(self, request, *args, **kwargs):
        key = request.data.get('key')
        kill_house_request = KillHouseRequest.objects.get(key=key)
        trash = kill_house_request.trash
        if kill_house_request.non_receipt_return:
            return Response({"result": "عدم وصول برای این بار قبلا ثبت و لغو گردیده!"})
        kill_house_request.trash = False
        kill_house_request.non_receipt = request.data['non_receipt']
        kill_house_request.non_receipt_return = request.data['non_receipt_return']
        kill_house_request.non_receipt_return_message = request.data['non_receipt_return_message']
        kill_house_request.save()
        if trash:
            update_kill_house_requests(kill_house_request.province_kill_request,
                                       kill_house_request.province_request.poultry_request)
            update_province_kill_requests(kill_house_request.province_request.poultry_request.hatching)

        return Response({"result": "با موفقیت ثبت شد"}, status=status.HTTP_200_OK)


class DirectBuyingPaymentViewSet(viewsets.ModelViewSet):
    queryset = DirectBuyingPayment.objects.all()
    serializer_class = DirectBuyingPaymentSerializer
    permission_classes = [TokenHasReadWriteScope]
    pagination_class = CustomPagination
    filter_backends = [DjangoFilterBackend]
    filterset_class = DirectBuyingPaymentFilterSet
    filterset_fields = [

        'province_kill_request__kill_request__kill_house__name',
        'province_kill_request__kill_request__kill_house__kill_house_operator__user__fullname',
        'province_kill_request__kill_request__kill_house__kill_house_operator__user__first_name',
        'province_kill_request__kill_request__kill_house__kill_house_operator__user__last_name',
        'province_kill_request__kill_request__kill_house__kill_house_operator__user__mobile',

    ]

    def create(self, request, *args, **kwargs):
        user = SystemUserProfile.objects.get(user=request.user, trash=False)
        province_kill_request = ProvinceKillRequest.objects.get(key=request.data['province_kill_request_key'])
        now = datetime.now()
        image = request.data.pop('image', None)
        request.data.pop('province_kill_request_key')
        serializer = self.serializer_class(data=request.data)
        if serializer.is_valid():
            payment = serializer.create(validated_data=request.data)
            payment.province_kill_request = province_kill_request
            payment.date = now
            payment.payment_registrar = user.fullname
            payment.payment_registrar_mobile = user.mobile
            payment.image = send_image_to_server(image)
            payment.save()

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

    def list(self, request, *args, **kwargs):
        province_kill_request = ProvinceKillRequest.objects.get(key=request.GET['province_kill_request_key'])
        filter = {'trash': False, 'province_kill_request': province_kill_request}
        date1 = request.GET.get('date1')
        date2 = request.GET.get('date2')
        if date1:
            filter['date1'] = datetime.strptime(str(date1), '%Y-%m-%d').date()
            filter['date2'] = datetime.strptime(str(date2), '%Y-%m-%d').date()
        payments = DirectBuyingPayment.objects.filter(**filter)

        if 'search' in request.GET:
            payments_list = []
            if request.GET['search'] == 'filter':
                if request.GET['value'] != "" and request.GET['value'] != 'undefined':
                    for item in self.filterset_fields:
                        query = QueryDict('{0}__contains={1}'.format(item, request.GET['value']))
                        if (self.filterset_class(
                                data=query,
                                queryset=payments
                        )
                        ).filter():
                            ps = self.filterset_class(data=query, queryset=payments)
                            payments_list = ps.filter()
                    payments = [] if len(
                        payments_list) == 0 else payments_list

        if request.GET.get('page'):

            page_size = request.query_params.get('page_size', None)
            if page_size:
                self.pagination_class.page_size = int(page_size)

            page = self.paginate_queryset(payments)
            if page is not None:
                serializer = self.serializer_class(page, many=True)
                return self.get_paginated_response(serializer.data)

        serializer = self.serializer_class(payments, many=True)
        return Response(serializer.data, status=status.HTTP_200_OK)

    def update(self, request, pk=None, *args, **kwargs):
        payment = DirectBuyingPayment.objects.get(key=request.data['key'])
        image = request.data.pop('image', None)
        if image:
            payment.image = send_image_to_server(image)
            payment.save()
        serializer = self.serializer_class(payment)
        serializer.update(instance=payment, validated_data=request.data)

        return Response(serializer.data, status=status.HTTP_200_OK)

    def destroy(self, request, pk=None, *args, **kwargs):
        payment = DirectBuyingPayment.objects.get(key=request.GET['key'])
        payment.trash = True
        payment.save()
        return Response({"result": "بار با موفقیت حذف شد !"}, status=status.HTTP_200_OK)


class ProvinceKillRequestDirectBuyingViewSet(viewsets.ModelViewSet):
    queryset = ProvinceKillRequest.objects.all()
    serializer_class = ProvinceKillRequestForDirectBuyingSerializer
    pagination_class = CustomPagination
    permission_classes = [TokenHasReadWriteScope]
    filter_backends = [DjangoFilterBackend]
    filterset_class = ProvinceKillRequestFilterSet
    filterset_fields = [
        'province_request__poultry_request__chicken_breed',
        'province_request__poultry_request__order_code',
        'province_request__poultry_request__poultry__address__city__name',
        'province_request__poultry_request__poultry__user__mobile',
        'province_request__poultry_request__poultry__user__fullname',

    ]

    def list(self, request, *args, **kwargs):
        user = SystemUserProfile.objects.get(user=request.user, trash=False)
        date1 = request.GET.get('date1')
        date2 = request.GET.get('date2')
        role = request.GET.get('role')
        state = request.GET.get('status')
        filter = {
            'trash': False,
            'payment_deadline': True,
            'return_to_province': False,
            'payment_deadline_archive': False if state == 'active' else True,
        }
        if date1:
            filter['kill_request__recive_date__date__gte'] = datetime.strptime(date1, '%Y-%m-%d').date()
            filter['kill_request__recive_date__date__lte'] = datetime.strptime(date2, '%Y-%m-%d').date()
        if role == 'KillHouse':
            kill_house = KillHouse.objects.filter(kill_house_operator__user=user).first()
            filter['killhouse_user'] = kill_house

        elif role in ('CityJahad', 'CityOperator', 'CityCommerce', 'CityVet', 'CitySupervisor', 'CityPoultry'):
            filter['kill_request__poultry__address__city'] = user.city

        province_kill_requests = ProvinceKillRequest.objects.filter(**filter).select_related('kill_request',
                                                                                             'kill_request__poultry_hatching',
                                                                                             'kill_request__poultry').only(
            'kill_request', 'kill_request__poultry_hatching', 'kill_request__poultry').order_by('payment_deadline_date')

        if 'search' in request.GET:
            province_kill_requests_list = []
            if request.GET['search'] == 'filter':
                if request.GET['value'] != "" and request.GET['value'] != 'undefined':
                    for item in self.filterset_fields:
                        query = QueryDict('{0}__contains={1}'.format(item, request.GET['value']))
                        if (self.filterset_class(
                                data=query,
                                queryset=province_kill_requests
                        )
                        ).filter():
                            ps = self.filterset_class(data=query, queryset=province_kill_requests)
                            province_kill_requests_list = ps.filter()
                    province_kill_requests = [] if len(
                        province_kill_requests_list) == 0 else province_kill_requests_list

        page_size = request.query_params.get('page_size', None)
        if page_size:
            self.pagination_class.page_size = int(page_size)

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

        serializer = self.get_serializer(province_kill_requests, many=True)
        return Response(serializer.data, status=status.HTTP_200_OK)

    def update(self, request, pk=None, *args, **kwargs):
        user = SystemUserProfile.objects.get(user=request.user, trash=False)
        province_kill_request = ProvinceKillRequest.objects.get(key=request.data['key'])
        check = request.data.pop('check', None)
        archive = request.data.pop('archive', None)
        if 'final_accept' in request.data.keys():
            role = request.data.pop('role', None)
            if request.data['final_accept'] == True:
                province_kill_request.payment_deadline_state = 'checking' if role == 'KillHouse' else 'accepted'
                province_kill_request.final_accept_registrar = user.fullname
                province_kill_request.final_accept_registrar_mobile = user.mobile
                province_kill_request.final_accept_date = datetime.now()
                if role != 'KillHouse':
                    province_kill_request.payment_deadline_checker_fullname = user.fullname
                    province_kill_request.payment_deadline_checker_mobile = user.mobile
                    province_kill_request.payment_deadline_check_date = datetime.now()
                    province_kill_request.payment_deadline_archive_message = 'تایید و تسویه کامل'
                    province_kill_request.payment_deadline_archive = True
                province_kill_request.save()
        if check:
            state = request.data.pop('state', None)
            province_kill_request.payment_deadline_checker_fullname = user.fullname
            province_kill_request.payment_deadline_checker_mobile = user.mobile
            province_kill_request.payment_deadline_check_date = datetime.now()
            province_kill_request.payment_deadline_archive = True if state == 'accepted' else False
            province_kill_request.payment_deadline_state = state

            if province_kill_request.payment_deadline_state == 'rejected':
                province_kill_request.final_accept = False
        if archive:
            province_kill_request.payment_deadline_checker_fullname = user.fullname
            province_kill_request.payment_deadline_checker_mobile = user.mobile
            province_kill_request.payment_deadline_check_date = datetime.now()
            province_kill_request.payment_deadline_archive = True
            province_kill_request.payment_deadline_state = 'archive'

        if 'extension_payment_deadline_days' in request.data.keys():
            province_kill_request.extension_payment_deadline_date = province_kill_request.payment_deadline_date + timedelta(
                days=request.data['extension_payment_deadline_days'])
            province_kill_request.kill_request.extension_payment_deadline_days = request.data[
                'extension_payment_deadline_days']
            province_kill_request.kill_request.extension_payment_deadline_date = province_kill_request.extension_payment_deadline_date
            province_kill_request.kill_request.save()

        province_kill_request.save()
        serializer = self.serializer_class(province_kill_request)
        serializer.update(instance=province_kill_request, validated_data=request.data)

        return Response(serializer.data, status=status.HTTP_200_OK)


class MarketKillRequestViewSet(viewsets.ModelViewSet):
    queryset = KillRequest.objects.all()
    serializer_class = KillRequestForDirectBuyingSerializer
    pagination_class = CustomPagination
    permission_classes = [TokenHasReadWriteScope]
    filter_backends = [DjangoFilterBackend]
    filterset_class = KillRequestFilterSet
    filterset_fields = [
        'kill_house__kill_house_operator__user__mobile',
        'kill_house__kill_house_operator__user__fullname',
        'kill_house__kill_house_operator__user__first_name',
        'kill_house__kill_house_operator__user__last_name',
        'poultry_request__chicken_breed',
        'poultry_request__order_code',
        'poultry_request__poultry__address__city__name',
        'poultry_request__poultry__user__mobile',
        'poultry_request__poultry__user__fullname',

    ]

    def calculate_province_kill_request_wage(self, kill_request):
        province_check = ProvinceCheckOperatorRequest.objects.get(poultry_request=kill_request.poultry_request)

        wage_type = WageType.objects.filter(en_name='province-kill-request', trash=False).first()
        wage = wage_type.amount if wage_type.status == True else 0
        percentages_wage_type = PercentageOfWageType.objects.filter(wage_type=wage_type, percent__gt=0,
                                                                    trash=False)
        province_killrequest = ProvinceKillRequest(
            killhouse_user=kill_request.kill_house,
            kill_request=kill_request,
            province_request=province_check,
            quantity=kill_request.kill_capacity,
            total_killed_quantity=kill_request.kill_capacity,
            total_killed_weight=int(kill_request.kill_capacity * kill_request.poultry_request.Index_weight),
            main_quantity=kill_request.kill_capacity,
            wage=wage,
            market=True,
            payment_deadline=True,
            payment_deadline_days=kill_request.payment_deadline_days,
            payment_deadline_date=kill_request.payment_deadline_date,
            state='accepted',
            kill_house_price=kill_request.amount,
            total_wage_amount=wage * int(kill_request.kill_capacity * kill_request.poultry_request.Index_weight),
        )
        province_killrequest.save()
        kill_house_check = KillHouseCheckRequest(
            province_kill_request=province_killrequest,
            state='accepted'
        )

        kill_house_check.save()
        vet_farm = VetFarm.objects.filter(trash=False,
                                          poultry=province_killrequest.province_request.poultry_request.poultry).first()
        bot_eitaa_for_each_province_kill_request(province_killrequest, vet_farm)
        if wage_type and wage_type.status == True and percentages_wage_type:
            for percentage_wage_type in percentages_wage_type:
                if percentage_wage_type.share_type.en_name == 'union':
                    province_killrequest.union_share = int(
                        (percentage_wage_type.percent / 100) * province_killrequest.total_wage_amount)
                    province_killrequest.union_share_percent = percentage_wage_type.percent

                elif percentage_wage_type.share_type.en_name == 'company':
                    province_killrequest.company_share = int(
                        (percentage_wage_type.percent / 100) * province_killrequest.total_wage_amount)
                    province_killrequest.company_share_percent = percentage_wage_type.percent

                elif percentage_wage_type.share_type.en_name == 'guilds':
                    province_killrequest.guilds_share = int(
                        (percentage_wage_type.percent / 100) * province_killrequest.total_wage_amount)
                    province_killrequest.guilds_share_percent = percentage_wage_type.percent

                elif percentage_wage_type.share_type.en_name == 'city':
                    province_killrequest.city_share = int(
                        (percentage_wage_type.percent / 100) * province_killrequest.total_wage_amount)
                    province_killrequest.city_share_percent = percentage_wage_type.percent

                elif percentage_wage_type.share_type.en_name == 'other':
                    province_killrequest.other_share = int(
                        (percentage_wage_type.percent / 100) * province_killrequest.total_wage_amount)
                    province_killrequest.other_share_percent = percentage_wage_type.percent

                elif percentage_wage_type.share_type.en_name == 'wallet':
                    province_killrequest.wallet_share = int(
                        (percentage_wage_type.percent / 100) * province_killrequest.total_wage_amount)
                    province_killrequest.wallet_share_percent = percentage_wage_type.percent

                else:
                    province_killrequest.other_share = int(
                        (percentage_wage_type.percent / 100) * province_killrequest.total_wage_amount)
                    province_killrequest.other_share_percent = percentage_wage_type.percent
                province_killrequest.save()

    def create(self, request, *args, **kwargs):
        total_unpaid_wage = 0
        total_paid_wage = 0
        user = SystemUserProfile.objects.get(trash=False, user=request.user)
        now = datetime.now()
        kill_house_ids = KillHousePercentage.objects.filter(kill_house__type='exclusive', trash=False).values_list(
            'kill_house', flat=True)
        kill_houses = KillHouse.objects.filter(out_province=False, market_buying=True, trash=False).exclude(
            id__in=kill_house_ids).order_by('id', 'killer')
        kill_house_for_killer = None
        kill_house = KillHouse.objects.filter(kill_house_operator__user=user, trash=False).first()

        if kill_house.ware_house_remaining_weight_limitation_status:
            if kill_house.total_remain_warehouse_governmental_weight > kill_house.ware_house_remaining_weight_limitation:
                return Response({
                    "result": "باقی مانده انبار شما از حداکثر محدودیت وزن باقی مانده انبار بیشتر است !"},
                    status=status.HTTP_403_FORBIDDEN)

        if kill_house.ware_house_remaining_percent_limitation_status:
            if not check_kill_house_remain_limitation_weight(kill_house):
                return Response({
                    "result": "باقی مانده انبار شما از حداکثر محدودیت وزن باقی مانده روزانه انبار بیشتر است !"},
                    status=status.HTTP_403_FORBIDDEN)
        with transaction.atomic():
            poultry_request = PoultryRequest.objects.select_for_update().get(key=request.data['poultry_request_key'])
            if poultry_request.free_sale_in_province == True:

                if kill_house.quota:
                    kill_house_info = calculate_governmental_quota(kill_house)
                    if kill_house_info == 'not_allowed':
                        return Response({"result": " امکان خرید آزاد تا تکمیل تعهد دولتی وجود ندارد!"},
                                        status=status.HTTP_403_FORBIDDEN)

            index_weight_category = IndexWeightCategory.objects.filter(trash=False, name='سبک').first()
            light_max_value = index_weight_category.max_value if index_weight_category else 0
            if kill_house.market_buying_limitation:
                kill_house_info = market_kill_request_share_quantity(kill_house, total_kill_houses=kill_houses)
                kill_house_share = kill_house_info['kill_house_today_share']
                kill_house_buying = kill_house_info['kill_house_market_kill_requests_quantity'] + request.data[
                    'kill_capacity']
                if kill_house.market_light_capacity:
                    total_remain_light_weight = kill_house_info['total_remain_poultry_requests_quantity_light_weight']
                    kill_house_market_kill_requests_quantity_light_weight = kill_house_info[
                        'kill_house_market_kill_requests_quantity_light_weight']
                    real_kill_house_market_kill_requests_quantity_light_weight = kill_house_info['light_real_quantity']
                    if poultry_request.Index_weight >= light_max_value:
                        if real_kill_house_market_kill_requests_quantity_light_weight > 0:
                            if total_remain_light_weight > real_kill_house_market_kill_requests_quantity_light_weight:
                                if real_kill_house_market_kill_requests_quantity_light_weight > kill_house_market_kill_requests_quantity_light_weight:
                                    return Response({"result": "الویت با خرید و تکمیل نهایی  سهمیه سبک  می باشد!"},
                                                    status=status.HTTP_403_FORBIDDEN)
                            else:
                                if total_remain_light_weight > kill_house_market_kill_requests_quantity_light_weight:
                                    return Response({"result": "الویت با خرید و تکمیل نهایی  سهمیه سبک  می باشد!"},
                                                    status=status.HTTP_403_FORBIDDEN)

                if kill_house_share - kill_house_buying < 0:
                    return Response({"result": "حجم خریداری شده از سهمیه  شما بیشتر است !"},
                                    status=status.HTTP_403_FORBIDDEN)
            kill_request = KillRequest.objects.filter(trash=False, poultry_request=poultry_request,
                                                      kill_house=kill_house,
                                                      market_final_accept=False).first()
            # if poultry_request.remain_quantity < request.data['kill_capacity']:
            #     return Response({"result": "حجم وارد شده از باقی مانده قابل فروش بیشتر است !"},
            #                     status=status.HTTP_403_FORBIDDEN)
            market_requests_quantity = KillRequest.objects.filter(poultry_request=poultry_request, trash=False,
                                                                  market_state__in=('pending', 'accepted'),
                                                                  market=True).aggregate(
                total=Sum('kill_capacity'))['total'] or 0
            if market_requests_quantity + request.data['kill_capacity'] > poultry_request.quantity:
                return Response({"result": "باقی مانده اعلام نیاز مرغدار کمتر از درخواست شماست!"},
                                status=status.HTTP_403_FORBIDDEN)

            kill_house_purchase = KillHousePurchaseRequest.objects.filter(kill_house=kill_house).first()
            total_unpaid_wage = get_finance_info(kill_house)['total_price']
            if kill_house.killer and kill_house.type == 'public':

                slaughter_transactions = InternalTransaction.objects.filter(
                    kill_house=kill_house,parent_kill_house=kill_house, status='completed',
                    trash=False)
            else:
                slaughter_transactions = InternalTransaction.objects.filter(
                    kill_house=kill_house, status='completed',
                    trash=False)

            total_paid_wage += slaughter_transactions.aggregate(total=Sum('amount'))[
                                   'total'] or 0
            if kill_house_purchase.limitation == True:

                if kill_house_purchase.limitation_number <= total_unpaid_wage - total_paid_wage:
                    if not ProvinceKillRequest.objects.filter(killhouse_user=kill_house,
                                                              kill_request__recive_date__date=now.date(),
                                                              trash=False,
                                                              state__in=('pending', 'accepted')).exists():
                        return Response({
                            "result": "به علت بدهی امکان ثبت درخواست وحود ندارد لطفا بدهی خود را در پنل کارمزد ها تسویه کنید"},
                            status=status.HTTP_403_FORBIDDEN)

            if kill_request:
                kill_request.kill_capacity += request.data['kill_capacity']
                kill_request.remain_quantity += request.data['kill_capacity']
                kill_request.save()
                market_poultry_request_remain_quantity(kill_request.poultry_request)
                return Response({"result": "با موفقیت ثبت شد."}, status=status.HTTP_200_OK)
            request.data.pop('poultry_request_key')
            if kill_house.killer and kill_house.type == 'public':
                percentage = KillHousePercentage.objects.filter(trash=False, kill_house=kill_house,
                                                                kill_house_for_killer__isnull=False).first()
                kill_house_for_killer = percentage.kill_house_for_killer
            serializer = self.serializer_class(data=request.data)
            if serializer.is_valid():
                market_kill_request = serializer.create(validated_data=request.data)
                market_kill_request.kill_house = kill_house
                market_kill_request.poultry_request = poultry_request
                market_kill_request.poultry_hatching = poultry_request.hatching
                market_kill_request.poultry = poultry_request.poultry
                market_kill_request.recive_date = now
                market_kill_request.chicken_breed = poultry_request.chicken_breed
                market_kill_request.remain_quantity = market_kill_request.kill_capacity
                market_kill_request.amount = poultry_request.amount
                market_kill_request.Index_weight = poultry_request.Index_weight
                market_kill_request.market = True
                market_kill_request.payment_deadline = True
                if kill_house_for_killer:
                    market_kill_request.slaughter_house = kill_house_for_killer
                market_kill_request.market_expire_date_time = now + timedelta(
                    minutes=30) if market_code_state else now + timedelta(minutes=5)
                if market_code_state:
                    market_kill_request.market_code_status = True
                market_kill_request.payment_deadline_date = datetime.now() + timedelta(
                    days=request.data['payment_deadline_days'])
                market_kill_request.save()
                market_poultry_request_remain_quantity(market_kill_request.poultry_request)
                return Response(serializer.data, status=status.HTTP_201_CREATED)

    def list(self, request, *args, **kwargs):
        from django.db.models import Value

        user = SystemUserProfile.objects.get(user=request.user, trash=False)
        now = datetime.now().date()
        role = request.GET.get('role')
        poultry_request_key = request.GET.get('poultry_request_key')
        date1 = request.GET.get('date1')
        date2 = request.GET.get('date2')
        # filter = {
        #     'trash': False,
        #     'market': True,
        # }
        filter = {
            'market': True
        }
        if date1:
            filter['recive_date__date__gte'] = date1
            filter['recive_date__date__lte'] = date2

        else:
            filter['recive_date__date'] = now

        if role == 'KillHouse':
            kill_house = KillHouse.objects.filter(kill_house_operator__user=user).first()
            filter['kill_house'] = kill_house

        elif role in ('CityJahad', 'CityOperator', 'CityCommerce', 'CityVet', 'CitySupervisor', 'CityPoultry'):
            filter['poultry__address__city'] = user.city
        state_type = request.GET.get('type')

        if state_type and state_type != 'all':
            filter['market_state'] = state_type

        if state_type in ('pending', 'accepted', 'rejected'):
            filter['trash'] = False
        elif state_type == 'deleted':
            filter['trash'] = True

        if poultry_request_key:
            filter['poultry_request__key'] = poultry_request_key

        kill_requests = KillRequest.objects.filter(**filter).select_related('poultry_hatching', 'poultry').only(
            'poultry_hatching', 'poultry').order_by(
            Case(
                When(market_state='pending', then=Value(0)),
                default=Value(1)
            ),
            '-create_date'
        )

        if 'search' in request.GET:
            kill_requests_list = []
            if request.GET['search'] == 'filter':
                if request.GET['value'] != "" and request.GET['value'] != 'undefined':
                    for item in self.filterset_fields:
                        query = QueryDict('{0}__contains={1}'.format(item, request.GET['value']))
                        if (self.filterset_class(
                                data=query,
                                queryset=kill_requests
                        )
                        ).filter():
                            ps = self.filterset_class(data=query, queryset=kill_requests)
                            kill_requests_list = ps.filter()
                    kill_requests = [] if len(
                        kill_requests_list) == 0 else kill_requests_list

        page_size = request.query_params.get('page_size', None)
        if page_size:
            self.pagination_class.page_size = int(page_size)

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

        serializer = self.get_serializer(kill_requests, many=True)
        return Response(serializer.data, status=status.HTTP_200_OK)

    def update(self, request, pk=None, *args, **kwargs):
        kill_request = KillRequest.objects.get(key=request.data['key'])
        if kill_request.trash:
            return Response({"result": "درخواست شما توسط کاربر حذف گردید!"}, status=status.HTTP_403_FORBIDDEN)

        if 'check' in request.data.keys():
            state = request.data['market_state']
            if state == 'accepted':
                self.calculate_province_kill_request_wage(kill_request)
            request.data.pop('check')

        if 'market_final_accept' in request.data.keys():
            # market_poultry_request_remain_quantity(kill_request.poultry_request)
            poultry_request = kill_request.poultry_request
            # market_requests_quantity = KillRequest.objects.filter(poultry_request=poultry_request, trash=False,
            #                                                       market_state__in=('pending', 'accepted'), market=True,
            #                                                       market_final_accept=True).aggregate(
            #     total=Sum('kill_capacity'))['total'] or 0
            # if market_requests_quantity + kill_request.kill_capacity > poultry_request.quantity:
            #     return Response({"result": "باقی مانده اعلام نیاز مرغدار کمتر از درخواست شماست!"},
            #                     status=status.HTTP_403_FORBIDDEN)
            if market_code_state:
                code = str(random.randint(10000, 99000))
                kill_request.market_code = code
                kill_request.save()
                market_sms = threading.Thread(
                    target=send_sms_fro_kill_request_market,
                    args=(
                        kill_request,))

                market_sms.start()
            kill_request.remain_quantity -= kill_request.kill_capacity
            kill_request.save()
        if 'kill_capacity' in request.data.keys():
            kill_house_ids = KillHousePercentage.objects.filter(kill_house__type='exclusive', trash=False).values_list(
                'kill_house', flat=True)
            kill_houses = KillHouse.objects.filter(out_province=False, market_buying=True, trash=False).exclude(
                id__in=kill_house_ids).order_by('id', 'killer')
            if kill_request.kill_house.market_buying_limitation:
                kill_house_info = market_kill_request_share_quantity(kill_request.kill_house,
                                                                     total_kill_houses=kill_houses)
                kill_house_share = kill_house_info['kill_house_today_share']
                kill_house_today_left_share = kill_house_info['kill_house_today_left_share']
                kill_house_buying = kill_house_info['kill_house_market_kill_requests_quantity'] + request.data[
                    'kill_capacity']
                if (kill_house_today_left_share + kill_request.kill_capacity) < request.data['kill_capacity']:
                    return Response({"result": "حجم خریداری شده از سهمیه  شما بیشتر است !"},
                                    status=status.HTTP_403_FORBIDDEN)
            if kill_request.poultry_request.remain_quantity + kill_request.kill_capacity < request.data[
                'kill_capacity']:
                return Response({"result": "حجم وارد شده از باقی مانده قابل فروش بیشتر است !"},
                                status=status.HTTP_403_FORBIDDEN)
            kill_request.remain_quantity = request.data['kill_capacity']
        if 'payment_deadline_days' in request.data.keys():
            kill_request.payment_deadline_date = datetime.now() + timedelta(
                days=request.data['payment_deadline_days'])
        if 'input_market_code' in request.data.keys():
            if request.data['input_market_code'] != kill_request.market_code:
                return Response({"result": "کد وارد شده صحیح نمی باشد!"}, status=status.HTTP_403_FORBIDDEN)
            kill_request.input_market_code = request.data['input_market_code']
            self.calculate_province_kill_request_wage(kill_request)
            kill_request.market_state = 'accepted'
        kill_request.save()
        serializer = self.serializer_class(kill_request)
        serializer.update(instance=kill_request, validated_data=request.data)
        market_poultry_request_remain_quantity(kill_request.poultry_request)
        return Response(serializer.data, status=status.HTTP_200_OK)

    def destroy(self, request, pk=None, *args, **kwargs):
        user = SystemUserProfile.objects.get(trash=False, user=request.user)
        kill_request = KillRequest.objects.get(key=request.GET["key"])
        kill_request.trash = True
        kill_request.market_state_message = {
            "fullname": user.fullname,
            "mobile": user.mobile,
            "date": str(datetime.now())
        }
        kill_request.market_state = 'deleted'
        kill_request.save()
        market_poultry_request_remain_quantity(kill_request.poultry_request)
        return Response(' با موفقیت حذف شد', status=status.HTTP_200_OK)


class MarketKillHouseViewSet(viewsets.ModelViewSet):
    queryset = KillHouse.objects.all()
    serializer_class = KillHouseForCommonlyUsedSerializer
    pagination_class = CustomPagination
    permission_classes = [TokenHasReadWriteScope]
    filter_backends = [DjangoFilterBackend]
    filterset_class = KillHouseFilterSet
    filterset_fields = [
        'name',
        'kill_house_operator__user__mobile',
        'kill_house_operator__user__fullname',
        'kill_house_operator__user__first_name',
        'kill_house_operator__user__last_name'

    ]

    def list(self, request, *args, **kwargs):

        kill_houses = KillHouse.objects.filter(out_province=False, trash=False).order_by(
            'id', 'killer')

        if 'search' in request.GET:
            kill_house_list = []
            if request.GET['search'] == 'filter':
                if request.GET['value'] != "" and request.GET['value'] != 'undefined':
                    for item in self.filterset_fields:
                        query = QueryDict('{0}__contains={1}'.format(item, request.GET['value']))
                        if (self.filterset_class(
                                data=query,
                                queryset=kill_houses
                        )
                        ).filter():
                            ps = self.filterset_class(data=query, queryset=kill_houses)
                            kill_house_list = ps.filter()
                    kill_houses = [] if len(
                        kill_house_list) == 0 else kill_house_list

        page_size = request.query_params.get('page_size', None)
        if page_size:
            self.pagination_class.page_size = int(page_size)

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

        serializer = self.get_serializer(kill_houses, many=True)
        return Response(serializer.data, status=status.HTTP_200_OK)

    def update(self, request, pk=None, *args, **kwargs):
        kill_house = KillHouse.objects.get(key=request.data['key'])
        serializer = self.serializer_class(kill_house)
        serializer.update(instance=kill_house, validated_data=request.data)

        return Response(serializer.data, status=status.HTTP_200_OK)


class KillHouseMarketInfoViewSet(APIView):
    permission_classes = [TokenHasReadWriteScope]
    serializer_class = KillHouseMarketInfoSerializer
    filter_backends = [DjangoFilterBackend]
    filterset_class = KillHouseFilterSet
    filterset_fields = [
        'name',
        'kill_house_operator__user__mobile',
        'kill_house_operator__user__fullname',
        'kill_house_operator__user__first_name',
        'kill_house_operator__user__last_name'

    ]

    def get(self, request):
        role = request.GET.get('role')
        date1 = request.GET.get('date1')
        date2 = request.GET.get('date2')
        kill_house_ids = KillHousePercentage.objects.filter(kill_house__type='exclusive', trash=False).values_list(
            'kill_house', flat=True)
        kill_houses = KillHouse.objects.filter(out_province=False, market_buying=True, trash=False).exclude(
            id__in=kill_house_ids).order_by('id', 'killer')
        if role == 'KillHouse':
            user = SystemUserProfile.objects.get(trash=False, user=request.user)
            kill_house = KillHouse.objects.filter(kill_house_operator__user=user, trash=False).first()
            serializer = self.serializer_class(kill_house,
                                               context={'date1': date1, 'date2': date2, 'kill_houses': kill_houses})

        else:
            if 'search' in request.GET:
                kill_house_list = []
                if request.GET['search'] == 'filter':
                    if request.GET['value'] != "" and request.GET['value'] != 'undefined':
                        for item in self.filterset_fields:
                            query = QueryDict('{0}__contains={1}'.format(item, request.GET['value']))
                            if (self.filterset_class(
                                    data=query,
                                    queryset=kill_houses
                            )
                            ).filter():
                                ps = self.filterset_class(data=query, queryset=kill_houses)
                                kill_house_list = ps.filter()
                        kill_houses = [] if len(
                            kill_house_list) == 0 else kill_house_list

            serializer = self.serializer_class(kill_houses, many=True,
                                               context={'date1': date1, 'date2': date2, 'kill_houses': kill_houses})

        return Response(serializer.data, status=status.HTTP_200_OK)


class KillHouseMarketInfoDashboardViewSet(APIView):
    permission_classes = [TokenHasReadWriteScope]
    filter_backends = [DjangoFilterBackend]
    filterset_class = KillHouseFilterSet
    filterset_fields = [
        'name',
        'kill_house_operator__user__mobile',
        'kill_house_operator__user__fullname',
        'kill_house_operator__user__first_name',
        'kill_house_operator__user__last_name'

    ]

    def get(self, request):
        today = datetime.now().date()
        date1 = request.GET.get('date1')
        date2 = request.GET.get('date2')
        if date1:
            total_poultry_requests_quantity = (
                    PoultryRequest.objects.filter(
                        send_date__date__gte=date1,
                        send_date__date__lte=date2,
                        state_process='accepted',
                        province_state='accepted',
                        final_state__in=('pending', 'accepted'),
                        temporary_trash=False,
                        trash=False,
                        out=False,
                        market=True,
                    ).aggregate(total=Sum('quantity'))['total'] or 0
            )

        else:
            total_poultry_requests_quantity = (
                    PoultryRequest.objects.filter(
                        send_date__date=today,
                        state_process='accepted',
                        province_state='accepted',
                        final_state__in=('pending', 'accepted'),
                        temporary_trash=False,
                        trash=False,
                        out=False,
                        market=True,
                    ).aggregate(total=Sum('quantity'))['total'] or 0
            )

        exclusive_kill_house_ids = KillHousePercentage.objects.filter(
            kill_house__type='exclusive',
            trash=False
        ).values_list('kill_house', flat=True)

        kill_houses = KillHouse.objects.filter(
            out_province=False,
            market_buying=True,
            trash=False
        ).exclude(id__in=exclusive_kill_house_ids).order_by('id', 'killer')

        if 'search' in request.GET:
            kill_house_list = []
            if request.GET['search'] == 'filter':
                if request.GET['value'] != "" and request.GET['value'] != 'undefined':
                    for item in self.filterset_fields:
                        query = QueryDict('{0}__contains={1}'.format(item, request.GET['value']))
                        if (self.filterset_class(
                                data=query,
                                queryset=kill_houses
                        )
                        ).filter():
                            ps = self.filterset_class(data=query, queryset=kill_houses)
                            kill_house_list = ps.filter()
                    kill_houses = [] if len(
                        kill_house_list) == 0 else kill_house_list

        dashboard_data = {
            "kill_house_today_share": 0,
            "market_light_share": 0,
            "kill_house_market_kill_requests_quantity": 0,
            "kill_house_market_kill_requests_quantity_first": 0,
            "kill_house_market_kill_requests_quantity_final": 0,
            "kill_house_today_left_share": 0,
            "kill_house_market_kill_requests_quantity_weight": 0,
            "kill_house_market_kill_requests_quantity_first_weight": 0,
            "kill_house_market_kill_requests_quantity_final_weight": 0,
            "total_kill_house_market_kill_requests_quantity_agreement_light_weight": 0,
            "total_kill_house_market_kill_requests_quantity_light_weight": 0,
            "total_kill_house_market_kill_requests_quantity_heavy_weight": 0,
        }

        for kill_house in kill_houses:
            if date1:
                info = market_kill_request_share_quantity(kill_house, date1, date2, total_kill_houses=kill_houses)
            else:
                info = market_kill_request_share_quantity(kill_house, total_kill_houses=kill_houses)
            for key in dashboard_data:
                dashboard_data[key] += info.get(key, 0) or 0

        result = {"total_poultry_requests_quantity": total_poultry_requests_quantity, **dashboard_data}

        return Response(result, status=200)


def make_fine_for_requests_cron():
    now = datetime.now().date()
    fine = FinePermission.objects.filter(trash=False).first()

    province_kill_requests = ProvinceKillRequest.objects.filter(trash=False, temporary_trash=False,
                                                                return_to_province=False,
                                                                kill_request__recive_date__date__lt=now,
                                                                first_car_allocated_quantity=0,
                                                                state__in=('pending', 'accepted')).select_related(
        'province_request__poultry_request__hatching')
    if province_kill_requests:
        for province_kill_request in province_kill_requests:
            hatching = province_kill_request.province_request.poultry_request.hatching
            province_kill_request.fine = True
            province_kill_request.fine_amount = fine.in_province_allocations_fine_coefficient * province_kill_request.total_wage_amount
            province_kill_request.fine_coefficient = fine.in_province_allocations_fine_coefficient
            if province_kill_request.market:
                province_kill_request.kill_request.market_state = 'deleted'
                province_kill_request.kill_request.save()
            province_kill_request.delete_message = "حذف  تخصیص و اعمال جریمه به دلیل عدم ثبت خودرو در بازه مشخص"
            province_kill_request.trash = True
            province_kill_request.save()
            update_province_kill_requests(hatching)

    kill_house_requests = KillHouseRequest.objects.filter(
        Q(assignment_state_archive='pending') | Q(ware_house_confirmation=False), fine=False, trash=False,
        kill_request__recive_date__date__lt=now,
        temporary_trash=False).select_related('province_kill_request', 'province_request__poultry_request',
                                              'province_request__poultry_request__hatching')
    empty_info_bars = kill_house_requests.filter(assignment_state_archive='pending', ware_house_confirmation=False)
    not_completed_bars = kill_house_requests.filter(assignment_state_archive='pending', ware_house_confirmation=True)
    not_entered_bars = kill_house_requests.filter(assignment_state_archive='True', ware_house_confirmation=False)

    if empty_info_bars:
        for empty_info_bar in empty_info_bars:
            poultry_request = empty_info_bar.province_request.poultry_request
            hatching = empty_info_bar.province_request.poultry_request.hatching
            province_kill_request = empty_info_bar.province_kill_request
            empty_info_bar.fine = True
            empty_info_bar.fine_amount = (
                                                 fine.in_province_bars_fine_coefficient * empty_info_bar.accepted_real_weight) * province_kill_request.wage
            empty_info_bar.fine_coefficient = fine.in_province_bars_fine_coefficient
            empty_info_bar.message = 'لغو بار و اعمال جریمه به علت عدم تکمبل اطلاعات و ورود به انبار'
            empty_info_bar.bar_remover = {
                "date": str(datetime.now()),
                "role": "system",
                "mobile": "-",
                "full_name": "system"
            }
            empty_info_bar.trash = True
            empty_info_bar.save()
            update_kill_house_requests(province_kill_request, poultry_request)
            update_province_kill_requests(hatching)

    if not_completed_bars:
        for not_completed_bar in not_completed_bars:
            province_kill_request = not_completed_bar.province_kill_request

            not_completed_bar.fine = True
            not_completed_bar.fine_amount = (
                                                    fine.in_province_bars_fine_coefficient * not_completed_bar.accepted_real_weight) * province_kill_request.wage
            not_completed_bar.fine_coefficient = fine.in_province_bars_fine_coefficient
            not_completed_bar.message = 'اعمال جریمه به علت عدم تکمبل اطلاعات'
            not_completed_bar.save()

    if not_entered_bars:
        for not_entered_bar in not_entered_bars:
            province_kill_request = not_entered_bar.province_kill_request

            not_entered_bar.ware_house_accepted_real_quantity = not_entered_bar.accepted_real_quantity
            not_entered_bar.ware_house_accepted_real_weight = int(not_entered_bar.accepted_real_weight - (
                    (not_entered_bar.accepted_real_weight * 25) / 100))
            not_entered_bar.weight_loss = 25
            poultry_prediction(not_entered_bar.province_request.poultry_request.poultry)

            not_entered_bar.ware_house_input_type = "loss_weight"
            not_entered_bar.ware_house_confirmation = True
            not_entered_bar.date_of_ware_house = str(datetime.now())
            not_entered_bar.fine = True
            not_entered_bar.fine_amount = (
                                                  fine.in_province_bars_fine_coefficient * not_entered_bar.accepted_real_weight) * province_kill_request.wage
            not_entered_bar.fine_coefficient = fine.in_province_bars_fine_coefficient
            not_entered_bar.message = 'اعمال جریمه به علت عدم ورود به انبار'
            not_entered_bar.save()
            product = RolesProducts.objects.filter(parent_product__product_id=2,
                                                   kill_house=not_entered_bar.killhouse_user).first()
            kill_house_requests_product_warehousing(product)


# class KillHouseSalesInformationViewSet(APIView):
#     permission_classes = [TokenHasReadWriteScope]
#
#     def get(self, request):
#         date1 = request.GET.get('date1')
#         date2 = request.GET.get('date2')
#         key = request.GET.get('key')
#         kill_house = KillHouse.objects.get(key=key, trash=False)
#         kill_house_request_filter = {
#             'killhouse_user': kill_house,
#             'ware_house_confirmation': True,
#             'trash': False,
#             'calculate_status': True,
#         }
#         kill_house_free_buying_bar_filter = {
#             'kill_house': kill_house,
#             'trash': False,
#             'calculate_status': True,
#         }
#         kill_house_allocation_filter = {
#             'trash': False,
#             'calculate_status': True,
#         }
#
#         kill_house_free_sale_bars_filter = {
#             'trash': False,
#             'calculate_status': True,
#         }
#         if date1:
#             kill_house_request_filter['kill_request__recive_date__date__gte'] = datetime.strptime(date1,
#                                                                                                   '%Y-%m-%d').date() - timedelta(
#                 days=1)
#             kill_house_request_filter['kill_request__recive_date__date__lte'] = datetime.strptime(date2,
#                                                                                                   '%Y-%m-%d').date() - timedelta(
#                 days=1)
#             kill_house_free_buying_bar_filter['date__date__gte'] = date1
#             kill_house_free_buying_bar_filter['date__date__lte'] = date2
#             kill_house_allocation_filter['date__date__gte'] = date1
#             kill_house_allocation_filter['date__date__lte'] = date2
#             kill_house_free_sale_bars_filter['date__date__gte'] = date1
#             kill_house_free_sale_bars_filter['date__date__lte'] = date2
#
#         kill_house_requests = KillHouseRequest.objects.filter(**kill_house_request_filter)
#         kill_house_free_buying_bars = KillHouseFreeBarInformation.objects.filter(
#             **kill_house_free_buying_bar_filter).exclude(entered_message='ورود به انبار مجازی')
#         kill_house_allocations = StewardAllocation.objects.filter(
#             Q(kill_house=kill_house) | Q(to_kill_house=kill_house), **kill_house_allocation_filter)
#         kill_house_free_sale_bars = KillHouseFreeSaleBarInformation.objects.filter(**kill_house_free_sale_bars_filter)
#
#         kill_house_requests_aggregates = kill_house_requests.aggregate(
#             total_count=Count('id'),
#             total_governmental_weight=Sum('ware_house_accepted_real_weight',
#                                           filter=Q(province_request__poultry_request__free_sale_in_province=False)),
#             total_free_weight=Sum('ware_house_accepted_real_weight',
#                                   filter=Q(province_request__poultry_request__free_sale_in_province=True)),
#         )
#
#         kill_house_free_buying_bars_aggregates = kill_house_free_buying_bars.aggregate(
#             total_count=Count('id'),
#             total_weight=Sum('weight_of_carcasses'),
#         )
#
#         kill_house_allocations_aggregates = kill_house_allocations.aggregate(
#             total_count=Count('id'),
#             total_receive_governmental_weight=Sum('receiver_real_weight_of_carcasses',
#                                                   filter=Q(approved_price_status=True, receiver_state='accepted',
#                                                            kill_house__isnull=True, to_cold_house__isnull=True)),
#             total_receive_free_weight=Sum('receiver_real_weight_of_carcasses',
#                                           filter=Q(approved_price_status=False, receiver_state='accepted',
#                                                    kill_house__isnull=True, to_cold_house__isnull=True)),
#             total_allocated_governmental_weight=Sum('receiver_real_weight_of_carcasses',
#                                                     filter=Q(approved_price_status=False, receiver_state='accepted',
#                                                              kill_house__isnull=False, to_cold_house__isnull=True)),
#             total_allocated_free_weight=Sum('receiver_real_weight_of_carcasses',
#                                             filter=Q(approved_price_status=False, receiver_state='accepted',
#                                                      kill_house__isnull=False, to_cold_house__isnull=True)),
#
#         )
#         kill_house_free_sale_bars_aggregates = kill_house_free_sale_bars.aggregate(
#             total_count=Count('id'),
#             total_governmental_weight=Sum('real_weight_of_carcasses',
#                                           filter=Q(sale_type='governmental')),
#             total_free_weight=Sum('real_weight_of_carcasses',
#                                   filter=Q(sale_type='free')),
#         )
#
#         result = {
#             "kill_house_request_governmental_weight": kill_house_requests_aggregates['total_governmental_weight'] or 0,
#             "kill_house_request_free_weight": kill_house_requests_aggregates['total_free_weight'] or 0,
#             "kill_house_free_buying_bars_weight": kill_house_free_buying_bars_aggregates['total_weight'] or 0,
#             "total_receive_governmental_weight": kill_house_allocations_aggregates[
#                                                      'total_receive_governmental_weight'] or 0,
#             "total_receive_free_weight": kill_house_allocations_aggregates['total_receive_free_weight'] or 0,
#             "total_in_allocated_governmental_weight": kill_house_allocations_aggregates[
#                                                           'total_allocated_governmental_weight'] or 0,
#             "total_in_allocated_free_weight": kill_house_allocations_aggregates['total_allocated_free_weight'] or 0,
#             "total_out_allocated_free_weight": kill_house_free_sale_bars_aggregates['total_governmental_weight'] or 0,
#             "total_out_free_weight": kill_house_free_sale_bars_aggregates['total_free_weight'] or 0,
#         }
#
#         return Response(result, status=200)
class KillHouseSalesInformationViewSet(APIView):
    permission_classes = [TokenHasReadWriteScope]

    def get(self, request):
        user = SystemUserProfile.objects.get(user=request.user, trash=False)
        kill_house = KillHouse.objects.filter(kill_house_operator__user=user, trash=False).first()
        product = RolesProducts.objects.filter(kill_house=kill_house, trash=False, name='مرغ گرم').first()

        kill_house_requests = KillHouseRequest.objects.filter(
            input_warehouse=kill_house,
            temporary_trash=False,
            temporary_deleted=False,
            trash=False, calculate_status=True, warehouse=True)

        kill_house_free_bar_informations = KillHouseFreeBarInformation.objects.filter(input_warehouse=kill_house,
                                                                                      trash=False,
                                                                                      temporary_trash=False,
                                                                                      temporary_deleted=False,
                                                                                      calculate_status=True,
                                                                                      warehouse=True).exclude(
            entered_message='ورود به انبار مجازی')
        kill_house_free_Sale_bar_informations = KillHouseFreeSaleBarInformation.objects.filter(
            kill_house=kill_house,
            trash=False,
            temporary_trash=False,
            temporary_deleted=False,
            calculate_status=True, warehouse=True)
        kill_house_allocations = StewardAllocation.objects.filter(kill_house=kill_house, trash=False,
                                                                  receiver_state__in=('pending', 'accepted'),
                                                                  temporary_trash=False,
                                                                  temporary_deleted=False,
                                                                  to_cold_house__isnull=True,
                                                                  calculate_status=True, warehouse=True)

        segmentations = PosSegmentation.objects.filter(kill_house=kill_house, trash=False, warehouse=True)
        cold_house_allocations = StewardAllocation.objects.filter(
            kill_house=kill_house,
            to_cold_house__isnull=False,
            receiver_state__in=('accepted', 'pending'),
            trash=False, warehouse=True)
        transactions = ProductsTransactions.objects.filter(product=product, transaction__paid=True, trash=False,
                                                           warehouse=True)
        total_entered_kill_house_requests_carcasses_governmental_weight = \
            kill_house_requests.filter(ware_house_confirmation=True,
                                       province_request__poultry_request__free_sale_in_province=False).aggregate(
                total=Sum('ware_house_accepted_real_weight'))[
                'total'] or 0
        total_entered_kill_house_requests_carcasses_free_weight = \
            kill_house_requests.filter(ware_house_confirmation=True,
                                       province_request__poultry_request__free_sale_in_province=True).aggregate(
                total=Sum('ware_house_accepted_real_weight'))[
                'total'] or 0

        total_entered_kill_house_free_bar_carcasses_weight = \
            kill_house_free_bar_informations.aggregate(total=Sum('weight_of_carcasses'))[
                'total'] or 0
        total_kill_house_free_sale__bar_carcasses_weight = \
            kill_house_free_Sale_bar_informations.aggregate(total=Sum('real_weight_of_carcasses'))[
                'total'] or 0
        total_kill_house_free_sale__bar_carcasses_governmental_weight = \
            kill_house_free_Sale_bar_informations.filter(quota='governmental').aggregate(
                total=Sum('real_weight_of_carcasses'))[
                'total'] or 0

        total_kill_house_free_sale__bar_carcasses_free_weight = \
            kill_house_free_Sale_bar_informations.filter(quota='free').aggregate(total=Sum('real_weight_of_carcasses'))[
                'total'] or 0

        total_kill_house_allocations_weight = \
            kill_house_allocations.aggregate(total=Sum('real_weight_of_carcasses'))[
                'total'] or 0

        total_kill_house_allocations_governmental_weight = \
            kill_house_allocations.filter(quota='governmental').aggregate(total=Sum('real_weight_of_carcasses'))[
                'total'] or 0
        total_kill_house_allocations_free_weight = \
            kill_house_allocations.filter(quota='free').aggregate(total=Sum('real_weight_of_carcasses'))[
                'total'] or 0

        segmentations_weight = \
            segmentations.aggregate(total=Sum('weight'))[
                'total'] or 0
        segmentations_governmental_weight = \
            segmentations.filter(quota='governmental').aggregate(total=Sum('weight'))[
                'total'] or 0
        segmentations_free_weight = \
            segmentations.filter(quota='free').aggregate(total=Sum('weight'))[
                'total'] or 0

        cold_house_allocations_weight = \
            cold_house_allocations.aggregate(total=Sum('real_weight_of_carcasses'))[
                'total'] or 0

        cold_house_allocations_governmental_weight = \
            cold_house_allocations.filter(quota='governmental').aggregate(total=Sum('real_weight_of_carcasses'))[
                'total'] or 0

        cold_house_allocations_free_weight = \
            cold_house_allocations.filter(quota='free').aggregate(total=Sum('real_weight_of_carcasses'))[
                'total'] or 0
        pos_allocated_weight_info = transactions.aggregate(
            pos_allocated_weight=Sum('cur_weight'),
            pos_governmental_allocated_weight=Sum('cur_weight',
                                                  filter=Q(price_approved=True)),
            pos_free_allocated_weight=Sum('cur_weight', filter=Q(price_approved=False)),

        )
        pos_allocated_weight = pos_allocated_weight_info['pos_allocated_weight'] or 0
        pos_governmental_allocated_weight = pos_allocated_weight_info['pos_governmental_allocated_weight'] or 0
        pos_free_allocated_weight = pos_allocated_weight_info['pos_free_allocated_weight'] or 0

        total_governmental_input_weight = total_entered_kill_house_requests_carcasses_governmental_weight
        total_free_input_weight = total_entered_kill_house_requests_carcasses_free_weight + total_entered_kill_house_free_bar_carcasses_weight
        total_governmental_output_weight = total_kill_house_free_sale__bar_carcasses_governmental_weight + segmentations_governmental_weight + total_kill_house_allocations_governmental_weight + cold_house_allocations_governmental_weight + int(pos_governmental_allocated_weight / 1000)
        total_free_output_weight = total_kill_house_free_sale__bar_carcasses_free_weight + total_kill_house_allocations_free_weight + segmentations_free_weight + cold_house_allocations_free_weight + int(pos_free_allocated_weight / 1000)
        total_governmental_remain_weight = (
                                                   total_governmental_input_weight - total_governmental_output_weight) - kill_house.ware_house_archive_governmental_weight
        total_free_remain_weight = (
                                           total_free_input_weight - total_free_output_weight) - kill_house.ware_house_archive_free_weight

        result = {

            "total_governmental_input_weight": int(total_governmental_input_weight),
            "total_free_input_weight": int(total_free_input_weight),
            "total_governmental_output_weight": int(total_governmental_output_weight),
            "total_free_output_weight": int(total_free_output_weight),
            "total_governmental_remain_weight": int(total_governmental_remain_weight),
            "total_free_remain_weight": int(total_free_remain_weight),
            "total_kill_house_free_sale__bar_carcasses_weight": int(total_kill_house_free_sale__bar_carcasses_weight),
            "total_kill_house_allocations_weight": int(total_kill_house_allocations_weight),
            "segmentations_weight": int(segmentations_weight),
            "cold_house_allocations_weight": int(cold_house_allocations_weight),
            "total_selling_in_province_governmental_weight": kill_house.total_selling_in_province_governmental_weight,
            "total_selling_in_province_free_weight": kill_house.total_selling_in_province_free_weight,
            "total_commitment_selling_in_province_governmental_weight": kill_house.total_commitment_selling_in_province_governmental_weight,
            "total_commitment_selling_in_province_governmental_remain_weight": kill_house.total_commitment_selling_in_province_governmental_remain_weight,
            "total_commitment_selling_in_province_free_weight": kill_house.total_commitment_selling_in_province_free_weight,
            "total_commitment_selling_in_province_free_remain_weight": kill_house.total_commitment_selling_in_province_free_remain_weight,
            "pos_allocated_weight": int(pos_allocated_weight / 1000),
            "pos_governmental_allocated_weight": int(pos_governmental_allocated_weight / 1000),
            "pos_free_allocated_weight": int(pos_free_allocated_weight / 1000),
            "ware_house_archive_governmental_weight": kill_house.ware_house_archive_governmental_weight,
            "ware_house_archive_free_weight": kill_house.ware_house_archive_free_weight,

        }

        return Response(result, status=200)


class KillHouseForColdHouseAllocationViewSet(GenericAPIView):
    permission_classes = [TokenHasReadWriteScope]
    serializer_class = KillHouseForColdHouseAllocationSerializer
    pagination_class = CustomPagination
    filter_backends = [DjangoFilterBackend]
    filterset_class = KillHouseFilterSet
    filterset_fields = [
        'name',
        'kill_house_operator__user__mobile',
        'kill_house_operator__user__fullname',
        'kill_house_operator__user__first_name',
        'kill_house_operator__user__last_name'

    ]

    def get(self, request):
        date1 = request.GET.get('date1')
        date2 = request.GET.get('date2')
        role = request.GET.get('role')
        user = SystemUserProfile.objects.get(user=request.user, trash=False)
        kill_house_filters = {'out_province': False, 'trash': False}
        if role in ['CityJahad']:
            kill_house_filters['kill_house_operator__user__city'] = user.city
        kill_houses = KillHouse.objects.filter(**kill_house_filters).order_by('id', 'killer')
        if 'search' in request.GET:
            kill_house_list = []
            if request.GET['search'] == 'filter':
                if request.GET['value'] != "" and request.GET['value'] != 'undefined':
                    for item in self.filterset_fields:
                        query = QueryDict('{0}__contains={1}'.format(item, request.GET['value']))
                        if (self.filterset_class(
                                data=query,
                                queryset=kill_houses
                        )
                        ).filter():
                            ps = self.filterset_class(data=query, queryset=kill_houses)
                            kill_house_list = ps.filter()
                    kill_houses = [] if len(
                        kill_house_list) == 0 else kill_house_list

        page_size = request.query_params.get('page_size', None)
        if page_size:
            self.pagination_class.page_size = int(page_size)

        page = self.paginate_queryset(kill_houses)
        if page is not None:
            serializer = self.get_serializer(page, many=True, context={'date1': date1, 'date2': date2})
            return self.get_paginated_response(serializer.data)

        serializer = self.serializer_class(kill_houses, many=True, context={'date1': date1, 'date2': date2})
        return Response(serializer.data, status=status.HTTP_200_OK)


class KillHouseForSegmentationViewSet(GenericAPIView):
    permission_classes = [TokenHasReadWriteScope]
    serializer_class = KillHouseForSegmentationSerializer
    pagination_class = CustomPagination
    filter_backends = [DjangoFilterBackend]
    filterset_class = KillHouseFilterSet
    filterset_fields = [
        'name',
        'kill_house_operator__user__mobile',
        'kill_house_operator__user__fullname',
        'kill_house_operator__user__first_name',
        'kill_house_operator__user__last_name'

    ]

    def get(self, request):
        date1 = request.GET.get('date1')
        date2 = request.GET.get('date2')
        role = request.GET.get('role')
        user = SystemUserProfile.objects.get(user=request.user, trash=False)
        kill_house_filters = {'out_province': False, 'trash': False}
        if role in ['CityJahad']:
            kill_house_filters['kill_house_operator__user__city'] = user.city

        kill_houses = KillHouse.objects.filter(**kill_house_filters).order_by('id', 'killer')

        if 'search' in request.GET:
            kill_house_list = []
            if request.GET['search'] == 'filter':
                if request.GET['value'] != "" and request.GET['value'] != 'undefined':
                    for item in self.filterset_fields:
                        query = QueryDict('{0}__contains={1}'.format(item, request.GET['value']))
                        if (self.filterset_class(
                                data=query,
                                queryset=kill_houses
                        )
                        ).filter():
                            ps = self.filterset_class(data=query, queryset=kill_houses)
                            kill_house_list = ps.filter()
                    kill_houses = [] if len(
                        kill_house_list) == 0 else kill_house_list

        page_size = request.query_params.get('page_size', None)
        if page_size:
            self.pagination_class.page_size = int(page_size)

        page = self.paginate_queryset(kill_houses)
        if page is not None:
            serializer = self.get_serializer(page, many=True, context={'date1': date1, 'date2': date2})
            return self.get_paginated_response(serializer.data)

        serializer = self.serializer_class(kill_houses, many=True, context={'date1': date1, 'date2': date2})
        return Response(serializer.data, status=status.HTTP_200_OK)


class KillHouseComparativeInformationViewSet(GenericAPIView):
    permission_classes = [TokenHasReadWriteScope]
    serializer_class = KillHouseComparativeInformationSerializer
    filter_backends = [DjangoFilterBackend]
    filterset_class = KillHouseFilterSet
    filterset_fields = [
        'name',
        'kill_house_operator__user__mobile',
        'kill_house_operator__user__fullname',
        'kill_house_operator__user__first_name',
        'kill_house_operator__user__last_name'

    ]

    def get(self, request):
        date1 = request.GET.get('date1')
        date2 = request.GET.get('date2')
        # kill_house_ids = KillHousePercentage.objects.filter(kill_house__type='exclusive', trash=False).values_list(
        #     'kill_house', flat=True)
        # kill_houses = KillHouse.objects.filter(out_province=False,killer=False,trash=False).exclude(
        #     id__in=kill_house_ids).order_by('id')
        kill_houses = KillHouse.objects.filter(out_province=False, killer=False, trash=False).order_by('id')
        codes = kill_houses.values_list('unique_identifier', flat=True)
        code = ",".join(codes)
        if date1:
            url = f"https://rsibackend.rasadyar.com/app/send_transport_carcass_detail_for_rasadyaar/?code={code}&date1={date1}&date2={date2}"
        else:
            url = f"https://rsibackend.rasadyar.com/app/send_transport_carcass_detail_for_rasadyaar/?code={code}"

        response = requests.get(url)
        rsi_data = response.json()
        if 'search' in request.GET:
            kill_house_list = []
            if request.GET['search'] == 'filter':
                if request.GET['value'] != "" and request.GET['value'] != 'undefined':
                    for item in self.filterset_fields:
                        query = QueryDict('{0}__contains={1}'.format(item, request.GET['value']))
                        if (self.filterset_class(
                                data=query,
                                queryset=kill_houses
                        )
                        ).filter():
                            ps = self.filterset_class(data=query, queryset=kill_houses)
                            kill_house_list = ps.filter()
                    kill_houses = [] if len(
                        kill_house_list) == 0 else kill_house_list
        serializer = self.serializer_class(kill_houses, many=True,
                                           context={'date1': date1, 'date2': date2, 'rsi_data': rsi_data})
        return Response(serializer.data, status=status.HTTP_200_OK)


def cancel_bar_and_province_request(request):
    date_str = '2025-10-11'
    date = datetime.now().date() - timedelta(days=1)

    kill_house_requests = KillHouseRequest.objects.filter(trash=False, ware_house_confirmation=False,
                                                          kill_request__recive_date__date__lte=date,
                                                          kill_request__recive_date__date__gte=date_str)
    all_province_requests = kill_house_requests.values_list('province_kill_request', flat=True).distinct()
    for kill_house_request in kill_house_requests:
        kill_house_request.trash = True
        kill_house_request.return_trash = True
        kill_house_request.save()
        update_kill_house_requests(kill_house_request.province_kill_request,
                                   kill_house_request.province_request.poultry_request)
        update_province_kill_requests(
            kill_house_request.province_kill_request.province_request.poultry_request.hatching)

    for all_province_request in all_province_requests:
        if not KillHouseRequest.objects.filter(trash=False, province_kill_request=all_province_request).exists():
            all_province_request.return_to_province = True
            all_province_request.returner = {"date": str(datetime.today()),
                                             "mobile": "09000000000", "fullname": "برگشت به دلیل حذف سیستمی بار"}
            all_province_request.save()

    province_requests = ProvinceKillRequest.objects.filter(trash=False, first_car_allocated_quantity=0,
                                                           return_to_province=False,
                                                           kill_request__recive_date__date=datetime.now().date(),
                                                           )
    for province_request in province_requests:
        province_request.trash = True
        province_request.return_trash = True
        province_request.save()
        update_province_kill_requests(province_request.province_request.poultry_request.hatching)

    return HttpResponse('ok')


def cancel_bar_and_province_request_cron():
    date_str = '2025-10-11'
    date = datetime.now().date() - timedelta(days=1)

    kill_house_requests = KillHouseRequest.objects.filter(trash=False, ware_house_confirmation=False,
                                                          kill_request__recive_date__date__lte=date,
                                                          kill_request__recive_date__date__gte=date_str)
    all_province_requests = kill_house_requests.values_list('province_kill_request', flat=True).distinct()
    for kill_house_request in kill_house_requests:
        kill_house_request.trash = True
        kill_house_request.return_trash = True
        kill_house_request.save()
        update_kill_house_requests(kill_house_request.province_kill_request,
                                   kill_house_request.province_request.poultry_request)
        update_province_kill_requests(
            kill_house_request.province_kill_request.province_request.poultry_request.hatching)

    for all_province_request in all_province_requests:
        if not KillHouseRequest.objects.filter(trash=False, province_kill_request=all_province_request).exists():
            all_province_request.return_to_province = True
            all_province_request.returner = {"date": str(datetime.today()),
                                             "mobile": "09000000000", "fullname": "برگشت به دلیل حذف سیستمی بار"}
            all_province_request.save()

    province_requests = ProvinceKillRequest.objects.filter(trash=False, first_car_allocated_quantity=0,
                                                           return_to_province=False,
                                                           kill_request__recive_date__date=datetime.now().date(),
                                                           )
    for province_request in province_requests:
        province_request.trash = True
        province_request.return_trash = True
        province_request.save()
        update_province_kill_requests(province_request.province_request.poultry_request.hatching)


class ReturnProvinceKillRequestViewSet(GenericAPIView):
    permission_classes = [TokenHasReadWriteScope]
    serializer_class = ReturnProvinceKillRequestSerializer
    pagination_class = CustomPagination
    filter_backends = [DjangoFilterBackend]
    filterset_class = ReturnProvinceKillRequestFilterSet
    filterset_fields = [
        'province_request__poultry_request__order_code',
        'killhouse_user__name',
        'killhouse_user__kill_house_operator__user__fullname',
        'killhouse_user__kill_house_operator__user__mobile',
        'killhouse_user__kill_house_operator__address__city__name',
        'province_request__poultry_request__poultry__unit_name',
        'province_request__poultry_request__poultry__user__fullname',
        'province_request__poultry_request__poultry__user__mobile',
        'province_request__poultry_request__poultry__address__city__name',
    ]

    def get(self, request):
        date1 = request.GET.get('date1')
        date2 = request.GET.get('date2')
        role = request.GET.get('role')
        user = SystemUserProfile.objects.get(user=request.user, trash=False)
        filters = {
            'archive_wage': False,
            'state__in': ('pending', 'accepted'),
            'first_car_allocated_quantity': 0
        }
        if role == 'KillHouse':
            filters['killhouse_user__kill_house_operator__user'] = user
        if date1:
            filters['kill_request__recive_date__date__gte'] = date1
            filters['kill_request__recive_date__date__lte'] = date2

        return_province_kill_requests = ProvinceKillRequest.objects.filter(
            Q(trash=False, return_to_province=True) | Q(trash=True, return_trash=True), **filters).order_by('id')

        if 'search' in request.GET:
            return_province_kill_requests_list = []
            if request.GET['search'] == 'filter':
                if request.GET['value'] != "" and request.GET['value'] != 'undefined':
                    for item in self.filterset_fields:
                        query = QueryDict('{0}__contains={1}'.format(item, request.GET['value']))
                        if (self.filterset_class(
                                data=query,
                                queryset=return_province_kill_requests
                        )
                        ).filter():
                            ps = self.filterset_class(data=query, queryset=return_province_kill_requests)
                            return_province_kill_requests_list = ps.filter()
                    return_province_kill_requests = [] if len(
                        return_province_kill_requests_list) == 0 else return_province_kill_requests_list
        page_size = request.query_params.get('page_size', None)
        if page_size:
            self.pagination_class.page_size = int(page_size)

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

        serializer = self.serializer_class(return_province_kill_requests, many=True)
        return Response(serializer.data, status=status.HTTP_200_OK)

    def put(self, request):
        return_province_kill_requests = ProvinceKillRequest.objects.get(
            key=request.data['key'])
        request.data.pop('key')
        serializer = self.serializer_class(return_province_kill_requests)
        serializer.update(instance=return_province_kill_requests, validated_data=request.data)
        update_province_kill_requests(return_province_kill_requests.province_request.poultry_request.hatching)
        poultry_prediction(return_province_kill_requests.province_request.poultry_request.hatching.poultry)
        return Response(serializer.data, status=status.HTTP_200_OK)


class ReturnKillHouseRequestViewSet(viewsets.ModelViewSet):
    queryset = KillHouseRequest.objects.all()
    serializer_class = KillHouseRequestForBarManagementSerializer
    pagination_class = CustomPagination
    permission_classes = [TokenHasReadWriteScope]
    filter_backends = [DjangoFilterBackend]
    filterset_class = KillHouseRequestFilterSet
    filterset_fields = [
        'killhouse_user__kill_house_operator__user__fullname',
        'killhouse_user__kill_house_operator__user__mobile',
        'province_request__poultry_request__poultry__user__fullname',
        'province_request__poultry_request__poultry__user__mobile',
        'province_request__poultry_request__order_code',
        'province_request__poultry_request__order_code',
        'bar_code',
    ]

    def list(self, request, *args, **kwargs):
        if request.GET['role'] == 'KillHouse':
            user = SystemUserProfile.objects.get(user=request.user)
            kill_house = KillHouse.objects.filter(kill_house_operator__user=user, trash=False).first()
            if 'date1' in request.GET and 'date2' in request.GET:
                date1 = datetime.strptime(str(request.GET['date1']), '%Y-%m-%d').date()
                date2 = datetime.strptime(str(request.GET['date2']), '%Y-%m-%d').date()
                kill_house_requests = KillHouseRequest.objects.filter(
                    Q(killhouse_user=kill_house) | Q(killer=kill_house),
                    Q(non_receipt=True, main_non_receipt=True) | Q(trash=True, return_trash=True),
                    kill_request__recive_date__date__gte=date1,
                    kill_request__recive_date__date__lte=date2)

            else:
                kill_house_requests = KillHouseRequest.objects.filter(
                    Q(killhouse_user=kill_house) | Q(killer=kill_house),
                    Q(non_receipt=True, main_non_receipt=True) | Q(trash=True, return_trash=True))

        else:
            if 'date1' in request.GET and 'date2' in request.GET:
                date1 = datetime.strptime(str(request.GET['date1']), '%Y-%m-%d').date()
                date2 = datetime.strptime(str(request.GET['date2']), '%Y-%m-%d').date()
                kill_house_requests = KillHouseRequest.objects.filter(
                    Q(non_receipt=True, main_non_receipt=True) | Q(trash=True, return_trash=True),
                    kill_request__recive_date__date__gte=date1,
                    kill_request__recive_date__date__lte=date2)

            else:
                kill_house_requests = KillHouseRequest.objects.filter(
                    Q(non_receipt=True, main_non_receipt=True) | Q(trash=True, return_trash=True))

        if 'search' in request.GET:
            kill_house_request_list = []
            if request.GET['search'] == 'filter':
                if request.GET['value'] != "" and request.GET['value'] != 'undefined':
                    for item in self.filterset_fields:
                        query = QueryDict('{0}__contains={1}'.format(item, request.GET['value']))
                        if (self.filterset_class(
                                data=query,
                                queryset=kill_house_requests
                        )
                        ).filter():
                            ps = self.filterset_class(data=query, queryset=kill_house_requests)
                            kill_house_request_list = ps.filter()
                    kill_house_requests = [] if len(kill_house_request_list) == 0 else kill_house_request_list

        page_size = request.query_params.get('page_size', None)
        if page_size:
            self.pagination_class.page_size = int(page_size)

        page = self.paginate_queryset(kill_house_requests)
        if page is not None:
            serializer = KillHouseRequestForBarManagementSerializer(page, many=True)
            return self.get_paginated_response(serializer.data)

        serializer = KillHouseRequestForBarManagementSerializer(kill_house_requests, many=True)
        return Response(serializer.data, status=status.HTTP_200_OK)

    def update(self, request, *args, **kwargs):
        kill_house_requests = KillHouseRequest.objects.get(key=request.data['key'])
        kill_house_requests.province_kill_request.trash = False
        kill_house_requests.province_kill_request.return_trash = False
        kill_house_requests.province_kill_request.return_to_province = False
        kill_house_requests.province_kill_request.returner = None
        kill_house_requests.province_kill_request.save()
        request.data.pop('key')
        serializer = self.serializer_class(kill_house_requests)
        serializer.update(instance=kill_house_requests, validated_data=request.data)
        update_kill_house_requests(kill_house_requests.province_kill_request,
                                   kill_house_requests.province_request.poultry_request)
        update_province_kill_requests(kill_house_requests.province_request.poultry_request.hatching)
        return Response(serializer.data, status=status.HTTP_200_OK)


class ReturnRequestDashboardViewSet(GenericAPIView):
    permission_classes = [TokenHasReadWriteScope]

    def get(self, request):
        date1 = request.GET.get('date1')
        date2 = request.GET.get('date2')
        role = request.GET.get('role')
        user = SystemUserProfile.objects.get(user=request.user, trash=False)
        total_wage_type = WageType.objects.filter(trash=False)
        province_live_wage_type = total_wage_type.filter(en_name='province-kill-request', trash=False).first()
        province_live_wage_type_amount = province_live_wage_type.amount if province_live_wage_type.status == True else 0

        province_kill_request_filters = {
            'archive_wage': False,
            'state__in': ('pending', 'accepted'),
            'first_car_allocated_quantity': 0
        }

        kill_house_request_filters = {}
        if date1:
            province_kill_request_filters['kill_request__recive_date__date__gte'] = date1
            province_kill_request_filters['kill_request__recive_date__date__lte'] = date2
            kill_house_request_filters['kill_request__recive_date__date__gte'] = date1
            kill_house_request_filters['kill_request__recive_date__date__lte'] = date2
        if role == 'KillHouse':
            kill_house = KillHouse.objects.filter(kill_house_operator__user=user, trash=False).first()
            province_kill_request_filters['killhouse_user'] = kill_house
            return_kill_house_requests = KillHouseRequest.objects.filter(
                Q(killhouse_user=kill_house) | Q(killer=kill_house),
                Q(non_receipt=True, main_non_receipt=True, non_receipt_state__in=('pending', 'accepted')) | Q(
                    trash=True, return_trash=True),
                **kill_house_request_filters)
        else:
            return_kill_house_requests = KillHouseRequest.objects.filter(
                Q(non_receipt=True, main_non_receipt=True, non_receipt_state__in=('pending', 'accepted')) | Q(
                    trash=True, return_trash=True),
                **kill_house_request_filters)

        return_province_kill_requests = ProvinceKillRequest.objects.filter(
            Q(trash=False, return_to_province=True) | Q(trash=True, return_trash=True),
            **province_kill_request_filters).order_by('id')

        return_province_kill_requests_aggregates = return_province_kill_requests.aggregate(
            total_count=Count('id'),
            total_operator_return_count=Count('id', filter=Q(trash=False, return_to_province=True)),
            total_system_return_count=Count('id', filter=Q(trash=True, return_trash=True)),
            total_quantity=Sum('total_killed_quantity'),
            total_operator_return_quantity=Sum('main_quantity', filter=Q(trash=False, return_to_province=True)),
            total_system_return_quantity=Sum('total_killed_quantity', filter=Q(trash=True, return_trash=True)),
            total_weight=Sum('total_killed_weight'),
            total_operator_return_weight=Sum(F('main_quantity') * F('province_request__poultry_request__Index_weight'),
                                             filter=Q(trash=False, return_to_province=True)),
            total_system_return_weight=Sum('total_killed_weight', filter=Q(trash=True, return_trash=True)),

        )
        return_kill_house_requests_aggregates = return_kill_house_requests.aggregate(
            total_count=Count('id'),
            total_non_receipt_count=Count('id', filter=Q(non_receipt=True, main_non_receipt=True)),
            total_system_return_count=Count('id', filter=Q(trash=True, return_trash=True)),
            total_quantity=Sum('accepted_real_quantity'),
            total_non_receipt_quantity=Sum('accepted_real_quantity', filter=Q(non_receipt=True, main_non_receipt=True)),
            total_system_return_quantity=Sum('accepted_real_quantity', filter=Q(trash=True, return_trash=True)),
            total_weight=Sum('accepted_real_weight'),
            total_non_receipt_weight=Sum('accepted_real_weight', filter=Q(non_receipt=True, main_non_receipt=True)),
            total_system_return_weight=Sum('accepted_real_weight', filter=Q(trash=True, return_trash=True)),
        )
        province_kill_request_total_operator_return_quantity = return_province_kill_requests_aggregates[
                                                                   'total_operator_return_quantity'] or 0
        province_kill_request_total_system_return_quantity = return_province_kill_requests_aggregates[
                                                                 'total_system_return_quantity'] or 0
        province_kill_request_total_quantity = province_kill_request_total_operator_return_quantity + province_kill_request_total_system_return_quantity
        province_kill_request_total_operator_return_weight = return_province_kill_requests_aggregates[
                                                                 'total_operator_return_weight'] or 0
        province_kill_request_total_system_return_weight = return_province_kill_requests_aggregates[
                                                               'total_system_return_weight'] or 0
        province_kill_request_total_weight = province_kill_request_total_operator_return_weight + province_kill_request_total_system_return_weight
        kill_house_request_total_system_return_weight = return_kill_house_requests_aggregates[
                                                            'total_system_return_weight'] or 0
        total_return_weight_with_wage = province_kill_request_total_system_return_weight + kill_house_request_total_system_return_weight
        result = {
            "province_kill_request_total_count": return_province_kill_requests_aggregates['total_count'] or 0,
            "province_kill_request_total_operator_return_count": return_province_kill_requests_aggregates[
                                                                     'total_operator_return_count'] or 0,
            "province_kill_request_total_system_return_count": return_province_kill_requests_aggregates[
                                                                   'total_system_return_count'] or 0,
            "province_kill_request_total_quantity": province_kill_request_total_quantity,
            "province_kill_request_total_operator_return_quantity": province_kill_request_total_operator_return_quantity,
            "province_kill_request_total_system_return_quantity": province_kill_request_total_system_return_quantity,
            "province_kill_request_total_weight": province_kill_request_total_weight,
            "province_kill_request_total_operator_return_weight": province_kill_request_total_operator_return_weight,
            "province_kill_request_total_system_return_weight": province_kill_request_total_system_return_weight,
            "kill_house_request_total_count": return_kill_house_requests_aggregates['total_count'] or 0,
            "kill_house_request_total_non_receipt_count": return_kill_house_requests_aggregates[
                                                              'total_non_receipt_count'] or 0,
            "kill_house_request_total_system_return_count": return_kill_house_requests_aggregates[
                                                                'total_system_return_count'] or 0,
            "kill_house_request_total_quantity": return_kill_house_requests_aggregates['total_quantity'] or 0,
            "kill_house_request_total_non_receipt_quantity": return_kill_house_requests_aggregates[
                                                                 'total_non_receipt_quantity'] or 0,
            "kill_house_request_total_system_return_quantity": return_kill_house_requests_aggregates[
                                                                   'total_system_return_quantity'] or 0,
            "kill_house_request_total_weight": return_kill_house_requests_aggregates['total_weight'] or 0,
            "kill_house_request_total_non_receipt_weight": return_kill_house_requests_aggregates[
                                                               'total_non_receipt_weight'] or 0,
            "kill_house_request_total_system_return_weight": kill_house_request_total_system_return_weight,
            "total_return_weight_with_wage": total_return_weight_with_wage,
            "total_return_wage": total_return_weight_with_wage * province_live_wage_type_amount,
        }

        return Response(result, status=status.HTTP_200_OK)


# class KillHouseRemainWeightViewSet(GenericAPIView):
#     permission_classes = [TokenHasReadWriteScope]
#
#     def get(self, request):
#         # چک کردن آیا کاربر بازه تاریخی دلخواه فرستاده یا نه
#         start_date_param = request.query_params.get('date1', None)
#         end_date_param = request.query_params.get('date2', None)
#
#         if start_date_param and end_date_param:
#             # بازه تاریخی دلخواه از ورودی کاربر
#             user = SystemUserProfile.objects.get(user=request.user, trash=False)
#             kill_house = KillHouse.objects.filter(kill_house_operator__user=user).first()
#             product = RolesProducts.objects.filter(kill_house=kill_house, trash=False, name='مرغ گرم').first()
#
#             # تبدیل string به date
#             from datetime import datetime as dt
#             start_date = dt.strptime(start_date_param, '%Y-%m-%d').date()
#             end_date = dt.strptime(end_date_param, '%Y-%m-%d').date()
#
#             # ساخت لیست تمام روزهای بین start_date و end_date
#             days = []
#             current_day = start_date
#             while current_day <= end_date:
#                 days.append(current_day)
#                 current_day += timedelta(days=1)
#
#             kill_house_requests = KillHouseRequest.objects.filter(
#                 input_warehouse=kill_house,
#                 kill_request__recive_date__date__gte=start_date,
#                 kill_request__recive_date__date__lte=end_date,
#                 ware_house_confirmation=True,
#                 trash=False,
#                 calculate_status=True,
#                 warehouse=True
#             )
#
#             kill_house_free_buying_bars = KillHouseFreeBarInformation.objects.filter(
#                 trash=False,
#                 calculate_status=True,
#                 warehouse=True,
#                 date__date__gte=start_date,
#                 date__date__lte=end_date,
#                 input_warehouse=kill_house
#             ).exclude(entered_message='ورود به انبار مجازی')
#
#             kill_house_allocations = StewardAllocation.objects.filter(
#                 kill_house=kill_house,
#                 trash=False,
#                 calculate_status=True,
#                 warehouse=True,
#                 receiver_state__in=('pending', 'accepted'),
#                 production_date__date__gte=start_date,
#                 production_date__date__lte=end_date
#             )
#
#             kill_house_free_sale_bars = KillHouseFreeSaleBarInformation.objects.filter(
#                 kill_house=kill_house,
#                 production_date__date__gte=start_date,
#                 production_date__date__lte=end_date,
#                 trash=False,
#                 calculate_status=True,
#                 warehouse=True
#             )
#
#             segmentations = PosSegmentation.objects.filter(
#                 kill_house=kill_house,
#                 production_date__date__gte=start_date,
#                 production_date__date__lte=end_date,
#                 trash=False,
#                 warehouse=True
#             )
#
#             transactions = ProductsTransactions.objects.filter(
#                 product=product,
#                 transaction__paid=True,
#                 transaction__date__date__gte=start_date,
#                 transaction__date__date__lte=end_date,
#                 trash=False,
#                 warehouse=True
#             )
#
#             governmental_list = []
#             free_list = []
#             final_dict = {}
#
#             for day in days:
#                 kill_house_requests_info = kill_house_requests.aggregate(
#                     total_kill_house_request_governmental_weight=Sum(
#                         'ware_house_accepted_real_weight',
#                         filter=Q(province_request__poultry_request__free_sale_in_province=False,
#                                  kill_request__recive_date__date=day)
#                     ),
#                     total_kill_house_request_free_weight=Sum(
#                         'ware_house_accepted_real_weight',
#                         filter=Q(province_request__poultry_request__free_sale_in_province=True,
#                                  kill_request__recive_date__date=day)
#                     ),
#                 )
#
#                 kill_house_free_buying_bars_info = kill_house_free_buying_bars.aggregate(
#                     total_kill_house_free_buying_bars_weight=Sum(
#                         'weight_of_carcasses', filter=Q(date__date=day)
#                     )
#                 )
#
#                 kill_house_allocations_info = kill_house_allocations.aggregate(
#                     total_kill_house_allocations_governmental_weight=Sum(
#                         'real_weight_of_carcasses',
#                         filter=Q(quota='governmental', production_date__date=day)
#                     ),
#                     total_kill_house_allocations_free_weight=Sum(
#                         'real_weight_of_carcasses',
#                         filter=Q(quota='free', production_date__date=day)
#                     ),
#                 )
#
#                 kill_house_free_sale_bars_info = kill_house_free_sale_bars.aggregate(
#                     total_kill_house_free_sale_bars_governmental_weight=Sum(
#                         'real_weight_of_carcasses',
#                         filter=Q(quota='governmental', production_date__date=day)
#                     ),
#                     total_kill_house_free_sale_bars_free_weight=Sum(
#                         'real_weight_of_carcasses',
#                         filter=Q(quota='free', production_date__date=day)
#                     ),
#                 )
#
#                 segmentations_info = segmentations.aggregate(
#                     segmentations_governmental_weight=Sum(
#                         'weight', filter=Q(quota='governmental', production_date__date=day)
#                     ),
#                     segmentations_free_weight=Sum(
#                         'weight', filter=Q(quota='free', production_date__date=day)
#                     ),
#                 )
#
#                 pos_allocated_weight_info = transactions.aggregate(
#                     pos_governmental_allocated_weight=Sum(
#                         'cur_weight', filter=Q(price_approved=True, transaction__date__date=day)
#                     ),
#                     pos_free_allocated_weight=Sum(
#                         'cur_weight', filter=Q(price_approved=False, transaction__date__date=day)
#                     ),
#                 )
#
#                 total_kill_house_request_governmental_weight = kill_house_requests_info[
#                                                                    'total_kill_house_request_governmental_weight'] or 0
#                 total_kill_house_request_free_weight = kill_house_requests_info[
#                                                            'total_kill_house_request_free_weight'] or 0
#                 total_kill_house_free_buying_bars_weight = kill_house_free_buying_bars_info[
#                                                                'total_kill_house_free_buying_bars_weight'] or 0
#                 total_kill_house_allocations_governmental_weight = kill_house_allocations_info[
#                                                                        'total_kill_house_allocations_governmental_weight'] or 0
#                 total_kill_house_allocations_free_weight = kill_house_allocations_info[
#                                                                'total_kill_house_allocations_free_weight'] or 0
#                 total_kill_house_free_sale_bars_governmental_weight = kill_house_free_sale_bars_info[
#                                                                           'total_kill_house_free_sale_bars_governmental_weight'] or 0
#                 total_kill_house_free_sale_bars_free_weight = kill_house_free_sale_bars_info[
#                                                                   'total_kill_house_free_sale_bars_free_weight'] or 0
#                 segmentations_governmental_weight = segmentations_info['segmentations_governmental_weight'] or 0
#                 segmentations_free_weight = segmentations_info['segmentations_free_weight'] or 0
#                 pos_governmental_allocated_weight = pos_allocated_weight_info['pos_governmental_allocated_weight'] or 0
#                 pos_free_allocated_weight = pos_allocated_weight_info['pos_free_allocated_weight'] or 0
#
#                 total_governmental_input = total_kill_house_request_governmental_weight
#                 total_free_input = total_kill_house_request_free_weight + total_kill_house_free_buying_bars_weight
#
#                 total_governmental_output = (
#                         total_kill_house_allocations_governmental_weight +
#                         total_kill_house_free_sale_bars_governmental_weight +
#                         segmentations_governmental_weight +
#                         int(pos_governmental_allocated_weight / 1000)
#                 )
#
#                 total_free_output = (
#                         total_kill_house_allocations_free_weight +
#                         total_kill_house_free_sale_bars_free_weight +
#                         segmentations_free_weight +
#                         int(pos_free_allocated_weight / 1000)
#                 )
#
#                 governmental_data = {
#                     'day': day,
#                     'amount': total_governmental_input - total_governmental_output,
#                 }
#                 free_data = {
#                     'day': day,
#                     'amount': total_free_input - total_free_output,
#                 }
#
#                 governmental_list.append(governmental_data)
#                 free_list.append(free_data)
#
#             final_dict['governmental'] = governmental_list
#             final_dict['free'] = free_list
#             return Response(final_dict, status=status.HTTP_200_OK)
#
#         # حالت پیش‌فرض: 3 روز اخیر (کد قبلی دست نخورده)
#         user = SystemUserProfile.objects.get(user=request.user, trash=False)
#         kill_house = KillHouse.objects.filter(kill_house_operator__user=user).first()
#         product = RolesProducts.objects.filter(kill_house=kill_house, trash=False, name='مرغ گرم').first()
#         today = datetime.now().date()
#         yesterday = today - timedelta(days=1)
#         two_days_ago = yesterday - timedelta(days=1)
#         days = (two_days_ago, yesterday, today)
#
#         archives = WarehouseArchive.objects.filter(kill_house=kill_house, trash=False,date__date__gte=two_days_ago,date__date__lte=today)
#
#
#         kill_house_requests = KillHouseRequest.objects.filter(input_warehouse=kill_house,
#                                                               kill_request__recive_date__date__gte=two_days_ago,
#                                                               kill_request__recive_date__date__lte=today,
#                                                               ware_house_confirmation=True, trash=False,
#                                                               calculate_status=True, warehouse=True)
#         kill_house_free_buying_bars = KillHouseFreeBarInformation.objects.filter(trash=False,
#                                                                                  calculate_status=True, warehouse=True,
#                                                                                  date__date__gte=two_days_ago,
#                                                                                  date__date__lte=today,
#                                                                                  input_warehouse=kill_house) \
#             .exclude(entered_message='ورود به انبار مجازی')
#         kill_house_allocations = StewardAllocation.objects.filter(
#             kill_house=kill_house, trash=False, calculate_status=True, warehouse=True,
#             receiver_state__in=('pending', 'accepted'), production_date__date__gte=two_days_ago,
#             production_date__date__lte=today)
#
#         kill_house_free_sale_bars = KillHouseFreeSaleBarInformation.objects.filter(kill_house=kill_house,
#                                                                                    production_date__date__gte=two_days_ago,
#                                                                                    production_date__date__lte=today,
#                                                                                    trash=False,
#                                                                                    calculate_status=True,
#                                                                                    warehouse=True)
#         segmentations = PosSegmentation.objects.filter(kill_house=kill_house, production_date__date__gte=two_days_ago,
#                                                        production_date__date__lte=today, trash=False,
#                                                        warehouse=True)
#         transactions = ProductsTransactions.objects.filter(product=product, transaction__paid=True,
#                                                            transaction__date__date__gte=two_days_ago,
#                                                            transaction__date__date__lte=today, trash=False,
#                                                            warehouse=True)
#
#         governmental_list = []
#         free_list = []
#         final_dict = {}
#
#         for day in days:
#             kill_house_requests_info = kill_house_requests.aggregate(
#                 total_kill_house_request_governmental_weight=Sum('ware_house_accepted_real_weight', filter=Q(
#                     province_request__poultry_request__free_sale_in_province=False,
#                     kill_request__recive_date__date=day)),
#                 total_kill_house_request_free_weight=Sum('ware_house_accepted_real_weight', filter=Q(
#                     province_request__poultry_request__free_sale_in_province=True,
#                     kill_request__recive_date__date=day)),
#
#             )
#
#             kill_house_free_buying_bars_info = kill_house_free_buying_bars.aggregate(
#                 total_kill_house_free_buying_bars_weight=Sum('weight_of_carcasses', filter=Q(date__date=day)))
#
#             kill_house_allocations_info = kill_house_allocations.aggregate(
#                 total_kill_house_allocations_governmental_weight=Sum('real_weight_of_carcasses',
#                                                                      filter=Q(quota='governmental',
#                                                                               production_date__date=day)),
#                 total_kill_house_allocations_free_weight=Sum('real_weight_of_carcasses',
#                                                              filter=Q(quota='free', production_date__date=day)),
#
#             )
#
#             kill_house_free_sale_bars_info = kill_house_free_sale_bars.aggregate(
#                 total_kill_house_free_sale_bars_governmental_weight=Sum('real_weight_of_carcasses',
#                                                                         filter=Q(quota='governmental',
#                                                                                  production_date__date=day)),
#                 total_kill_house_free_sale_bars_free_weight=Sum('real_weight_of_carcasses',
#                                                                 filter=Q(quota='free', production_date__date=day)),
#
#             )
#
#             segmentations_info = segmentations.aggregate(
#                 segmentations_governmental_weight=Sum('weight',
#                                                       filter=Q(quota='governmental', production_date__date=day)),
#                 segmentations_free_weight=Sum('weight', filter=Q(quota='free', production_date__date=day)),
#
#             )
#             pos_allocated_weight_info = transactions.aggregate(
#                 pos_governmental_allocated_weight=Sum('cur_weight',
#                                                       filter=Q(price_approved=True, transaction__date__date=day)),
#                 pos_free_allocated_weight=Sum('cur_weight',
#                                               filter=Q(price_approved=False, transaction__date__date=day)),
#
#             )
#
#             archives_info = archives.aggregate(
#                 archives_governmental_weight=Sum('weight',
#                                                       filter=Q(quota='governmental', date__date=day)),
#                 archives_free_weight=Sum('weight',
#                                               filter=Q(quota='free', date__date=day)),
#
#             )
#
#             total_kill_house_request_governmental_weight = kill_house_requests_info[
#                                                                'total_kill_house_request_governmental_weight'] or 0
#             total_kill_house_request_free_weight = kill_house_requests_info['total_kill_house_request_free_weight'] or 0
#             total_kill_house_free_buying_bars_weight = kill_house_free_buying_bars_info[
#                                                            'total_kill_house_free_buying_bars_weight'] or 0
#             total_kill_house_allocations_governmental_weight = kill_house_allocations_info[
#                                                                    'total_kill_house_allocations_governmental_weight'] or 0
#             total_kill_house_allocations_free_weight = kill_house_allocations_info[
#                                                            'total_kill_house_allocations_free_weight'] or 0
#             total_kill_house_free_sale_bars_governmental_weight = kill_house_free_sale_bars_info[
#                                                                       'total_kill_house_free_sale_bars_governmental_weight'] or 0
#             total_kill_house_free_sale_bars_free_weight = kill_house_free_sale_bars_info[
#                                                               'total_kill_house_free_sale_bars_free_weight'] or 0
#             segmentations_governmental_weight = segmentations_info['segmentations_governmental_weight'] or 0
#             segmentations_free_weight = segmentations_info['segmentations_free_weight'] or 0
#             pos_governmental_allocated_weight = pos_allocated_weight_info['pos_governmental_allocated_weight'] or 0
#             pos_free_allocated_weight = pos_allocated_weight_info['pos_free_allocated_weight'] or 0
#
#             archives_governmental_weight = archives_info['archives_governmental_weight'] or 0
#             archives_free_weight = archives_info['archives_free_weight'] or 0
#
#             total_governmental_input = total_kill_house_request_governmental_weight
#             total_free_input = total_kill_house_request_free_weight + total_kill_house_free_buying_bars_weight
#             total_governmental_output = total_kill_house_allocations_governmental_weight + total_kill_house_free_sale_bars_governmental_weight + segmentations_governmental_weight + int(
#                 pos_governmental_allocated_weight / 1000)
#             total_free_output = total_kill_house_allocations_free_weight + total_kill_house_free_sale_bars_free_weight + segmentations_free_weight + int(
#                 pos_free_allocated_weight / 1000)
#             governmental_data = {
#                 'day': day,
#                 'amount': (total_governmental_input - total_governmental_output) - archives_governmental_weight,
#             }
#             free_data = {
#                 'day': day,
#                 'amount': (total_free_input - total_free_output) - archives_free_weight,
#             }
#
#             governmental_list.append(governmental_data)
#             free_list.append(free_data)
#         final_dict['governmental'] = governmental_list
#         final_dict['free'] = free_list
#         return Response(final_dict, status=status.HTTP_200_OK)
#
#     # def get(self, request):
#     #     target_date = request.GET.get('date')
#     #     user = SystemUserProfile.objects.get(user=request.user, trash=False)
#     #
#     #     kill_house = KillHouse.objects.filter(kill_house_operator__user=user).first()
#     #
#     #     product = RolesProducts.objects.filter(kill_house=kill_house, trash=False, name='مرغ گرم').first()
#     #
#     #     today = datetime.now().date() if not target_date else datetime.strptime(target_date, "%Y-%m-%d").date()
#     #     month_ago = today - timedelta(days=30)
#     #     yesterday = today - timedelta(days=1)
#     #     two_days_ago = yesterday - timedelta(days=1)
#     #
#     #     days = [month_ago + timedelta(days=i) for i in range(31)]
#     #     target_days = [two_days_ago ,yesterday , today]
#     #
#     #     kill_house_requests = KillHouseRequest.objects.filter(
#     #         input_warehouse=kill_house,
#     #         kill_request__recive_date__date__gte=month_ago,
#     #         kill_request__recive_date__date__lte=today,
#     #         ware_house_confirmation=True,
#     #         trash=False,
#     #         calculate_status=True,
#     #         warehouse=True
#     #     )
#     #
#     #     kill_house_free_buying_bars = KillHouseFreeBarInformation.objects.filter(
#     #         trash=False,
#     #         calculate_status=True,
#     #         warehouse=True,
#     #         date__date__gte=month_ago,
#     #         date__date__lte=today,
#     #         input_warehouse=kill_house
#     #     ).exclude(entered_message='ورود به انبار مجازی')
#     #
#     #     kill_house_allocations = StewardAllocation.objects.filter(
#     #         kill_house=kill_house,
#     #         trash=False,
#     #         calculate_status=True,
#     #         warehouse=True,
#     #         receiver_state__in=('pending', 'accepted'),
#     #         production_date__date__gte=month_ago,
#     #         production_date__date__lte=today
#     #     )
#     #
#     #     kill_house_free_sale_bars = KillHouseFreeSaleBarInformation.objects.filter(
#     #         kill_house=kill_house,
#     #         production_date__date__gte=month_ago,
#     #         production_date__date__lte=today,
#     #         trash=False,
#     #         calculate_status=True,
#     #         warehouse=True
#     #     )
#     #
#     #     segmentations = PosSegmentation.objects.filter(
#     #         kill_house=kill_house,
#     #         production_date__date__gte=month_ago,
#     #         production_date__date__lte=today,
#     #         trash=False,
#     #         warehouse=True
#     #     )
#     #
#     #     transactions = ProductsTransactions.objects.filter(
#     #         product=product,
#     #         transaction__paid=True,
#     #         transaction__date__date__gte=month_ago,
#     #         transaction__date__date__lte=today,
#     #         trash=False,
#     #         warehouse=True
#     #     )
#     #     archives = WarehouseArchive.objects.filter(kill_house=kill_house, trash=False)
#     #
#     #
#     #     governmental_list = []
#     #     free_list = []
#     #     final_dict = {}
#     #
#     #     for day in days:
#     #         kill_house_requests_info = kill_house_requests.aggregate(
#     #             total_kill_house_request_governmental_weight=Sum(
#     #                 'ware_house_accepted_real_weight',
#     #                 filter=Q(province_request__poultry_request__free_sale_in_province=False,
#     #                          kill_request__recive_date__date=day)
#     #             ),
#     #             total_kill_house_request_free_weight=Sum(
#     #                 'ware_house_accepted_real_weight',
#     #                 filter=Q(province_request__poultry_request__free_sale_in_province=True,
#     #                          kill_request__recive_date__date=day)
#     #             ),
#     #         )
#     #
#     #         kill_house_free_buying_bars_info = kill_house_free_buying_bars.aggregate(
#     #             total_kill_house_free_buying_bars_weight=Sum(
#     #                 'weight_of_carcasses', filter=Q(date__date=day)
#     #             )
#     #         )
#     #
#     #         kill_house_allocations_info = kill_house_allocations.aggregate(
#     #             total_kill_house_allocations_governmental_weight=Sum(
#     #                 'real_weight_of_carcasses',
#     #                 filter=Q(quota='governmental', production_date__date=day)
#     #             ),
#     #             total_kill_house_allocations_free_weight=Sum(
#     #                 'real_weight_of_carcasses',
#     #                 filter=Q(quota='free', production_date__date=day)
#     #             ),
#     #         )
#     #
#     #         kill_house_free_sale_bars_info = kill_house_free_sale_bars.aggregate(
#     #             total_kill_house_free_sale_bars_governmental_weight=Sum(
#     #                 'real_weight_of_carcasses',
#     #                 filter=Q(quota='governmental', production_date__date=day)
#     #             ),
#     #             total_kill_house_free_sale_bars_free_weight=Sum(
#     #                 'real_weight_of_carcasses',
#     #                 filter=Q(quota='free', production_date__date=day)
#     #             ),
#     #         )
#     #
#     #         segmentations_info = segmentations.aggregate(
#     #             segmentations_governmental_weight=Sum(
#     #                 'weight', filter=Q(quota='governmental', production_date__date=day)
#     #             ),
#     #             segmentations_free_weight=Sum(
#     #                 'weight', filter=Q(quota='free', production_date__date=day)
#     #             ),
#     #         )
#     #
#     #         pos_allocated_weight_info = transactions.aggregate(
#     #             pos_governmental_allocated_weight=Sum(
#     #                 'cur_weight', filter=Q(price_approved=True, transaction__date__date=day)
#     #             ),
#     #             pos_free_allocated_weight=Sum(
#     #                 'cur_weight', filter=Q(price_approved=False, transaction__date__date=day)
#     #             ),
#     #         )
#     #
#     #         archives_info = archives.aggregate(
#     #             total_archive_governmental_weight=Sum('weight', filter=Q(date__date=day, quota='governmental')),
#     #             total_archive_free_weight=Sum('weight', filter=Q(date__date=day, quota='free')),
#     #         )
#     #
#     #         total_kill_house_request_governmental_weight = kill_house_requests_info['total_kill_house_request_governmental_weight'] or 0
#     #         total_kill_house_request_free_weight = kill_house_requests_info['total_kill_house_request_free_weight'] or 0
#     #         total_kill_house_free_buying_bars_weight = kill_house_free_buying_bars_info['total_kill_house_free_buying_bars_weight'] or 0
#     #         total_kill_house_allocations_governmental_weight = kill_house_allocations_info['total_kill_house_allocations_governmental_weight'] or 0
#     #         total_kill_house_allocations_free_weight = kill_house_allocations_info['total_kill_house_allocations_free_weight'] or 0
#     #         total_kill_house_free_sale_bars_governmental_weight = kill_house_free_sale_bars_info['total_kill_house_free_sale_bars_governmental_weight'] or 0
#     #         total_kill_house_free_sale_bars_free_weight = kill_house_free_sale_bars_info['total_kill_house_free_sale_bars_free_weight'] or 0
#     #         segmentations_governmental_weight = segmentations_info['segmentations_governmental_weight'] or 0
#     #         segmentations_free_weight = segmentations_info['segmentations_free_weight'] or 0
#     #         pos_governmental_allocated_weight = pos_allocated_weight_info['pos_governmental_allocated_weight'] or 0
#     #         pos_free_allocated_weight = pos_allocated_weight_info['pos_free_allocated_weight'] or 0
#     #         total_archive_governmental_weight = archives_info['total_archive_governmental_weight'] or 0
#     #         total_archive_free_weight = archives_info['total_archive_free_weight'] or 0
#     #
#     #         total_governmental_input = total_kill_house_request_governmental_weight
#     #         total_free_input = total_kill_house_request_free_weight + total_kill_house_free_buying_bars_weight
#     #
#     #         total_governmental_output = (
#     #             total_kill_house_allocations_governmental_weight +
#     #             total_kill_house_free_sale_bars_governmental_weight +
#     #             segmentations_governmental_weight +
#     #             int(pos_governmental_allocated_weight / 1000)
#     #         )
#     #
#     #         total_free_output = (
#     #             total_kill_house_allocations_free_weight +
#     #             total_kill_house_free_sale_bars_free_weight +
#     #             segmentations_free_weight +
#     #             int(pos_free_allocated_weight / 1000)
#     #         )
#     #
#     #         governmental_amount = (
#     #                                           total_governmental_input - total_governmental_output) - total_archive_governmental_weight
#     #         free_amount = (total_free_input - total_free_output) - total_archive_free_weight
#     #
#     #         governmental_data = {
#     #             'day': day,
#     #             'amount': governmental_amount,
#     #             'active': True if day in target_days else False,
#     #         }
#     #         free_data = {
#     #             'day': day,
#     #             'amount': free_amount,
#     #             'active': True if day in target_days else False,
#     #         }
#     #
#     #         governmental_list.append(governmental_data)
#     #         free_list.append(free_data)
#     #
#     #     final_dict['governmental'] = governmental_list
#     #     final_dict['free'] = free_list
#     #
#     #     return Response(final_dict, status=status.HTTP_200_OK)

class KillHouseRemainWeightViewSet(GenericAPIView):
    permission_classes = [TokenHasReadWriteScope]

    def get(self, request):
        target_date = request.GET.get('date')
        user = SystemUserProfile.objects.get(user=request.user, trash=False)

        kill_house = KillHouse.objects.filter(kill_house_operator__user=user).first()
        product = RolesProducts.objects.filter(kill_house=kill_house, trash=False, name='مرغ گرم').first()

        today = datetime.now().date() if not target_date else datetime.strptime(target_date, "%Y-%m-%d").date()
        month_ago = today - timedelta(days=30)
        yesterday = today - timedelta(days=1)
        two_days_ago = yesterday - timedelta(days=1)

        days = [month_ago + timedelta(days=i) for i in range(31)]
        target_days = {two_days_ago, yesterday, today}
        req_vals = list(
            KillHouseRequest.objects.filter(
                input_warehouse=kill_house,
                kill_request__recive_date__date__gte=month_ago,
                kill_request__recive_date__date__lte=today,
                ware_house_confirmation=True,
                trash=False,
                calculate_status=True,
                warehouse=True
            ).values(
                "kill_request__recive_date__date",
                "ware_house_accepted_real_weight",
                "province_request__poultry_request__free_sale_in_province"
            )
        )

        free_buy_vals = list(
            KillHouseFreeBarInformation.objects.filter(
                trash=False,
                calculate_status=True,
                warehouse=True,
                date__date__gte=month_ago,
                date__date__lte=today,
                input_warehouse=kill_house
            ).exclude(entered_message='ورود به انبار مجازی')
                .values("date__date", "weight_of_carcasses")
        )

        alloc_vals = list(
            StewardAllocation.objects.filter(
                kill_house=kill_house,
                trash=False,
                calculate_status=True,
                warehouse=True,
                receiver_state__in=('pending', 'accepted'),
                production_date__date__gte=month_ago,
                production_date__date__lte=today
            ).values(
                "production_date__date",
                "quota",
                "real_weight_of_carcasses"
            )
        )

        free_sale_vals = list(
            KillHouseFreeSaleBarInformation.objects.filter(
                kill_house=kill_house,
                production_date__date__gte=month_ago,
                production_date__date__lte=today,
                trash=False,
                calculate_status=True,
                warehouse=True
            ).values("production_date__date", "quota", "real_weight_of_carcasses")
        )

        seg_vals = list(
            PosSegmentation.objects.filter(
                kill_house=kill_house,
                production_date__date__gte=month_ago,
                production_date__date__lte=today,
                trash=False,
                warehouse=True
            ).values("production_date__date", "quota", "weight")
        )

        pos_vals = list(
            ProductsTransactions.objects.filter(
                product=product,
                transaction__paid=True,
                transaction__date__date__gte=month_ago,
                transaction__date__date__lte=today,
                trash=False,
                warehouse=True
            ).values(
                "transaction__date__date",
                "price_approved",
                "cur_weight"
            )
        )

        arch_vals = list(
            WarehouseArchive.objects.filter(
                kill_house=kill_house,
                warehouse=True,
                trash=False
            ).values("date__date", "quota", "weight")
        )

        req_daily = {}
        for r in req_vals:
            d = r["kill_request__recive_date__date"]
            w = r["ware_house_accepted_real_weight"] or 0
            if d not in req_daily:
                req_daily[d] = {"governmental": 0, "free": 0}
            if r["province_request__poultry_request__free_sale_in_province"]:
                req_daily[d]["free"] += w
            else:
                req_daily[d]["governmental"] += w

        free_buy_daily = {}
        for r in free_buy_vals:
            d = r["date__date"]
            w = r["weight_of_carcasses"] or 0
            free_buy_daily[d] = free_buy_daily.get(d, 0) + w

        alloc_daily = {}
        for r in alloc_vals:
            d = r["production_date__date"]
            w = r["real_weight_of_carcasses"] or 0
            q = r["quota"]
            if d not in alloc_daily:
                alloc_daily[d] = {"governmental": 0, "free": 0}
            alloc_daily[d][q] += w

        free_sale_daily = {}
        for r in free_sale_vals:
            d = r["production_date__date"]
            w = r["real_weight_of_carcasses"] or 0
            q = r["quota"]
            if d not in free_sale_daily:
                free_sale_daily[d] = {"governmental": 0, "free": 0}
            free_sale_daily[d][q] += w

        seg_daily = {}
        for r in seg_vals:
            d = r["production_date__date"]
            w = r["weight"] or 0
            q = r["quota"]
            if d not in seg_daily:
                seg_daily[d] = {"governmental": 0, "free": 0}
            seg_daily[d][q] += w

        pos_daily = {}
        for r in pos_vals:
            d = r["transaction__date__date"]
            w = r["cur_weight"] or 0
            if d not in pos_daily:
                pos_daily[d] = {"governmental": 0, "free": 0}
            if r["price_approved"]:
                pos_daily[d]["governmental"] += w
            else:
                pos_daily[d]["free"] += w

        arch_daily = {}
        for r in arch_vals:
            d = r["date__date"]
            w = r["weight"] or 0
            q = r["quota"]
            if d not in arch_daily:
                arch_daily[d] = {"governmental": 0, "free": 0}
            arch_daily[d][q] += w

        governmental_list = []
        free_list = []

        for day in days:
            gov_in = req_daily.get(day, {}).get("governmental", 0)
            free_in = req_daily.get(day, {}).get("free", 0) + free_buy_daily.get(day, 0)

            gov_out = (
                    alloc_daily.get(day, {}).get("governmental", 0) +
                    free_sale_daily.get(day, {}).get("governmental", 0) +
                    seg_daily.get(day, {}).get("governmental", 0) +
                    (pos_daily.get(day, {}).get("governmental", 0) // 1000)
            )

            free_out = (
                    alloc_daily.get(day, {}).get("free", 0) +
                    free_sale_daily.get(day, {}).get("free", 0) +
                    seg_daily.get(day, {}).get("free", 0) +
                    (pos_daily.get(day, {}).get("free", 0) // 1000)
            )

            gov_remain = gov_in - gov_out - arch_daily.get(day, {}).get("governmental", 0)
            free_remain = free_in - free_out - arch_daily.get(day, {}).get("free", 0)

            governmental_list.append({
                "day": day,
                "amount": gov_remain if gov_remain > 0 else 0,
                "active": day in target_days,
            })

            free_list.append({
                "day": day,
                "amount": free_remain if free_remain > 0 else 0,
                "active": day in target_days,
            })

        return Response({
            "governmental": governmental_list,
            "free": free_list
        }, status=status.HTTP_200_OK)


# class TotalKillHouseRemainWeightViewSet(GenericAPIView):
#     permission_classes = [TokenHasReadWriteScope]
#     serializer_class = TotalKillHouseRemainWeightViewSetSerializer
#     pagination_class = CustomPagination
#     filter_backends = [DjangoFilterBackend]
#     filterset_class = KillHouseFilterSet
#     filterset_fields = [
#         'name',
#         'kill_house_operator__user__mobile',
#         'kill_house_operator__user__fullname',
#         'kill_house_operator__user__first_name',
#         'kill_house_operator__user__last_name'
#
#     ]
#
#     def get(self, request):
#
#         kill_house_filters = {'out_province': False, 'trash': False, 'total_remain_warehouse_weight__gt': 0}
#         kill_houses = KillHouse.objects.filter(**kill_house_filters).order_by('id', 'killer')
#
#         if 'search' in request.GET:
#             kill_house_list = []
#             if request.GET['search'] == 'filter':
#                 if request.GET['value'] != "" and request.GET['value'] != 'undefined':
#                     for item in self.filterset_fields:
#                         query = QueryDict('{0}__contains={1}'.format(item, request.GET['value']))
#                         if (self.filterset_class(
#                                 data=query,
#                                 queryset=kill_houses
#                         )
#                         ).filter():
#                             ps = self.filterset_class(data=query, queryset=kill_houses)
#                             kill_house_list = ps.filter()
#                     kill_houses = [] if len(
#                         kill_house_list) == 0 else kill_house_list
#
#         page_size = request.query_params.get('page_size', None)
#         if page_size:
#             self.pagination_class.page_size = int(page_size)
#
#         page = self.paginate_queryset(kill_houses)
#         if page is not None:
#             serializer = self.get_serializer(page, many=True)
#             return self.get_paginated_response(serializer.data)
#
#         serializer = self.serializer_class(kill_houses, many=True)
#         return Response(serializer.data, status=status.HTTP_200_OK)
class TotalKillHouseRemainWeightViewSet(GenericAPIView):
    permission_classes = [TokenHasReadWriteScope]
    serializer_class = TotalKillHouseRemainWeightViewSetSerializer
    pagination_class = CustomPagination
    filter_backends = [DjangoFilterBackend]
    filterset_class = KillHouseFilterSet
    filterset_fields = [
        'name',
        'kill_house_operator__user__mobile',
        'kill_house_operator__user__fullname',
        'kill_house_operator__user__first_name',
        'kill_house_operator__user__last_name'

    ]

    def get(self, request):
        quota = request.GET.get("quota")
        kill_house_filters = {'out_province': False, 'trash': False, 'total_remain_warehouse_weight__gt': 0}
        kill_houses = KillHouse.objects.filter(**kill_house_filters).order_by('id', 'killer')

        if 'search' in request.GET:
            kill_house_list = []
            if request.GET['search'] == 'filter':
                if request.GET['value'] != "" and request.GET['value'] != 'undefined':
                    for item in self.filterset_fields:
                        query = QueryDict('{0}__contains={1}'.format(item, request.GET['value']))
                        if (self.filterset_class(
                                data=query,
                                queryset=kill_houses
                        )
                        ).filter():
                            ps = self.filterset_class(data=query, queryset=kill_houses)
                            kill_house_list = ps.filter()
                    kill_houses = [] if len(
                        kill_house_list) == 0 else kill_house_list

        all_data = TotalKillHouseRemainWeightViewSetSerializer(kill_houses, many=True).data
        if quota in ("governmental", "free"):
            filtered = []
            today = datetime.today().date()
            two_days_ago = today - timedelta(days=2)

            for item in all_data:
                info = item.get("info")
                if not info:
                    continue

                for row in info.get(quota, []):
                    day = row["day"]
                    amount = row["amount"]
                    if amount > 0 and day < two_days_ago:
                        filtered.append(item)
                        break

            all_data = filtered

        page_size = request.query_params.get('page_size', None)
        if page_size:
            self.pagination_class.page_size = int(page_size)

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

        # serializer = self.serializer_class(kill_houses, many=True)
        return Response(all_data, status=status.HTTP_200_OK)


class TotalKillHouseWarehouseArchiveDashboardViewSet(GenericAPIView):
    permission_classes = [TokenHasReadWriteScope]
    serializer_class = TotalKillHouseWarehouseArchiveDashboardSerializer
    pagination_class = CustomPagination
    filter_backends = [DjangoFilterBackend]
    filterset_class = KillHouseFilterSet
    filterset_fields = [
        'name',
        'kill_house_operator__user__mobile',
        'kill_house_operator__user__fullname',
        'kill_house_operator__user__first_name',
        'kill_house_operator__user__last_name'

    ]

    def get(self, request):
        date1 = request.GET.get('date1')
        date2 = request.GET.get('date2')
        archives_filters = {"trash": False, "kill_house__isnull": False}
        if date1:
            archives_filters['create_date__date__gte'] = date1
            archives_filters['create_date__date__lte'] = date2

        archives = WarehouseArchive.objects.filter(**archives_filters)
        kill_houses = KillHouse.objects.filter(id__in=archives.values_list('kill_house__id', flat=True), trash=False)
        if 'search' in request.GET:
            kill_house_list = []
            if request.GET['search'] == 'filter':
                if request.GET['value'] != "" and request.GET['value'] != 'undefined':
                    for item in self.filterset_fields:
                        query = QueryDict('{0}__contains={1}'.format(item, request.GET['value']))
                        if (self.filterset_class(
                                data=query,
                                queryset=kill_houses
                        )
                        ).filter():
                            ps = self.filterset_class(data=query, queryset=kill_houses)
                            kill_house_list = ps.filter()
                    kill_houses = [] if len(
                        kill_house_list) == 0 else kill_house_list

        page_size = request.query_params.get('page_size', None)
        if page_size:
            self.pagination_class.page_size = int(page_size)

        page = self.paginate_queryset(kill_houses)
        if page is not None:
            serializer = self.get_serializer(page, many=True, context={'date1': date1, 'date2': date2})
            return self.get_paginated_response(serializer.data)

        serializer = self.serializer_class(kill_houses, many=True, context={'date1': date1, 'date2': date2})
        return Response(serializer.data, status=status.HTTP_200_OK)


def fix_wage(request):
    kill_house_requests = KillHouseRequest.objects.filter(trash=True, return_trash=True)
    kill_house_requests_values = kill_house_requests.values_list('province_kill_request__id', flat=True).distinct()
    province_requests = ProvinceKillRequest.objects.filter(trash=True, id__in=kill_house_requests_values,
                                                           return_trash=True)
    return HttpResponse(province_requests.count())


class KillHouseLock(APIView):

    def get(self, request):

        wage_lock = False
        ware_house_lock = False
        user = SystemUserProfile.objects.get(user=request.user, trash=False)
        kill_house = KillHouse.objects.filter(kill_house_operator__user=user, trash=False).first()
        kill_house_purchase = KillHousePurchaseRequest.objects.filter(kill_house=kill_house).first()
        total_unpaid_wage = get_finance_info(kill_house)['total_price']
        if kill_house.killer and kill_house.type=='public':
            slaughter_transactions = InternalTransaction.objects.filter(kill_house=kill_house,parent_kill_house=kill_house,
                                                                        status='completed',
                                                                        trash=False)
        else:
            slaughter_transactions = InternalTransaction.objects.filter(
                Q(kill_house=kill_house) | Q(parent_kill_house=kill_house),
                status='completed',
                trash=False)

        total_paid_wage = slaughter_transactions.aggregate(total=Sum('amount'))[
                              'total'] or 0
        total_unpaid_wage -= total_paid_wage

        if kill_house_purchase:
            if kill_house_purchase.limitation == True:

                if kill_house_purchase.limitation_number <= total_unpaid_wage:
                    wage_lock = True

        if kill_house.ware_house_remaining_weight_limitation_status:
            if kill_house.total_remain_warehouse_governmental_weight > kill_house.ware_house_remaining_weight_limitation:
                ware_house_lock = True

        if kill_house.ware_house_remaining_percent_limitation_status:
            if not check_kill_house_remain_limitation_weight(kill_house):
                ware_house_lock = True

        result = {
            'wage': total_unpaid_wage,
            'wage_lock': wage_lock,
            'ware_house_lock': ware_house_lock
        }

        return Response (result,status=status.HTTP_200_OK)