from django.shortcuts import redirect, render
from django.contrib import messages
from django.urls import reverse
from account.models import *
from django.core.paginator import Paginator
from .utils.decorators import role_required



from django.contrib.auth import get_user_model
User = get_user_model()
from .variable import *
from .custom_today import get_custom_today


#TODO: Settings
# member type
def read_member_type_setting(request):
    memberTypeTable = MemberType.objects.all()
    context = {
        "memberTypeTable":memberTypeTable
    }
    return render(request,'setting/memberType_table.html',context)

#Leave Type
@role_required('read_leave_type_setting')
def read_leave_type_setting(request):
    leaveTypeTable = LeaveType.objects.all() 
    context = {
        "leaveTypeTable":leaveTypeTable
    }
    return render(request,'setting/leaveType_table.html',context)    

#member status
@role_required('read_member_status_setting')
def read_member_status_setting(request):
    member_status = MemberStatus.objects.all().order_by('name')
    context = {
        "member_status":member_status
    }
    return render(request,'setting/read_member_status.html',context)

@role_required('create_member_status_setting')
def create_member_status_setting(request):
    if request.method != "POST":
        messages.error(request, "Method Not Allowed")
        return redirect('read_member_status_setting')
    else:
        name = request.POST.get('name')
        if not all([name]):
            messages.error(request, "All fields are required")
            return redirect('read_member_status_setting')
        MemberStatus.objects.create(name=name)
        messages.success(request,'Member Status Added')
        return redirect('read_member_status_setting')

@role_required('update_member_status_setting')
def update_member_status_setting(request,id):
    member_status = MemberStatus.objects.get(id=id)
    if request.method == 'POST':
        name = request.POST.get('name')
        if not all([name]):
            messages.error(request, "All fields are required")
            return redirect('edit_member_status_setting', id=id)
        member_status.name = name
        member_status.save()
        messages.success(request, "Member status updated successfully")
        return redirect("read_member_status_setting")

@role_required('delete_member_status_setting')
def delete_member_status_setting(request,id):
    member_status = MemberStatus.objects.get(id=id)
    member_status.delete()
    messages.success(request, "Member status deleted successfully")
    return redirect("read_member_status_setting")




#rank
@role_required('read_rank_setting')
def read_rank_setting(request):
    rankTable = Rank.objects.all()
    memberTypes =MemberType.objects.all()
    member_statuses = MemberStatus.objects.all()
    context = {
        "rankTable":rankTable,
        "memberTypes":memberTypes,
        "member_statuses":member_statuses
    }
    return render(request,'setting/rank_table.html',context)

@role_required('create_rank_setting')
def create_rank_setting(request):
    if request.method != "POST":
        messages.error(request, "Method Not Allowed")
        return redirect('read_rank_setting')
    else:
        name = request.POST.get('name')
        memberType_id = request.POST.get('memberType')
        member_status_id = request.POST.get('member_status')
        if not all([name,memberType_id,member_status_id]):
            messages.error(request, "All fields are required")
            return redirect('read_rank_setting')
        memberType = MemberType.objects.get(id=memberType_id)
        member_status = MemberStatus.objects.get(id=member_status_id)
        if Rank.objects.filter(name=name, memberType=memberType, member_status=member_status).exists():
            messages.error(request, "Rank with this name, member type and status already exists")
            return redirect('read_rank_setting')
        Rank.objects.create(name=name,memberType=memberType, member_status=member_status)
        messages.success(request,'rank added')
        return redirect('read_rank_setting')
    
@role_required('update_rank_setting')
def update_rank_setting(request,id):
    rank = Rank.objects.get(id=id)
    memberTypes =MemberType.objects.all()
    member_statuses = MemberStatus.objects.all()
    context = {
        "rank":rank,
        "memberTypes":memberTypes,
        "member_statuses":member_statuses
    }
    if request.method == 'POST':
        name = request.POST.get('name')
        memberType_id = request.POST.get('memberType')
        member_status_id = request.POST.get('member_status')
        if not all([name,memberType_id,member_status_id]):
            messages.error(request, "All fields are required")
            return redirect('update_rank_setting', id=id)
        memberType = MemberType.objects.get(id=memberType_id)
        member_status = MemberStatus.objects.get(id=member_status_id)
        if Rank.objects.filter(name=name, memberType=memberType, member_status=member_status).exclude(id=id).exists():
            messages.error(request, "Rank with this name, member type and status already exists")
            return redirect('update_rank_setting', id=id)
        rank.name = name
        rank.memberType = memberType
        rank.member_status = member_status
        rank.save()
        messages.success(request, "Rank updated successfully")
        return redirect("read_rank_setting") 
    return render(request,'setting/edit_rank_form.html',context)

