/home/report/report/report/ Current File: /home/report/report/report/views.py
import json
from django.http import JsonResponse
from rest_framework.decorators import api_view
from django.shortcuts import render
import requests
import httpx
import math
from rest_framework.permissions import IsAuthenticated
from rest_framework.decorators import api_view, permission_classes
from accountAuth.models import *
from rest_framework.response import Response
from rest_framework import status
from .tasks import *
from datetime import timedelta
from django.utils.timezone import now
from accountAuth.serializers import *

typeRas: dict = {
    '1': {"down": 0, "up": 20, "name": "طلایی"},
    '2': {"down": 21, "up": 30, "name": "نقره ای"},
    '3': {"down": 31, "up": 45, "name": "برنزی"},
    '4': {"down": 46, "up": 100, "name": "قرمز"},
    '5': {"down": 101, "name": "سیاه"},
    '6': {"down": 101, "name": "بی رنگ"},
}
defaul_limit = int(config("DEFAULT_LIMIT"))


def getUrl(header):
    type = header['type'] if 'type' in header else '1'
    return config('URL'+type)
    # if type == '1':
    #     return config('URL1')
    # else:
    #     return config('URL2')


def createFilter2(id, headers, filters_index):
    type = headers['type'] if 'type' in headers else '1'
    if filters_index:
        if filters_index['value'] == 1:
            list_tuple = Group.objects.filter(type=type, users__id=id, count=1).values_list('GID')
        else:
            list_tuple = Group.objects.filter(type=type, users__id=id, count__gt=1).values_list('GID')
    else:
        list_tuple = Group.objects.filter(type=type, users__id=id).values_list('GID')
    list_group = list(sum(list_tuple, ()))  # تبدیل لیستی از تاپل ها به لیست
    filter2 = {
        "field": "GID",
        "value": list_group,
        "op": "in"
    }
    return filter2


def calRas(tvazn):
    ras = str(tvazn).index('راس')
    rooz = str(tvazn).index('روز')
    sub = str(tvazn)[ras + 4:rooz]
    return sub


def getFilterRas(filters, field_filters):
    filter_ras = {}
    filter_ras = {}
    if 'ras' in field_filters:
        key_ras = field_filters.index('ras')
        filter_ras = filters[key_ras]
        del filters[key_ras]
    return filters, filter_ras,


def getRequest(data):
    page = data['page'] if 'page' in data else 1
    limit = data['limit'] if 'limit' in data else 10
    filters = data['filters'] if 'filters' in data else []
    field_filters = [k['field'] for k in filters]
    return page, limit, filters, field_filters


def getAllRequest(data, user, headers):
    page, limit, filters, field_filters = getRequest(data)
    filters, filter_ras = getFilterRas(filters, field_filters)
    search, filters = createParams(data, user, headers, filters, field_filters)
    return page, limit, filters, filter_ras, search


@api_view(["POST"])
@permission_classes([IsAuthenticated])
def listCustomers(request):
    data = request.data
    url = getUrl(request.headers)
    page, limit, filters, filter_ras, search = getAllRequest(data, request.user, request.headers)
    data_request = {
        "page": page,
        "limit": limit,
        "search": search,
        "filters": filters
    }
    res = httpx.post(url, json=data_request).json()
    if filter_ras:
        customer_list = res['rows'][0]
        listCu = []
        for customer in customer_list:
            sub = calRas(customer['Tvazn'])
            if int(sub) >= filter_ras['value'][0] and int(sub) <= filter_ras['value'][1]:
                listCu.append(customer)
        dict_res = {
            'count': len(listCu),
            'page': page,
            'limit': limit,
            'rows': listCu[(limit * (page - 1)):(limit * page)]
        }
    else:
        dict_res = res
    return JsonResponse(dict_res, safe=False)


