from django.shortcuts import render ,HttpResponse
from django.views.generic import TemplateView
from django.shortcuts import render, get_object_or_404, redirect
from pprint import pprint
import json
from django.utils import timezone
from service.models import Parts_Request
from django.http import JsonResponse
from _keenthemes.__init__ import KTLayout
from django.core.mail import EmailMessage
from _keenthemes.libs.theme import KTTheme
from django.conf import settings
# from quotation.models import Quotation,ContractOfSale,QuotationItem,Signature
from quotation.models import GST,Discount,Quotation,ContractOfSale, QuotationItem,Signature,QuotationVersion, Supplier,Customer, Product,Invoice,InvoiceItem,SerialNumber,InvoicePdf,Customer_Payment,Order,Order_Item,User,Technician_Assigned_Order_Item,Technician_Comment,Supplier_Bill
from django.db.models import Q
from authentication.decorators import is_admin, is_sales, is_technician, is_customer,is_superuser
from django.contrib.auth.decorators import user_passes_test
from django.contrib.auth.decorators import login_required
from django.db.models import Case, When
# from datetime import datetime, timedelta,date
import datetime 
from datetime import time
# from django.utils import timezone
import calendar as cal1
from django.http import HttpResponseServerError
from django.http import HttpResponseNotFound
from leads.models import Lead,Leadnote
from django.db.models import F, Func, Value, Case, When, CharField
from django.db.models.functions import Concat, Coalesce
from django.db.models import Exists, OuterRef
from PyPDF2 import PdfMerger
from django.http import FileResponse
import os
from io import BytesIO
from django.core.files.base import ContentFile
from django.core.files.storage import default_storage
# def merge_pdfs(request):
#     pdfs = [
#         os.path.join(settings.MEDIA_ROOT, "attachments", "22-attachment.pdf"),
#         os.path.join(settings.MEDIA_ROOT, "attachments", "EC_80-1_report_1747826291.pdf"),
#         os.path.join(settings.MEDIA_ROOT, "attachments", "22-attachment.pdf"),
#         os.path.join(settings.MEDIA_ROOT, "attachments", "EC_80-1_report_1747826291.pdf"),
#         os.path.join(settings.MEDIA_ROOT, "attachments", "22-attachment.pdf"),
#         os.path.join(settings.MEDIA_ROOT, "attachments", "EC_80-1_report_1747826291.pdf"),
#         os.path.join(settings.MEDIA_ROOT, "attachments", "22-attachment.pdf"),
#         os.path.join(settings.MEDIA_ROOT, "attachments", "EC_80-1_report_1747826291.pdf"),
#     ]

#     merger = PdfMerger()
#     for pdf in pdfs:
#         merger.append(pdf)

#     output_path = os.path.join(settings.MEDIA_ROOT, "attachments", "merged.pdf")
#     merger.write(output_path)
#     merger.close()

#     return FileResponse(open(output_path, "rb"), as_attachment=True, filename="merged.pdf")
def merge_pdfs(request):
    pdfs = [
        os.path.join(settings.MEDIA_ROOT, "attachments", "22-attachment.pdf"),
        os.path.join(settings.MEDIA_ROOT, "attachments", "EC_80-1_report_1747826291.pdf"),
        os.path.join(settings.MEDIA_ROOT, "attachments", "22-attachment.pdf"),
        os.path.join(settings.MEDIA_ROOT, "attachments", "EC_80-1_report_1747826291.pdf"),
    ]

    merger = PdfMerger()
    for pdf in pdfs:
        merger.append(pdf)

    # Save merged into memory first
    output_stream = BytesIO()
    merger.write(output_stream)
    merger.close()
    output_stream.seek(0)

    # Save into Django storage (MEDIA_ROOT / cloud storage)
    merged_filename = "attachments/merged.pdf"
    default_storage.save(merged_filename, ContentFile(output_stream.read()))

    # Rewind for response
    output_stream.seek(0)

    return FileResponse(output_stream, as_attachment=True, filename="merged.pdf")
# @user_passes_test(lambda u: is_customer(u) or is_admin(u) or is_superuser(u) or is_sales(u))
# @login_required
     
#     elif is_sales(request.user):
#         quote_by = User.objects.get(id=request.user.id)
#         quotations = Quotation.objects.filter(quote_by=quote_by, deleted_at__isnull=False).order_by('status', 'created_at')

def thankyou(request):
    return render(request,'thankyou_page.html')
    
