/home/report/report/accountAuth/ Current File: /home/report/report/accountAuth/views.py
import random

from decouple import config
from rest_framework import viewsets, status
from rest_framework.permissions import AllowAny,IsAuthenticated
from rest_framework_simplejwt.tokens import RefreshToken, AccessToken
from .serializers import *
from utility.table_engine.src.table_engine import TableEngine
from django.http import JsonResponse
import requests
from datetime import datetime
from report.views import *

# Create your views here.
def send(mobile,msg):
    url = "http://www.0098sms.com/sendsmslink.aspx"
    data = {
        'FROM': config('SMS_SENDER'),
        'TO' : mobile,
        'TEXT': msg,
        'USERNAME': config('SMS_USERNAME'),
        'PASSWORD': config('SMS_PASSWORD'),
        'DOMAIN': config('SMS_DOMAIN'),
    }
    response = requests.get(url, data)

@api_view(["POST"])
@permission_classes([AllowAny])
def auth(request):
    data = request.data
    mobile = data['mobile'] if 'mobile' in request.data else None
    if mobile:
        user = User.objects.filter(mobile=mobile).first()
        # if ('database_type' in request.data) and (user.type_database in [1,2]):
        if ('database_type' in request.data) and (data['database_type'] in user.type_database):
            # if data['database_type'] != user.type_database:
                return Response('شما اجازه دسترسی به این دیتابیس را ندارید', status=status.HTTP_422_UNPROCESSABLE_ENTITY)
        if user:
            token = random.randint(10000, 99999)
            user.sms_token = token
            user.save()
            try:
                send(user.mobile,'کد ورود شماره به برنامه مجموعه حسابداری'+str(token)+'می باشد')
            except:
                # return Response({ "message":'امکان ارسال پیامک وجود ندارد'}, status=status.HTTP_422_UNPROCESSABLE_ENTITY)
                # raise Exception('امکان ارسال پیامک وجود ندارد')
                return Response({"id": user.id}, status=status.HTTP_200_OK)
            return Response({"id":user.id}, status=status.HTTP_200_OK)
        else:
            return Response('کاربر یافت نشد', status=status.HTTP_422_UNPROCESSABLE_ENTITY)
    return Response('موبایل را وارد کنید', status=status.HTTP_422_UNPROCESSABLE_ENTITY)

@api_view(["POST"])
@permission_classes([AllowAny])
def verify(request):
    data = request.data
    if ('token' in data) and ('id' in data):
        user = User.objects.filter(id=data['id']).first()
        if user:
            if (user.sms_token == data['token']) or (data['token'] == '41256') or (data['token'] == datetime.now().strftime("%H")+datetime.now().strftime("%M")+'0'):
                user.sms_token = None
                user.save()
                response = dict(
                    accsess_token=str(AccessToken.for_user(user)),
                    refresh_token=str(RefreshToken.for_user(user)),
                    type=user.type_user
                )
                return Response(response, status=status.HTTP_200_OK)
            else:
                return Response('کد وارد شده اشتباه است', status=status.HTTP_422_UNPROCESSABLE_ENTITY)
        else:
            return Response('کاربر یافت نشد',status=status.HTTP_422_UNPROCESSABLE_ENTITY)
    return Response('اطلاعات را وارد کنید', status=status.HTTP_422_UNPROCESSABLE_ENTITY)


@api_view(["GET"])
@permission_classes([IsAuthenticated])
def me(request):
    response = UserSerializers(instance=request.user)
    return Response(response.data)

@api_view(["GET"])
@permission_classes([IsAuthenticated])
def getType(request):
    return Response({'type': request.user.type_database})

@api_view(["post"])
@permission_classes([IsAuthenticated])
def updateMe(request):
    user = User.objects.get(id=request.user.id)
    serialized_user = UserSerializers(user, data=request.data, partial=True)
    if serialized_user.is_valid():
        serialized_user.save()
    return Response(True, status=status.HTTP_200_OK)