@api_view(["GET"])
@permission_classes([IsAuthenticated])
def listCustomersRas(request):
    data = request.data
    type_group = request.headers['type'] if 'type' in request.headers else '1'
    filter1 = {
        "field": "Tvazn",
        "value": ":",
        "op": "like"
    }
    filters = [filter1]
    if request.user.type_user == 4:
        filter2 = createFilter2(request.user.id, request.headers, [])
        filters.append(filter2)
    data_request = {
        "page": 1,
        "limit": defaul_limit,
        "filters": filters
    }
    url = getUrl(request.headers)
    res = httpx.post(url, json=data_request).json()
    count = math.ceil(res['count'] / defaul_limit)
    if res['count'] > defaul_limit:
        customer_list = []
        for i in range(count):
            data_request = {
                "page": i + 1,
                "limit": defaul_limit,
                "filters": filters
            }
            res = httpx.post(url, json=data_request).json()
            customer_list = customer_list + res['rows'][0]
    else:
        customer_list = res['rows'][0]
    array_count = [0 for i in range(6)]
    array_vt_positive = [0 for i in range(6)]
    array_vp_positive = [0 for i in range(6)]
    array_vt_negative = [0 for i in range(6)]
    array_vp_negative = [0 for i in range(6)]
    dic_send = {}
    sum_ras = 0
    for customer in customer_list:
        if customer['JamV_T'] != '0.0000' or (customer['JamV_P'] > 0 or customer['JamV_P'] < 0):
        # if customer['JamV_T'] != '0.0000' or str(customer['JamV_P'] != '0.0'):
            list_color = Category.objects.filter(group__GID=customer['GID'], group__type=type_group).first()
            if list_color:
                color = list_color.color
                if color and len(customer['Tvazn'])>0:
                    sub = calRas(customer['Tvazn'])
                    if int(sub) >= color[0]['down'] and int(sub) <= color[0]['up']:
                        array_count[0] += 1
                        array_vt_positive[0], \
                        array_vt_negative[0], \
                        array_vp_positive[0], \
                        array_vp_negative[0] = cal(customer, array_vt_positive[0], array_vt_negative[0],
                                               array_vp_positive[0], array_vp_negative[0])
                    elif int(sub) <= color[1]['up']:
                        array_count[1] += 1
                        array_vt_positive[1], \
                        array_vt_negative[1], \
                        array_vp_positive[1], \
                        array_vp_negative[1] = cal(customer, array_vt_positive[1], array_vt_negative[1], array_vp_positive[1],
                                           array_vp_negative[1])
                    elif int(sub) <= color[2]['up']:
                        array_count[2] += 1
                        array_vt_positive[2],\
                        array_vt_negative[2],\
                        array_vp_positive[2],\
                        array_vp_negative[2] = cal(customer, array_vt_positive[2], array_vt_negative[2], array_vp_positive[2], array_vp_negative[2])
                    elif int(sub) <= color[3]['up']:
                        array_count[3] += 1
                        array_vt_positive[3],\
                        array_vt_negative[3],\
                        array_vp_positive[3],\
                        array_vp_negative[3] = cal(customer, array_vt_positive[3], array_vt_negative[3], array_vp_positive[3], array_vp_negative[3])
                    elif int(sub) > color[4]['down']:
                        array_count[4] += 1
                        array_vt_positive[4],\
                        array_vt_negative[4],\
                        array_vp_positive[4],\
                        array_vp_negative[4] = cal(customer, array_vt_positive[4], array_vt_negative[4], array_vp_positive[4], array_vp_negative[4])
                else:
                    array_count[5] += 1
                    array_vt_positive[5], \
                    array_vt_negative[5], \
                    array_vp_positive[5], \
                    array_vp_negative[5] = cal(customer, array_vt_positive[5], array_vt_negative[5],
                                               array_vp_positive[5], array_vp_negative[5])

    for i in range(6):
        sum_ras += array_count[i]
    print(sum_ras)
    for key, val in typeRas.items():
        dict = {}
        dict_pos = {}
        dict_negative = {}
        dict['count'] = array_count[int(key) - 1]
        # if res['count'] > 0:
        #     dict['percent'] = (array_count[int(key)-1]/res['count'])*100
        # else:
        #     dict['percent'] = 0
        if sum_ras > 0:
            dict['percent'] = (array_count[int(key) - 1] / sum_ras) * 100
        else:
            dict['percent'] = 0
        dict_pos['tala'] = array_vt_positive[int(key) - 1]
        dict_pos['rial'] = array_vp_positive[int(key) - 1]
        dict_negative['tala'] = array_vt_negative[int(key) - 1]
        dict_negative['rial'] = array_vp_negative[int(key) - 1]
        dic_send[val['name']] = dict
        dic_send[val['name']]['positive'] = dict_pos
        dic_send[val['name']]['negative'] = dict_negative

    return JsonResponse(dic_send, safe=False)


def cal(customer, vt_p, vt_n, vp_p, vp_n):
    if float(customer['JamV_T']) > 0:
        vt_p += float(customer['JamV_T'])
    else:
        vt_n += float(customer['JamV_T'])
    if customer['JamV_P'] > 0:
        vp_p += customer['JamV_P']
    else:
        vp_n += customer['JamV_P']
    return vt_p, vt_n, vp_p, vp_n