def tracking_order_status_search(request):
    today = timezone.now().date()
    default_time = time(0, 0)
    customer_id = request.GET.get('customer_id')
    product_id = request.GET.get('product_id')
    supplier_id = request.GET.get('supplier_id')
    orderno = request.GET.get('orderno')
    billno = request.GET.get('billno')
    # if customer_id and product_id:
    #     or_condition.add(Q(**{'order__invoice__customer__id': customer_id}), Q.AND)
    #     or_condition.add(Q(**{'product__id': product_id}), Q.AND)
    # elif customer_id:
    #     or_condition.add(Q(**{'order__invoice__customer__id': customer_id}), Q.AND)
        
    # if supplier_id and product_id:
    #     snor_condition.add(Q(**{'bill__supplier__id': supplier_id}), Q.AND)
    #     or_condition.add(Q(**{'serial_number__bill__supplier__id': supplier_id}), Q.AND)
    
    # elif supplier_id:
    #     snor_condition.add(Q(**{'bill__supplier__id': supplier_id}), Q.AND)
    #     or_condition.add(Q(**{'serial_number__bill__supplier__id': supplier_id}), Q.AND)
        
    # if orderno:
    #     or_condition.add(Q(**{'order__id': orderno}), Q.AND)
        
    # if product_id:
    #     snor_condition.add(Q(**{'product__id': product_id}), Q.AND)
    #     or_condition.add(Q(**{'product__id': product_id}), Q.AND)
    # if billno:
    #     snor_condition.add(Q(**{'bill__id': billno}), Q.AND)
    order_items = ()
    order_items_trade = ()
    if orderno or customer_id or product_id or supplier_id:
        if supplier_id:
            snor_condition = Q()
            snand_condition = Q(customer__isnull=True)
            snor_condition.add(Q(**{'invoice__isnull': True}), Q.AND)
        or_condition = Q()
        and_condition = Q(serial_number__isnull=False)
        if orderno:
            if orderno and customer_id and product_id:
                or_condition.add(Q(**{'order__id': orderno}), Q.AND)
                or_condition.add(Q(**{'order__invoice__customer__id': customer_id}), Q.AND)
                or_condition.add(Q(**{'product__id': product_id}), Q.AND)
            elif  orderno and customer_id:
                or_condition.add(Q(**{'order__invoice__customer__id': customer_id}), Q.AND)
                or_condition.add(Q(**{'order__id': orderno}), Q.AND)
            elif orderno and product_id:
                or_condition.add(Q(**{'product__id': product_id}), Q.AND)
                or_condition.add(Q(**{'order__id': orderno}), Q.AND)
            else:
                or_condition.add(Q(**{'order__id': orderno}), Q.AND)
        elif customer_id:
            if customer_id  and product_id:
                or_condition.add(Q(**{'product__id': product_id}), Q.AND)
                or_condition.add(Q(**{'order__invoice__customer__id': customer_id}), Q.AND)
            else :
                or_condition.add(Q(**{'order__invoice__customer__id': customer_id}), Q.AND)
        else:
            or_condition.add(Q(**{'product__id': product_id}), Q.AND)
        if orderno or customer_id or product_id:    
            and_condition.add(or_condition, Q.AND)
        order_items = Order_Item.objects.filter(and_condition)
        
        # order_items = Order_Item.objects.filter(and_condition)
        order_items = list(order_items) 
        order_items = sorted(order_items, key=lambda x: (x.installation_date or today, x.installation_time or default_time))
         
    if orderno or supplier_id or product_id:
        if not supplier_id:
            snor_condition = Q()
            snand_condition = Q(customer__isnull=True)
            snor_condition.add(Q(**{'invoice__isnull': True}), Q.AND)
        if orderno:
            if orderno and supplier_id and product_id:
                snor_condition.add(Q(**{'bill__id': orderno}), Q.AND)
                snor_condition.add(Q(**{'bill__supplier__id': supplier_id}), Q.AND)
                or_condition.add(Q(**{'serial_number__bill__supplier__id': supplier_id}), Q.AND)
                snor_condition.add(Q(**{'product__id': product_id}), Q.AND)
            elif  orderno and supplier_id:
                snor_condition.add(Q(**{'bill__supplier__id': supplier_id}), Q.AND)
                or_condition.add(Q(**{'serial_number__bill__supplier__id': supplier_id}), Q.AND)
                snor_condition.add(Q(**{'bill__id': orderno}), Q.AND)
            elif orderno and product_id:
                snor_condition.add(Q(**{'product__id': product_id}), Q.AND)
                snor_condition.add(Q(**{'bill__id': orderno}), Q.AND)
            else:
                snor_condition.add(Q(**{'bill__id': orderno}), Q.AND)
        elif supplier_id:
            if supplier_id  and product_id:
                snor_condition.add(Q(**{'product__id': product_id}), Q.AND)
                snor_condition.add(Q(**{'bill__supplier__id': supplier_id}), Q.AND)
                or_condition.add(Q(**{'serial_number__bill__supplier__id': supplier_id}), Q.AND)
            else :
                snor_condition.add(Q(**{'bill__supplier__id': supplier_id}), Q.AND)
                or_condition.add(Q(**{'serial_number__bill__supplier__id': supplier_id}), Q.AND)
        else:
            snor_condition.add(Q(**{'product__id': product_id}), Q.AND)
        snand_condition.add(snor_condition, Q.AND)
        # dd(snand_condition)
        serial_numbers = SerialNumber.objects.filter(snand_condition).order_by(Case(
        When(tracking_status=3, then='arrived_date'),
        default='Arrival_ETA_date'
    ))
        order_items = list(order_items)
        order_items = sorted(order_items, key=lambda x: (x.installation_date or today, x.installation_time or default_time))
        order_items = list(order_items) + list(serial_numbers)
        
    
    
    # dd(and_condition)
    
    
    
    technicians=User.objects.filter(role=3,deleted_at__isnull=True)
    customer = Customer.objects.all()
    suppliers = Supplier.objects.all()
    products=Product.objects.filter(deleted_at__isnull=True ).order_by('category__category_name')
    return render(request,'pages/order/tracking_status.html',{'order_items':order_items,'technicians':technicians,'customers':customer,'suppliers':suppliers,'products':products})
    
@user_passes_test(lambda u: is_customer(u) or is_admin(u) or is_superuser(u) or is_sales(u))
@login_required
def tracking_order_status(request):
    today = timezone.now().date()
    order_itemsold = Order_Item.objects.filter( Q(status__lt=5) | Q(status=12),serial_number__isnull=False).order_by('serial_number__Arrival_ETA_date')
    order_itemsTrade = Order_Item.objects.filter(is_trade=1, status=4)
    order_itemsmerge = order_itemsold | order_itemsTrade

    if is_admin(request.user):
        print('admin')
        order_itemsold = Order_Item.objects.filter(Q(status__lt=5) | Q(status=12),serial_number__isnull=False).order_by('serial_number__Arrival_ETA_date')
        order_itemsTrade = Order_Item.objects.filter(is_trade=1, status=4)
        order_itemsmerge = order_itemsold | order_itemsTrade
        # order_items = sorted(order_itemsmerge, key=lambda x: (x.installation_date, x.installation_time))
        order_items = sorted(
            order_itemsmerge,
            key=lambda x: (
                x.installation_date or datetime.date.max,
                x.installation_time or datetime.time.max
            )
        )
        services = Technician_Assigned_Order_Item.objects.filter(
            deleted_by__isnull=True,
            job_type = 2,
            working_status = 4 ,
        )
        
    elif is_sales(request.user):
        print('sales')
        quote_by = User.objects.get(id=request.user.id)
        # order_items = Order_Item.objects.filter(,serial_number__isnull=False)
        
        order_itemsold = Order_Item.objects.filter(order__invoice__quotation__quote_by=quote_by,serial_number__isnull=False,status__lt=5).order_by('serial_number__Arrival_ETA_date')
        order_itemsTrade = Order_Item.objects.filter(is_trade=1, status=4)
        order_itemsmerge = order_itemsTrade | order_itemsTrade
        # order_items = sorted(order_itemsmerge, key=lambda x: (x.installation_date, x.installation_time))
        order_items = sorted(
            order_itemsmerge,
            key=lambda x: (
                x.installation_date or datetime.date.max,
                x.installation_time or datetime.time.max
                # x.installation_date or float('inf'),  # Use float('inf') as a placeholder for None dates
                # x.installation_time or float('inf')   # Use float('inf') as a placeholder for None times
            )
        )
        services = Technician_Assigned_Order_Item.objects.filter(
            deleted_by__isnull=True,
            job_type = 2
        )
    else:
        print('superadmin')
        order_items = sorted(
            order_itemsmerge,
            key=lambda x: (
                x.installation_date or datetime.date.max,
                x.installation_time or datetime.time.max
                # x.installation_date or float('inf'),  # Use float('inf') as a placeholder for None dates
                # x.installation_time or float('inf')   # Use float('inf') as a placeholder for None times
            )
        )
        services = Technician_Assigned_Order_Item.objects.filter(
            deleted_by__isnull=True,
            job_type = 2
        ).prefetch_related('technician_jobs_interval__technician__userinfo')
        

    serial_numbers = SerialNumber.objects.filter(customer__isnull=True, invoice__isnull=True).order_by(Case(
        When(tracking_status=3, then='arrived_date'),
        default='Arrival_ETA_date'
    ))
    order_items = list(order_items) + list(serial_numbers)
    # dd(order_itemsTrade)
    technicians=User.objects.filter(role=3,deleted_at__isnull=True)
    customer = Customer.objects.all()
    suppliers = Supplier.objects.all()
    products=Product.objects.filter(deleted_at__isnull=True ).order_by('category__category_name')
    # print(order_items)
    return render(request,'pages/order/tracking_status.html',{'order_items':order_items,'technicians':technicians,'customers':customer,'suppliers':suppliers,'products':products,'services':services})