@role_required('delete_rank_setting')
def delete_rank_setting(request,id):
    rank = Rank.objects.get(id=id)
    rank.delete()
    messages.success(request, "Rank deleted successfully")
    return redirect("read_rank_setting")

#apartment
@role_required('read_appointment_setting')
def read_appointment_setting(request):
    apartmentTable = Apartment.objects.all()
    context = {
        "apartmentTable":apartmentTable
    }
    return render(request,'setting/apartment_table.html',context)

@role_required('create_appointment_setting')
def create_appointment_setting(request):
    if request.method != "POST":
        messages.error(request, "Method Not Allowed")
        return redirect('read_appointment_setting')
    else:
        name = request.POST.get('name')
        if not all([name]):
            messages.error(request, "All fields are required")
            return redirect('read_appointment_setting')
        Apartment.objects.create(name=name)
        messages.success(request,'apartment added')
        return redirect('read_appointment_setting')
    
@role_required('update_appointment_setting')
def update_appointment_setting(request,id):
    apartment = Apartment.objects.get(id=id)
    if request.method == 'POST':
        name = request.POST.get('name')
        if not all([name]):
            messages.error(request, "All fields are required")
            return redirect('update_appointment_setting', id=id)
        apartment.name = name
        apartment.save()
        messages.success(request, "Apartment updated successfully")
        return redirect("read_appointment_setting")
    
@role_required('delete_appointment_setting')
def delete_appointment_setting(request,id):
    apartment = Apartment.objects.get(id=id)
    apartment.delete()
    messages.success(request, "Apartment deleted successfully")
    return redirect("read_appointment_setting")

#trade
@role_required('read_trade_setting')
def read_trade_setting(request):
    tradeTable = Trade.objects.all()
    context = {
        "tradeTable":tradeTable
    }
    return render(request,'setting/trade_table.html',context)
@role_required('create_trade_setting')
def create_trade_setting(request):
    if request.method != "POST":
        messages.error(request, "Method Not Allowed")
        return redirect('read_trade_setting')
    else:
        name = request.POST.get('name')
        if not all([name]):
            messages.error(request, "All fields are required")
            return redirect('read_trade_setting')
        Trade.objects.create(name=name)
        messages.success(request,'trade added')
        return redirect('read_trade_setting')

@role_required('update_trade_setting')
def update_trade_setting(request,id):
    trade = Trade.objects.get(id=id)
    if request.method == 'POST':
        name = request.POST.get('name')
        if not all([name]):
            messages.error(request, "All fields are required")
            return redirect('update_trade_setting', id=id)
        trade.name = name
        trade.save()
        messages.success(request, "Trade updated successfully")
        return redirect("read_trade_setting") 
@role_required('delete_trade_setting')
def delete_trade_setting(request,id):
    trade = Trade.objects.get(id=id)
    trade.delete()
    messages.success(request, "Trade deleted successfully")
    return redirect("read_trade_setting")

    
#core
@role_required('read_core_setting')
def read_core_setting(request):
    coreTable = Core.objects.all()
    context = {
        "coreTable":coreTable
    }
    return render(request,'setting/core_table.html',context)

@role_required('create_core_setting')
def create_core_setting(request):
    if request.method != "POST":
        messages.error(request, "Method Not Allowed")
        return redirect('read_core_setting')
    else:
        name = request.POST.get('name')
        if not all([name]):
            messages.error(request, "All fields are required")
            return redirect('read_core_setting')
        Core.objects.create(name=name)
        messages.success(request,'core added')
        return redirect('read_core_setting')
    
