from django.shortcuts import render
import json
from django.conf import settings
from django.shortcuts import render
from common.models import *
from masters.models import *
from masters.forms import *
from privilege.models import *
import hashlib
import os
from django.conf import settings
from datetime import datetime
from django.utils import timezone
from django.db.models import Max, F, Q
import base64
from django.shortcuts import render
from io import BytesIO
from django.conf import settings
from django.template.loader import get_template
from django.http import HttpResponse,JsonResponse,HttpResponseRedirect
from django.shortcuts import get_object_or_404
from django.templatetags.static import static
from xhtml2pdf import pisa
from num2words import num2words
from django.contrib.staticfiles import finders
from common.utils import *
from django.db.models.functions import Cast
from django.db import transaction
from decimal import Decimal
from store.models import branch_table
from ledger.views import create_ledger_master_and_opening_balance



#```````````````````````````````````````````````````````````**UOM**````````````````````````````````````````````````````````````````````````````````


def category(request):
    if 'user_id' in request.session:
        user_type = request.session.get('user_type')
        if user_type == 'admin':
            cmpy = select_row(company_table, {'id':1})
            category = selectList(category_table, order_by='name')
            return render(request, 'category.html', {'company': cmpy,'category':category})
        else:
            return HttpResponseRedirect("/")
    else:
        return HttpResponseRedirect("/")



def category_sub_category(request):
    if 'user_id' in request.session:
        user_type = request.session.get('user_type')
        if user_type == 'admin':
            encoded_id = request.GET.get('id', None)
            decoded_id = decode_base64_id(encoded_id)
            if decoded_id:
                company = select_row(company_table, {'id': 1})                  
                category = selectList(category_table, order_by='name')
                details = select_row(category_table, {'id':decoded_id})
            else:
                return HttpResponse("ID parameter is missing")
            
            return render(request, 'sub_category.html', {'company': company,'category':category,'id':decoded_id})
        else:
            return HttpResponseRedirect("/")
    else:
        return HttpResponseRedirect("/")
    




def category_view(request):  
    role_id = request.session.get('role_id')
    has_access, error_message = check_user_access(role_id, 'master_category', "read")
    if not has_access:
        return JsonResponse({'message': 'warning', 'error_message': 'You do not have permission to view the category details'})
    

    data = list(selectList(category_table, order_by='sort_no').values())
   
    formatted = [
        {
            'id': index + 1,
            'action': '<button type="button" onclick="category_edit(\'{}\')" class="btn btn-outline-success btn-xs p-1"><i class="fas fa-edit" title="Edit"></i></button> \
                       <button type="button" onclick="category_delete(\'{}\')" class="btn btn-outline-danger btn-xs p-1" title="Delete"><i class="fas fa-trash-alt"></i></button> \
                       <button type="button" onclick="view_data(\'{}\')" class="btn btn-outline-primary btn-xs p-1" title="View subcategory"> <i class="fas fa-eye"></i></button>'.format(item['id'], item['id'], item['id']), 
            
            'category': item['name'] if item['name'] else '-', 
            'order': item['sort_no'] if item['sort_no'] else '-', 
            'description': item['description'] if item['description'] else '-', 
            'status': '<span class="badge text-bg-success">Active</span>' if item['is_active'] else '<span class="badge text-bg-danger">Inactive</span>'  # Assuming is_active is a boolean field
        } 
        for index, item in enumerate(data)
    ]
    return JsonResponse({'data': formatted})





from django.http import JsonResponse
from django.utils import timezone

def category_add(request):
    if request.method == 'POST':
        try:
            user_id = request.session.get('user_id')           
            company_id = request.session.get('company_id') 
            role_id = request.session.get('role_id')

            has_access, error_message = check_user_access(role_id, 'master_category', "create")
            if not has_access:
                return JsonResponse({'message': 'warning', 'error_message': 'You do not have permission to add category details'})

            form = categoryForm(request.POST, request.FILES)
            if form.is_valid():
                name = request.POST.get('name', '').strip()

                if category_table.objects.filter(name__iexact=name, status =1).exists():
                    return JsonResponse({'message': 'info', 'error_message': 'Category name already exists'})


                category = form.save(commit=False)
                category.name = name
                category.description = request.POST.get('description', '')
                category.sort_no = request.POST.get('sort_no') or 1
                category.created_by = user_id
                category.updated_by = user_id
                category.company_id = company_id
                category.is_active = 1
                category.status = 1
                category.created_on = date_time
                category.updated_on = date_time
                category.save()

                return JsonResponse({'message': 'success'})

            else:
                errors = form.errors.as_json()
                return JsonResponse({'message': 'form_error', 'errors': errors}, status=400)

        except Exception as e:
            return JsonResponse({'message': 'exception', 'error': str(e)}, status=500)



def category_edit(request):
    if request.headers.get('x-requested-with') == 'XMLHttpRequest' and request.method == "POST":
        data = category_table.objects.filter(id=request.POST.get('id'))    
    return JsonResponse(data.values()[0])


def category_update(request):
    if request.method == "POST":
        try:
            category_id = request.POST.get('id')
            category = category_table.objects.get(id=category_id)
            form = categoryForm(request.POST, request.FILES, instance=category)
            
            role_id = request.session.get('role_id')
            company_id = request.session.get('company_id')
            has_access, error_message = check_user_access(role_id, 'master_category', "update")

            if not has_access:
                return JsonResponse({'message': 'warning', 'error_message': 'You do not have permission to update category details'})

            if form.is_valid():
                name = request.POST.get('name').strip()
                desc = request.POST.get('description')
                
                sort_no = request.POST.get('sort_no') or 1
                is_active = request.POST.get('is_active')


                # ✅ Check only if name has changed
                if name.lower() != category.name.lower():
                    if category_table.objects.filter(name__iexact=name, status=1).exclude(id=category_id).exists():
                        return JsonResponse({'message': 'info', 'error_message': 'Category name already exists'})

                updated_category = form.save(commit=False)
                updated_category.name = name    
                updated_category.sort_no = sort_no            
                updated_category.is_active = is_active            
                updated_category.description = desc
                updated_category.updated_by = request.session.get('user_id')
                updated_category.updated_on = format_datetime(date_time)
                updated_category.save()

                return JsonResponse({'message': 'success'})
            else:
                errors = form.errors.as_json()
                return JsonResponse({'message': 'error', 'errors': errors})

        except Exception as e:
            return JsonResponse({'message': 'exception', 'error': str(e)})



def category_delete(request):
    if request.method == 'POST':
        data_id = request.POST.get('id')    
        role_id = request.session.get('role_id')

        has_access, error_message = check_user_access(role_id, 'master_category', "delete")

        if not has_access:
            return JsonResponse({'message': 'warning', 'error_message': 'You do not have permission to delete category details'})
               
        try:
            updated = category_table.objects.filter(id=data_id).update(status=0)
            if updated:
                return JsonResponse({'message': 'yes'})
            else:
                return JsonResponse({'message': 'no such data'})
        except Exception as e:
            return JsonResponse({'message': 'exception', 'error': str(e)})

    return JsonResponse({'message': 'Invalid request method'})


def check_category_name(request):
    name = request.POST.get('name', '').strip()
    category_id = request.POST.get('category_id')  # for edit case

    exists = category_table.objects.filter(
        name__iexact=name,
        status=1
    )

    if category_id:
        exists = exists.exclude(id=category_id)

    if exists.exists():
        return JsonResponse({
            'exists': True,
            'message': 'Category name already exists'
        })

    return JsonResponse({'exists': False})

#```````````````````````````````````````````````````````````**SUB CATEGORY**````````````````````````````````````````````````````````````````````````````````

def sub_category(request):
    if 'user_id' in request.session:
        user_type = request.session.get('user_type')
        if user_type == 'admin':
            cmpy = select_row(company_table, {'id':1})
            category = selectList(category_table, order_by='name')
            return render(request, 'sub_category.html', {'company': cmpy,'category':category})
        else:
            return HttpResponseRedirect("/")
    else:
        return HttpResponseRedirect("/")
    


def get_category_type(request):
    category_id = request.GET.get('category_id')

    subcategories = category_table.objects.filter(
        group_id=category_id,
        status=1
    ).values('id', 'name')

    return JsonResponse({
        "subcategories": list(subcategories)
    })