@login_required
def tracking_order_status_changes(request):
    order_itemsold = Order_Item.objects.filter(serial_number__isnull=False,status__lt=5)
    order_itemsTrade = Order_Item.objects.filter(product__category__id=23,status__lt=5)
    order_items = order_itemsold | order_itemsTrade
    # dd(order_items)
    if is_admin(request.user) and is_sales(request.user):
        order_itemsold = Order_Item.objects.filter(serial_number__isnull=False,status__lt=5)
        order_itemsTrade = Order_Item.objects.filter(product__category__id=23,status__lt=5)
        order_items = order_itemsold | order_itemsTrade
    elif is_sales(request.user):
        quote_by = User.objects.get(id=request.user.id)
        # order_items = Order_Item.objects.filter(,serial_number__isnull=False)
        order_itemsold = Order_Item.objects.filter(order__invoice__quotation__quote_by=quote_by,serial_number__isnull=False,status__lt=5)
        order_itemsTrade = Order_Item.objects.filter(order__invoice__quotation__quote_by=quote_by,is_trade=1,status__lt=5)
        order_items = order_itemsold | order_itemsTrade

    serial_numbers = SerialNumber.objects.filter(customer__isnull=True, invoice__isnull=True)
    order_items = list(order_items) + list(serial_numbers)
    technicians=User.objects.filter(role=3,deleted_at__isnull=True)
    customer = Customer.objects.all()
    suppliers = Supplier.objects.all()
    products=Product.objects.filter(deleted_at__isnull=True ).order_by('category__category_name')
    #dd(order_items)
    return render(request,'pages/order/tracking_status_changes.html',{'order_items':order_items,'technicians':technicians,'customers':customer,'suppliers':suppliers,'products':products})

@user_passes_test(lambda u: is_customer(u) or is_admin(u) or is_superuser(u) or is_sales(u))
@login_required
def calendar(request):
    technicians=User.objects.filter(role__in=[2, 3],deleted_at__isnull=True)
    suppliers = Supplier.objects.all()
    customer = Customer.objects.all()
    techs=User.objects.filter(role__in=[2, 3],deleted_at__isnull=True)
    products=Product.objects.filter(deleted_at__isnull=True ).order_by('category__category_name')
    
    if is_admin(request.user) and is_sales(request.user):
      order_items = Order_Item.objects.filter(status__in=[0,1,2,3,4])
      technician_assigned_job_lists = Technician_Assigned_Order_Item.objects.filter(order_item__isnull=False)
      Leadnote.objects.annotate( lead_exists=Exists(Lead.objects.filter(id=OuterRef('lead_id'))) ).filter(lead_exists=False).delete()
      lead_notes=Leadnote.objects.filter(reminder_date__isnull=False,lead__isnull=False)
      print('sales+admin')
    elif is_sales(request.user):
        quote_by = User.objects.get(id=request.user.id)
        # order_items = Order_Item.objects.filter(order__invoice__quotation__quote_by=quote_by,serial_number__isnull=False)
        order_itemsold = Order_Item.objects.filter(order__invoice__quotation__quote_by=quote_by,status__in=[0,1,2,3,4])
        # order_itemsTrade = Order_Item.objects.filter(order__invoice__quotation__quote_by=quote_by,product__is_product=1,status__in=[0,1,2,3,4])
        order_items = order_itemsold # | order_itemsTrade
        technician_assigned_job_lists = Technician_Assigned_Order_Item.objects.filter(order_item__isnull=False,order_item__order__invoice__quotation__quote_by=quote_by)
        Leadnote.objects.annotate( lead_exists=Exists(Lead.objects.filter(id=OuterRef('lead_id'))) ).filter(lead_exists=False).delete()
        lead_notes=Leadnote.objects.filter(reminder_date__isnull=False,assigned_to__isnull=False,lead__isnull=False,assigned_to=quote_by)
        print('sales')
    else:
        # order_items = Order_Item.objects.filter(serial_number__isnull=False)
        order_itemsold = Order_Item.objects.filter(status__in=[0,1,2,3,4])
        # order_itemsTrade = Order_Item.objects.filter(product__is_product=1,status__in=[0,1,2,3,4])
        order_items = order_itemsold # | order_itemsTrade
        technician_assigned_job_lists = Technician_Assigned_Order_Item.objects.filter(order_item__isnull=False)
        Leadnote.objects.annotate( lead_exists=Exists(Lead.objects.filter(id=OuterRef('lead_id'))) ).filter(lead_exists=False).delete()
        lead_notes=Leadnote.objects.filter(reminder_date__isnull=False,lead__isnull=False)
        print('else')
        #dd(technician_assigned_job_lists)
    # dd(order_items)
    serial_numbers=SerialNumber.objects.filter(customer__isnull=True, invoice__isnull=True,bill__isnull=False)
    
    return render(request,'calendar.html',{'order_items':order_items,'techs':techs,'serial_numbers':serial_numbers,'lead_notes':lead_notes,'technicians':technicians,'customers':customer,'suppliers':suppliers,'products':products,'technician_assigned_job_lists':technician_assigned_job_lists})