@role_required('update_core_setting')
def update_core_setting(request,id):
    core = Core.objects.get(id=id)
    if request.method == 'POST':
        name = request.POST.get('name')
        if not all([name]):
            messages.error(request, "All fields are required")
            return redirect('update_core_setting', id=id)
        core.name = name
        core.save()
        messages.success(request, "Core updated successfully")
        return redirect("read_core_setting") 

@role_required('delete_core_setting')
def delete_core_setting(request,id):
    core = Core.objects.get(id=id)
    core.delete()
    messages.success(request, "Core deleted successfully")
    return redirect("read_core_setting")

    
#special_quality
@role_required('read_special_quality_setting')
def read_special_quality_setting(request):
    special_qualityTable = SpecialQuality.objects.all()
    context = {
        "special_qualityTable":special_qualityTable
    }
    return render(request,'setting/special_quality_table.html',context)

@role_required('create_special_quality_setting')
def create_special_quality_setting(request):
    if request.method != "POST":
        messages.error(request, "Method Not Allowed")
        return redirect('read_special_quality_setting')
    else:
        name = request.POST.get('name')
        if not all([name]):
            messages.error(request, "All fields are required")
            return redirect('read_special_quality_setting')
        SpecialQuality.objects.create(name=name)
        messages.success(request,'special_quality added')
        return redirect('read_special_quality_setting')

@role_required('update_special_quality_setting')
def update_special_quality_setting(request,id):
    special_quality = SpecialQuality.objects.get(id=id)
    if request.method == 'POST':
        name = request.POST.get('name')
        if not all([name]):
            messages.error(request, "All fields are required")
            return redirect('update_special_quality_setting', id=id)
        special_quality.name = name
        special_quality.save()
        messages.success(request, "SpecialQuality updated successfully")
        return redirect("read_special_quality_setting") 

@role_required('delete_special_quality_setting')
def delete_special_quality_setting(request,id):
    special_quality = SpecialQuality.objects.get(id=id)
    special_quality.delete()
    messages.success(request, "SpecialQuality deleted successfully")
    return redirect("read_special_quality_setting")

#punishment_type
@role_required('read_punishment_type_setting')
def read_punishment_type_setting(request):
    punishment_type = PunishmentType.objects.all()
    context = {
        "punishment_type":punishment_type
    }
    return render(request,'setting/read_punishment_type.html',context)

@role_required('create_punishment_type_setting')
def create_punishment_type_setting(request):
    if request.method != "POST":
        messages.error(request, "Method Not Allowed")
        return redirect('read_punishment_type_setting')
    else:
        text = request.POST.get('text')
        if not all([text]):
            messages.error(request, "All fields are required")
            return redirect('read_punishment_type_setting')
        PunishmentType.objects.create(text=text)
        messages.success(request,'Punishment Type Added')
        return redirect('read_punishment_type_setting')

@role_required('update_punishment_type_setting')
def update_punishment_type_setting(request,id):
    punishment_type = PunishmentType.objects.get(id=id)
    if request.method == 'POST':
        text = request.POST.get('text')
        if not all([text]):
            messages.error(request, "All fields are required")
            return redirect('update_punishment_type_setting', id=id)
        punishment_type.text = text
        punishment_type.save()
        messages.success(request, "Punishment type updated successfully")
        return redirect("read_punishment_type_setting") 

@role_required('delete_punishment_type_setting')
def delete_punishment_type_setting(request,id):
    punishment_type = PunishmentType.objects.get(id=id)
    punishment_type.delete()
    messages.success(request, "Punishment type deleted successfully")
    return redirect("read_punishment_type_setting")

#punishment_name
@role_required('read_punishment_name_setting')
def read_punishment_name_setting(request):
    punishment_name = PunishmentName.objects.all()
    context = {
        "punishment_name":punishment_name
    }
    return render(request,'setting/read_punishment_name.html',context)

@role_required('create_punishment_name_setting')
def create_punishment_name_setting(request):
    if request.method != "POST":
        messages.error(request, "Method Not Allowed")
        return redirect('read_punishment_name_setting')
    else:
        text = request.POST.get('text')
        if not all([text]):
            messages.error(request, "All fields are required")
            return redirect('read_punishment_text_setting')
        PunishmentName.objects.create(text=text)
        messages.success(request,'Punishment Name Added')
        return redirect('read_punishment_name_setting')