def sub_category_add(request):
    if request.method == 'POST':
        try:
            user_id = request.session.get('user_id')           
            company_id = request.session.get('company_id')           
            form = subcategoryForm(request.POST, request.FILES)

            role_id = request.session.get('role_id')
            has_access, error_message = check_user_access(role_id, 'master_subcategory', "create")

            if not has_access:
                return JsonResponse({'message': 'warning', 'error_message': 'You do not have permission to add sub category details'})
            
            if form.is_valid():
                category = form.save(commit=False)
                category_id =  request.POST.get('category_id')
                name = request.POST.get('name').strip()
                description = request.POST.get('description')

                if sub_category_table.objects.filter(name__iexact=name, category_id=category_id, status=1).exists():
                    return JsonResponse({'message': 'info', 'error_message': 'Sub Category name already exists'})


                category.category_id =category_id
                category.name = name
                category.description = description               
                category.status = 1
                category.is_active = 1
                category.company_id = company_id
                category.created_by = user_id
                category.updated_by = user_id
                category.created_on = format_datetime(date_time)
                category.updated_on = format_datetime(date_time)
                category.save()
                return JsonResponse({'message': 'success'})
            else:
                errors = form.errors.as_json()
                return JsonResponse({'message': 'form_error', 'errors': errors}, status=400)

        except Exception as e:
            return JsonResponse({'message': 'exception', 'error': str(e)}, status=500)




def sub_category_view(request):  

    role_id = request.session.get('role_id')
    
    category_id = request.POST.get('category_id')
    s_type = request.POST.get('type')

    query = Q(status=1)

    if category_id:
        query &= Q(category_id=category_id)

    if s_type:
        query &= Q(type=s_type)
    
    has_access, error_message = check_user_access(role_id, 'master_subcategory', "read")
    if not has_access:
        return JsonResponse({'message': 'warning', 'error_message': 'You do not have permission to view the sub category details'})
    
    
    data = list(selectList(sub_category_table, query).values())
    formatted = [
        {
            'id': index + 1,
            'action': '<button type="button" onclick="edit_data(\'{}\')" class="btn btn-outline-success btn-xs p-1" title="Edit"><i class="fas fa-edit"></i></button> \
                        <button type="button" onclick="delete_data(\'{}\')" class="btn btn-outline-danger btn-xs p-1" title="Delete"><i class="fas fa-trash-alt"></i></button>'.format(item['id'],  item['id']), 
            'name': item['name'] if item['name'] else '-', 
            'category': getItemNameById(category_table, item['category_id'] )  if item['category_id'] else '-', 
            'description': item['description'] if item['description'] else '-', 
            'status': '<span class="badge text-bg-success">Active</span>' if item['is_active'] else '<span class="badge text-bg-danger">Inactive</span>'  # Assuming is_active is a boolean field
        } 
        for index, item in enumerate(data)
    ]
    return JsonResponse({'data': formatted})


def sub_category_edit(request):
    if request.headers.get('x-requested-with') == 'XMLHttpRequest' and request.method == "POST":
         frm = request.POST
    data = sub_category_table.objects.filter(id=request.POST.get('id'))    
    return JsonResponse(data.values()[0])



def sub_category_update(request):
    if request.method == "POST":
        try:
            subcategory_id = request.POST.get('id')
            category = sub_category_table.objects.get(id=subcategory_id)
            form = subcategoryForm(request.POST, request.FILES, instance=category)

            role_id = request.session.get('role_id')
            has_access, error_message = check_user_access(role_id, 'master_subcategory', "update")

            if not has_access:
                return JsonResponse({'message': 'warning', 'error_message': 'You do not have permission to update sub category details'})
            
            
            if form.is_valid():
                updated_category = form.save(commit=False)
                category_id =  request.POST.get('category_id')
                name = request.POST.get('name')
                description = request.POST.get('description')                
                is_active = request.POST.get('is_active')

                if name.lower() != category.name.lower():
                    if sub_category_table.objects.filter(name__iexact=name, category_id=category_id, status=1).exclude(id=subcategory_id).exists():
                        return JsonResponse({'message': 'info', 'error_message': 'Sub Category name already exists'})


                updated_category.name = name          
                updated_category.category_id = category_id            
                updated_category.description = description            
                updated_category.is_active = is_active            
                updated_category.updated_by = request.session.get('user_id')
                updated_category.updated_on = format_datetime(date_time)
                updated_category.save()
                return JsonResponse({'message': 'success'})
            else:
                errors = form.errors.as_json()
                return JsonResponse({'message': 'error', 'errors': errors})
        except Exception as e:
            return JsonResponse({'message': 'exception', 'error': str(e)})



def sub_category_delete(request):
    if request.method == 'POST':
        data_id = request.POST.get('id') 

        role_id = request.session.get('role_id')
        has_access, error_message = check_user_access(role_id, 'master_subcategory', "delete")

        if not has_access:
            return JsonResponse({'message': 'warning', 'error_message': 'You do not have permission to delete sub category details'})
             
        try:
            updated = sub_category_table.objects.filter(id=data_id).update(status=0)
            if updated:
                return JsonResponse({'message': 'yes'})
            else:
                return JsonResponse({'message': 'no such data'})
        except Exception as e:
            return JsonResponse({'message': 'exception', 'error': str(e)})

    return JsonResponse({'message': 'Invalid request method'})


def check_subcategory_name(request):
    name = request.POST.get('name', '').strip()
    category_id = request.POST.get('category_id')
    data_id = request.POST.get('data_id')  # for edit case

    exists = sub_category_table.objects.filter(
        category_id=category_id,
        name__iexact=name,
        status=1
    )

    if data_id:
        exists = exists.exclude(id=data_id)

    if exists.exists():
        return JsonResponse({
            'exists': True,
            'message': 'Subcategory name already exists'
        })

    return JsonResponse({'exists': False})

#```````````````````````````````````````````````````````````**BRANDS**````````````````````````````````````````````````````````````````````````````````

def brands(request):
    if 'user_id' in request.session:
        user_type = request.session.get('user_type')
        if user_type == 'admin':
            cmpy = select_row(company_table, {'id':1})
            category = selectList(category_table, order_by='name')
            return render(request, 'brands.html', {'company': cmpy,'category':category})
        else:
            return HttpResponseRedirect("/")
    else:
        return HttpResponseRedirect("/")



def brand_item(request):
    if 'user_id' in request.session:
        user_type = request.session.get('user_type')
        if user_type == 'admin':
            encoded_id = request.GET.get('id', None)
            decoded_id = decode_base64_id(encoded_id)
            if decoded_id:
                company = select_row(company_table, {'id': 1})                  
                category = selectList(category_table, order_by='name')     
                sub_category = selectList(sub_category_table, order_by='name')
                uom = selectList(uom_table, order_by='name')  
                brand = selectList(brand_table, order_by='name')  
                
            else:
                return HttpResponse("ID parameter is missing")
            
            return render(request, 'items.html', {'company': company,'category':category,'sub_category':sub_category,'uom':uom, 'brand_id':decoded_id,'brand':brand})
        else:
            return HttpResponseRedirect("/")
    else:
        return HttpResponseRedirect("/")

def brand_view(request):  
    role_id = request.session.get('role_id')
    has_access, error_message = check_user_access(role_id, 'master_brands', "read")
    if not has_access:
        return JsonResponse({'message': 'warning', 'error_message': 'You do not have permission to view the brand details'})

    data = list(selectList(brand_table, order_by='sort_no').values())
   
    formatted = [
        {
            'id': index + 1,
            'action': '<button type="button" onclick="edit_data(\'{}\')" class="btn btn-outline-success btn-xs p-1"><i class="fas fa-edit" title="Edit"></i></button> \
                        <button type="button" onclick="delete_data(\'{}\')" class="btn btn-outline-danger btn-xs p-1"><i class="fas fa-trash-alt" title="Delete"></i></button>'.format(item['id'], item['id']), 
            'category': item['name'] if item['name'] else '-', 
            'order': item['sort_no'] if item['sort_no'] else '-', 
            'description': item['description'] if item['description'] else '-', 
            'maintenance': format_amount(item['maintenance_value']) if item['maintenance_value'] else '-',
            'status': '<span class="badge text-bg-success">Active</span>' if item['is_active'] else '<span class="badge text-bg-danger">Inactive</span>'  # Assuming is_active is a boolean field
        } 
        for index, item in enumerate(data)
    ]
    return JsonResponse({'data': formatted})




def brand_add(request):
    if request.method == 'POST':
        try:
            user_id = request.session.get('user_id')           
            company_id = request.session.get('company_id') 
            role_id = request.session.get('role_id')
            has_access,error_message = check_user_access(role_id, 'master_brands', "create")

            if not has_access:
                return JsonResponse({'message': 'warning', 'error_message': 'You do not have permission to add brand details'})
            
            form = brandForm(request.POST, request.FILES)
            if form.is_valid():
                brand = form.save(commit=False)
                brand.name = request.POST.get('name')
                brand.maintenance_value = request.POST.get('maintenance_value')
                brand.description = request.POST.get('description')
                brand.sort_no = request.POST.get('sort_no') or 1
                brand.created_by = user_id
                brand.updated_by = user_id
                brand.company_id = company_id
                brand.is_active = 1
                brand.status = 1
                brand.created_on = format_datetime(date_time)
                brand.updated_on = format_datetime(date_time)
                brand.save()
                return JsonResponse({'message': 'success'})
            else:
                errors = form.errors.as_json()
                return JsonResponse({'message': 'form_error', 'errors': errors}, status=400)

        except Exception as e:
            return JsonResponse({'message': 'exception', 'error': str(e)}, status=500)