@user_passes_test(lambda u: is_customer(u) or is_admin(u) or is_superuser(u) or is_sales(u))
@login_required
def allmodals(request):
    viewMode = request.GET.get('viewMode')
    navigation = request.GET.get('navigation')
    dates=next_week(viewMode,navigation)
    technicians=User.objects.filter(role=3,deleted_at__isnull=True)
    suppliers = Supplier.objects.all()
    customer = Customer.objects.all()
    techs=User.objects.filter(role=3,deleted_at__isnull=True)
    products=Product.objects.filter(deleted_at__isnull=True ).order_by('category__category_name')
    Leadnote.objects.annotate(
        lead_exists=Exists(Lead.objects.filter(id=OuterRef('lead_id')))
    ).filter(lead_exists=False).delete()
    if is_admin(request.user) and is_sales(request.user):
      order_items = Order_Item.objects.filter(status__in=[0,1,2,3,4],updated_at__gte=dates['startdate'],updated_at__lte=dates['enddate'])
      technician_assigned_job_lists = Technician_Assigned_Order_Item.objects.filter(order_item__isnull=False,updated_at__gte=dates['startdate'],updated_at__lte=dates['enddate'])
      lead_notes=Leadnote.objects.filter(reminder_date__isnull=False,lead__isnull=False,reminder_date__gte=dates['startdate'],reminder_date__lte=dates['enddate'])
    elif is_sales(request.user):
        quote_by = User.objects.get(id=request.user.id)
        # order_items = Order_Item.objects.filter(order__invoice__quotation__quote_by=quote_by,serial_number__isnull=False)
        order_itemsold = Order_Item.objects.filter(order__invoice__quotation__quote_by=quote_by,status__in=[0,1,2,3,4],updated_at__gte=dates['startdate'],updated_at__lte=dates['enddate'])
        # order_itemsTrade = Order_Item.objects.filter(order__invoice__quotation__quote_by=quote_by,product__is_product=1,status__in=[0,1,2,3,4])
        order_items = order_itemsold # | order_itemsTrade
        technician_assigned_job_lists = Technician_Assigned_Order_Item.objects.filter(order_item__isnull=False,order_item__order__invoice__quotation__quote_by=quote_by,updated_at__gte=dates['startdate'],updated_at__lte=dates['enddate'])
        lead_notes=Leadnote.objects.filter(reminder_date__isnull=False,assigned_to__isnull=False,lead__isnull=False,assigned_to=quote_by,reminder_date__gte=dates['startdate'],reminder_date__lte=dates['enddate'])
    else:
        # order_items = Order_Item.objects.filter(serial_number__isnull=False)
        order_itemsold = Order_Item.objects.filter(status__in=[0,1,2,3,4],updated_at__gte=dates['startdate'],updated_at__lte=dates['enddate'])
        # order_itemsTrade = Order_Item.objects.filter(product__is_product=1,status__in=[0,1,2,3,4])
        order_items = order_itemsold # | order_itemsTrade
        technician_assigned_job_lists = Technician_Assigned_Order_Item.objects.filter(order_item__isnull=False,updated_at__gte=dates['startdate'],updated_at__lte=dates['enddate'])
        lead_notes=Leadnote.objects.filter(reminder_date__isnull=False,lead__isnull=False,reminder_date__gte=dates['startdate'],reminder_date__lte=dates['enddate'])
        #dd(technician_assigned_job_lists)
    # dd(order_items)
    
    
    serial_numbers=SerialNumber.objects.filter(customer__isnull=True, invoice__isnull=True,bill__isnull=False,updated_at__gte=dates['startdate'],updated_at__lte=dates['enddate'])
    return render(request,'calendarmodals.html',{'order_items':order_items,'techs':techs,'serial_numbers':serial_numbers,'lead_notes':lead_notes,'technicians':technicians,'customers':customer,'suppliers':suppliers,'products':products,'technician_assigned_job_lists':technician_assigned_job_lists})

def next_week(viewMode, navigation):
    today = datetime.date.today()
    navigation = int(navigation)  # Ensure navigation is an integer

    if viewMode == 'weekly':
        if navigation == 0:
            idx = (today.weekday() + 1) % 7
            sun = today - datetime.timedelta(days=idx)
            sat = today + datetime.timedelta(days=(6 - idx))
        else:
            # Calculate the start and end of the week based on the navigation value
            navigation *= 7
            idx = (today.weekday() + 1) % 7
            sun = today + datetime.timedelta(days=navigation - idx)
            sat = sun + datetime.timedelta(days=6)
        print("Start of week:", sun)
        print("End of week:", sat)

    else:  # Assuming viewMode is 'monthly'
        if navigation == 0:
            # Current month’s first and last days
            sun = today.replace(day=1)
            last_day = cal1.monthrange(today.year, today.month)[1]
            sat = today.replace(day=last_day)
        else:
            # Handle month navigation
            new_month = today.month + navigation
            new_year = today.year

            # Adjust year and month if it overflows
            if new_month > 12:
                new_year += new_month // 12
                new_month = new_month % 12
            elif new_month < 1:
                new_year += (new_month - 1) // 12
                new_month = 12 + (new_month % 12)
                
            # Handle edge cases when new_month becomes 0 or negative
            if new_month <= 0:
                new_year -= 1
                new_month += 12

            # Calculate first and last day of the target month
            sun = today.replace(year=new_year, month=new_month, day=1)
            last_day_next_month = cal1.monthrange(new_year, new_month)[1]
            sat = sun.replace(day=last_day_next_month)

        print("Start of month:", sun)
        print("End of month:", sat)
    print('sun-sat')
    print(sun)
    print(sat)
    return {'startdate':sun,'enddate':sat}
   
@user_passes_test(lambda u: is_customer(u) or is_admin(u) or is_superuser(u) or is_sales(u))
@login_required
def calendar_new(request):
    technicians=User.objects.filter(role=3,deleted_at__isnull=True)
    suppliers = Supplier.objects.all()
    customer = Customer.objects.all()
    techs=User.objects.filter(role=3,deleted_at__isnull=True)
    products=Product.objects.filter(deleted_at__isnull=True ).order_by('category__category_name')
    
    if is_admin(request.user) and is_sales(request.user):
      order_items = Order_Item.objects.filter(status__in=[0,1,2,3,4])
      technician_assigned_job_lists = Technician_Assigned_Order_Item.objects.filter(order_item__isnull=False)
    elif is_sales(request.user):
        quote_by = User.objects.get(id=request.user.id)
        # order_items = Order_Item.objects.filter(order__invoice__quotation__quote_by=quote_by,serial_number__isnull=False)
        order_itemsold = Order_Item.objects.filter(order__invoice__quotation__quote_by=quote_by,status__in=[0,1,2,3,4])
        # order_itemsTrade = Order_Item.objects.filter(order__invoice__quotation__quote_by=quote_by,product__is_product=1,status__in=[0,1,2,3,4])
        order_items = order_itemsold # | order_itemsTrade
        technician_assigned_job_lists = Technician_Assigned_Order_Item.objects.filter(order_item__isnull=False,order_item__order__invoice__quotation__quote_by=quote_by)
        
    else:
        # order_items = Order_Item.objects.filter(serial_number__isnull=False)
        order_itemsold = Order_Item.objects.filter(status__in=[0,1,2,3,4])
        # order_itemsTrade = Order_Item.objects.filter(product__is_product=1,status__in=[0,1,2,3,4])
        order_items = order_itemsold # | order_itemsTrade
        technician_assigned_job_lists = Technician_Assigned_Order_Item.objects.filter(order_item__isnull=False)
        #dd(technician_assigned_job_lists)
    # dd(order_items)
    serial_numbers=SerialNumber.objects.filter(customer__isnull=True, invoice__isnull=True,bill__isnull=False)
    return render(request,'calendar.html',{'order_items':order_items,'techs':techs,'serial_numbers':serial_numbers,'technicians':technicians,'customers':customer,'suppliers':suppliers,'products':products,'technician_assigned_job_lists':technician_assigned_job_lists})