@role_required('update_punishment_name_setting')
def update_punishment_name_setting(request,id):
    punishment_name = PunishmentName.objects.get(id=id)
    if request.method == 'POST':
        text = request.POST.get('text')
        if not all([text]):
            messages.error(request, "All fields are required")
            return redirect('update_punishment_name_setting', id=id)
        punishment_name.text = text
        punishment_name.save()
        messages.success(request, "Punishment Name updated successfully")
        return redirect("read_punishment_name_setting") 

@role_required('delete_punishment_name_setting')
def delete_punishment_name_setting(request,id):
    punishment_name = PunishmentName.objects.get(id=id)
    punishment_name.delete()
    messages.success(request, "Punishment type deleted successfully")
    return redirect("read_punishment_name_setting")

#promotion_type
@role_required('read_promotion_type_setting')
def read_promotion_type_setting(request):
    promotion_type = PromotionType.objects.all()
    context = {
        "promotion_type":promotion_type
    }
    return render(request,'setting/read_promotion_type.html',context)

@role_required('create_promotion_type_setting')
def create_promotion_type_setting(request):
    if request.method != "POST":
        messages.error(request, "Method Not Allowed")
        return redirect('read_promotion_type_setting')
    else:
        text = request.POST.get('text')
        if not all([text]):
            messages.error(request, "All fields are required")
            return redirect('read_promotion_type_setting')
        PromotionType.objects.create(text=text)
        messages.success(request,'Promotion Type Added')
        return redirect('read_promotion_type_setting')
    
@role_required('update_promotion_type_setting')
def update_promotion_type_setting(request,id):
    promotion_type = PromotionType.objects.get(id=id)
    if request.method == 'POST':
        text = request.POST.get('text')
        if not all([text]):
            messages.error(request, "All fields are required")
            return redirect('update_promotion_type_setting', id=id)
        promotion_type.text = text
        promotion_type.save()
        messages.success(request, "Promotion type updated successfully")
        return redirect("read_promotion_type_setting") 
    
@role_required('delete_promotion_type_setting')
def delete_promotion_type_setting(request,id):
    promotion_type = PromotionType.objects.get(id=id)
    promotion_type.delete()
    messages.success(request, "Promotion type deleted successfully")
    return redirect("read_promotion_type_setting")

#demotion_type
@role_required('read_demotion_type_setting')
def read_demotion_type_setting(request):
    demotion_type = DemotionType.objects.all()
    context = {
        "demotion_type":demotion_type
    }
    return render(request,'setting/read_demotion_type.html',context)

@role_required('create_demotion_type_setting')
def create_demotion_type_setting(request):
    if request.method != "POST":
        messages.error(request, "Method Not Allowed")
        return redirect('read_demotion_type_setting')
    else:
        text = request.POST.get('text')
        if not all([text]):
            messages.error(request, "All fields are required")
            return redirect('read_demotion_type_setting')
        DemotionType.objects.create(text=text)
        messages.success(request,'Demotion Type Added')
        return redirect('read_demotion_type_setting')
    
@role_required('update_demotion_type_setting')
def update_demotion_type_setting(request,id):
    demotion_type = DemotionType.objects.get(id=id)
    if request.method == 'POST':
        text = request.POST.get('text')
        if not all([text]):
            messages.error(request, "All fields are required")
            return redirect('update_demotion_type_setting', id=id)
        demotion_type.text = text
        demotion_type.save()
        messages.success(request, "Demotion type updated successfully")
        return redirect("read_demotion_type_setting") 
    
@role_required('delete_demotion_type_setting')
def delete_demotion_type_setting(request,id):
    demotion_type = DemotionType.objects.get(id=id)
    demotion_type.delete()
    messages.success(request, "Demotion type deleted successfully")
    return redirect("read_demotion_type_setting")


#leaveReason
@role_required('read_leave_reason_setting')
def read_leave_reason_setting(request):
    leave_reason = LeaveReason.objects.all().order_by('text')
    context = {
        "leave_reason":leave_reason
    }
    return render(request,'setting/read_leave_reason.html',context)