def brand_edit(request):
    if request.headers.get('x-requested-with') == 'XMLHttpRequest' and request.method == "POST":
        data = brand_table.objects.filter(id=request.POST.get('id'))    
    return JsonResponse(data.values()[0])



def brand_update(request):
    if request.method == "POST":
        try:
            brand_id = request.POST.get('id')
            brand = brand_table.objects.get(id=brand_id)
            form = brandForm(request.POST, request.FILES, instance=brand)
            role_id = request.session.get('role_id')

            has_access, error_message = check_user_access(role_id, 'master_brands', "update")

            if not has_access:
                return JsonResponse({'message': 'warning', 'error_message': 'You do not have permission to update brand details'})
            
            
            if form.is_valid():
                updated_brand = form.save(commit=False)
                desc = request.POST.get('description')
                maintenance_value = request.POST.get('maintenance_value')
                name = request.POST.get('name')
                sort_no = request.POST.get('sort_no') or 1
                is_active = request.POST.get('is_active')

                updated_brand.maintenance_value = maintenance_value            
                updated_brand.name = name            
                updated_brand.sort_no = sort_no            
                updated_brand.is_active = is_active            
                updated_brand.description = desc
                updated_brand.updated_by = request.session.get('user_id')
                updated_brand.updated_on = format_datetime(date_time)
                updated_brand.save()
                return JsonResponse({'message': 'success'})
            else:
                errors = form.errors.as_json()
                return JsonResponse({'message': 'error', 'errors': errors})
        except Exception as e:
            return JsonResponse({'message': 'exception', 'error': str(e)})



def brand_delete(request):
    if request.method == 'POST':
        data_id = request.POST.get('id')    
        role_id = request.session.get('role_id')

        has_access, error_message = check_user_access(role_id, 'master_brands', "delete")

        if not has_access:
            return JsonResponse({'message': 'warning', 'error_message': 'You do not have permission to delete brand details'})
               
        try:
            updated = brand_table.objects.filter(id=data_id).update(status=0)
            if updated:
                return JsonResponse({'message': 'yes'})
            else:
                return JsonResponse({'message': 'no such data'})
        except Exception as e:
            return JsonResponse({'message': 'exception', 'error': str(e)})

    return JsonResponse({'message': 'Invalid request method'})



def check_brand_name(request):
    name = request.POST.get('name', '').strip()
    data_id = request.POST.get('data_id')  # for edit case

    exists = brand_table.objects.filter(
        name__iexact=name,
        status=1
    )

    if data_id:
        exists = exists.exclude(id=data_id)

    if exists.exists():
        return JsonResponse({
            'exists': True,
            'message': 'Brand name already exists'
        })

    return JsonResponse({'exists': False})



# *************************************************************************************************************************
def model(request):
    if 'user_id' in request.session:
        user_type = request.session.get('user_type')
        if user_type == 'admin':
            cmpy = select_row(company_table, {'id':1})
            brand = selectList(brand_table, order_by='name')
            return render(request, 'model.html', {'company': cmpy,'brand':brand})
        else:
            return HttpResponseRedirect("/")
    else:
        return HttpResponseRedirect("/")




def model_add(request):
    if request.method == 'POST':
        try:
            user_id = request.session.get('user_id')           
            company_id = request.session.get('company_id')           
            role_id = request.session.get('role_id')
            has_access,error_message = check_user_access(role_id, 'master_model', "create")

            if not has_access:
                return JsonResponse({'message': 'warning', 'error_message': 'You do not have permission to add Model details'})
            
            form = DeviceModelForm(request.POST, request.FILES)
            if form.is_valid():
                category = form.save(commit=False)
                category.name = request.POST.get('name')
                category.brand_id = request.POST.get('brand_id')
                category.description = request.POST.get('description')
                category.company_id = company_id
                category.is_active = 1
                category.status = 1
                category.created_by = user_id
                category.updated_by = user_id
                category.created_on = format_datetime(date_time)
                category.updated_on = format_datetime(date_time)
                category.save()
                return JsonResponse({'message': 'success'})
            else:
                errors = form.errors.as_json()
                return JsonResponse({'message': 'form_error', 'errors': errors}, status=400)

        except Exception as e:
            return JsonResponse({'message': 'exception', 'error': str(e)}, status=500)



def model_view(request):  
    role_id = request.session.get('role_id')
    has_access, error_message = check_user_access(role_id, 'master_model', "read")
    if not has_access:
        return JsonResponse({'message': 'warning', 'error_message': 'You do not have permission to view Model details'})
    
    brand_id = request.POST.get('brand_id')

    query =Q(status=1)
    if brand_id:
        query &= Q(brand_id=brand_id)

    data = list(selectList(model_table, query).values())
    formatted = [
        {
            'id': index + 1,
            'action': '<button type="button" onclick="edit_data(\'{}\')" class="btn btn-outline-success btn-xs p-1"><i class="fas fa-edit"></i></button> \
                      <button type="button" onclick="delete_data(\'{}\')" class="btn btn-outline-danger btn-xs p-1"> <i class="fas fa-trash-alt"></i></button>'.format(item['id'], item['id']), 
            'brand': getItemNameById(brand_table, item['brand_id']) if item['brand_id'] else '-', 
            'category': item['name'] if item['name'] else '-', 
            'description': item['description'] if item['description'] else '-', 
            'status': '<span class="badge text-bg-success">Active</span>' if item['is_active'] else '<span class="badge text-bg-danger">Inactive</span>'  # Assuming is_active is a boolean field
        } 
        for index, item in enumerate(data)
    ]
    return JsonResponse({'data': formatted})



def model_edit(request):
    if request.headers.get('x-requested-with') == 'XMLHttpRequest' and request.method == "POST":
        data = model_table.objects.filter(id=request.POST.get('id'))    
    return JsonResponse(data.values()[0])




def model_update(request):
    if request.method == "POST":
        try:
            category_id = request.POST.get('id')
            category = model_table.objects.get(id=category_id)
            role_id = request.session.get('role_id')
            has_access,error_message = check_user_access(role_id, 'master_model', "update")

            if not has_access:
                return JsonResponse({'message': 'warning', 'error_message': 'You do not have permission to update Model details'})
            
            
            form = DeviceModelForm(request.POST, request.FILES, instance=category)
            if form.is_valid():
                updated_category = form.save(commit=False)
                desc = request.POST.get('description')
                name = request.POST.get('name')
                brand_id = request.POST.get('brand_id')
                is_active = request.POST.get('is_active')

                updated_category.name = name     
                updated_category.brand_id = brand_id       
                updated_category.is_active = is_active            
                updated_category.description = desc
                updated_category.updated_by = request.session.get('user_id')
                updated_category.updated_on = format_datetime(date_time)
                updated_category.save()
                return JsonResponse({'message': 'success'})
            else:
                errors = form.errors.as_json()
                return JsonResponse({'message': 'error', 'errors': errors})
        except Exception as e:
            return JsonResponse({'message': 'exception', 'error': str(e)})



def model_delete(request):
    if request.method == 'POST':
        data_id = request.POST.get('id')    
        role_id = request.session.get('role_id')
        has_access,error_message = check_user_access(role_id, 'master_model', "delete")

        if not has_access:
            return JsonResponse({'message': 'warning', 'error_message': 'You do not have permission to delete Model details'})
               
        try:
            updated = model_table.objects.filter(id=data_id).update(status=0)
            if updated:
                return JsonResponse({'message': 'yes'})
            else:
                return JsonResponse({'message': 'no such data'})
        except Exception as e:
            return JsonResponse({'message': 'exception', 'error': str(e)})

    return JsonResponse({'message': 'Invalid request method'})



def check_model_name(request):
    name = request.POST.get('name', '').strip()
    brand_id = request.POST.get('brand_id')
    data_id = request.POST.get('data_id')  # for edit case

    exists = model_table.objects.filter(
        brand_id=brand_id,
        name__iexact=name,
        status=1
    )

    if data_id:
        exists = exists.exclude(id=data_id)

    if exists.exists():
        return JsonResponse({
            'exists': True,
            'message': 'Model name already exists'
        })

    return JsonResponse({'exists': False})



# *************************************************************************************************************************
def variant(request):
    if 'user_id' in request.session:
        user_type = request.session.get('user_type')
        if user_type == 'admin':
            cmpy = select_row(company_table, {'id':1})
            brand = selectList(brand_table, order_by='name')
            model = selectList(model_table, order_by='name')
            return render(request, 'variant.html', {'company': cmpy,'brand':brand,'model':model})
        else:
            return HttpResponseRedirect("/")
    else:
        return HttpResponseRedirect("/")