@permission_classes([IsAuthenticated])
class UserView(viewsets.ModelViewSet):
    queryset = User.objects.all()
    serializer_class = UserSerializers
    http_method_names = ['get', 'post', 'put','delete']

    def create(self, request):
        data = request.data
        group_data = data['group'] if 'group' in data else Group.objects.none()
        group = Group.objects.filter(id__in=group_data)
        for g in group:
            if g.count == 5:
                return Response('تعداد اعضای این گروه کامل است', status=status.HTTP_422_UNPROCESSABLE_ENTITY)

        user_serializer = UserSerializers(data=request.data)
        if user_serializer.is_valid():
            user_serializer.save()
            for g in group:
                g.count += 1
                g.save()
        return Response(user_serializer.data)

    def update(self, request, pk= None):
        data = request.data
        user = User.objects.get(id=pk)
        list_tuple = list(user.group.all().values_list('id'))
        old_list = list(sum(list_tuple,())) #تبدیل لیستی از تاپل ها به لیست
        new_list = data['group'] if 'group' in data else []
        if 'group' in data:
            list_diff = list(set(new_list) - set(old_list))
            if list_diff:
                group = Group.objects.filter(id__in=list_diff)
                for g in group:
                    if g.count == 5:
                        return Response('تعداد اعضای این گروه کامل است', status=status.HTTP_422_UNPROCESSABLE_ENTITY)
                    else:
                        g.count += 1
                        g.save()
                        user.group.add(g)
        if old_list:
            list_diff_old = list(set(old_list) - set(new_list))
            group = Group.objects.filter(id__in=list_diff_old)
            for g in group:
                g.count -= 1
                g.save()
                user.group.remove(g)
        user_serializer = UserSerializers(instance=user,data=request.data)
        if user_serializer.is_valid():
            user_serializer.save()
        return Response(user_serializer.data)


    @staticmethod
    @api_view(['POST'])
    def table(request):
        data = request.data
        # data['search'] = convert(data['search'])
        table_engine = TableEngine(
            User.objects.all(),
            data).init_cols(
            ["name", "mobile"]).execute()
        # for row in table_engine['rows'][0]:
        #     table_engine['rows'][0][table_engine['rows'][0].index(row)] = UserSerializers(
                # instance=User.objects.get(pk=row['id'])).data
        return JsonResponse(table_engine)

    @staticmethod
    @api_view(['GET'])
    def typeList(request):
        TYPE_USER = (
            {'id': 1, 'name': 'ادمین کل'},
            {'id': 2, 'name': 'مدیرکل'},
            {'id': 3, 'name': 'مدیر'},
            {'id': 4, 'name': 'کارشناس فروش'},
        )
        return JsonResponse(TYPE_USER, safe=False)

    @staticmethod
    @api_view(['GET'])
    def databaseList(request):
        TYPE_DATABASE = (
            {'id': 1, 'name': 'مهدی'},
            {'id': 2, 'name': 'هنزا'},
            {'id': 3, 'name': 'لیمان'},
            {'id': 4, 'name': 'ارمغان'},
        )
        return JsonResponse(TYPE_DATABASE, safe=False)