@role_required('create_leave_reason_setting')
def create_leave_reason_setting(request):
    if request.method != "POST":
        messages.error(request, "Method Not Allowed")
        return redirect('read_leave_reason_setting')
    else:
        text = request.POST.get('text')
        if not all([text]):
            messages.error(request, "All fields are required")
            return redirect('read_leave_reason_setting')
        LeaveReason.objects.create(text=text)
        messages.success(request,'Punishment Type Added')
        return redirect('read_leave_reason_setting')

@role_required('update_leave_reason_setting')
def update_leave_reason_setting(request,id):
    leave_reason = LeaveReason.objects.get(id=id)
    if request.method == 'POST':
        text = request.POST.get('text')
        if not all([text]):
            messages.error(request, "All fields are required")
            return redirect('update_leave_reason_setting', id=id)
        leave_reason.text = text
        leave_reason.save()
        messages.success(request, "Punishment type updated successfully")
        return redirect("read_leave_reason_setting") 

@role_required('delete_leave_reason_setting')
def delete_leave_reason_setting(request,id):
    leave_reason = LeaveReason.objects.get(id=id)
    leave_reason.delete()
    messages.success(request, "Punishment type deleted successfully")
    return redirect("read_leave_reason_setting")


#leave_reason_des
@role_required('read_leave_reason_des_setting')
def read_leave_reason_des_setting(request):
    leave_reason_des_table = LeaveReasonDes.objects.all()
    leave_reasons = LeaveReason.objects.all()
    context = {
        "leave_reason_des_table":leave_reason_des_table,
        "leave_reasons":leave_reasons
    }
    return render(request,'setting/read_leave_reason_des.html',context)

@role_required('create_leave_reason_des_setting')
def create_leave_reason_des_setting(request):
    if request.method != "POST":
        messages.error(request, "Method Not Allowed")
        return redirect('read_leave_reason_des_setting')
    else:
        text = request.POST.get('text')
        leave_reason_id = request.POST.get('leave_reason')
        if not all([text,leave_reason_id]):
            messages.error(request, "All fields are required")
            return redirect('read_leave_reason_des_setting')
        leave_reason = LeaveReason.objects.get(id=leave_reason_id)
        LeaveReasonDes.objects.create(text=text, leave_reason=leave_reason)
        messages.success(request,'leave reason description added')
        return redirect('read_leave_reason_des_setting')
    
@role_required('update_leave_reason_des_setting')
def update_leave_reason_des_setting(request,id):
    leave_reason_des = LeaveReasonDes.objects.get(id=id)
    leave_reasons = LeaveReason.objects.all()
    context = {
        "leave_reason_des":leave_reason_des,
        "leave_reasons":leave_reasons
    }
    if request.method == 'POST':
        text = request.POST.get('text')
        leave_reason_id = request.POST.get('leave_reason')
        if not all([text,leave_reason_id]):
            messages.error(request, "All fields are required")
            return redirect('update_leave_reason_des_setting', id=id)
        leave_reason = LeaveReason.objects.get(id=leave_reason_id)
        leave_reason_des.text = text
        leave_reason_des.leave_reason = leave_reason
        leave_reason_des.save()
        messages.success(request, "Leave Reason Description updated successfully")
        return redirect("read_leave_reason_des_setting") 
    return render(request,'setting/edit_leave_reason_des.html',context)

@role_required('delete_leave_reason_des_setting')
def delete_leave_reason_des_setting(request,id):
    leave_reason_des = LeaveReasonDes.objects.get(id=id)
    leave_reason_des.delete()
    messages.success(request, "Leave Reason Description deleted successfully")
    return redirect("read_leave_reason_des_setting")



#courseName
@role_required('read_course_name_setting')
def read_course_name_setting(request):
    course_name = CourseName.objects.all().order_by('text')
    context = {
        "course_name":course_name
    }
    return render(request,'setting/read_course_name.html',context)

@role_required('create_course_name_setting')
def create_course_name_setting(request):
    if request.method != "POST":
        messages.error(request, "Method Not Allowed")
        return redirect('read_course_name_setting')
    else:
        text = request.POST.get('text')
        if not all([text]):
            messages.error(request, "All fields are required")
            return redirect('read_course_name_setting')
        CourseName.objects.create(text=text)
        messages.success(request,'Course Name Added')
        return redirect('read_course_name_setting')