@api_view(["POST"])
@permission_classes([IsAuthenticated])
def listSendCustomRas(request):
    url = getUrl(request.headers)
    type_group = request.headers['type'] if 'type' in request.headers else '1'
    data = request.data
    page, limit, filters, filter_ras, search = getAllRequest(data, request.user, request.headers)
    data_request = {
        "page": 1,
        "limit": defaul_limit,
        "search": search,
        "filters": filters
    }
    res = httpx.post(url, json=data_request).json()
    count = math.ceil(res['count'] / defaul_limit)
    if res['count'] > defaul_limit:
        customer_list = []
        for i in range(count):
            data_request = {
                "page": i + 1,
                "limit": defaul_limit,
                "search": search,
                "filters": filters
            }
            res = httpx.post(url, json=data_request).json()
            customer_list = customer_list + res['rows'][0]
    else:
        customer_list = res['rows'][0]
    if filter_ras:
        listCu = []
        for customer in customer_list:
            sub = calRas(customer['Tvazn'])
            if int(sub) >= filter_ras['value'][0] and int(sub) <= filter_ras['value'][1]:
                listCu.append(customer)
        customer_list = listCu
    listCu = []
    for customer in customer_list:
        if (customer['JamV_T'] != '0.0000') or (customer['JamV_P'] > 0 or customer['JamV_P'] < 0):
        # if (customer['JamV_T'] != '0.0000') or str(customer['JamV_P']) !='0.0':
            list_color = Category.objects.filter(group__GID=customer['GID'], group__type=type_group).first()
            if list_color:
                color = list_color.color
                if data['type'] < 6:
                    if color:
                        sub = calRas(customer['Tvazn'])
                        if data['type'] < 5:
                            if int(sub) >= color[data['type']-1]['down'] and int(sub) <= color[data['type']-1]['up']:
                                listCu.append(customer)
                        elif data['type'] == 5:
                            if int(sub) > color[4]['down']:
                                listCu.append(customer)
                else:
                    if not color:
                        listCu.append(customer)
    dict = {
        'count': len(listCu),
        'page': page,
        'limit': limit,
        'rows': listCu[limit * (page - 1):limit * page]
    }
    return JsonResponse(dict, safe=False)


def listType(request):
    return JsonResponse(typeRas, safe=False)


def convert(search):
    if not (search is None):
        search = str(search).replace('ی', 'ي')
    return search


@api_view(["GET"])
@permission_classes([IsAuthenticated])
def listGroupFilter(request):
    type = request.headers['type']
    if request.user.type_user == 4:
        list_tuple = Group.objects.filter(type=type, users__id=request.user.id).values('GID', 'name')
    else:
        list_tuple = Group.objects.filter(type=type).values('GID', 'name')
    return JsonResponse(list(list_tuple), safe=False)


def createParams(data, user, headers, filters, field_filters):
    search = convert(data['search'] if 'search' in data else None)
    type = headers['type'] if 'type' in headers else '1'
    filter1 = {
        "field": "Tvazn",
        "value": ":",
        "op": "like"
    }
    filters.append(filter1)
    filters_index = {}
    if 'single' in field_filters:
        key = field_filters.index("single")
        filters_index = filters[key]
        del filters[key]
    if 'category' in field_filters:
        key_category = field_filters.index('category')
        print(user.type_user )
        if user.type_user != 4:
            list_tuple_gid = Group.objects.filter(category__id__in=filters[key_category]['value'], category__type=type).values_list('GID')
        else:
            list_tuple_gid = Group.objects.filter(category__id__in=filters[key_category]['value'],
                                                  category__type=type, users__id=user.id).values_list('GID')
        list_group = list(sum(list_tuple_gid, ()))  # تبدیل لیستی از تاپل ها به لیست
        del filters[key_category]
        filter2 = {
            "field": "GID",
            "value": list_group,
            "op": "in"
        }
        filters.append(filter2)
    print(filters)

    if user.type_user == 4:
        if not ('GID' in field_filters) and not ('category' in field_filters):
            filter2 = createFilter2(user.id, headers, filters_index)
            filters.append(filter2)
    return search, filters


def testCelery(request):
    test1 = test.apply_async(eta=now() + timedelta(seconds=20))
    return JsonResponse(test1.status, safe=False)

@api_view(['GET'])
def test(request):
    filter = [{
        "field": "Tvazn",
        "value": ":",
        "op": "like"
    }]
    data_request = {
        "page": 1,
        "limit": int(config("DEFAULT_LIMIT")),
        "filters": filter
    }
    url = 'http://31.7.68.158:82/api/moshtarian/table'
    res = httpx.post(url, json=data_request).json()
    customer_list = res['rows'][0]
    for customer in customer_list:
        if (customer['JamV_T'] != '0.0000') or (customer['JamV_P'] > 0 or customer['JamV_P'] < 0):
            list_color = Category.objects.filter(group__GID=customer['GID'], group__type=1).exclude(
                id__in=[10, 14]).first()
            ras = str(customer['Tvazn']).index('راس')
            rooz = str(customer['Tvazn']).index('روز')
            sub = str(customer['Tvazn'])[ras + 4:rooz]
            if list_color:
                color = list_color.color
                if (int(sub) == (int(color[3]['down']) - 3)) or (int(sub) == int(color[4]['down'])-3):
                    print(customer['code'],'custumer.code')
                    print(list_color.name,'title')
                    print(list_color.color,'color')
                    print(sub,'sub')
                    print(color[3]['down'] - 3,'color[3]')
                    print(color[4]['down'] - 3,'color[4]')

    return JsonResponse(True, safe=False)