def getserial (request):
    ev_type = request.GET.get('event_type')
    viewMode = request.GET.get('viewMode')
    navigation = request.GET.get('navigation')
    dates=next_week(viewMode,navigation)
    print(ev_type)
    if not ev_type :
        print('not')
        customer_id = request.GET.get('customer_id')
        product_id = request.GET.get('product_id')
        supplier_id = request.GET.get('supplier_id')
        # orderno = request.GET.get('orderno')
        status = request.GET.get('status')
        billno = request.GET.get('orderno')
        snor_condition = Q()
        snand_condition = Q(customer__isnull=True)
        snand_condition &= Q(updated_at__gte=dates['startdate'])
        snand_condition &= Q(updated_at__lte=dates['enddate'])
        snor_condition.add(Q(**{'invoice__isnull': True}), Q.AND)
        snor_condition.add(Q(**{'bill__isnull': False}), Q.AND)
        snor_condition.add(Q(**{'tracking_status__in': [0,1,2,3,4]}), Q.AND)
        # if customer_id and product_id:
        #     or_condition.add(Q(**{'order__invoice__customer__id': customer_id}), Q.AND)
        #     or_condition.add(Q(**{'product__id': product_id}), Q.AND)
        # elif customer_id:
        #     or_condition.add(Q(**{'order__invoice__customer__id': customer_id}), Q.AND)
        if not customer_id:
            if supplier_id and product_id:
                snor_condition.add(Q(**{'bill__supplier__id': supplier_id}), Q.AND)
            
            elif supplier_id:
                snor_condition.add(Q(**{'bill__supplier__id': supplier_id}), Q.AND)
                
            # if orderno:
            #     or_condition.add(Q(**{'order__id': orderno}), Q.AND)
            
            if product_id:
                snor_condition.add(Q(**{'product__id': product_id}), Q.AND)
                # or_condition.add(Q(**{'product__id': product_id}), Q.AND)
                
            if billno:
                snor_condition.add(Q(**{'bill__id': billno}), Q.AND)
            
            if status:
                if status == '1':
                    snor_condition.add(Q(**{'status': 1}), Q.AND)
            # if status:
            #     snor_condition.add(Q(**{'tracking_status': status}), Q.AND)
             
            # and_condition.add(or_condition, Q.AND)
            snand_condition.add(snor_condition, Q.AND)
            # dd(and_condition)
            # order_items = Order_Item.objects.filter(and_condition)
            order_items = list(SerialNumber.objects.filter(snand_condition).extra(select={'hdate':"to_char(product_serialnumber.updated_at, 'DD-MM-YYYY')",'statusofitem':"product_serialnumber.tracking_status",'id':"product_serialnumber.id"}).values())
        else:
            order_items=[]
        # order_items = list(SerialNumber.objects.filter(customer__isnull=True, invoice__isnull=True,bill__isnull=False).extra(select={'hdate':"to_char(updated_at, 'DD-MM-YYYY')",'statusofitem':"tracking_status",'id':"id"}).values())
        return JsonResponse({'test':order_items})
    elif ev_type:
        if   ev_type == '3' :
            customer_id = request.GET.get('customer_id')
            product_id = request.GET.get('product_id')
            supplier_id = request.GET.get('supplier_id')
            orderno = request.GET.get('orderno')
            status = request.GET.get('status')
            billno = request.GET.get('billno')
            snor_condition = Q()
            snand_condition = Q(customer__isnull=True)
            snand_condition &= Q(updated_at__gte=dates['startdate'])
            snand_condition &= Q(updated_at__lte=dates['enddate'])
            snor_condition.add(Q(**{'invoice__isnull': True}), Q.AND)
            snor_condition.add(Q(**{'tracking_status__in': [0,1,2,3,4]}), Q.AND)
            # if customer_id and product_id:
            #     or_condition.add(Q(**{'order__invoice__customer__id': customer_id}), Q.AND)
            #     or_condition.add(Q(**{'product__id': product_id}), Q.AND)
            # elif customer_id:
            #     or_condition.add(Q(**{'order__invoice__customer__id': customer_id}), Q.AND)
            if not customer_id:
                if supplier_id and product_id:
                    snor_condition.add(Q(**{'bill__supplier__id': supplier_id}), Q.AND)
                
                elif supplier_id:
                    snor_condition.add(Q(**{'bill__supplier__id': supplier_id}), Q.AND)
                    
                # if orderno:
                #     or_condition.add(Q(**{'order__id': orderno}), Q.AND)
                
                if product_id:
                    snor_condition.add(Q(**{'product__id': product_id}), Q.AND)
                    # or_condition.add(Q(**{'product__id': product_id}), Q.AND)
                    
                if billno:
                    snor_condition.add(Q(**{'bill__id': billno}), Q.AND)
                if status:
                    if status == '1':
                        snor_condition.add(Q(**{'status': 1}), Q.AND)
                 
                # and_condition.add(or_condition, Q.AND)
                snand_condition.add(snor_condition, Q.AND)
                # dd(and_condition)
                # order_items = Order_Item.objects.filter(and_condition)
                order_items = list(SerialNumber.objects.filter(snand_condition).extra(select={'hdate':"to_char(product_serialnumber.updated_at, 'DD-MM-YYYY')",'statusofitem':"product_serialnumber.tracking_status",'id':"product_serialnumber.id"}).values())
            else:
                order_items=[]
            # order_items = list(SerialNumber.objects.filter(customer__isnull=True, invoice__isnull=True,bill__isnull=False).extra(select={'hdate':"to_char(updated_at, 'DD-MM-YYYY')",'statusofitem':"tracking_status",'id':"id"}).values())
            return JsonResponse({'test':order_items})
        else:
            return JsonResponse({'test':[]})
    else:
            return JsonResponse({'test':[]})
 