# views.py
from django.http import JsonResponse

def ajax_load_models(request):
    if request.method == 'POST':
        brand_id = request.POST.get('brand_id')

        models = model_table.objects.filter(
            brand_id=brand_id,
            status=1
        ).values('id', 'name')

        return JsonResponse(list(models), safe=False)

    return JsonResponse([], safe=False)

def variant_add(request):
    if request.method == 'POST':
        try:
            user_id = request.session.get('user_id')           
            company_id = request.session.get('company_id')           
            role_id = request.session.get('role_id')
            has_access,error_message = check_user_access(role_id, 'master_variants', "create")

            if not has_access:
                return JsonResponse({'message': 'warning', 'error_message': 'You do not have permission to add variant details'})
            
            form = VariantForm(request.POST, request.FILES)
            if form.is_valid():
                category = form.save(commit=False)
                category.name = request.POST.get('name')
                category.brand_id = request.POST.get('brand_id')
                category.model_id = request.POST.get('model_id')
                category.description = request.POST.get('description')
                category.company_id = company_id
                category.is_active = 1
                category.status = 1
                category.created_by = user_id
                category.updated_by = user_id
                category.created_on = format_datetime(date_time)
                category.updated_on = format_datetime(date_time)
                category.save()
                return JsonResponse({'message': 'success'})
            else:
                errors = form.errors.as_json()
                return JsonResponse({'message': 'form_error', 'errors': errors}, status=400)

        except Exception as e:
            return JsonResponse({'message': 'exception', 'error': str(e)}, status=500)



def variant_view(request):  
    role_id = request.session.get('role_id')
    has_access, error_message = check_user_access(role_id, 'master_variants', "read")
    if not has_access:
        return JsonResponse({'message': 'warning', 'error_message': 'You do not have permission to view variant details'})
    
    brand_id = request.POST.get('brand_id')
    model_id = request.POST.get('model_id')

    query =Q(status=1)

    if brand_id:
        query &= Q(brand_id=brand_id)
    if model_id:
        query &= Q(model_id=model_id)
    
    data = list(selectList(variant_table, query).values())
    formatted = [
        {
            'id': index + 1,
            'action': '<button type="button" onclick="edit_data(\'{}\')" class="btn btn-outline-success btn-xs p-1"><i class="fas fa-edit"></i></button> \
                      <button type="button" onclick="delete_data(\'{}\')" class="btn btn-outline-danger btn-xs p-1"> <i class="fas fa-trash-alt"></i></button>'.format(item['id'], item['id']), 
            'brand':getItemNameById(brand_table, item['brand_id']),
            'model':getItemNameById(model_table, item['model_id']),
            'name': item['name'] if item['name'] else '-', 
            'description': item['description'] if item['description'] else '-', 
            'status': '<span class="badge text-bg-success">Active</span>' if item['is_active'] else '<span class="badge text-bg-danger">Inactive</span>'  # Assuming is_active is a boolean field
        } 
        for index, item in enumerate(data)
    ]
    return JsonResponse({'data': formatted})



def variant_edit(request):
    if request.headers.get('x-requested-with') == 'XMLHttpRequest' and request.method == "POST":
        data = variant_table.objects.filter(id=request.POST.get('id'))    
    return JsonResponse(data.values()[0])




def variant_update(request):
    if request.method == "POST":
        try:
            category_id = request.POST.get('id')
            category = variant_table.objects.get(id=category_id)
            role_id = request.session.get('role_id')
            has_access,error_message = check_user_access(role_id, 'master_variants', "update")

            if not has_access:
                return JsonResponse({'message': 'warning', 'error_message': 'You do not have permission to update variant details'})
            
            
            form = VariantForm(request.POST, request.FILES, instance=category)
            if form.is_valid():
                updated_category = form.save(commit=False)
                desc = request.POST.get('description')
                name = request.POST.get('name')
                is_active = request.POST.get('is_active')
                brand_id = request.POST.get('brand_id')
                model_id = request.POST.get('model_id')

                updated_category.name = name      
                updated_category.brand_id = brand_id
                updated_category.model_id = model_id      
                updated_category.is_active = is_active            
                updated_category.description = desc
                updated_category.updated_by = request.session.get('user_id')
                updated_category.updated_on = format_datetime(date_time)
                updated_category.save()
                return JsonResponse({'message': 'success'})
            else:
                errors = form.errors.as_json()
                return JsonResponse({'message': 'error', 'errors': errors})
        except Exception as e:
            return JsonResponse({'message': 'exception', 'error': str(e)})



def variant_delete(request):
    if request.method == 'POST':
        data_id = request.POST.get('id')    
        role_id = request.session.get('role_id')
        has_access,error_message = check_user_access(role_id, 'master_variants', "delete")

        if not has_access:
            return JsonResponse({'message': 'warning', 'error_message': 'You do not have permission to delete Variant details'})
               
        try:
            updated = variant_table.objects.filter(id=data_id).update(status=0)
            if updated:
                return JsonResponse({'message': 'yes'})
            else:
                return JsonResponse({'message': 'no such data'})
        except Exception as e:
            return JsonResponse({'message': 'exception', 'error': str(e)})

    return JsonResponse({'message': 'Invalid request method'})





def check_variant_name(request):
    name = request.POST.get('name', '').strip()
    brand_id = request.POST.get('brand_id')
    model_id = request.POST.get('model_id')
    data_id = request.POST.get('data_id')  # for edit case

    exists = variant_table.objects.filter(
        brand_id=brand_id,
        model_id=model_id,
        name__iexact=name,
        status=1
    )

    if data_id:
        exists = exists.exclude(id=data_id)

    if exists.exists():
        return JsonResponse({
            'exists': True,
            'message': 'Variant name already exists'
        })

    return JsonResponse({'exists': False})



#```````````````````````````````````````````````````````````**UOM**````````````````````````````````````````````````````````````````````````````````
def ajax_load_variants(request):
    if request.method == 'POST':
        brand_id = request.POST.get('brand_id')
        model_id = request.POST.get('model_id')

        variants = variant_table.objects.filter(
            brand_id=brand_id,
            model_id=model_id,
            status=1
        ).values('id', 'name')

        return JsonResponse(list(variants), safe=False)

    return JsonResponse([], safe=False)

from django.http import JsonResponse
from django.db.models import Q

def check_color_name(request):
    name = request.POST.get('name', '').strip()
    brand_id = request.POST.get('brand_id')
    model_id = request.POST.get('model_id')
    variant_id = request.POST.get('variant_id')
    data_id = request.POST.get('data_id')

    if not name:
        return JsonResponse({'exists': False})

    query = Q(status=1, name__iexact=name)

    if brand_id:
        query &= Q(brand_id=brand_id)
    if model_id:
        query &= Q(model_id=model_id)
    if variant_id:
        query &= Q(variant_id=variant_id)

    qs = color_table.objects.filter(query)

    if data_id:
        qs = qs.exclude(id=data_id)

    if qs.exists():
        return JsonResponse({
            'exists': True,
            'message': 'Color name already exists'
        })

    return JsonResponse({'exists': False})


def color(request):
    if 'user_id' in request.session:
        user_type = request.session.get('user_type')
        if user_type == 'admin':
            cmpy = select_row(company_table, {'id':1})
            brand = selectList(brand_table, order_by='name')
            model = selectList(model_table, order_by='name')
            variant = selectList(variant_table, order_by='name')
            return render(request, 'color.html', {'company': cmpy,'brand':brand,'model':model,'variant':variant})
        else:
            return HttpResponseRedirect("/")
    else:
        return HttpResponseRedirect("/")




def color_add(request):
    if request.method == 'POST':
        try:
            user_id = request.session.get('user_id')           
            company_id = request.session.get('company_id')           
            role_id = request.session.get('role_id')
            has_access,error_message = check_user_access(role_id, 'master_color', "create")

            if not has_access:
                return JsonResponse({'message': 'warning', 'error_message': 'You do not have permission to add Color details'})
            
            form = ColorForm(request.POST, request.FILES)
            if form.is_valid():
                category = form.save(commit=False)
                category.brand_id = request.POST.get('brand_id')
                category.model_id = request.POST.get('model_id')
                category.variant_id = request.POST.get('variant_id')
                category.name = request.POST.get('name')
                category.description = request.POST.get('description')
                category.company_id = company_id
                category.is_active = 1
                category.status = 1
                category.created_by = user_id
                category.updated_by = user_id
                category.created_on = format_datetime(date_time)
                category.updated_on = format_datetime(date_time)
                category.save()
                return JsonResponse({'message': 'success'})
            else:
                errors = form.errors.as_json()
                return JsonResponse({'message': 'form_error', 'errors': errors}, status=400)

        except Exception as e:
            return JsonResponse({'message': 'exception', 'error': str(e)}, status=500)