@role_required('update_course_name_setting')
def update_course_name_setting(request,id):
    course_name = CourseName.objects.get(id=id)
    if request.method == 'POST':
        text = request.POST.get('text')
        if not all([text]):
            messages.error(request, "All fields are required")
            return redirect('update_course_name_setting', id=id)
        course_name.text = text
        course_name.save()
        messages.success(request, "Punishment type updated successfully")
        return redirect("read_course_name_setting") 
    
@role_required('delete_course_name_setting')
def delete_course_name_setting(request,id):
    course_name = CourseName.objects.get(id=id)
    course_name.delete()
    messages.success(request, "Punishment type deleted successfully")
    return redirect("read_course_name_setting")


#courseInstitution
@role_required('read_course_institution_setting')
def read_course_institution_setting(request):
    course_institution = CourseInstitution.objects.all().order_by('text')
    context = {
        "course_institution":course_institution
    }
    return render(request,'setting/read_course_institution.html',context)

@role_required('create_course_institution_setting')
def create_course_institution_setting(request):
    if request.method != "POST":
        messages.error(request, "Method Not Allowed")
        return redirect('read_course_institution_setting')
    else:
        text = request.POST.get('text')
        if not all([text]):
            messages.error(request, "All fields are required")
            return redirect('read_course_institution_setting')
        CourseInstitution.objects.create(text=text)
        messages.success(request,'Course Institution Added')
        return redirect('read_course_institution_setting')
    
@role_required('update_course_institution_setting')
def update_course_institution_setting(request,id):
    course_institution = CourseInstitution.objects.get(id=id)
    if request.method == 'POST':
        text = request.POST.get('text')
        if not all([text]):
            messages.error(request, "All fields are required")
            return redirect('update_course_institution_setting', id=id)
        course_institution.text = text
        course_institution.save()
        messages.success(request, "Punishment type updated successfully")
        return redirect("read_course_institution_setting") 

@role_required('delete_course_institution_setting')
def delete_course_institution_setting(request,id):
    course_institution = CourseInstitution.objects.get(id=id)
    course_institution.delete()
    messages.success(request, "Punishment type deleted successfully")
    return redirect("read_course_institution_setting")


#opsDeplLocation
@role_required('read_ops_depl_location_setting')
def read_ops_depl_location_setting(request):
    ops_depl_location = OpsDeplLocation.objects.all().order_by('text')
    context = {
        "ops_depl_location":ops_depl_location
    }
    return render(request,'setting/read_ops_depl_location.html',context)

@role_required('create_ops_depl_location_setting')
def create_ops_depl_location_setting(request):
    if request.method != "POST":
        messages.error(request, "Method Not Allowed")
        return redirect('read_ops_depl_location_setting')
    else:
        text = request.POST.get('text')
        if not all([text]):
            messages.error(request, "All fields are required")
            return redirect('read_ops_depl_location_setting')
        OpsDeplLocation.objects.create(text=text)
        messages.success(request,'Punishment Type Added')
        return redirect('read_ops_depl_location_setting')

@role_required('update_ops_depl_location_setting')
def update_ops_depl_location_setting(request,id):
    ops_depl_location = OpsDeplLocation.objects.get(id=id)
    if request.method == 'POST':
        text = request.POST.get('text')
        if not all([text]):
            messages.error(request, "All fields are required")
            return redirect('update_ops_depl_location_setting', id=id)
        ops_depl_location.text = text
        ops_depl_location.save()
        messages.success(request, "Punishment type updated successfully")
        return redirect("read_ops_depl_location_setting") 

@role_required('delete_ops_depl_location_setting')
def delete_ops_depl_location_setting(request,id):
    ops_depl_location = OpsDeplLocation.objects.get(id=id)
    ops_depl_location.delete()
    messages.success(request, "Punishment type deleted successfully")
    return redirect("read_ops_depl_location_setting")

    
#district
@role_required('read_district_setting')
def read_district_setting(request):
    districtTable = District.objects.all().order_by('name')
    context = {
        "districtTable":districtTable
    }
    return render(request,'setting/district_table.html',context)