def getleadnotes(request):
    ev_type = request.GET.get('event_type')
    viewMode = request.GET.get('viewMode')
    navigation = request.GET.get('navigation')
    dates=next_week(viewMode,navigation)
    if not ev_type :
        print('not')
        customer_id = request.GET.get('customer_id')
        technician_id = request.GET.get('technician_id')
        product_id = request.GET.get('product_id')
        supplier_id = request.GET.get('supplier_id')
        status = request.GET.get('status')
        orderno = request.GET.get('orderno')
        # billno = request.GET.get('billno')
      
        or_condition = Q()
        and_condition = Q(reminder_date__isnull=False)
        # or_condition.add(Q(**{'job_status__in': [0,1,2,3,4]}), Q.AND)
        if technician_id:
            or_condition.add(Q(**{'assigned_to_id': technician_id}), Q.AND)
        # elif supplier_id:
        #     or_condition.add(Q(**{'order_item__serial_number__bill__supplier__id': supplier_id}), Q.AND)
        # if orderno:
        #     or_condition.add(Q(**{'id': orderno}), Q.AND)
        # if product_id:
        #     or_condition.add(Q(**{'order_item__product__id': product_id}), Q.AND)
        # if status:
        #     or_condition.add(Q(**{'job_status': status}), Q.AND)
        and_condition.add(or_condition, Q.AND)
        if is_admin(request.user) and is_sales(request.user):
            and_condition &= Q(reminder_date__gte=dates['startdate'])
            and_condition &= Q(reminder_date__lte=dates['enddate'])
        elif is_sales(request.user):
            and_condition &= Q(reminder_date__gte=dates['startdate'])
            and_condition &= Q(reminder_date__lte=dates['enddate'])
            quote_by = User.objects.get(id=request.user.id)
            and_condition &= Q(assigned_to__isnull=False)
            and_condition &= Q(assigned_to=quote_by)
            # lead_notes=Leadnote.objects.filter(reminder_date__isnull=False,assigned_to__isnull=False,lead__isnull=False,assigned_to=quote_by)
        else:
            and_condition &= Q(reminder_date__gte=dates['startdate'])
            and_condition &= Q(reminder_date__lte=dates['enddate'])
            
        and_condition.add(or_condition, Q.AND)
        # technician_assigned_job_lists = list(Leadnote.objects.filter(and_condition).extra(select={'hdate':"to_char(reminder_date, 'DD-MM-YYYY')",'id':"id",'name':'lead'}).values())
        # technician_assigned_job_lists = list(
        #     Leadnote.objects
        #     .filter(and_condition)
        #     .annotate(hdate=Func(F('reminder_date'), function='to_char', template="to_char(%(expressions)s, 'DD-MM-YYYY')"))
        #     .values('id', 'hdate', 'lead__first_name', 'lead__last_name')
        # )
        technician_assigned_job_lists = list(
            Leadnote.objects
            .filter(and_condition)
            .annotate(
                hdate=Func(F('reminder_date'), function='to_char', template="to_char(%(expressions)s, 'DD-MM-YYYY')"),
                name=Case(
                    When(lead__company_name__isnull=False, then=F('lead__company_name')),
                    default=Concat(F('lead__first_name'), Value(' '), F('lead__last_name')),
                    output_field=CharField()
                )
            )
            .values('id', 'hdate', 'name')
        )
        # order_items = list(Order_Item.objects.filter(serial_number__isnull=False).extra(select={'hdate':"to_char(updated_at, 'DD-MM-YYYY')",'statusofitem':"status",'id':"id"}).values())
        return JsonResponse({'test':technician_assigned_job_lists})
        
    elif ev_type :
        if ev_type == '4' :
            customer_id = request.GET.get('customer_id')
            technician_id = request.GET.get('technician_id')
            product_id = request.GET.get('product_id')
            supplier_id = request.GET.get('supplier_id')
            status = request.GET.get('status')
            orderno = request.GET.get('orderno')
            # billno = request.GET.get('billno')
            
            or_condition = Q()
            and_condition = Q(reminder_date__isnull=False)
            if technician_id:
                or_condition.add(Q(**{'assigned_to_id': technician_id}), Q.AND)
            if is_admin(request.user) and is_sales(request.user):
                and_condition &= Q(reminder_date__gte=dates['startdate'])
                and_condition &= Q(reminder_date__lte=dates['enddate'])
            elif is_sales(request.user):
                and_condition &= Q(reminder_date__gte=dates['startdate'])
                and_condition &= Q(reminder_date__lte=dates['enddate'])
                quote_by = User.objects.get(id=request.user.id)
                and_condition &= Q(assigned_to__isnull=False)
                and_condition &= Q(assigned_to=quote_by)
                # lead_notes=Leadnote.objects.filter(reminder_date__isnull=False,assigned_to__isnull=False,lead__isnull=False,assigned_to=quote_by)
            else:
                and_condition &= Q(reminder_date__gte=dates['startdate'])
                and_condition &= Q(reminder_date__lte=dates['enddate'])
            
            and_condition.add(or_condition, Q.AND)
            # technician_assigned_job_lists = list(LeadNote.objects.filter(and_condition).extra(select={'hdate':"to_char(reminder_date, 'DD-MM-YYYY')",'id':"id"}).values())
            technician_assigned_job_lists = list(
                    Leadnote.objects
                    .filter(and_condition)
                    .annotate(
                        hdate=Func(F('reminder_date'), function='to_char', template="to_char(%(expressions)s, 'DD-MM-YYYY')"),
                        name=Case(
                            When(lead__company_name__isnull=False, then=F('lead__company_name')),
                            default=Concat(F('lead__first_name'), Value(' '), F('lead__last_name')),
                            output_field=CharField()
                        )
                    )
                    .values('id', 'hdate', 'name')
                )
            # order_items = list(Order_Item.objects.filter(serial_number__isnull=False).extra(select={'hdate':"to_char(updated_at, 'DD-MM-YYYY')",'statusofitem':"status",'id':"id"}).values())
            return JsonResponse({'test':technician_assigned_job_lists})
        else:
            return JsonResponse({'test':[]})
    else:
        return JsonResponse({'test': []})
        