def color_view(request):  
    role_id = request.session.get('role_id')
    has_access, error_message = check_user_access(role_id, 'master_color', "read")
    if not has_access:
        return JsonResponse({'message': 'warning', 'error_message': 'You do not have permission to view Color details'})
    brand_id = request.POST.get('brand_id')
    model_id = request.POST.get('model_id')
    variant_id = request.POST.get('variant_id')
    query =Q(status=1)
    if brand_id:
        query &= Q(brand_id=brand_id)
    if model_id:
        query &= Q(model_id=model_id)
    if variant_id:
        query &= Q(variant_id=variant_id)
    
    data = list(selectList(color_table, query).values())
    formatted = [
        {
            'id': index + 1,
            'action': '<button type="button" onclick="edit_data(\'{}\')" class="btn btn-outline-success btn-xs p-1"><i class="fas fa-edit"></i></button> \
                      <button type="button" onclick="delete_data(\'{}\')" class="btn btn-outline-danger btn-xs p-1"> <i class="fas fa-trash-alt"></i></button>'.format(item['id'], item['id']), 
           'brand':getItemNameById(brand_table,item['brand_id']),
            'model':getItemNameById(model_table,item['model_id']),
            'variant':getItemNameById(variant_table,item['variant_id']),
            'category': item['name'] if item['name'] else '-', 
            'description': item['description'] if item['description'] else '-', 
            'status': '<span class="badge text-bg-success">Active</span>' if item['is_active'] else '<span class="badge text-bg-danger">Inactive</span>'  # Assuming is_active is a boolean field
        } 
        for index, item in enumerate(data)
    ]
    return JsonResponse({'data': formatted})



def color_edit(request):
    if request.headers.get('x-requested-with') == 'XMLHttpRequest' and request.method == "POST":
        data = color_table.objects.filter(id=request.POST.get('id'))    
    return JsonResponse(data.values()[0])




def color_update(request):
    if request.method == "POST":
        try:
            category_id = request.POST.get('id')
            category = color_table.objects.get(id=category_id)
            role_id = request.session.get('role_id')
            has_access,error_message = check_user_access(role_id, 'master_color', "update")

            if not has_access:
                return JsonResponse({'message': 'warning', 'error_message': 'You do not have permission to update Color details'})
            
            
            form = ColorForm(request.POST, request.FILES, instance=category)
            if form.is_valid():
                updated_category = form.save(commit=False)
                desc = request.POST.get('description')
                brand_id = request.POST.get('brand_id')
                model_id = request.POST.get('model_id')
                variant_id = request.POST.get('variant_id')
                name = request.POST.get('name')
                is_active = request.POST.get('is_active')

                updated_category.name = name      
                updated_category.brand_id = brand_id      
                updated_category.model_id = model_id      
                updated_category.variant_id = variant_id      
                updated_category.is_active = is_active            
                updated_category.description = desc
                updated_category.updated_by = request.session.get('user_id')
                updated_category.updated_on = format_datetime(date_time)
                updated_category.save()
                return JsonResponse({'message': 'success'})
            else:
                errors = form.errors.as_json()
                return JsonResponse({'message': 'error', 'errors': errors})
        except Exception as e:
            return JsonResponse({'message': 'exception', 'error': str(e)})



def color_delete(request):
    if request.method == 'POST':
        data_id = request.POST.get('id')    
        role_id = request.session.get('role_id')
        has_access,error_message = check_user_access(role_id, 'master_color', "delete")

        if not has_access:
            return JsonResponse({'message': 'warning', 'error_message': 'You do not have permission to delete Color details'})
               
        try:
            updated = color_table.objects.filter(id=data_id).update(status=0)
            if updated:
                return JsonResponse({'message': 'yes'})
            else:
                return JsonResponse({'message': 'no such data'})
        except Exception as e:
            return JsonResponse({'message': 'exception', 'error': str(e)})

    return JsonResponse({'message': 'Invalid request method'})

# ************************************************************************************************************************************

def uom(request):
    if 'user_id' in request.session:
        user_type = request.session.get('user_type')
        if user_type == 'admin':
            cmpy = select_row(company_table, {'id':1})
            category = selectList(category_table, order_by='name')
            return render(request, 'uom.html', {'company': cmpy,'category':category})
        else:
            return HttpResponseRedirect("/")
    else:
        return HttpResponseRedirect("/")




def uom_add(request):
    if request.method == 'POST':
        try:
            user_id = request.session.get('user_id')           
            company_id = request.session.get('company_id')           
            role_id = request.session.get('role_id')
            has_access,error_message = check_user_access(role_id, 'master_uom', "create")

            if not has_access:
                return JsonResponse({'message': 'warning', 'error_message': 'You do not have permission to add UOM details'})
            
            form = uomForm(request.POST, request.FILES)
            if form.is_valid():
                category = form.save(commit=False)
                category.name = request.POST.get('name')
                category.description = request.POST.get('description')
                category.company_id = company_id
                category.is_active = 1
                category.status = 1
                category.created_by = user_id
                category.updated_by = user_id
                category.created_on = format_datetime(date_time)
                category.updated_on = format_datetime(date_time)
                category.save()
                return JsonResponse({'message': 'success'})
            else:
                errors = form.errors.as_json()
                return JsonResponse({'message': 'form_error', 'errors': errors}, status=400)

        except Exception as e:
            return JsonResponse({'message': 'exception', 'error': str(e)}, status=500)



def uom_view(request):  
    role_id = request.session.get('role_id')
    has_access, error_message = check_user_access(role_id, 'master_uom', "read")
    if not has_access:
        return JsonResponse({'message': 'warning', 'error_message': 'You do not have permission to view UOM details'})
    
    
    data = list(selectList(uom_table).values())
    formatted = [
        {
            'id': index + 1,
            'action': '<button type="button" onclick="edit_data(\'{}\')" class="btn btn-outline-success btn-xs p-1"><i class="fas fa-edit"></i></button> \
                      <button type="button" onclick="delete_data(\'{}\')" class="btn btn-outline-danger btn-xs p-1"> <i class="fas fa-trash-alt"></i></button>'.format(item['id'], item['id']), 
            'category': item['name'] if item['name'] else '-', 
            'description': item['description'] if item['description'] else '-', 
            'status': '<span class="badge text-bg-success">Active</span>' if item['is_active'] else '<span class="badge text-bg-danger">Inactive</span>'  # Assuming is_active is a boolean field
        } 
        for index, item in enumerate(data)
    ]
    return JsonResponse({'data': formatted})



def uom_edit(request):
    if request.headers.get('x-requested-with') == 'XMLHttpRequest' and request.method == "POST":
        data = uom_table.objects.filter(id=request.POST.get('id'))    
    return JsonResponse(data.values()[0])




def uom_update(request):
    if request.method == "POST":
        try:
            category_id = request.POST.get('id')
            category = uom_table.objects.get(id=category_id)
            role_id = request.session.get('role_id')
            has_access,error_message = check_user_access(role_id, 'master_uom', "update")

            if not has_access:
                return JsonResponse({'message': 'warning', 'error_message': 'You do not have permission to update UOM details'})
            
            
            form = uomForm(request.POST, request.FILES, instance=category)
            if form.is_valid():
                updated_category = form.save(commit=False)
                desc = request.POST.get('description')
                name = request.POST.get('name')
                is_active = request.POST.get('is_active')

                updated_category.name = name            
                updated_category.is_active = is_active            
                updated_category.description = desc
                updated_category.updated_by = request.session.get('user_id')
                updated_category.updated_on = format_datetime(date_time)
                updated_category.save()
                return JsonResponse({'message': 'success'})
            else:
                errors = form.errors.as_json()
                return JsonResponse({'message': 'error', 'errors': errors})
        except Exception as e:
            return JsonResponse({'message': 'exception', 'error': str(e)})



def uom_delete(request):
    if request.method == 'POST':
        data_id = request.POST.get('id')    
        role_id = request.session.get('role_id')
        has_access,error_message = check_user_access(role_id, 'master_uom', "delete")

        if not has_access:
            return JsonResponse({'message': 'warning', 'error_message': 'You do not have permission to delete UOM details'})
               
        try:
            updated = uom_table.objects.filter(id=data_id).update(status=0)
            if updated:
                return JsonResponse({'message': 'yes'})
            else:
                return JsonResponse({'message': 'no such data'})
        except Exception as e:
            return JsonResponse({'message': 'exception', 'error': str(e)})

    return JsonResponse({'message': 'Invalid request method'})