@role_required('create_district_setting')
def create_district_setting(request):
    if request.method != "POST":
        messages.error(request, "Method Not Allowed")
        return redirect('read_district_setting')
    else:
        name = request.POST.get('name')
        if not all([name]):
            messages.error(request, "All fields are required")
            return redirect('read_district_setting')
        District.objects.create(name=name)
        messages.success(request,'district added')
        return redirect('read_district_setting')
    
@role_required('update_district_setting')
def update_district_setting(request,id):
    district = District.objects.get(id=id)
    if request.method == 'POST':
        name = request.POST.get('name')
        if not all([name]):
            messages.error(request, "All fields are required")
            return redirect('update_district_setting', id=id)
        district.name = name
        district.save()
        messages.success(request, "District updated successfully")
        return redirect("read_district_setting") 
    
@role_required('delete_district_setting')
def delete_district_setting(request,id):
    district = District.objects.get(id=id)
    district.delete()
    messages.success(request, "District deleted successfully")
    return redirect("read_district_setting")


#upazila
@role_required('read_upazila_setting')
def read_upazila_setting(request):
    upazilaTable = Upazila.objects.all().order_by('name')
    districts =District.objects.all().order_by('name')
    context = {
        "upazilaTable":upazilaTable,
        "districts":districts
    }
    return render(request,'setting/upazila_table.html',context)

@role_required('create_upazila_setting')
def create_upazila_setting(request):
    if request.method != "POST":
        messages.error(request, "Method Not Allowed")
        return redirect('read_upazila_setting')
    else:
        name = request.POST.get('name')
        district_id = request.POST.get('district')
        if not all([name,district_id]):
            messages.error(request, "All fields are required")
            return redirect('read_upazila_setting')
        district = District.objects.get(id=district_id)
        Upazila.objects.create(name=name,district=district)
        messages.success(request,'upazila added')
        return redirect('read_upazila_setting')
    
@role_required('update_upazila_setting')
def update_upazila_setting(request,id):
    upazila = Upazila.objects.get(id=id)
    districts =District.objects.all()
    context = {
        "upazila":upazila,
        "districts":districts
    }
    if request.method == 'POST':
        name = request.POST.get('name')
        district_id = request.POST.get('district')
        if not all([name,district_id]):
            messages.error(request, "All fields are required")
            return redirect('update_upazila_setting', id=id)
        district = District.objects.get(id=district_id)
        upazila.name = name
        upazila.district = district
        upazila.save()
        messages.success(request, "Upazila updated successfully")
        return redirect("read_upazila_setting") 
    return render(request,'setting/edit_upazila.html',context)

@role_required('delete_upazila_setting')
def delete_upazila_setting(request,id):
    upazila = Upazila.objects.get(id=id)
    upazila.delete()
    messages.success(request, "Upazila deleted successfully")
    return redirect("read_upazila_setting")



#ex_perf_name
@role_required('read_ex_perf_name_setting')
def read_ex_perf_name_setting(request):
    ex_perf_name = ExPerfName.objects.all().order_by('text')
    context = {
        "ex_perf_name":ex_perf_name
    }
    return render(request,'setting/read_ex_perf_name.html',context)

@role_required('create_ex_perf_name_setting')
def create_ex_perf_name_setting(request):
    if request.method != "POST":
        messages.error(request, "Method Not Allowed")
        return redirect('read_ex_perf_name_setting')
    else:
        text = request.POST.get('text')
        if not all([text]):
            messages.error(request, "All fields are required")
            return redirect('read_ex_perf_name_setting')
        ExPerfName.objects.create(text=text)
        messages.success(request,'Ex Performance Name Added')
        return redirect('read_ex_perf_name_setting')
    
@role_required('update_ex_perf_name_setting')
def update_ex_perf_name_setting(request,id):
    ex_perf_name = ExPerfName.objects.get(id=id)
    if request.method == 'POST':
        text = request.POST.get('text')
        if not all([text]):
            messages.error(request, "All fields are required")
            return redirect('update_ex_perf_name_setting', id=id)
        ex_perf_name.text = text
        ex_perf_name.save()
        messages.success(request, "Ex Performance Name updated successfully")
        return redirect("read_ex_perf_name_setting") 
    