def getjob(request):
    ev_type = request.GET.get('event_type')
    viewMode = request.GET.get('viewMode')
    navigation = request.GET.get('navigation')
    dates=next_week(viewMode,navigation)
    if not ev_type :
        print('not')
        customer_id = request.GET.get('customer_id')
        technician_id = request.GET.get('technician_id')
        product_id = request.GET.get('product_id')
        supplier_id = request.GET.get('supplier_id')
        status = request.GET.get('status')
        orderno = request.GET.get('orderno')
        # billno = request.GET.get('billno')
        if status:
            if status == '6':
                status = 0
            if status == '7':
                status = 1
            if status == '8':
                status = 2
            if status == '9':
                status = 3
            if status == '10':
                status = 4
        or_condition = Q()
        and_condition = Q(order_item__isnull=False)
        or_condition.add(Q(**{'job_status__in': [0,1,2,3,4]}), Q.AND)
        and_condition &= Q(updated_at__gte=dates['startdate'])
        and_condition &= Q(updated_at__lte=dates['enddate'])
        # or_condition.add(Q(**{'status__in': [0,1,2,3,4]}), Q.AND)
        # or_condition.add(Q(status__in=[0,1,2,3,4] , Q.AND))
        if customer_id and product_id:
            or_condition.add(Q(**{'order_item__order__invoice__customer__id': customer_id}), Q.AND)
            or_condition.add(Q(**{'order_item__product__id': product_id}), Q.AND)
        elif customer_id:
            or_condition.add(Q(**{'order_item__order__invoice__customer__id': customer_id}), Q.AND)
        if supplier_id and product_id:
            or_condition.add(Q(**{'order_item__serial_number__bill__supplier__id': supplier_id}), Q.AND)
        elif technician_id:
            or_condition.add(Q(**{'order_item__order_item__technician__id': technician_id}), Q.AND)
        elif supplier_id:
            or_condition.add(Q(**{'order_item__serial_number__bill__supplier__id': supplier_id}), Q.AND)
        if orderno:
            or_condition.add(Q(**{'id': orderno}), Q.AND)
        if product_id:
            or_condition.add(Q(**{'order_item__product__id': product_id}), Q.AND)
        if status:
            or_condition.add(Q(**{'job_status': status}), Q.AND)
        and_condition.add(or_condition, Q.AND)
        technician_assigned_job_lists = list(Technician_Assigned_Order_Item.objects.filter(and_condition).extra(select={'hdate':"to_char(quotation_technician_assigned_order_item.updated_at, 'DD-MM-YYYY')",'statusofitem':"quotation_technician_assigned_order_item.job_status",'id':"quotation_technician_assigned_order_item.id"}).values())
        # order_items = list(Order_Item.objects.filter(serial_number__isnull=False).extra(select={'hdate':"to_char(updated_at, 'DD-MM-YYYY')",'statusofitem':"status",'id':"id"}).values())
        return JsonResponse({'test':technician_assigned_job_lists})
        
    elif ev_type :
        if ev_type == '2' :
            customer_id = request.GET.get('customer_id')
            technician_id = request.GET.get('technician_id')
            product_id = request.GET.get('product_id')
            supplier_id = request.GET.get('supplier_id')
            status = request.GET.get('status')
            orderno = request.GET.get('orderno')
            # billno = request.GET.get('billno')
            if status:
                if status == '6':
                    status = 0
                if status == '7':
                    status = 1
                if status == '8':
                    status = 2
                if status == '9':
                    status = 3
                if status == '10':
                    status = 4
            or_condition = Q()
            and_condition = Q(order_item__isnull=False)
            and_condition &= Q(updated_at__gte=dates['startdate'])
            and_condition &= Q(updated_at__lte=dates['enddate'])
            or_condition.add(Q(**{'job_status__in': [0,1,2,3,4]}), Q.AND)
            # or_condition.add(Q(**{'status__in': [0,1,2,3,4]}), Q.AND)
            # or_condition.add(Q(status__in=[0,1,2,3,4] , Q.AND))
            if customer_id and product_id:
                or_condition.add(Q(**{'order_item__order__invoice__customer__id': customer_id}), Q.AND)
                or_condition.add(Q(**{'order_item__product__id': product_id}), Q.AND)
            elif customer_id:
                or_condition.add(Q(**{'order_item__order__invoice__customer__id': customer_id}), Q.AND)
            elif technician_id:
                or_condition.add(Q(**{'order_item__order_item__technician__id': technician_id}), Q.AND)
            if supplier_id and product_id:
                or_condition.add(Q(**{'order_item__serial_number__bill__supplier__id': supplier_id}), Q.AND)
            elif supplier_id:
                or_condition.add(Q(**{'order_item__serial_number__bill__supplier__id': supplier_id}), Q.AND)
            if orderno:
                or_condition.add(Q(**{'id': orderno}), Q.AND)
            if product_id:
                or_condition.add(Q(**{'order_item__product__id': product_id}), Q.AND)
            if status:
                or_condition.add(Q(**{'job_status': status}), Q.AND)
            and_condition.add(or_condition, Q.AND)
            technician_assigned_job_lists = list(Technician_Assigned_Order_Item.objects.filter(and_condition).extra(select={'hdate':"to_char(updated_at, 'DD-MM-YYYY')",'statusofitem':"job_status",'id':"id"}).values())
            # order_items = list(Order_Item.objects.filter(serial_number__isnull=False).extra(select={'hdate':"to_char(updated_at, 'DD-MM-YYYY')",'statusofitem':"status",'id':"id"}).values())
            return JsonResponse({'test':technician_assigned_job_lists})
        else:
            return JsonResponse({'test':[]})
    else:
        return JsonResponse({'test': []})
    