def check_uom_name(request):
    name = request.POST.get('name', '').strip()
    category_id = request.POST.get('category_id')  # for edit case

    exists = uom_table.objects.filter(
        name__iexact=name,
        status=1
    )

    if category_id:
        exists = exists.exclude(id=category_id)

    if exists.exists():
        return JsonResponse({
            'exists': True,
            'message': 'UOM name already exists'
        })

    return JsonResponse({'exists': False})

#```````````````````````````````````````````````````````````**TAX**````````````````````````````````````````````````````````````````````````````````


def tax(request):
    if 'user_id' in request.session:
        user_type = request.session.get('user_type')
        if user_type == 'admin':
            cmpy = select_row(company_table, {'id':1})
            category = selectList(category_table, order_by='name')
            return render(request, 'tax.html', {'company': cmpy,'category':category})
        else:
            return HttpResponseRedirect("/")
    else:
        return HttpResponseRedirect("/")




def tax_add(request):
    if request.method == 'POST':
        try:
            user_id = request.session.get('user_id')           
            company_id = request.session.get('company_id')           
            role_id = request.session.get('role_id')
            has_access,error_message = check_user_access(role_id, 'master_tax', "create")

            if not has_access:
                return JsonResponse({'message': 'warning', 'error_message': 'You do not have permission to add Tax details'})
            
            form = TaxForm(request.POST, request.FILES)
            if form.is_valid():
                category = form.save(commit=False)
                category.name = request.POST.get('name')
                category.percentage = request.POST.get('percentage')
                category.description = request.POST.get('description')
                category.company_id = company_id
                category.is_active = 1
                category.status = 1
                category.created_by = user_id
                category.updated_by = user_id
                category.created_on = format_datetime(date_time)
                category.updated_on = format_datetime(date_time)
                category.save()
                return JsonResponse({'message': 'success'})
            else:
                errors = form.errors.as_json()
                return JsonResponse({'message': 'form_error', 'errors': errors}, status=400)

        except Exception as e:
            return JsonResponse({'message': 'exception', 'error': str(e)}, status=500)



def tax_view(request):  
    role_id = request.session.get('role_id')
    has_access, error_message = check_user_access(role_id, 'master_tax', "read")
    if not has_access:
        return JsonResponse({'message': 'warning', 'error_message': 'You do not have permission to view Tax details'})
    
    
    data = list(selectList(tax_table).values())
    formatted = [
        {
            'id': index + 1,
            'action': '<button type="button" onclick="edit_data(\'{}\')" class="btn btn-outline-success btn-xs p-1"><i class="fas fa-edit"></i></button> \
                      <button type="button" onclick="delete_data(\'{}\')" class="btn btn-outline-danger btn-xs p-1"> <i class="fas fa-trash-alt"></i></button>'.format(item['id'], item['id']), 
            'category': item['name'] if item['name'] else '-', 
            'percentage': item['percentage'] if item['percentage'] else '-', 
            'description': item['description'] if item['description'] else '-', 
            'status': '<span class="badge text-bg-success">Active</span>' if item['is_active'] else '<span class="badge text-bg-danger">Inactive</span>'  # Assuming is_active is a boolean field
        } 
        for index, item in enumerate(data)
    ]
    return JsonResponse({'data': formatted})



def tax_edit(request):
    if request.headers.get('x-requested-with') == 'XMLHttpRequest' and request.method == "POST":
        data = tax_table.objects.filter(id=request.POST.get('id'))    
    return JsonResponse(data.values()[0])




def tax_update(request):
    if request.method == "POST":
        try:
            category_id = request.POST.get('id')
            category = tax_table.objects.get(id=category_id)
            role_id = request.session.get('role_id')
            has_access,error_message = check_user_access(role_id, 'master_tax', "update")

            if not has_access:
                return JsonResponse({'message': 'warning', 'error_message': 'You do not have permission to update Tax details'})
            
            
            form = TaxForm(request.POST, request.FILES, instance=category)
            if form.is_valid():
                updated_category = form.save(commit=False)
                desc = request.POST.get('description')
                name = request.POST.get('name')
                percentage = request.POST.get('percentage')
                is_active = request.POST.get('is_active')

                updated_category.name = name            
                updated_category.is_active = is_active  
                updated_category.percentage = percentage                          
                updated_category.description = desc
                updated_category.updated_by = request.session.get('user_id')
                updated_category.updated_on = format_datetime(date_time)
                updated_category.save()
                return JsonResponse({'message': 'success'})
            else:
                errors = form.errors.as_json()
                return JsonResponse({'message': 'error', 'errors': errors})
        except Exception as e:
            return JsonResponse({'message': 'exception', 'error': str(e)})



def tax_delete(request):
    if request.method == 'POST':
        data_id = request.POST.get('id')    
        role_id = request.session.get('role_id')
        has_access,error_message = check_user_access(role_id, 'master_tax', "delete")

        if not has_access:
            return JsonResponse({'message': 'warning', 'error_message': 'You do not have permission to delete UOM details'})
               
        try:
            updated = tax_table.objects.filter(id=data_id).update(status=0)
            if updated:
                return JsonResponse({'message': 'yes'})
            else:
                return JsonResponse({'message': 'no such data'})
        except Exception as e:
            return JsonResponse({'message': 'exception', 'error': str(e)})

    return JsonResponse({'message': 'Invalid request method'})


def check_tax_name(request):
    name = request.POST.get('name', '').strip()
    category_id = request.POST.get('category_id')  # for edit case

    exists = tax_table.objects.filter(
        name__iexact=name,
        status=1
    )

    if category_id:
        exists = exists.exclude(id=category_id)

    if exists.exists():
        return JsonResponse({
            'exists': True,
            'message': 'Tax name already exists'
        })

    return JsonResponse({'exists': False})


#```````````````````````````````````````````````````````````**UOM**````````````````````````````````````````````````````````````````````````````````


def bank(request):
    if 'user_id' in request.session:
        user_type = request.session.get('user_type')
        if user_type == 'admin':
            cmpy = select_row(company_table, {'id':1})
            category = selectList(category_table, order_by='name')
            return render(request, 'bank.html', {'company': cmpy,'category':category})
        else:
            return HttpResponseRedirect("/")
    else:
        return HttpResponseRedirect("/")

import json

def bank_add(request):
    if request.method == 'POST':
        try:
            with transaction.atomic():
                user_id = request.session.get('user_id')
                company_id = request.session.get('company_id')
                role_id = request.session.get('role_id')
                current_time = timezone.localtime(timezone.now())

                has_access, error_message = check_user_access(role_id, 'bank_accounts', "create")
                if not has_access:
                    return JsonResponse({
                        'message': 'warning',
                        'error_message': 'You do not have permission to add Bank details'
                    })

                form = BankForm(request.POST, request.FILES)

                if form.is_valid():
                    bank = form.save(commit=False)

                    bank.code = generate_code(
                        model=bank_table,
                        prefix="BK",
                        code_field="code",
                        status_field="status"
                    )

                    bank_name = request.POST.get('name')
                    opening_balance = request.POST.get('opening') or 0

                    bank.name = bank_name
                    bank.account_number = request.POST.get('account_number')
                    bank.description = request.POST.get('description')
                    bank.opening = opening_balance
                    bank.date = request.POST.get('date')
                    bank.time = current_time.strftime('%H:%M:%S')
                    bank.company_id = company_id
                    bank.is_active = 1
                    bank.status = 1
                    bank.is_default = request.POST.get('is_default', 0)
                    bank.created_by = user_id
                    bank.updated_by = user_id
                    bank.created_on = format_datetime(date_time)
                    bank.updated_on = format_datetime(date_time)
                    bank.save()

                    ho_branch = branch_table.objects.filter(is_ho=1).first()
                    ho_branch_id = ho_branch.id if ho_branch else 0

                    fyf_name = request.session.get('fyf')
                    financial_year = calculate_financial_year(fyf_name)

                    if int(request.POST.get('is_default', 0)) == 0:
                        create_ledger_master_and_opening_balance(
                            current_fy=financial_year,
                            branch_id=ho_branch_id,
                            master_id=bank.id,
                            master_name=bank_name,
                            ledger_type="bank",
                            ledger_mode="bank",
                            payable=opening_balance,
                            receivable=0,
                            created_by=user_id,
                            updated_by=user_id,
                        )

                    # 🔥 NOW SAVE QR DATA
                    qr_json = request.POST.get('items')
                    if not qr_json:
                        return JsonResponse({
                            'message': 'error',
                            'error': 'QR data not received'
                        }, status=400)

                    qr_items = json.loads(qr_json)

                    for qr in qr_items:
                        qr_table.objects.create(
                            bank_id=bank.id,
                            name=qr.get('qr_name'),   # 🎯 FIXED
                            description="",           # (optional)
                            is_active=1,
                            status=1,
                            created_by=user_id,
                            updated_by=user_id,
                            created_on=format_datetime(date_time),
                            updated_on=format_datetime(date_time),
                        )

                    return JsonResponse({'message': 'success'})

                else:
                    errors = form.errors.as_json()
                    return JsonResponse({'message': 'form_error', 'errors': errors}, status=400)

        except Exception as e:
            return JsonResponse({'message': 'exception', 'error': str(e)}, status=500)