@role_required('delete_ex_perf_name_setting')
def delete_ex_perf_name_setting(request,id):
    ex_perf_name = ExPerfName.objects.get(id=id)
    ex_perf_name.delete()
    messages.success(request, "Ex Performance Name deleted successfully")
    return redirect("read_ex_perf_name_setting")


#range
@role_required('read_range_setting')
def read_range_setting(request):
    range = Range.objects.all().order_by('text')
    context = {
        "range":range
    }
    return render(request,'setting/read_range.html',context)

@role_required('create_range_setting')
def create_range_setting(request):
    if request.method != "POST":
        messages.error(request, "Method Not Allowed")
        return redirect('read_range_setting')
    else:
        text = request.POST.get('text')
        if not all([text]):
            messages.error(request, "All fields are required")
            return redirect('read_range_setting')
        Range.objects.create(text=text)
        messages.success(request,'Range Added')
        return redirect('read_range_setting')
    
@role_required('update_range_setting')
def update_range_setting(request,id):
    range = Range.objects.get(id=id)
    if request.method == 'POST':
        text = request.POST.get('text')
        if not all([text]):
            messages.error(request, "All fields are required")
            return redirect('update_range_setting', id=id)
        range.text = text
        range.save()
        messages.success(request, "Range updated successfully")
        return redirect("read_range_setting")

@role_required('delete_range_setting')
def delete_range_setting(request,id):
    range = Range.objects.get(id=id)
    range.delete()
    messages.success(request, "Range deleted successfully")
    return redirect("read_range_setting")



#batch
@role_required('read_batch_setting')
def read_batch_setting(request):
    batch = Batch.objects.all().order_by('-id')
    context = {
        "batch":batch
    }
    return render(request,'setting/read_batch.html',context)

@role_required('create_batch_setting')
def create_batch_setting(request):
    if request.method != "POST":
        messages.error(request, "Method Not Allowed")
        return redirect('read_batch_setting')
    else:
        text = request.POST.get('text')
        if not all([text]):
            messages.error(request, "All fields are required")
            return redirect('read_batch_setting')
        Batch.objects.create(text=text)
        messages.success(request,'Batch Added')
        return redirect('read_batch_setting')
    
@role_required('update_batch_setting')
def update_batch_setting(request,id):
    batch = Batch.objects.get(id=id)
    if request.method == 'POST':
        text = request.POST.get('text')
        if not all([text]):
            messages.error(request, "All fields are required")
            return redirect('update_batch_setting', id=id)
        batch.text = text
        batch.save()
        messages.success(request, "Batch updated successfully")
        return redirect("read_batch_setting")

@role_required('delete_batch_setting')
def delete_batch_setting(request,id):
    batch = Batch.objects.get(id=id)
    batch.delete()
    messages.success(request, "Batch deleted successfully")
    return redirect("read_batch_setting")



#list_category
@role_required('read_list_category_setting')
def read_list_category_setting(request):
    list_category = ListCategory.objects.all().order_by('-id')
    context = {
        "list_category":list_category
    }
    return render(request,'setting/read_list_category.html',context)

@role_required('create_list_category_setting')
def create_list_category_setting(request):
    if request.method != "POST":
        messages.error(request, "Method Not Allowed")
        return redirect('read_list_category_setting')
    else:
        text = request.POST.get('text')
        if not all([text]):
            messages.error(request, "All fields are required")
            return redirect('read_list_category_setting')
        ListCategory.objects.create(text=text)
        messages.success(request,'ListCategory Added')
        return redirect('read_list_category_setting')
    
@role_required('update_list_category_setting')
def update_list_category_setting(request,id):
    list_category = ListCategory.objects.get(id=id)
    if request.method == 'POST':
        text = request.POST.get('text')
        if not all([text]):
            messages.error(request, "All fields are required")
            return redirect('update_list_category_setting', id=id)
        list_category.text = text
        list_category.save()
        messages.success(request, "ListCategory updated successfully")
        return redirect("read_list_category_setting")

@role_required('delete_list_category_setting')
def delete_list_category_setting(request,id):
    list_category = ListCategory.objects.get(id=id)
    list_category.delete()
    messages.success(request, "ListCategory deleted successfully")
    return redirect("read_list_category_setting")