def getEvents(request):
    ev_type = request.GET.get('event_type')
    viewMode = request.GET.get('viewMode')
    navigation = request.GET.get('navigation')
    dates=next_week(viewMode,navigation)
    print(dates['startdate'])
    print(dates['enddate'])
    # dd(request.GET)
    if not ev_type :
        print('not')
        customer_id = request.GET.get('customer_id')
        technician_id = request.GET.get('technician_id')
        product_id = request.GET.get('product_id')
        supplier_id = request.GET.get('supplier_id')
        status = request.GET.get('status')
        orderno = request.GET.get('orderno')
        # billno = request.GET.get('billno')
        or_condition = Q()
        # and_condition = Q(serial_number__isnull=False)
        and_condition = Q(status__in=[0,1,2,3,4])
        and_condition &= Q(updated_at__gte=dates['startdate'])
        and_condition &= Q(updated_at__lte=dates['enddate'])
        # or_condition.add(Q(**{'status__in': [0,1,2,3,4]}), Q.AND)
        # or_condition.add(Q(**{'product__is_product': 1}), Q.AND)
        # or_condition.add(Q(status__in=[0,1,2,3,4] , Q.AND))
        if not technician_id:
            if customer_id and product_id:
                or_condition.add(Q(**{'order__invoice__customer__id': customer_id}), Q.AND)
                or_condition.add(Q(**{'product__id': product_id}), Q.AND)
            elif customer_id:
                or_condition.add(Q(**{'order__invoice__customer__id': customer_id}), Q.AND)
            if supplier_id and product_id:
                or_condition.add(Q(**{'serial_number__bill__supplier__id': supplier_id}), Q.AND)
            elif supplier_id:
                or_condition.add(Q(**{'serial_number__bill__supplier__id': supplier_id}), Q.AND)
            if orderno:
                or_condition.add(Q(**{'order__id': orderno}), Q.AND)
            if status:
                if status == '2':
                    status = 0
                if status == '3':
                    status=1
                if status == '4':
                    status = 3
                if status == '5':
                    status = 4
            if product_id:
                or_condition.add(Q(**{'product__id': product_id}), Q.AND)
            and_condition.add(or_condition, Q.AND)
            order_items = list(Order_Item.objects.filter(and_condition).extra(select={'hdate':"to_char(quotation_order_item.updated_at, 'DD-MM-YYYY')",'statusofitem':"quotation_order_item.status",'id':"quotation_order_item.id"}).values())
            # order_items = list(Order_Item.objects.filter(serial_number__isnull=False).extra(select={'hdate':"to_char(updated_at, 'DD-MM-YYYY')",'statusofitem':"status",'id':"id"}).values())
        else:
            order_items=[]
        return JsonResponse({'test':order_items})
    elif ev_type:
        print('yes')
        if  ev_type == '1'  :
            print('order')
            customer_id = request.GET.get('customer_id')
            product_id = request.GET.get('product_id')
            supplier_id = request.GET.get('supplier_id')
            status = request.GET.get('status')
            orderno = request.GET.get('orderno')
            billno = request.GET.get('billno')
            or_condition = Q()
            # and_condition = Q(serial_number__isnull=False)
            and_condition = Q(**{'status__in': [0,1,2,3,4]})
            and_condition &= Q(updated_at__gte=dates['startdate'])
            and_condition &= Q(updated_at__lte=dates['enddate'])
            # or_condition.add(Q(**{'status__in': [0,1,2,3,4]}), Q.AND)
            # or_condition.add(Q(status__in=[0,1,2,3,4] , Q.AND))
            if customer_id and product_id:
                or_condition.add(Q(**{'order__invoice__customer__id': customer_id}), Q.AND)
                or_condition.add(Q(**{'product__id': product_id}), Q.AND)
            elif customer_id:
                or_condition.add(Q(**{'order__invoice__customer__id': customer_id}), Q.AND)
            if supplier_id and product_id:
                or_condition.add(Q(**{'serial_number__bill__supplier__id': supplier_id}), Q.AND)
            elif supplier_id:
                or_condition.add(Q(**{'serial_number__bill__supplier__id': supplier_id}), Q.AND)
            if orderno:
                or_condition.add(Q(**{'order__id': orderno}), Q.AND)
            if product_id:
                or_condition.add(Q(**{'product__id': product_id}), Q.AND)
            if status:
                if status == '2':
                    status = 0
                if status == '3':
                    status=1
                if status == '4':
                    status = 3
                if status == '5':
                    status = 4
                or_condition.add(Q(**{'status': status}), Q.AND)
            and_condition.add(or_condition, Q.AND)
            
            order_items = list(Order_Item.objects.filter(and_condition).extra(select={'hdate':"to_char(updated_at, 'DD-MM-YYYY')",'statusofitem':"status",'id':"id"}).values())
            # order_items = list(Order_Item.objects.filter(serial_number__isnull=False).extra(select={'hdate':"to_char(updated_at, 'DD-MM-YYYY')",'statusofitem':"status",'id':"id"}).values())
            return JsonResponse({'test':order_items})
        else:
            print('not order')
            return JsonResponse({'test':[]})
    else:
            return JsonResponse({'test':[]})

        

def test_doc(request):
    quotation = get_object_or_404(Quotation, id=1)
    contracts = ContractOfSale.objects.first()
    quotationitems = QuotationItem.objects.filter(quotation=quotation)
    # return render(request,'pages/quotation/quote_doc.html',{'quotation':quotation,'quotationitems':quotationitems,'contracts':contracts})
    return render(request,'pages/test_quote_doc.html',{'quotation':quotation,'quotationitems':quotationitems,'contracts':contracts})
    
def quotation_pdf(request):
    return render(request,'pages/quotation/quotation_pdf.html')
    
def list_quotation(request):
    return render(request,'pages/quotation/list.html')

def create_quotation(request):
    return render(request,'pages/quotation/create.html')

def edit_quotation(request):
    return render(request,'pages/quotation/edit.html')

def edit_contract(request):
    return render(request,'pages/contract_of_sale/edit.html')

def view_contract(request):
    return render(request,'pages/contract_of_sale/view.html')

def history(row):
    result = []
    # dd(result)
    old = []
    newarr = []
    # dd(row)
   
    if row.action == 'Updated':
        a = json.dumps(row.new_data[0]['fields'])
        b = json.dumps( row.old_data[0]['fields'])
        a = json.loads(a)
        b = json.loads(b)
        for key in a:
            if key not in b:
                result.append(f'Newly Added {dict({key: a[key]})} -> {"key deleted"}')
            
            if not ( key == 'updated_at' or key == 'updated_at' or key == 'updated_by' or key == 'deleted_at'):
                if a[key] != b[key]:
                    result.append(f'{key} From  {a[key]} to {b[key]}')
                # result.append(f' {key} From {a[key]} to {b[key]}')
                # old[row.action][key]['from']=a[key]
                # old[row.action][key]['to']=b[key]
                # old.append(key)
                
    if row.action == 'Deleted':
        result.append(f'Deleted')
        # old[row.action]=[]
    if row.action == 'Created':
        a = json.dumps(row.new_data[0]['fields'])
        a = json.loads(a)
        # result.append(f'Created {a}')
        for key in a:
            # old[row.action][key]=a[key]
            # old.append(key)
            result.append(f'{key} From {a[key]}')
    
    old.append(f' model:{row.model_name} timestamp:{row.timestamp} user:{row.user_id} action:{row.action}')
    # result='\n'.join(t for t in result)
    # result1='\n'.join(t for t in result1)
    # dd({'result':result,'result1':result1})
    return {'result':result,'old':old}
    

def activity_invoice(request, id):
    invoice = get_object_or_404(Invoice, pk=id)
    invoiceitems = InvoiceItem.objects.filter(invoice=invoice)
    context={'invoices': invoice}
    # dd(invoice.get_history)
    t1=[]
    for inv in invoice.get_history:
        t=history(inv)
        # dd(t)
        # if t.result!='':
        #     t.append(f' model:{row.model_name} timestamp:{row.timestamp} user:{row.user_id} action:{row.action}')
        t1.append(t)
    # for t in t1:
    #     dd(t)
   
    return render(request, 'pages/invoice/activity.html', {'invoices':t1})
# class SystemView(TemplateView):
#     template_name = 'pages/system/not-found.html'
#     status = ''

#     def get_context_data(self, **kwargs):
#         # Call the base implementation first to get a context
#         context = super().get_context_data(**kwargs)

#         # A function to init the global layout. It is defined in _keenthemes/__init__.py file
#         context = KTLayout.init(context)

#         # Define the layout for this module
#         # _templates/layout/system.html
#         context.update({
#             'layout': KTTheme.setLayout('system.html', context),
#             'status': self.status,
#         })

#         return context

def custom_404_view(request, exception):
    # return HttpResponseNotFound("Page not found")
    return render(request, "errors/404.html", status=404)

def custom_500_view(request):
    return render(request, "errors/500.html", status=500)