def bank_view(request):  
    try:
        role_id = request.session.get('role_id')
        has_access, error_message = check_user_access(role_id, 'bank_accounts', "read")

        if not has_access:
            return JsonResponse({
                'message': 'warning',
                'error_message': 'You do not have permission to view Bank details'
            })

        data = list(selectList(bank_table).values())

        formatted = []
        for index, item in enumerate(data):
            is_default = item.get('is_default', 0)

            # Default Button (shown only when not default)
            default_button = (
                '<button type="button" onclick="make_default(\'{}\')" '
                'class="btn btn-outline-primary btn-xs p-1">Make Default</button>'
                .format(item['id'])
                if is_default == 0 else ''
            )


            # Combined ACTION column (Edit + Delete + Default)
            action_buttons = (
                '<button type="button" onclick="edit_data(\'{}\')" '
                'class="btn btn-outline-success btn-xs p-1"><i class="fas fa-edit"></i></button> '
                '<button type="button" onclick="delete_data(\'{}\')" '
                'class="btn btn-outline-danger btn-xs p-1"><i class="fas fa-trash-alt"></i></button> '
            ).format(item['id'], item['id'])

            formatted.append({
                'id': index + 1,
                'action': action_buttons,
                'code': item.get('code') or '-',
                'name': item.get('name') or '-',
                'branch': item.get('branch_name') or '-',
                'holder': item.get('holder_name') or '-',
                'account': item.get('account_number') or '-',
                'ifsc': item.get('ifsc_code') or '-',
                'account_type': item.get('account_type') or '-',
                'address': item.get('address') or '-',
                'description': item.get('description') or '-',
                'date': format_date_month_year(item.get('date')) or '-',
                'opening': item.get('opening') or '-',
                'default': (
                    '<span class="badge text-bg-success">Yes</span>'
                    if item.get('is_default', 1)
                    else '<span class="badge text-bg-danger">No</span>'
                ),

                'status': (
                    '<span class="badge text-bg-success">Active</span>'
                    if item.get('is_active', 1)
                    else '<span class="badge text-bg-danger">Inactive</span>'
                ),
            })

        return JsonResponse({'data': formatted})

    except Exception as e:
        return JsonResponse({'message': 'exception', 'error': str(e)}, status=500)


def bank_edit(request):
    if request.headers.get('x-requested-with') == 'XMLHttpRequest' and request.method == "POST":
        data = bank_table.objects.filter(id=request.POST.get('id'))    
    return JsonResponse(data.values()[0])




def bank_update(request):
    if request.method == "POST":
        try:
            with transaction.atomic():
                category_id = request.POST.get('id')
                category = bank_table.objects.get(id=category_id)
                role_id = request.session.get('role_id')
                has_access,error_message = check_user_access(role_id, 'bank_accounts', "update")

                if not has_access:
                    return JsonResponse({'message': 'warning', 'error_message': 'You do not have permission to update Bank details'})
                
                
                form = BankForm(request.POST, request.FILES, instance=category)
                if form.is_valid():
                    updated_category = form.save(commit=False)
                    name = request.POST.get('name')
                    account_no = request.POST.get('account_number')
                    desc = request.POST.get('description')
                    is_active = request.POST.get('is_active')
                    opening = request.POST.get('opening') or 0
                    date = request.POST.get('date')
                    is_default = request.POST.get('is_default', 0)
                    
                    updated_category.name = name
                    # updated_category.is_default = is_default
                    updated_category.date = date
                    updated_category.account_number = account_no            
                    updated_category.description = desc
                    updated_category.opening = opening
                    updated_category.is_active = is_active            
                    updated_category.updated_by = request.session.get('user_id')
                    updated_category.updated_on = format_datetime(date_time)
                    updated_category.save()

                    ho_branch = branch_table.objects.filter(is_ho=1).first()
                    ho_branch_id = ho_branch.id if ho_branch else 0

                    fyf_name = request.session.get('fyf')
                    financial_year = calculate_financial_year(fyf_name)

                    if int(category.is_default) == 0:
                        create_ledger_master_and_opening_balance(
                            current_fy=financial_year,
                            branch_id=ho_branch_id,
                            master_id=updated_category.id,
                            master_name=name,
                            ledger_type="bank",
                            ledger_mode="bank",
                            payable=opening,
                            receivable=0,
                            created_by=request.session.get('user_id'),
                            updated_by=request.session.get('user_id'),
                            update=True
                        )

                    return JsonResponse({'message': 'success'})
                else:
                    errors = form.errors.as_json()
                    return JsonResponse({'message': 'error', 'errors': errors})
        except Exception as e:
            return JsonResponse({'message': 'exception', 'error': str(e)})



def bank_delete(request):
    if request.method == 'POST':
        data_id = request.POST.get('id')    
        role_id = request.session.get('role_id')
        has_access,error_message = check_user_access(role_id, 'bank_accounts', "delete")

        if not has_access:
            return JsonResponse({'message': 'warning', 'error_message': 'You do not have permission to delete Bank details'})
               
        try:
            updated = bank_table.objects.filter(id=data_id).update(status=0)
            if updated:
                return JsonResponse({'message': 'yes'})
            else:
                return JsonResponse({'message': 'no such data'})
        except Exception as e:
            return JsonResponse({'message': 'exception', 'error': str(e)})

    return JsonResponse({'message': 'Invalid request method'})



def make_default_bank(request):
    try:
        if request.method != 'POST':
            return JsonResponse({'message': 'invalid', 'error': 'Invalid request method'}, status=400)

        role_id = request.session.get('role_id')
        has_access, error_message = check_user_access(role_id, 'master_uom', "update")

        if not has_access:
            return JsonResponse({'message': 'warning', 'error_message': 'You do not have permission to update Bank details'})

        bank_id = request.POST.get('id')

        if not bank_id:
            return JsonResponse({'message': 'missing', 'error': 'Bank ID is required'}, status=400)

        # 1️⃣ Set all others to default = 0
        bank_table.objects.update(is_default=0)

        # 2️⃣ Set selected ID as default = 1
        bank = bank_table.objects.get(id=bank_id)
        bank.is_default = 1
        bank.save()

        return JsonResponse({'message': 'success', 'text': 'Default bank updated!'})

    except Exception as e:
        return JsonResponse({'message': 'exception', 'error': str(e)}, status=500)





def ajax_qr_view(request):  
    role_id = request.session.get('role_id')
    
    
    bank_id = request.POST.get('edit_id')
    data = list(selectList(qr_table,{'bank_id':bank_id}).values())
    formatted = [
        {
            'id': index + 1,
            'action': '<button type="button" onclick="edit_tx(\'{}\')" class="btn btn-outline-success btn-xs p-1"><i class="fas fa-edit"></i></button> \
                      <button type="button" onclick="delete_tx(\'{}\')" class="btn btn-outline-danger btn-xs p-1"> <i class="fas fa-trash-alt"></i></button>'.format(item['id'], item['id']), 
            'name': item['name'] if item['name'] else '-', 
        } 
        for index, item in enumerate(data)
    ]
    return JsonResponse({'data': formatted})

def bank_qr_add(request):
    if request.method == "POST":
        try:
            user_id = request.session.get('user_id')
            bank_id = request.POST.get('bank_id')
            name = request.POST.get('name').strip()
            tx_id = int(request.POST.get('tx_id', 0)) 
            print('tex',tx_id)

            # Duplicate check (ignore current row if editing)
            duplicate_qs = qr_table.objects.filter(
                bank_id=bank_id,
                name__iexact=name,
                status=1
            )
            if tx_id > 0:
                duplicate_qs = duplicate_qs.exclude(id=tx_id)

            if duplicate_qs.exists():
                return JsonResponse({
                    "message": "duplicate",
                    "error": "QR name already exists for this bank"
                })

            if tx_id in [0, '']:
                # ✅ Add new QR
                qr_table.objects.create(
                    bank_id=bank_id,
                    name=name,
                    is_active=1,
                    status=1,
                    created_by=user_id,
                    updated_by=user_id,
                    created_on=format_datetime(date_time),
                    updated_on=format_datetime(date_time)
                )
            else:
                # ✏️ Edit existing QR
                qr = qr_table.objects.get(id=tx_id)
                qr.name = name
                qr.updated_by = user_id
                qr.updated_on = format_datetime(date_time)
                qr.save()

            return JsonResponse({"message": "success"})

        except Exception as e:
            return JsonResponse({"message": "exception", "error": str(e)})