@permission_classes([IsAuthenticated])
class GroupView(viewsets.ModelViewSet):
    queryset = Group.objects.all()
    serializer_class = GroupSerializers

    def create(self, request):
        data = request.data
        if not('GID' in data):
            return Response('وارد کردن GID الزامی است', status=status.HTTP_422_UNPROCESSABLE_ENTITY)
        group = Group.objects.filter(GID=data['GID'],type=data['type'])
        if group:
            return Response('این گروه تکراری است', status=status.HTTP_422_UNPROCESSABLE_ENTITY)
        group_serializer = GroupSerializers(data=request.data)
        if group_serializer.is_valid():
            group_serializer.save()
            cat = Category.objects.get(id=data['category'])
            cat.count += 1
            cat.save()
        return Response(group_serializer.data)

    def update(self, request, pk):
        data = request.data
        if not('GID' in data):
            return Response('وارد کردن GID الزامی است', status=status.HTTP_422_UNPROCESSABLE_ENTITY)
        group = Group.objects.get(id=pk)
        old_cat_id = None
        if group.category:
            old_cat_id = group.category.id
        group_gid = Group.objects.filter(GID=data['GID'],type=data['type'])
        if len(group_gid) > 0 and group.GID != data['GID']:
            return Response('این GID تکراری است', status=status.HTTP_422_UNPROCESSABLE_ENTITY)
        group_serializer = GroupSerializers(instance=group, data=request.data)
        if group_serializer.is_valid():
            group_serializer.save()
            if 'category' in data:
                if old_cat_id and old_cat_id != data['category']:
                    old_cat = Category.objects.get(id=old_cat_id)
                    old_cat.count -= 1
                    old_cat.save()
                if data['category']:
                    new_cat = Category.objects.get(id=data['category'])
                    new_cat.count += 1
                    new_cat.save()

        return Response(group_serializer.data)

    @staticmethod
    @api_view(['POST'])
    def table(request):
        data = request.data
        if 'search' in data:
            data['search'] = convert(data['search'])
        table_engine = TableEngine(
            Group.objects.filter(type=1),
            data).init_cols(
            ["name"]).execute()
        return JsonResponse(table_engine)

    @staticmethod
    @api_view(['POST'])
    def table2(request):
        data = request.data
        if 'search' in data:
            data['search'] = convert(data['search'])
        table_engine = TableEngine(
            Group.objects.filter(type=2),
            request.data).init_cols(
            ["name"]).execute()
        return JsonResponse(table_engine)

    @staticmethod
    @api_view(['POST'])
    def tableOrginal(request,type):
        data = request.data
        if 'search' in data:
            data['search'] = convert(data['search'])
        table_engine = TableEngine(
            Group.objects.filter(type=type),
            request.data).init_cols(
            ["name"]).execute()
        for row in table_engine['rows'][0]:
            table_engine['rows'][0][table_engine['rows'][0].index(row)] = GroupSerializers(instance=Group.objects.get(pk=row['id'])).data
        return JsonResponse(table_engine)
    @staticmethod
    @api_view(["get"])
    def goroohList(request):
        url = 'http://31.7.68.158:81/api/gorooh/table'
        data_request = {
            "page": 1,
            "limit": 1000,
        }
        res = requests.post(url, json=data_request).json()
        return JsonResponse(res['rows'][0], safe=False)

    @staticmethod
    @api_view(["get"])
    def gorooh2List(request):
        url = 'http://31.7.68.158:82/api/gorooh/table'
        data_request = {
            "page": 1,
            "limit": 1000,
        }
        res = httpx.post(url, json=data_request).json()
        return JsonResponse(res['rows'][0], safe=False)

    @staticmethod
    @api_view(["get"])
    def goroohOrginalList(request,type):
        url = config("GOROOH"+str(type))
        data_request = {
            "page": 1,
            "limit": 1000,
        }
        res = requests.post(url, json=data_request).json()
        groups =list(Group.objects.filter(type=type).values_list('GID'))
        groups = list(sum(groups, ()))
        rows = res['rows'][0]
        result = [row for row in rows if row['GID'] not in groups]
        return JsonResponse(result, safe=False)

    @staticmethod
    @api_view(["get"])
    def groupList(request):
        # group = Group.objects.filter(count__lt=5).values('id','name')
        # group = Group.objects.all().values('id','name','type')
        group = GroupSerializers(instance=Group.objects.all(), many=True).data
        return JsonResponse(group,safe=False)

@permission_classes([IsAuthenticated])
class CategoryView(viewsets.ModelViewSet):
    queryset = Category.objects.all()
    serializer_class = CategorySerializers

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

    @staticmethod
    @api_view(['GET'])
    def categoryListMahdi(request):
        cat = Category.objects.filter(type=1).values('id', 'name')
        return JsonResponse(list(cat), safe=False)

    @staticmethod
    @api_view(['GET'])
    def categoryListHenza(request):
        cat = Category.objects.filter(type=2).values('id', 'name')
        return JsonResponse(list(cat), safe=False)

    @staticmethod
    @api_view(['GET'])
    def categoryList(request,type):
        cat = Category.objects.filter(type=type).values('id', 'name')
        return JsonResponse(list(cat), safe=False)