def tx_edit_qr(request):
    if request.headers.get('x-requested-with') == 'XMLHttpRequest' and request.method == "POST":
        data = qr_table.objects.filter(id=request.POST.get('id'))    
    return JsonResponse(data.values()[0])



def tx_delete_qr(request):
    if request.method == "POST":
        try:
            tx_id = int(request.POST.get('id', 0))
            if tx_id == 0:
                return JsonResponse({"message": "error", "error": "Invalid QR ID"})

            # Soft delete (recommended) or hard delete
            qr = qr_table.objects.get(id=tx_id)
            qr.status = 0  # soft delete
            qr.save()

            return JsonResponse({"message": "success"})
        except qr_table.DoesNotExist:
            return JsonResponse({"message": "error", "error": "QR not found"})
        except Exception as e:
            return JsonResponse({"message": "error", "error": str(e)})
    return JsonResponse({"message": "error", "error": "Invalid request"})

#```````````````````````````````````````````````````````````**UOM**````````````````````````````````````````````````````````````````````````````````


def finance(request):
    if 'user_id' in request.session:
        user_type = request.session.get('user_type')
        if user_type == 'admin':
            cmpy = select_row(company_table, {'id':1})
            category = selectList(category_table, order_by='name')
            return render(request, 'finance.html', {'company': cmpy,'category':category})
        else:
            return HttpResponseRedirect("/")
    else:
        return HttpResponseRedirect("/")




def finance_add(request):
    if request.method == 'POST':
        try:
            with transaction.atomic():
                user_id = request.session.get('user_id')           
                company_id = request.session.get('company_id')           
                role_id = request.session.get('role_id')
                has_access,error_message = check_user_access(role_id, 'finance_cards', "create")

                if not has_access:
                    return JsonResponse({'message': 'warning', 'error_message': 'You do not have permission to add Finance/Cards details'})
                
                form = FinanceForm(request.POST, request.FILES)
                if form.is_valid():
                    category = form.save(commit=False)
                    category.code = generate_code(
                        model=finance_table,
                        prefix="FN",
                        code_field="code",
                        status_field="status"
                    )
                    category.name = request.POST.get('name')
                    category.f_type = request.POST.get('f_type')
                    category.description = request.POST.get('description')
                    category.receivable = request.POST.get('receivable') or 0
                    category.payable = request.POST.get('payable') or 0
                    category.company_id = company_id
                    category.is_active = 1
                    category.status = 1
                    category.created_by = user_id
                    category.updated_by = user_id
                    category.created_on = format_datetime(date_time)
                    category.updated_on = format_datetime(date_time)
                    category.save()

                    ho_branch = branch_table.objects.filter(is_ho=1).first()
                    ho_branch_id = ho_branch.id if ho_branch else 0

                    fyf_name = request.session.get('fyf')
                    financial_year = calculate_financial_year(fyf_name)

                    if category.f_type in ['finance', 'card']:
                        create_ledger_master_and_opening_balance(
                            current_fy=financial_year,
                            branch_id=ho_branch_id,
                            master_id=category.id,
                            master_name=category.name,
                            ledger_type=category.f_type,
                            ledger_mode=category.f_type,
                            payable=category.payable,
                            receivable=category.receivable,
                            created_by=user_id,
                            updated_by=user_id,
                        )

                    return JsonResponse({'message': 'success'})
                else:
                    errors = form.errors.as_json()
                    return JsonResponse({'message': 'form_error', 'errors': errors}, status=400)

        except Exception as e:
            return JsonResponse({'message': 'exception', 'error': str(e)}, status=500)



def finance_view(request):  
    role_id = request.session.get('role_id')
    has_access, error_message = check_user_access(role_id, 'finance_cards', "read")
    if not has_access:
        return JsonResponse({'message': 'warning', 'error_message': 'You do not have permission to view Finance/Cards details'})
    
    f_type = request.POST.get('f_type')
    query =Q(status=1)

    if f_type:
        query &= Q(f_type = f_type)
    
    data = list(selectList(finance_table, query).values())
    formatted = [
        {
            'id': index + 1,
            'action': '<button type="button" onclick="edit_data(\'{}\')" class="btn btn-outline-success btn-xs p-1"><i class="fas fa-edit"></i></button> \
                      <button type="button" onclick="delete_data(\'{}\')" class="btn btn-outline-danger btn-xs p-1"> <i class="fas fa-trash-alt"></i></button>'.format(item['id'], item['id']), 
            'category': item['name'] if item['name'] else '-', 
            'code': item['code'] if item['code'] else '-', 
            'type': format_badge(item['f_type'], mapping={
                'finance': 'badge text-bg-info',
                'card': 'badge text-bg-secondary'
            }, label_mapping={
                'finance': 'Finance',
                'card': 'Card'
            }),
            'receivable': item['receivable'] if item['receivable'] else '-', 
            'payable': item['payable'] if item['payable'] else '-', 
            'description': item['description'] if item['description'] else '-', 
            'status': '<span class="badge text-bg-success">Active</span>' if item['is_active'] else '<span class="badge text-bg-danger">Inactive</span>'  # Assuming is_active is a boolean field
        } 
        for index, item in enumerate(data)
    ]
    return JsonResponse({'data': formatted})



def finance_edit(request):
    if request.headers.get('x-requested-with') == 'XMLHttpRequest' and request.method == "POST":
        data = finance_table.objects.filter(id=request.POST.get('id'))    
    return JsonResponse(data.values()[0])




def finance_update(request):
    if request.method == "POST":
        try:
            with transaction.atomic():
                category_id = request.POST.get('id')
                category = finance_table.objects.get(id=category_id)
                role_id = request.session.get('role_id')
                has_access,error_message = check_user_access(role_id, 'finance_cards', "update")

                if not has_access:
                    return JsonResponse({'message': 'warning', 'error_message': 'You do not have permission to update Finance/Cards details'})
                
                form = FinanceForm(request.POST, request.FILES, instance=category)
                if form.is_valid():
                    updated_category = form.save(commit=False)
                    name = request.POST.get('name')
                    f_type = request.POST.get('f_type')
                    desc = request.POST.get('description')
                    is_active = request.POST.get('is_active')
                    receivable = request.POST.get('receivable') or 0
                    payable = request.POST.get('payable') or 0

                    updated_category.name = name            
                    updated_category.f_type = f_type          
                    updated_category.is_active = is_active            
                    updated_category.description = desc
                    updated_category.receivable = receivable
                    updated_category.payable = payable
                    updated_category.updated_by = request.session.get('user_id')
                    updated_category.updated_on = format_datetime(date_time)
                    updated_category.save()

                    ho_branch = branch_table.objects.filter(is_ho=1).first()
                    ho_branch_id = ho_branch.id if ho_branch else 0

                    fyf_name = request.session.get('fyf')
                    financial_year = calculate_financial_year(fyf_name)

                    if updated_category.f_type in ['finance', 'card']:
                        create_ledger_master_and_opening_balance(
                            current_fy=financial_year,
                            branch_id=ho_branch_id,
                            master_id=updated_category.id,
                            master_name=updated_category.name,
                            ledger_type=updated_category.f_type,
                            ledger_mode=updated_category.f_type,
                            payable=payable,
                            receivable=receivable,
                            created_by=request.session.get('user_id'),
                            updated_by=request.session.get('user_id'),
                        )

                    return JsonResponse({'message': 'success'})
                else:
                    errors = form.errors.as_json()
                    return JsonResponse({'message': 'error', 'errors': errors})
        except Exception as e:
            return JsonResponse({'message': 'exception', 'error': str(e)})



def finance_delete(request):
    if request.method == 'POST':
        data_id = request.POST.get('id')    
        role_id = request.session.get('role_id')
        has_access,error_message = check_user_access(role_id, 'finance_cards', "delete")

        if not has_access:
            return JsonResponse({'message': 'warning', 'error_message': 'You do not have permission to delete Finance/Cards details'})
               
        try:
            updated = finance_table.objects.filter(id=data_id).update(status=0)
            if updated:
                return JsonResponse({'message': 'yes'})
            else:
                return JsonResponse({'message': 'no such data'})
        except Exception as e:
            return JsonResponse({'message': 'exception', 'error': str(e)})

    return JsonResponse({'message': 'Invalid request method'})





from django.http import JsonResponse
from .models import item_table, brand_table

def ajax_load_brand(request):
    if request.method == 'POST':
        subcategory_id = request.POST.get('subcategory_id')

        if not subcategory_id:
            return JsonResponse({'brands': []})

        brand_ids = (
            item_table.objects
            .filter(sub_category_id=subcategory_id, status=1, is_active=1)
            .values_list('brand_id', flat=True)
            .distinct()
        )

        brands = brand_table.objects.filter(
            id__in=brand_ids,
            status=1,
            is_active=1
        ).values('id', 'name')
        return JsonResponse(list(brands), safe=False)
    
    return JsonResponse([], safe=False)
