from django.shortcuts import render, redirect, get_object_or_404,HttpResponse
from django.contrib.auth import login, authenticate,logout
from .forms import *
from django.views import View
from django.contrib.auth.decorators import login_required
from django.contrib.auth.models import Group
from django.contrib import messages
from .models import *
from .decorators import allowd_users
from django.db.models import Q
from django.db.models.functions import ExtractDay, ExtractMonth
from django.db.models import Count
import datetime
from leave.forms import LeaveCreationForm, HolidayForm
from django.contrib.auth import update_session_auth_hash
from leave.models import Leave, Holiday
from django.utils import timezone
from datetime import datetime as dt, timedelta
from django.contrib.auth.tokens import PasswordResetTokenGenerator
from django.http import HttpResponseForbidden, FileResponse, JsonResponse
from django.template.loader import get_template
from io import BytesIO
from xhtml2pdf import pisa
import os
from dateutil.relativedelta import relativedelta
from paypal.standard.forms import PayPalPaymentsForm
import uuid
from django.urls import reverse
import random 
from .checksum import generate_checksum, verify_checksum
from django.views.decorators.csrf import csrf_exempt
import requests
from django.utils.http import urlsafe_base64_encode
from django.core.paginator import Paginator
from django.utils.encoding import force_bytes
from django.db.models.functions import ExtractMonth, ExtractDay
from docx import Document
from django.core.mail import send_mail

def index2(request):
    return render(request, 'myapp/index2.html')

def get_started(request,plan):
    print(plan)
    if plan == '1-3%20members%20$5/month':
        request.session['selected_plan'] = '1-3 members $0/month'
    elif plan == '3-10%20members%20$5/month':
        request.session['selected_plan'] = '3-10 members $5/month'
    else:
       request.session['selected_plan'] = '10-50 members $15/month' 
    session_data = request.session.items()
    print(session_data)
    return redirect('register')

def htmltopdf(template_source, context):
    
    template = get_template(template_source)
    html = template.render(context)
    
    result = BytesIO()
    instance = context['instance']
    file_name = f'{instance.employee.email}_{instance.month}_{instance.year}_salary_slip.pdf'
    output_path = os.path.join(settings.BASE_DIR, 'media', 'salary_slip', file_name)

    pdf = pisa.pisaDocument(BytesIO(html.encode("UTF-8")),result)
    try:
        with open(output_path, 'wb+') as output:
            pdf = pisa.pisaDocument(BytesIO(html.encode("UTF-8")),output)
    except Exception as e:
        print(e)
    return file_name

def Home(request):
    if request.method == 'POST':
        form = PlanSelectionForm(request.POST)
        if form.is_valid():
            # Save plan selection to the user's session
            selected_plan = form.cleaned_data['selected_plan']
            print(selected_plan)
            request.session['selected_plan'] = selected_plan
            session_data = request.session.items()
            print(session_data)
            return redirect('register')
    form = PlanSelectionForm()
    return render(request, 'myapp/home.html',{'form': form})


def register(request):
    if request.method == 'POST':
        first_name = request.POST.get('first_name')
        print(first_name)
        last_name = request.POST.get('last_name')
        full_name = f"{first_name} {last_name}"
        email = request.POST.get('email')
        print(email)
        organisation = request.POST.get('organisation')
        print(organisation)
        password1 = request.POST.get('password1')
        password2 = request.POST.get('password2')
        query = User_Profile.objects.filter(Q(email__icontains=email) | Q(organisation__icontains=organisation))
        if query.exists():
            messages.error(request, "Email or Organisation Already Exists !", extra_tags="alert alert-warning alert-dismissible show")
            return redirect('register')
        if password1 == password2:
            admin_group = Group.objects.get(name='Organisation Admin')
            print(admin_group)
            user = User_Profile.objects.create_user(email=email,full_name=full_name,username=email,organisation=organisation,password=password1)
            
            user.save()
            user.groups.add(admin_group)
            request.session['admin_id'] = user.id
            selected_plan = request.session.get('selected_plan')
            if selected_plan == '1-3 members for free':
                return redirect('login')
            return redirect('checkout')
        else:
            messages.error(request, "Password and Confirm Password not matched", extra_tags="alert alert-warning alert-dismissible show")
            return redirect('register')  # Redirect to your home page or wherever you want
    
    return render(request, 'myapp/register.html')

def custom_signup(request):
    if request.method == 'POST':
        
        email = request.POST.get('email')
        organisation = request.POST.get('organisation')
        password1 = request.POST.get('password1')
        password2 = request.POST.get('password2')
        query = User_Profile.objects.filter(Q(email__icontains=email) | Q(organisation__icontains=organisation))
        if query.exists():
            messages.error(request, "Email or Organisation Already Exists !", extra_tags="alert alert-warning alert-dismissible show")
            return redirect('custom_signup')
        if password1 == password2:
            admin_group = Group.objects.get(name='Organisation Admin')
            print(admin_group)
            user = User_Profile.objects.create_user(email=email,username=email,organisation=organisation,password=password1)
            
            user.save()
            user.groups.add(admin_group)
            messages.success(request, "Your Registration Successfully done !!", extra_tags="alert alert-success alert-dismissible show")
            return redirect('login')
            
        else:
            messages.error(request, "Password and Confirm Password not matched", extra_tags="alert alert-warning alert-dismissible show")
            return redirect('register')  # Redirect to your home page or wherever you want
    messages.error(request, "Email does not exists, Please register here", extra_tags="alert alert-warning alert-dismissible show")
    return render(request, 'myapp/register.html')

def get_user_country(request):
    try:
        # Fetching the user's IP address from the request
        user_ip = request.META.get('HTTP_X_FORWARDED_FOR', request.META.get('REMOTE_ADDR'))
        
        # Using a free IP geolocation API to get the country from the IP address
        response = requests.get(f"http://ip-api.com/json/{user_ip}")
        
        if response.status_code == 200:
            data = response.json()
            country = data.get('countryCode')
            
            return country
        else:
            # Default country if unable to determine the user's country
            return 'US'
    except Exception as e:
        print(f"Error fetching user's country: {str(e)}")
        # Default country if an error occurs
        return 'US'

def get_currency_code(country):
    if country == 'IN':
        return 'INR'
    elif country == 'GB':
        return 'GBP'
    else:
        return 'USD'

import string

def generate_id(length=20):
    key = ''
    for i in range(length):
        key += random.choice(string.ascii_lowercase + string.ascii_uppercase + string.digits)
    return key


def CheckOut(request):

    amount = None
    selected_plan = request.session.get('selected_plan')
    user_id = request.session.get('admin_id')
    user_obj = get_object_or_404(User_Profile,id=user_id)
    if selected_plan:
        print(selected_plan)
        user_country = get_user_country(request)
        if selected_plan == '3-10 members $5/month':
            amount = 5
            billing_cycle = 1
            billing_cycle_unit = "M"
        elif selected_plan == '10-50 members $15/month':
            amount = 15
            billing_cycle = 1
            billing_cycle_unit = "M"

        currency_code = get_currency_code(user_country)
        host = request.get_host()

        paypal_checkout = {
            "cmd": "_xclick-subscriptions",
            'business': settings.PAYPAL_RECEIVER_EMAIL,
            
            "a3": amount,  # monthly price
            "p3": billing_cycle,  # duration of each unit (depends on unit)
            "t3": billing_cycle_unit,  # duration unit ("M for Month")
            "src": "1",  # make payments recur
            "sra": "1",  # reattempt payment on payment error
            "no_note": "1",  # remove extra notes (optional)
            'item_name': 'Content subscription',
            'custom': 1,     # custom data, pass something meaningful here

            'item_name': selected_plan,
            'invoice': uuid.uuid4(),
            'currency_code': 'INR',
            'notify_url': f"http://{host}{reverse('paypal-ipn')}",
            'return_url': f"http://{host}{reverse('payment-success')}",
            'cancel_url': f"http://{host}{reverse('payment-failed')}",
        }
        print(paypal_checkout)
        paypal_payment = PayPalPaymentsForm(initial=paypal_checkout)
        merchant_key = settings.PAYTM_SECRET_KEY
        print(merchant_key)
        paytm_params = {
            
            "MID":settings.PAYTM_MERCHANT_ID,
            "ORDER_ID":str(generate_id()),
            "CUST_ID":user_obj.email,
            "TXN_AMOUNT":str(amount),
            "CHANNEL_ID":settings.PAYTM_CHANNEL_ID,
            "WEBSITE":settings.PAYTM_WEBSITE,
            "INDUSTRY_TYPE_ID":settings.PAYTM_INDUSTRY_TYPE_ID,
            "CALLBACK_URL":"http://127.0.0.1:8000/handlerequest/",
            "CURRENCY":currency_code
        }
         
        
        checksum = generate_checksum(paytm_params, merchant_key)
        
        paytm_params['CHECKSUMHASH'] = checksum
        
        context = {
                'amount':amount,
                'paypal': paypal_payment,
                'paytm_params':paytm_params
            }
        print(context)
        return render(request, 'myapp/checkout.html', context)
    return redirect('login')


@csrf_exempt
def handlerequest(request):
    
    if request.method == 'POST':
        paytm_checksum = ''
        
        received_data = dict(request.POST)
        print(received_data)
        paytm_params = {}
        paytm_checksum = received_data['CHECKSUMHASH'][0]
        for key, value in received_data.items():
            if key == 'CHECKSUMHASH':
                paytm_checksum = value[0]
            else:
                paytm_params[key] = str(value[0])
        is_valid_checksum = verify_checksum(paytm_params, settings.PAYTM_SECRET_KEY, str(paytm_checksum))
        if is_valid_checksum:
            print("Checksum Matched")
            received_data['message'] = "Checksum Matched"
            user = request.session.get('admin_id')
            selected_plan = request.session.get('selected_plan')
            user_obj = get_object_or_404(User_Profile,id=user)
            Subscription.objects.create(user=user_obj,plan=selected_plan)
            return redirect('login')
        else:
            print("Checksum Mismatched")
            received_data['message'] = "Checksum Mismatched"

        return render(request, 'myapp/callback.html', context=received_data)


def PaymentSuccessful(request):
    user = request.session.get('admin_id')
    selected_plan = request.session.get('selected_plan')
    user_obj = get_object_or_404(User_Profile,id=user)
    Subscription.objects.create(user=user_obj,plan=selected_plan)
    return redirect('login')

def paymentFailed(request):
    return render(request, 'myapp/payment_failed.html')

class LoginView(View):
    def get(self, request):
        
        return render(request, 'myapp/login1.html')
    
    def post(self, request):
        email = request.POST.get('email')
        print(email)
        password = request.POST.get('password')
            #print(password)
        user = authenticate(email=email,password=password)
        print(user)
        if user is not None:
            login(request,user)
            return redirect('dashboard')
        else:
            messages.error(request, "email and password is incorrect", extra_tags="alert alert-warning alert-dismissible show")
            return redirect('login')


@login_required
def home_page(request):
    if request.user.is_superuser:
        return HttpResponse('Superuser is not authorize to view dashboard')
    
    user = request.user
    organisation = user.organisation
    employee = User_Profile.objects.get(id=user.id)
    print(organisation)
    current_date = datetime.date.today()
    year = current_date.year
    employees = User_Profile.objects.filter(organisation=organisation, is_active = True)
    leaves = Leave.objects.filter(Q(user__organisation=organisation) & Q(status__icontains='pending'))
    emp_leaves = Leave.objects.filter(Q(user=user))
    employees_birthday = employees.filter(Q(date_of_birth__month = current_date.month) & Q(organisation=organisation))
    staff_leaves = Leave.objects.filter(user = user)
    accounting = employees.filter(Q(Q(organisation=organisation ) & Q(department__name__icontains="Accounting")))
    engineering = employees.filter(Q(Q(organisation=organisation ) & Q(department__name__icontains="Engineering")))
    it = employees.filter(Q(Q(organisation=organisation ) & Q(department__name__icontains="IT")))
    legal = employees.filter(Q(Q(organisation=organisation ) & Q(department__name__icontains="Legal")))
    marketing = employees.filter(Q(Q(organisation=organisation ) & Q(department__name__icontains="Marketing")))
    sales = employees.filter(Q(Q(organisation=organisation ) & Q(department__name__icontains="Sales")))
    upcoming_holidays = Holiday.objects.filter(Q(user__organisation=organisation) & Q(holiday_date__gt=current_date)).order_by('holiday_date')
    upcoming_holidays = upcoming_holidays[:3]
    print(upcoming_holidays)
    current_month = current_date.month  # e.g., 9 (September)
    current_day = current_date.day   
    upcoming_birthdays = employees.filter(Q(organisation=organisation)).annotate(
            birth_month=ExtractMonth('date_of_birth'),
            birth_day=ExtractDay('date_of_birth')
        ).filter(
            Q(birth_month__gt=current_month) |
            Q(birth_month=current_month, birth_day__gt=current_day)
        )
    upcoming_birthdays = upcoming_birthdays[:3]
    upcoming_leaves = Leave.objects.filter(Q(user__organisation=organisation) & Q(status__icontains='approved') & Q(startdate__gt=current_date))
    print(upcoming_birthdays)
    approved_leaves = Leave.objects.filter(Q(user=request.user) & Q(status__icontains='approved')).count()
    half_day = Leave.objects.filter(Q(user=request.user) & Q(status__icontains='approved') & Q(leavetype='half day')).count()
    half_day = half_day * 0.5
    total_approved = approved_leaves - half_day
    pending_leaves = Leave.objects.filter(Q(user=request.user) & Q(status__icontains='pending')).count()
    remaining_leaves = 30 - total_approved
    context = {'employee':employee,'employees':employees,'leaves':leaves,'staff_leaves':staff_leaves, 
              'accounting':accounting,'engineering':engineering,'it':it,'legal':legal,'marketing':marketing,
               'sales':sales, 'employees_birthday':employees_birthday,'organisation':organisation,'emp_leaves':emp_leaves,'upcoming_holidays':
               upcoming_holidays,'upcoming_birthdays':upcoming_birthdays,'room_name': "HRMS",
               'upcoming_leaves':upcoming_leaves,'year':year,'approved_leaves':approved_leaves,'pending_leaves':pending_leaves,
               'remaining_leaves':remaining_leaves}
    return render(request, 'myapp/dashboard.html', context)

def user_logout(request):
    logout(request)
    return redirect('login')

def send_email(email, name, organisation,link):
    subject = 'One time Login link of our organisation'
    message = f'{name} You are added in our {organisation}, you can login {link} and this is one time login link after login you change your password'
    from_email = settings.EMAIL_HOST_USER
    recipient_list = [email]

    send_mail(subject, message, from_email, recipient_list)

@login_required
@allowd_users(allowd_roles=['Organisation Admin'])
def add_employee(request):
    user = request.user
    employee = User_Profile.objects.get(id=user.id)
    form = AddEmployeeForm()
    
    managers = User_Profile.objects.filter(Q(organisation=employee.organisation) & Q(groups__name__icontains='Manager'))
    form.fields['manager'].queryset = managers
    hrs = User_Profile.objects.filter(Q(organisation=employee.organisation) & Q(groups__name__icontains='HR'))
    form.fields['hr'].queryset = hrs
    team_leaders = User_Profile.objects.filter(Q(organisation=employee.organisation) & Q(groups__name__icontains='Team Leader'))
    form.fields['team_leader'].queryset = team_leaders
    groups = Group.objects.all()
    title = "Add Employee"
    if request.method == 'POST':
        form = AddEmployeeForm(request.POST, request.FILES)
        employee_id = request.POST.get('employee_id')
        email = request.POST.get('email')
        emp_image = request.FILES.get('image')
        
        check = request.POST.get('send_email',False)
        group = request.POST.get('role',None)
        if form.is_valid():
            user = form.save()
            group = Group.objects.filter(id=group).first()
            organisation = request.user.organisation
            user.groups.add(group)
            user.organisation = organisation
            user.profile_pic = emp_image
            user.save()
            msg = f"{user.full_name} is join in our company"
            Notification.objects.create(organisation=organisation,message=msg,notification_users='all',employee='employee')
            if check:
                token_generator = PasswordResetTokenGenerator()
                token = token_generator.make_token(user)
                uid = urlsafe_base64_encode(force_bytes(user.id))
                login_link = f'https://{request.get_host()}/password-reset-confirm/{uid}/{token}/'

                send_email(user.email,user.full_name,organisation,login_link)
            messages.success(request, f"Employee {user.full_name} Created Successfully !!",extra_tags = 'alert alert-success alert-dismissible show' )
            return redirect("add_documents")
        else:
            messages.error(request, "Something went wrong, Please correct below warnings !!",extra_tags = 'alert alert-warning alert-dismissible show' )
            managers = User_Profile.objects.filter(Q(organisation=employee.organisation) & Q(groups__name__icontains='Manager'))
            form.fields['manager'].queryset = managers
            hrs = User_Profile.objects.filter(Q(organisation=employee.organisation) & Q(groups__name__icontains='HR'))
            form.fields['hr'].queryset = hrs
            team_leaders = User_Profile.objects.filter(Q(organisation=employee.organisation) & Q(groups__name__icontains='Team Leader'))
            form.fields['team_leader'].queryset = team_leaders
            return render(request, 'myapp/add_people1.html',{'form':form,'groups':groups,'title':title,'employee':employee,'organisation':user.organisation,'managers':managers,'hrs':hrs,'team_leaders':team_leaders})
    
    
    return render(request, 'myapp/add_people1.html',{'form':form,'groups':groups,'title':title,'employee':employee,'organisation':user.organisation,'managers':managers,'hrs':hrs,'team_leaders':team_leaders})

@login_required
def all_employee(request):
    user = request.user
    organisation = user.organisation
    # print(organisation)
    employee = User_Profile.objects.get(id=user.id)
    employees = User_Profile.objects.filter(Q(Q(organisation=organisation ) & Q(is_active=True)) )
    
    paginator = Paginator(employees, 9)
    page_number = request.GET.get('page')
    page_obj = paginator.get_page(page_number)
    print(page_obj)
    title = "All Employee"
    last_page = page_obj.paginator.num_pages
    page_list = [i+1 for i in range(last_page)]
    return render(request, "myapp/all_employee1.html", {'employees':page_obj,'title':title,'employee':employee,'last_page':last_page,'page_list':page_list})



@login_required
def employee_detail(request, id):
    user_employee = User_Profile.objects.get(id=id)
    print(user_employee)
    leave = Leave.objects.filter(user=user_employee.id)
    bank = Bank.objects.filter(employee=user_employee.id)
    
    user_group = user_employee.groups.all()
    user = request.user
    employee = User_Profile.objects.get(id=user.id)
    title = "Employee Details"
    equipments = Handbook.objects.filter(employee__id=id)
    if equipments:
        equipments = equipments[0]
    education = education_certeficates.objects.filter(employee__id=id)  
    employement = employement_certeficates.objects.filter(employee__id=id)
    description = job_description.objects.filter(employee=user_employee)
    if description:
        description = description[0]
    agreement_docs = company_agreements.objects.filter(Q(employee__groups__name="Organisation Admin") & Q(employee__organisation=employee.organisation))
    if agreement_docs:
        agreement_docs = agreement_docs[0]
    employee_agreement = employee_agreements.objects.filter(employee=user_employee)
    if employee_agreement:
        employee_agreement = employee_agreement[0]
    context = {'user_employee':user_employee,'title':title,'user_group':user_group,'leave':leave,'employee':employee,'bank':bank,
            'equipments':equipments,'education':education,'employement':employement,'description':description,
            'agreement_docs':agreement_docs,'employee_agreement':employee_agreement}
    return render(request, 'myapp/employee_detail1.html',context )


@login_required
def edit_employee(request, id):
    user = request.user
    employee = User_Profile.objects.get(id=user.id)
    pi = User_Profile.objects.get(pk=id)
    fm = CustomUserChangeForm(instance=pi)
    managers = User_Profile.objects.filter(Q(organisation=employee.organisation) & Q(groups__name__icontains='Manager') & Q(is_active = True))
    fm.fields['manager'].queryset = managers
    hrs = User_Profile.objects.filter(Q(organisation=employee.organisation) & Q(groups__name__icontains='HR') & Q(is_active = True))
    fm.fields['hr'].queryset = hrs
    team_leaders = User_Profile.objects.filter(Q(organisation=employee.organisation) & Q(groups__name__icontains='Team Leader') & Q(is_active = True))
    fm.fields['team_leader'].queryset = team_leaders 
    departments = Department.objects.all()
    fm.fields['department'].queryset = departments 
    if request.method == 'POST':
        emp_image = request.FILES.get('image')
        pi = User_Profile.objects.get(pk=id)
        fm = CustomUserChangeForm(request.POST, request.FILES, instance=pi)
        if fm.is_valid():
            select_group = fm.cleaned_data['groups']
            print(select_group)
            for i in select_group:
                print(i)
                pi.groups.add(i.id)
            data = fm.save()
            if emp_image:
                data.profile_pic = emp_image
                data.save()
            messages.success(request, f'Employee {data.full_name} Updated Successfully !!!', extra_tags='alert alert-success alert-dismissible show')
            return redirect('edit_employee', id=id)
        else:
            messages.error(request, f'Something went wrong, Please check below warnings !!!', extra_tags='alert alert-warning alert-dismissible show')
            managers = User_Profile.objects.filter(Q(organisation=employee.organisation) & Q(groups__name__icontains='Manager') & Q(is_active = True))
            fm.fields['manager'].queryset = managers
            hrs = User_Profile.objects.filter(Q(organisation=employee.organisation) & Q(groups__name__icontains='HR') & Q(is_active = True))
            fm.fields['hr'].queryset = hrs
            team_leaders = User_Profile.objects.filter(Q(organisation=employee.organisation) & Q(groups__name__icontains='Team Leader') & Q(is_active = True))
            fm.fields['team_leader'].queryset = team_leaders 
            fm.fields['department'].queryset = departments 
            return render(request, 'myapp/employee_edit1.html', {'form': fm, 'employee': employee, 'organisation': user.organisation,'room_name': "HRMS"})

    return render(request, 'myapp/employee_edit1.html', {'form': fm, 'employee': employee, 'organisation': user.organisation,'room_name': "HRMS"})

@login_required
@allowd_users(allowd_roles=['HR','Organisation Admin'])
def add_documents(request):
    if request.method == 'POST':
            # form = DocumentsForm(request.POST,request.FILES)
            emp = request.POST['employee']
            if not emp:
                messages.error(request, "Please select an employee before submitting!")
                return redirect("add_documents")
            education = request.FILES.getlist('education')
            employement = request.FILES.getlist('employement') 
            credit = request.FILES.getlist('credit')  
            id_document = request.FILES.getlist('id_document')  
            criminal = request.FILES.getlist('criminal')    
            emp_obj = get_object_or_404(User_Profile,pk=emp)
            for i in education:

                obj = education_certeficates(employee=emp_obj,education=i,title=i.name)
                obj.save()
            for i in employement:

                obj = employement_certeficates(employee=emp_obj,employement=i,title=i.name)
                obj.save()
            for i in credit:

                obj = credit_documents(employee=emp_obj,credit=i,title=i.name)
                obj.save()
            for i in id_document:

                obj = id_documents(employee=emp_obj,id_document=i,title=i.name)
                obj.save()
            for i in criminal:

                obj = criminal_documents(employee=emp_obj,criminal=i,title=i.name)
                obj.save()
            messages.success(request, f'Documents of {emp_obj.full_name} Added Successfully !!', extra_tags = 'alert alert-success alert-dismissible show')
            return redirect("add_documents")
            
    # form = DocumentsForm()
    user = request.user
    employee = User_Profile.objects.get(id=user.id)
    employees = User_Profile.objects.filter(organisation=employee.organisation, is_active=True)
    return render(request, 'myapp/add_documents.html', {'employee':employee,'title':"Add Documents",'employees':employees})   

@login_required
def background_verification(request,emp_id):
    employee = User_Profile.objects.get(id=request.user.id)
    emp_obj = User_Profile.objects.get(id=emp_id)
    employement_doc = employement_certeficates.objects.filter(employee=emp_obj).first()
    education_doc = education_certeficates.objects.filter(employee=emp_obj).first()
    id_document = id_documents.objects.filter(employee=emp_obj).first()
    criminal_document = criminal_documents.objects.filter(employee=emp_obj).first()
    credit_document = credit_documents.objects.filter(employee=emp_obj).first()
    emp_verification = background_check.objects.filter(Q(employee=emp_obj) & Q(employement_check=True) & Q(education_check=True) & Q(id_check=True) & Q(crminal_check=True) & Q(credit_check=True)).first()
    context = {'title':'Background Checks','employee':employee,'emp_obj':emp_obj,'employement_doc':employement_doc,
               'education_doc':education_doc,'id_document':id_document,'criminal_document':criminal_document,
               'credit_document':credit_document,'emp_verification':emp_verification}
    if request.method == 'POST':
        employement = request.POST.get('employement')
        employement_check = True if request.POST.get('employement_check') == 'on' else False
        print(employement_check)
        education = request.POST.get('education')
        education_check = True if request.POST.get('education_check') == 'on' else False
        id_document = request.POST.get('id_document')
        id_check = True if request.POST.get('id_check') == 'on' else False
        criminal_document = request.POST.get('criminal_document')
        criminal_check = True if request.POST.get('criminal_check') == 'on' else False
        credit_document = request.POST.get('credit_document')
        credit_check = True if request.POST.get('credit_check') == 'on' else False
        
        obj = background_check(employee=emp_obj,employement=employement,employement_check=employement_check,
                               education=education,education_check=education_check,id_documents=id_document,
                               id_check=id_check,criminal_background=criminal_document,crminal_check=criminal_check,
                               credit=credit_document,credit_check=credit_check)
        obj.save()
        return redirect('background_check', emp_id=emp_id)
    
    return render(request, 'myapp/background_check.html',context=context)

@login_required    
def employee_background_status(request):
    employee = User_Profile.objects.get(id=request.user.id)
    context = {'employee':employee,'title':'All Employee Background Status'}
    data = []
    employees = User_Profile.objects.filter(organisation=employee.organisation, is_active = True)
    for i in employees:
        emp_verification = background_check.objects.filter(Q(employee=i) & Q(employement_check=True) & Q(education_check=True) & Q(id_check=True) & Q(crminal_check=True) & Q(credit_check=True))
        if emp_verification:
            data.append({'employee':i.full_name,'id':i.id,'status':'Done'})
        else:
            data.append({'employee':i.full_name,'id':i.id,'status':'Pending'})
    context = {'employee':employee,'title':'All Employee Background Status','data':data}   
    return render(request,'myapp/employee_background_status.html', context=context)

@login_required
@allowd_users(allowd_roles=['Organisation Admin'])
def add_job_description(request):
    employee = User_Profile.objects.get(id=request.user.id)
    form = JobDescriptionForm()
    employees = User_Profile.objects.filter(organisation=employee.organisation, is_active = True)
    form.fields['employee'].queryset = employees
    context = {'employee':employee,'title':'Add Job Description of Employee','form':form,'button_name':'Add'}
    if request.method == 'POST':
        form = JobDescriptionForm(data=request.POST)
        if form.is_valid():
            obj = form.save()
            messages.success(request, f"Job description of {obj.employee.full_name} added successfully !!", extra_tags="alert alert-success alert-dismissible show")
            return redirect('employee_detail', id=obj.employee.id)
        else:
            form.fields['employee'].queryset = employees
            context = {'employee':employee,'title':'Add Job Description of Employee','form':form,'button_name':'Add'}
            messages.error(request, f"Something went wrong, Please check below", extra_tags="alert alert-warning alert-dismissible show")
            return render(request, 'myapp/add_job_description.html',context=context)

    return render(request, 'myapp/add_job_description.html',context=context)

@login_required
@allowd_users(allowd_roles=['Organisation Admin'])
def edit_job_description(request,id):
    employee = User_Profile.objects.get(id=request.user.id)
    instance = job_description.objects.get(id=id)
    form = JobDescriptionForm(instance=instance)
    employees = User_Profile.objects.filter(organisation=employee.organisation)
    form.fields['employee'].queryset = employees
    title = f"Edit Job Description of {instance.employee.full_name}"
    context = {'employee':employee,'form':form,'title':title,'button_name':'Update'}
    if request.method == 'POST':
        form = JobDescriptionForm(request.POST,instance=instance)
        if form.is_valid():
            obj = form.save()
            messages.success(request, f"Job description of {obj.employee.full_name} updated successfully !!", extra_tags="alert alert-success alert-dismissible show")
            return redirect('employee_detail', id=obj.employee.id)
        else:
            form.fields['employee'].queryset = employees
            context = {'employee':employee,'title':title,'form':form,'button_name':'Update'}
            messages.error(request, f"Something went wrong, Please check below", extra_tags="alert alert-warning alert-dismissible show")
            return render(request, 'myapp/add_job_description.html',context=context)

    return render(request, 'myapp/add_job_description.html',context=context)


def delete_employee(request, id):
    emp = User_Profile.objects.get(id=id)
    emp.is_active = False
    emp.save()
    messages.success(request, f"Employee {emp.full_name} Deleted Successfully", extra_tags='alert alert-success alert-dismissible show')
    return redirect('all_employee')

@login_required
@allowd_users(allowd_roles=['Organisation Admin'])
def delete_employee_confirmation(request,id):
    employee = User_Profile.objects.get(id=request.user.id)
    emp = User_Profile.objects.get(id=id)
    return render(request, 'myapp/delete_employee_confirmation.html', {'id':id,'employee':employee,'emp':emp})   

@login_required
@allowd_users(allowd_roles=['Organisation Admin'])
def delete_employee_cancel(request):
    return redirect('all_employee')  

@login_required
def changepassword(request):
	if request.method == 'POST':
		form = ChangePasswordForm(request.user, request.POST)
		if form.is_valid():
			user = form.save(commit=True)
			update_session_auth_hash(request,user)

			messages.success(request,'Password changed successfully',extra_tags = 'alert alert-success alert-dismissible show' )
			return redirect('change_password')
		else:
			messages.error(request,'New password & confirm new password are not matched !!',extra_tags = 'alert alert-warning alert-dismissible show' )
			return redirect('change_password')
	else:
              form = ChangePasswordForm(request.user)
              employee = User_Profile.objects.get(id=request.user.id)
              title = "Change Password"
              return render(request, 'myapp/change_password.html', {'form':form, 'employee':employee,'organisation':employee.organisation,'title':title})

def leave_email(data):
    subject = 'Employee apply for leave'
    message = f"{data['name']} requested for holidays please approved or reject"
    from_email = settings.EMAIL_HOST_USER
    recipient_list = data['email']

    send_mail(subject, message, from_email, recipient_list)

def leave_creation(request):
    
    if request.user.is_authenticated:
		    
	
        if request.method == 'POST':
            form = LeaveCreationForm(data = request.POST)
            if form.is_valid():
                startdate = form.cleaned_data['startdate']
                enddate = form.cleaned_data['enddate']
                leave_days = (enddate - startdate).days
                instance = form.save(commit = False)
                user = request.user
                emp = User_Profile.objects.get(pk=user.id)
                hr = None
                if emp.hr:
                   hr = User_Profile.objects.get(pk=emp.hr.id)
                current_month = timezone.now().month
                leaves_taken_this_month = Leave.objects.filter(id=user.id,startdate__month=current_month, is_paid=True).count() + leave_days
                max_leaves_per_month = 3
                admin_email = User_Profile.objects.filter(Q(groups__name='Organisation Admin') & Q(organisation=user.organisation)).first()
                emails = []
                if admin_email and admin_email.email:
                    emails.append(admin_email.email)
                if hr and hr.email:
                    emails.append(hr.email)
                data = {'name':user.full_name,'email':emails}
                if leaves_taken_this_month <= max_leaves_per_month:
                    instance.user = user
                    instance.is_paid = True
                    instance.save()
                    msg = f"{user.full_name} has appliad for a leave"
                    obj = Notification(message=msg)
                    obj.user = hr
                    obj.leave = instance.id
                    obj.save()
                    
                    messages.success(request,'Leave Request Sent,wait for Organisation Admin response',extra_tags = 'alert alert-success alert-dismissible show')
                    return redirect('create_leave')

                else:
                    instance.user = user
                    instance.save()
                    msg = f"{user.full_name} has appliad for a leave"
                    obj = Notification(message=msg)
                    obj.user = hr
                    obj.leave = instance.id
                    obj.save() 
                    leave_email(data)  
                    messages.error(request,'Leave Request Sent,wait for Organisation Admin response',extra_tags = 'alert alert-success alert-dismissible show')
                    return redirect('create_leave')

                    
                # print(instance.defaultdays)
                
            else:
                messages.error(request,'failed to Request a Leave,please check entry dates',extra_tags = 'alert alert-warning alert-dismissible show')
                return redirect('create_leave')

        
        dataset = dict()
        form = LeaveCreationForm()
        user = request.user
        employee = User_Profile.objects.get(id=user.id)
        dataset['form'] = form
        dataset['title'] = 'Apply for Leave'
        dataset['employee'] = employee
        return render(request,'myapp/create_leave1.html',dataset)
    else:
         return redirect('login')


@login_required
@allowd_users(allowd_roles=['HR','Organisation Admin'])
def leaves_list(request):
    employee = User_Profile.objects.get(id=request.user.id)
    organisation = employee.organisation
    if request.method == 'POST':
        leave_type = request.POST['leave']
        print(leave_type)
        data = Leave.objects.filter(Q(status=leave_type) & Q(user__organisation=organisation) & Q(user__is_active=True))
        print(data)
        return render(request,'myapp/pending_leaves.html', {'employee':employee,'leave_list':data,'title': 'All Leaves',})
    
    
    leaves = Leave.objects.filter(Q(user__organisation=organisation) & Q(user__is_active = True))
    paginator = Paginator(leaves, 10)
    page_number = request.GET.get('page')
    page_obj = paginator.get_page(page_number)
    print(page_obj)
    
    last_page = page_obj.paginator.num_pages
    page_list = [i+1 for i in range(last_page)]
    
    return render(request, 'myapp/pending_leaves.html', {'employee':employee,'leave_list': page_obj, 'title': 'Leaves List - Pending','last_page':last_page,'page_list':page_list})



@login_required
@allowd_users(allowd_roles=['Manager'])
def approved_leaves(request):
    
    employee = User_Profile.objects.get(id=request.user.id)
    organisation = employee.organisation
    leaves = Leave.objects.filter(Q(user__manager=employee) & Q(status__icontains='approved') & Q(user__is_active = True))
    paginator = Paginator(leaves, 10)
    page_number = request.GET.get('page')
    page_obj = paginator.get_page(page_number)
    print(page_obj)
    
    last_page = page_obj.paginator.num_pages
    page_list = [i+1 for i in range(last_page)]
    
    data = {'employee':employee,'leave_list': page_obj, 'title': 'leaves list - pending','last_page':last_page,
            'page_list':page_list, 'leave_count': leaves.count}
    return render(request, 'myapp/approve_leaves.html', context=data)


@login_required
def leaves_view(request,id):
	if not (request.user.is_authenticated):
		return redirect('/')

	leave = get_object_or_404(Leave, id = id)
	employee1 = User_Profile.objects.filter(id = leave.user.id)[0]
	employee = request.user
	return render(request,'myapp/leave_detail.html',{'leave':leave,'employee1':employee1,'employee':employee,'title':'{0}-{1} leave'.format(leave.user.full_name,leave.status)})


@login_required
@allowd_users(allowd_roles=['HR','Organisation Admin'])
def approve_leave(request,id):
	
        leave = get_object_or_404(Leave, id = id)
        user_id= leave.user.id
        employee = User_Profile.objects.filter(id = user_id)[0]
        remaining_leaves = employee.leave_in_year
        print(remaining_leaves)
        remaining_leaves = remaining_leaves - leave.leave_days
        print(remaining_leaves)
        employee.leave_in_year = remaining_leaves
        employee.save()
        leave.approve_leave
        message = f'{employee.full_name} your leave from {leave.startdate} to {leave.enddate} is Approved'
        obj = Notification(message=message)
        obj.user = employee
        obj.save()
        data = {'name':employee.full_name,'startdate':leave.startdate,'enddate':leave.enddate,'email':[employee.email]}
        
        # channel_layer = get_channel_layer()
        # # print(channel_layer)
        # data = {'message':f'{employee.full_name} your leave from {leave.startdate} to {leave.enddate} is Approved'}
        # async_to_sync(channel_layer.group_send)(
        # "notification_HRMS",
        # {
        #     'type': 'send_notification',
        #     'message': f'{employee.full_name} your leave from {leave.startdate} to {leave.enddate} is Approved'
        # }
        # )
        messages.success(request,'Leave successfully approved of {0}'.format(employee.full_name),extra_tags = 'alert alert-success alert-dismissible show')
        return redirect('leaves_detail', id = id)
        # return HttpResponse('sent')

from django.utils.timesince import timesince

def notifications(request):
    
    notifications = Notification.objects.filter( Q(Q(organisation=request.user.organisation) & Q(notification_users = 'all')) | Q(user=request.user) ).order_by('-id')[:6]
    
    notifStatus = False
    total_unread = 0
    json_data = []
    roles = ['HR']
    groups = request.user.groups.all()
    list1 = [i.name for i in groups if i.name in roles]
    if list1:
        
        for d in notifications:
            try:
                notif_status = mark_read_notifications.objects.get(user=request.user,notif=d)
                if notif_status:
                    notifStatus = True
            except mark_read_notifications.DoesNotExist:
                notifStatus = False
            if not notifStatus:
                total_unread = total_unread + 1
            now = timezone.now()
                # Calculate the time difference between now and the value
            diff = now - d.created
            time = d.created.strftime('%Y-%m-%d')
                # If the difference is less than 1 hour, display in minutes ago
            if now - d.created > timedelta(days=1):
                time = d.created.strftime('%Y-%m-%d')
                
            elif now - d.created > timedelta(hours=1):
                timesince(d.created)
            else:
                minutes = int((now - d.created).total_seconds() / 60)
                time = f"{minutes} minute{'s' if minutes > 1 else ''} ago"
            json_data.append({
                'id':d.id,
                'notify_detail':d.message,
                'notifStatus':notifStatus,
                'notification_users':d.notification_users,
                'leave':d.leave,
                'time':time,
                'policy':d.policy,
                'training':d.training,
                'employee':d.employee
            })
        
        return JsonResponse({"data":json_data,'total_unread':total_unread,'role':'hr'})
    
    for d in notifications:
        print(d.created)
        try:
            notif_status = mark_read_notifications.objects.get(user=request.user,notif=d)
            if notif_status:
                notifStatus = True
        except mark_read_notifications.DoesNotExist:
            notifStatus = False
        if not notifStatus:
            total_unread = total_unread + 1
        now = timezone.now()
                # Calculate the time difference between now and the value
        diff = now - d.created
        # print(diff)
        time = d.created.strftime('%Y-%m-%d')
                # If the difference is less than 1 hour, display in minutes ago
        if now - d.created > timedelta(days=1):
            time = d.created.strftime('%Y-%m-%d')
            print(time)    
        elif now - d.created > timedelta(hours=1):
            time = timesince(d.created)
            print(time)
            time = f'{time} ago'
        else:
            minutes = int((now - d.created).total_seconds() / 60)
            time = f"{minutes} minute{'s' if minutes > 1 else ''} ago"
            print(time)
        
        json_data.append({
            'id':d.id,
            'notify_detail':d.message,
            'notifStatus':notifStatus,
            'notification_users':d.notification_users,
            'time':time,
            'policy':d.policy,
            'training':d.training,
            'employee':d.employee
        })
    
    # json_data.append({'total_unread':total_unread})
    return JsonResponse({"data":json_data,'total_unread':total_unread,'role':'employee'})

def all_notifications(request):
    employee = get_object_or_404(User_Profile,id=request.user.id)
    return render(request, 'myapp/all_notifications.html',{'employee':employee,'title':'All Notifications'})

def show_notifications(request):
    print('call')
    notifications = Notification.objects.filter( Q(Q(organisation=request.user.organisation) & Q(notification_users = 'all')) | Q(user=request.user) ).order_by('-id')
    
    notifStatus = False
    total_unread = 0
    json_data = []
    roles = ['HR']
    groups = request.user.groups.all()
    list1 = [i.name for i in groups if i.name in roles]
    if list1:
        
        for d in notifications:
            try:
                notif_status = mark_read_notifications.objects.get(user=request.user,notif=d)
                if notif_status:
                    notifStatus = True
            except mark_read_notifications.DoesNotExist:
                notifStatus = False
            if not notifStatus:
                total_unread = total_unread + 1
            now = timezone.now()
                # Calculate the time difference between now and the value
            diff = now - d.created
            time = d.created.strftime('%Y-%m-%d')
                # If the difference is less than 1 hour, display in minutes ago
            if now - d.created > timedelta(days=1):
                time = d.created.strftime('%Y-%m-%d')
                
            elif now - d.created > timedelta(hours=1):
                timesince(d.created)
            else:
                minutes = int((now - d.created).total_seconds() / 60)
                time = f"{minutes} minute{'s' if minutes > 1 else ''} ago"
            json_data.append({
                'id':d.id,
                'notify_detail':d.message,
                'notifStatus':notifStatus,
                'notification_users':d.notification_users,
                'leave':d.leave,
                'time':time,
                'policy':d.policy,
                'training':d.training,
                'employee':d.employee
            })
        
        return JsonResponse({"data":json_data,'total_unread':total_unread,'role':'hr'})
    
    for d in notifications:
        print(d.created)
        try:
            notif_status = mark_read_notifications.objects.get(user=request.user,notif=d)
            if notif_status:
                notifStatus = True
        except mark_read_notifications.DoesNotExist:
            notifStatus = False
        if not notifStatus:
            total_unread = total_unread + 1
        now = timezone.now()
                # Calculate the time difference between now and the value
        diff = now - d.created
        # print(diff)
        time = d.created.strftime('%Y-%m-%d')
                # If the difference is less than 1 hour, display in minutes ago
        if now - d.created > timedelta(days=1):
            time = d.created.strftime('%Y-%m-%d')
            print(time)    
        elif now - d.created > timedelta(hours=1):
            time = timesince(d.created)
            print(time)
            time = f'{time} ago'
        else:
            minutes = int((now - d.created).total_seconds() / 60)
            time = f"{minutes} minute{'s' if minutes > 1 else ''} ago"
            print(time)
        
        json_data.append({
            'id':d.id,
            'notify_detail':d.message,
            'notifStatus':notifStatus,
            'notification_users':d.notification_users,
            'time':time,
            'policy':d.policy,
            'training':d.training,
            'employee':d.employee
        })
    print(json_data)

    return JsonResponse({"data":json_data,'total_unread':total_unread,'role':'employee'})

def mark_read_notify(request):
    notify_id = request.GET['notify_id']
    obj = Notification.objects.get(id=notify_id)
    emp = User_Profile.objects.get(pk=request.user.id)
    notif_data = mark_read_notifications.objects.filter(Q(notif=obj) & Q(user=request.user) & Q(status=True))
    print(notif_data)
    if not notif_data:

        mark_read_notifications.objects.create(notif=obj, user=emp, status=True)
    return JsonResponse({"msg":True})

@login_required
@allowd_users(allowd_roles=['HR'])
def unapprove_leave(request,id):
        leave = get_object_or_404(Leave, id = id)
        user_id= leave.user.id
        employee = User_Profile.objects.filter(id = user_id)[0]
        remaining_leaves = employee.leave_in_year
        print(remaining_leaves)
        remaining_leaves = remaining_leaves + leave.leave_days
        print(remaining_leaves)
        employee.leave_in_year = remaining_leaves
        employee.save()
        leave.unapprove_leave
        message = f'{employee.full_name} your leave from {leave.startdate} to {leave.enddate} is not Approved'
        obj = Notification(message=message)
        obj.user = employee
        obj.save()
        messages.success(request,'Leave successfully unapproved of {0}'.format(employee.full_name),extra_tags = 'alert alert-success alert-dismissible show')
        return redirect('leaves_list') #redirect to unapproved list



@login_required
@allowd_users(allowd_roles=['Organisation Admin'])
def reject_leave(request,id):
        leave = get_object_or_404(Leave, id = id)
        user_id= leave.user.id
        employee = User_Profile.objects.filter(id = user_id)[0]
        remaining_leaves = employee.leave_in_year
        print(remaining_leaves)
        remaining_leaves = remaining_leaves + leave.leave_days
        print(remaining_leaves)
        employee.leave_in_year = remaining_leaves
        employee.save()
        leave.reject_leave
        message = f'{employee.full_name} your leave from {leave.startdate} to {leave.enddate} is Rejected'
        obj = Notification(message=message)
        obj.user = employee
        obj.save()
        data = {'name':employee.full_name,'startdate':leave.startdate,'enddate':leave.enddate,'email':[employee.email]}
        
        messages.success(request,'Leave Successfully Rejected of {0}'.format(employee.full_name),extra_tags = 'alert alert-success alert-dismissible show')
        return redirect('leaves_list')

@login_required
def view_my_leave_table(request):
	# work on the logics
	
        user = request.user
        leaves = Leave.objects.filter(user = user)
        employee = User_Profile.objects.filter(id=user.id).first()
        print(leaves)
        paginator = Paginator(leaves, 10)
        page_number = request.GET.get('page')
        page_obj = paginator.get_page(page_number)
        print(page_obj)
        
        last_page = page_obj.paginator.num_pages
        page_list = [i+1 for i in range(last_page)]
        dataset = dict()
        dataset['leave_list'] = page_obj
        dataset['employee'] = employee
        dataset['title'] = 'Leaves List'
        dataset['last_page'] = last_page
        dataset['page_list'] = page_list
        return render(request,'myapp/employee_leave.html',dataset)

@login_required
@allowd_users(allowd_roles=['Organisation Admin'])
def add_holiday(request):
    if 'Organisation Admin' in request.user.groups.all()[0].name:
        if request.method == 'POST':
            form = HolidayForm(request.POST)
            if form.is_valid():
                instance = form.save()
                instance.user = request.user
                instance.save()
                messages.success(request, 'Holiday Added Successfully !!', extra_tags = 'alert alert-success alert-dismissible show')
        form = HolidayForm()
        user = request.user
        employee = User_Profile.objects.get(id=user.id)
        return render(request, 'myapp/add_holiday1.html', {'form':form,'employee':employee,'organisation':employee.organisation,'title':"Add Holiday"})   
    else:
        return HttpResponse("Your are not authorize to view this page")

@login_required
def all_holiday(request):
     organisation = request.user.organisation
     year = timezone.now().year
     today = datetime.date.today()
     holidays = Holiday.objects.filter(user__organisation=organisation,holiday_date__gte=today).order_by('holiday_date')
     user = request.user
     employee = User_Profile.objects.get(id=user.id)
     title = f"All Holiday In {year}"
     paginator = Paginator(holidays, 8)
     page_number = request.GET.get('page')
     page_obj = paginator.get_page(page_number)
     print(page_obj)
        
     last_page = page_obj.paginator.num_pages
     page_list = [i+1 for i in range(last_page)]
     return render(request, 'myapp/all_holiday1.html', {'holidays':page_obj,'title':title,'year':year,'employee':employee,'last_page':last_page,'page_list': page_list})

@login_required
def past_holiday(request):
     organisation = request.user.organisation
     year = timezone.now().year
     today = datetime.date.today()
     holidays = Holiday.objects.filter(user__organisation=organisation,holiday_date__lt=today)
     user = request.user
     employee = User_Profile.objects.get(id=user.id)
     title = f"All Past Holiday of {year}"
     paginator = Paginator(holidays, 8)
     page_number = request.GET.get('page')
     page_obj = paginator.get_page(page_number)
     print(page_obj)
        
     last_page = page_obj.paginator.num_pages
     page_list = [i+1 for i in range(last_page)]
     return render(request, 'myapp/past_holiday.html', {'holidays':page_obj,'title':title,'year':year,'employee':employee,'last_page':last_page,'page_list': page_list})

@login_required
def new_employee(request):
    user = request.user
    organisation = user.organisation
    employee = User_Profile.objects.get(id=user.id)
    six_months_ago = dt.now() - relativedelta(months=6)  # Assuming a month is around 30 days
    print(six_months_ago)
    new_employees = User_Profile.objects.filter(Q(Q(date_join__gte=six_months_ago) & Q(organisation=organisation) & Q(groups__name="Employee") & Q(is_active=True)))
    paginator = Paginator(new_employees, 9)
    page_number = request.GET.get('page')
    page_obj = paginator.get_page(page_number)
    print(page_obj)
    
    last_page = page_obj.paginator.num_pages
    page_list = [i+1 for i in range(last_page)]
    title = "New Employee"

    return render(request, 'myapp/new_employee.html', {'employees':page_obj,'title':title,'employee':employee,'last_page':last_page,'page_list':page_list})


@login_required
def old_employee(request):
    user = request.user
    organisation = user.organisation
    employee = User_Profile.objects.get(id=user.id)
    
    old_employees = User_Profile.objects.filter(
        is_active=False,
        organisation=organisation
        
    ).distinct()
    print(old_employees)
    paginator = Paginator(old_employees, 9)
    page_number = request.GET.get('page')
    page_obj = paginator.get_page(page_number)
    print(page_obj)
    
    last_page = page_obj.paginator.num_pages
    page_list = [i+1 for i in range(last_page)]
    title = "Old Employee"
    return render(request, 'myapp/old_employee.html', {'new_employee':page_obj,'title':title,'employee':employee,'last_page':last_page,'page_list':page_list})

@login_required
@allowd_users(allowd_roles=['Organisation Admin'])
def bank_create(request):
    employee = User_Profile.objects.get(id=request.user.id)
    if request.method == 'POST':
        form = BankCreationForm(data=request.POST)
        if form.is_valid():
            instance = form.save()

            messages.success(request, 'Account Successfully Created for {0}'.format(instance.employee.full_name), extra_tags='alert alert-success alert-dismissible show')
            return redirect('bank_create')
        else:
            messages.error(request, 'Error Creating Account', extra_tags='alert alert-warning alert-dismissible show')
            return render(request, 'myapp/bank_create1.html', {'form':form,'employee':employee})

    dataset = dict()
    form = BankCreationForm()
    
    form.fields['employee'].queryset = User_Profile.objects.filter(Q(organisation__icontains=employee.organisation) & Q(is_active = True))
    employee = User_Profile.objects.get(id=request.user.id)
    dataset['employee']= employee
    dataset['form'] = form
    dataset['title'] = 'Account Creation Form'
    return render(request, 'myapp/bank_create1.html', dataset)

@login_required
@allowd_users(allowd_roles=['Organisation Admin'])
def bank_edit(request,id):
    employee = User_Profile.objects.get(id=request.user.id)
    if request.method == 'POST':
        pi = Bank.objects.get(pk=id)
        form = BankCreationForm(data=request.POST,instance=pi)
        if form.is_valid():
            instance = form.save()

            messages.success(request, 'Bank Details Successfully Update of {0}'.format(instance.employee.full_name), extra_tags='alert alert-success alert-dismissible show')
            return redirect('bank_edit', id=id)
        else:
            messages.error(request, 'Error In Updating Bank Details', extra_tags='alert alert-danger alert-dismissible show')
            return render(request, 'myapp/bank_edit1.html', {'form':form,'employee':employee})

    dataset = dict()
    pi = Bank.objects.get(id=id)
    form = BankCreationForm(instance=pi)
    
    form.fields['employee'].queryset = User_Profile.objects.filter(Q(organisation__icontains=employee.organisation) & Q(is_active = True))
    dataset['employee']= employee
    dataset['form'] = form
    dataset['organisation'] = employee.organisation
    dataset['title'] = 'Update Bank Details'
    return render(request, 'myapp/bank_edit1.html', dataset)

@login_required
def intern_employee(request):
    user = request.user
    organisation = user.organisation
    print()
    employee = User_Profile.objects.get(id=user.id)
    intern_employees = User_Profile.objects.filter(Q(employee_type="Intern") & Q(organisation__icontains=organisation) & Q(groups__name__icontains="Employee") & Q(is_active = True))
    paginator = Paginator(intern_employees, 9)
    page_number = request.GET.get('page')
    page_obj = paginator.get_page(page_number)
    print(page_obj)
    
    last_page = page_obj.paginator.num_pages
    page_list = [i+1 for i in range(last_page)]
    title = 'Intern Employee'
    return render(request, 'myapp/intern_employee.html', {'intern_employee':page_obj,'title':title,'employee':employee,'last_page':last_page,'page_list':page_list})

    
@login_required
@allowd_users(allowd_roles=['Organisation Admin'])
def salary_structure_create(request):
    dataset = dict()
    form = PayrollForm()
    employee = User_Profile.objects.get(id=request.user.id)
    form.fields['employee'].queryset = User_Profile.objects.filter(Q(organisation=employee.organisation) & Q(is_active = True))
    
    dataset['employee']= employee
    
    dataset['form'] = form
    dataset['title'] = 'Add Employee Salary'
    if request.method == 'POST':
        try:
            form = PayrollForm(request.POST)
        
            if form.is_valid():
                print('valid')
                instance = form.save()
                tax = 0
                per_day = int(instance.basic_salary)/int(instance.total_days)
                absent_days = int(instance.total_days) - int(instance.present_days)
                absent_money = per_day * int(absent_days)
                sal = per_day * int(instance.present_days)
                if instance.tax:
                    tax = int(instance.basic_salary) * (instance.tax/100)
                deduct = int(instance.pf)+int(instance.medical) + int(tax)
                addition = int(instance.convence) + int(instance.bonus)
                net_sal = sal - deduct + addition
                instance.net_salary = net_sal
                instance.save()
                bank = Bank.objects.filter(employee=instance.employee).first()
                template_path = 'myapp/payslip.html'
                context = {
                    'instance': instance,
                    'bank':bank,
                    'absent_money':absent_money,
                    'tax':tax
                }
                
                file_name = htmltopdf(template_path, context)
                instance.name = file_name
                instance.save()
                msg = f"{instance.employee.full_name} your salary of {instance.month} {instance.year} is added"
                Notification.objects.create(user=instance.employee,message=msg)
                slip_folder = os.path.join(settings.MEDIA_ROOT, 'salary_slip')
                file_path = os.path.join(slip_folder,file_name)
                with open(file_path, 'rb') as file:
                    instance.salary_slip.save(file_name, file, save=True)
                    pdf_content = file.read()
                    

                os.remove(file_path)            
                messages.success(request, f'Salary of {instance.employee.full_name} Added Successfully', extra_tags='alert alert-success alert-dismissible show')
                return redirect('show_salary_structure')
            else:
                messages.error(request, 'Error In Creating Salary of Employee', extra_tags='alert alert-warning alert-dismissible show')
                dataset['form'] = form
                return render(request, 'myapp/add_salary.html', dataset)

        except Exception as e:
            print("error in salary create",e)
            messages.error(request, e, extra_tags='alert alert-warning alert-dismissible show')
            return redirect('salary_structure_create')
    
    return render(request, 'myapp/add_salary.html', dataset)

@login_required
@allowd_users(allowd_roles=['Organisation Admin','HR'])
def show_salary_structure(request):
    if request.method == 'POST':
        employee = User_Profile.objects.get(id=request.user.id)
        query = request.POST['search']
        print(query)
        if query is not None:
            data = (Q(employee__username__icontains=query) | Q(employee__full_name__icontains=query) | Q(month__icontains=query) |
                    Q(year__icontains=query))
            structure = Payroll.objects.filter(data)
            
            return render(request, 'myapp/salary_table.html',{'data':structure,'employee':employee})
    user = request.user
    data = Payroll.objects.filter(employee__organisation=user.organisation)
    employee = User_Profile.objects.get(id=user.id)
    paginator = Paginator(data, 10)
    page_number = request.GET.get('page')
    page_obj = paginator.get_page(page_number)
    print(page_obj)
    title = "All Employee Salary"    
    last_page = page_obj.paginator.num_pages
    page_list = [i+1 for i in range(last_page)]
    return render(request, 'myapp/salary_table.html',{'data':page_obj,'title':title,'employee':employee,'last_page':last_page,'page_list': page_list})

@login_required
@allowd_users(allowd_roles=['Organisation Admin'])
def edit_salary(request,id):
    if request.method == 'POST':
        pi = get_object_or_404(Payroll, id=id)
        form = PayrollForm(data=request.POST, instance=pi)
        
        if form.is_valid():
            print('valid')
            instance = form.save()
            tax = 0
            per_day = int(instance.basic_salary)/int(instance.total_days)
            absent_days = int(instance.total_days) - int(instance.present_days)
            absent_money = per_day * int(absent_days)
            sal = per_day * int(instance.present_days)
            if instance.tax:
                tax = int(instance.basic_salary) * (instance.tax/100)
            deduct = int(instance.pf)+int(instance.medical) + int(tax)
            addition = int(instance.convence) + int(instance.bonus)
            net_sal = sal - deduct + addition
            instance.net_salary = net_sal
            instance.save() 
            bank = Bank.objects.filter(employee=instance.employee).first()
            template_path = 'myapp/payslip.html'
            context = {
                'instance': instance,
                'bank':bank,
                'absent_money':absent_money,
                'tax':tax
            }
            
            file_name = htmltopdf(template_path, context)
            old_slip_folder = os.path.join(settings.MEDIA_ROOT, 'salary slip')
            name = instance.name.replace("@","") 
            print(name)
            old_file_path = os.path.join(old_slip_folder,name)
            print(old_file_path)
            os.remove(old_file_path)
            print("old file remove")
            instance.name = file_name
            instance.save()
            
            slip_folder = os.path.join(settings.MEDIA_ROOT, 'salary_slip')
            file_path = os.path.join(slip_folder,file_name)
            with open(file_path, 'rb') as file:
                instance.salary_slip.save(file_name, file, save=True)
                pdf_content = file.read()
                

            os.remove(file_path)   
            messages.success(request, f'Salary of {instance.employee.full_name} Edited Successfully', extra_tags='alert alert-success alert-dismissible show')
            return redirect('edit_salary',id=id)
        else:
            messages.error(request, 'Error In Editing Salary of Employee', extra_tags='alert alert-warning alert-dismissible show')
            return redirect('edit_salary',id=id)

    dataset = dict()
    pi = get_object_or_404(Payroll, id=id)
    form = PayrollForm(instance=pi)
    employee = User_Profile.objects.get(id=request.user.id)
    form.fields['employee'].queryset = User_Profile.objects.filter(Q(organisation__icontains=employee.organisation) & Q(is_active = True))
    dataset['employee']= employee
    dataset['form'] = form
    dataset['title'] = 'Update Employee Salary'
    return render(request, 'myapp/salary_edit1.html', dataset)

@login_required
@allowd_users(allowd_roles=['Organisation Admin'])
def delete_salary(request,id):
    salary = get_object_or_404(Payroll, id=id)
    salary.delete()
    messages.success(request, f'Salary of {salary.employee.full_name} Deleted Successfully', extra_tags='alert alert-success alert-dismissible show')
    return redirect('show_salary_structure')

@login_required
@allowd_users(allowd_roles=['Organisation Admin'])
def delete_salary_confirmation(request,id):
    employee = User_Profile.objects.get(id=request.user.id)
    return render(request, 'myapp/delete_confirmation.html', {'id':id,'employee':employee})   

@login_required
@allowd_users(allowd_roles=['Organisation Admin'])
def delete_cancel(request):
    return redirect('show_salary_structure')  

@login_required
def download_pdf(request, id):
    salary = get_object_or_404(Payroll, id=id)
    with open(salary.salary_slip.path, 'rb') as f:
            response = HttpResponse(f.read(), content_type='application/pdf')
            response['Content-Disposition'] = 'inline; filename=' + salary.name
            return response

@login_required
def employee_salary(request):
    user = request.user
    data = Payroll.objects.filter(employee=user)
    employee = User_Profile.objects.get(id=user.id)
    title = "Salary Records"
    paginator = Paginator(data, 10)
    page_number = request.GET.get('page')
    page_obj = paginator.get_page(page_number)
    print(page_obj)
        
    last_page = page_obj.paginator.num_pages
    page_list = [i+1 for i in range(last_page)]
    return render(request, 'myapp/employee_salary.html',{'data':page_obj,'employee':employee,'title':title,'last_page': last_page,'page_list':page_list}) 


@login_required
@allowd_users(allowd_roles=['Organisation Admin'])
def create_project(request):
    user = request.user
    employees = User_Profile.objects.filter(Q(organisation=user.organisation) & Q(is_active = True))

    if request.method == 'POST':
        form = ProjectForm(request.POST)
        if form.is_valid():
            project = form.save()
            project.user = user
            project.save()
        messages.success(request, f'Project {project.project_name} Created Successfully', extra_tags='alert alert-success alert-dismissible show')
        return redirect('create_project')
            
    else:
        form = ProjectForm()
        form.fields['employees'].queryset = employees
        employee = User_Profile.objects.get(id=user.id)
    return render(request, 'myapp/create_project1.html', {'form':form,'employee':employee,'title':'Create Project','employees':employees})

@login_required
@allowd_users(allowd_roles=['Organisation Admin'])
def show_projects(request):
    user = request.user
    projects = Project.objects.filter(user=user)
    employee = User_Profile.objects.get(id=user.id)
    title = "Projects and Employees"
    paginator = Paginator(projects, 6)
    page_number = request.GET.get('page')
    page_obj = paginator.get_page(page_number)
    print(page_obj)
        
    last_page = page_obj.paginator.num_pages
    page_list = [i+1 for i in range(last_page)]
    context = {'projects':page_obj,'employee':employee,'organisation':user.organisation,'title':title,'last_page': last_page,'page_list':page_list}

    return render(request, 'myapp/show_projects1.html', context)

@login_required
def employee_project(request):
    if request.user.is_superuser:
        return HttpResponse("You are not authenticated to view this page")
    user = request.user
    projects = Project.objects.filter(employees=user)
    employee = User_Profile.objects.get(id=user.id)
    context = {'projects':projects, 'employee':employee,'title':"Employee Projects"}
    return render(request, 'myapp/employee_projects1.html', context)

@login_required
def check_in_out(request):
    if request.user.is_superuser:
        return HttpResponse("You are not authenticated to view this page")
    
    user = request.user
    employee = User_Profile.objects.get(id=user.id)
    today_date = datetime.date.today()
    employee_attendence = EmployeeAttendance.objects.filter(employee=user,created=today_date)
    
    return render(request, 'myapp/check_in_out1.html', {'employee':employee,'employee_attendence':employee_attendence})


@login_required
def check_in(request):
    if request.user.is_superuser:
        return HttpResponse("You are not authenticated to view this page")
    user = request.user
    data = EmployeeAttendance.objects.filter(employee=user, created=datetime.date.today(),is_in=True).exists()
    if data:
        messages.info(request, f'{user.full_name} You Already Punch-In and Punch-Out Today', extra_tags='alert alert-warning alert-dismissible show')
        return redirect('add_attendence')
    instance = EmployeeAttendance(employee=user, is_in=True, in_time=datetime.datetime.now())
    instance.save()
    messages.success(request, f'{instance.employee.full_name} You Are In Successfully', extra_tags='alert alert-success alert-dismissible show')
    return redirect('add_attendence')


@login_required
def check_out(request,id):
    if request.user.is_superuser:
        return HttpResponse("You are not authenticated to view this page")
    attendence = get_object_or_404(EmployeeAttendance, id = id)
    user_id= attendence.employee.id
    employee = User_Profile.objects.filter(id = user_id)[0]
    attendence.is_out = True
    intime = attendence.in_time
    outtime = timezone.now()
    attendence.out_time = outtime
    total_seconds = (outtime - intime).total_seconds()
    work_hour = total_seconds // 3600 
    if work_hour >= 5:
        attendence.day_type = 'Full Day'
    else:
        attendence.day_type = 'Half Day'
    
    attendence.save()
    messages.success(request, f'{employee.full_name} You Are Out Successfully', extra_tags='alert alert-success alert-dismissible show')
    return redirect('add_attendence')



@login_required
@allowd_users(allowd_roles=['Organisation Admin','HR'])
def all_attendence(request):
    user = request.user
    employee = User_Profile.objects.get(id=user.id)
    today_date = datetime.date.today().day
    attendances = EmployeeAttendance.objects.filter(employee__organisation=user.organisation).order_by('-created')

    title = "All Attendance"
    paginator = Paginator(attendances, 10)
    page_number = request.GET.get('page')
    page_obj = paginator.get_page(page_number)
    print(page_obj)
        
    last_page = page_obj.paginator.num_pages
    page_list = [i+1 for i in range(last_page)]
    return render(request, 'myapp/all_attendance1.html',{'employee':employee,'attendances':page_obj,'title':title,'last_page': last_page,'page_list':page_list})



@login_required
def teams(request):
    if request.user.is_superuser:
        return HttpResponse("You are not authenticated to view this page")
    user = request.user
    organisation = user.organisation
    org_admin = User_Profile.objects.filter(Q(organisation=organisation) & Q(groups__name="Organisation Admin"))
    accounting = User_Profile.objects.filter(Q(Q(organisation=organisation ) & Q(department__name__icontains="Accounting") & Q(is_active = True)))
    engineering = User_Profile.objects.filter(Q(Q(organisation=organisation ) & Q(department__name__icontains="Engineering") & Q(is_active = True)))
    it = User_Profile.objects.filter(Q(Q(organisation=organisation ) & Q(department__name__icontains="IT") & Q(is_active = True)))
    sales = User_Profile.objects.filter(Q(Q(organisation=organisation ) & Q(department__name__icontains="Sales") & Q(is_active = True)))
    marketing = User_Profile.objects.filter(Q(Q(organisation=organisation ) & Q(department__name__icontains="Marketing") & Q(is_active = True)))
    legal = User_Profile.objects.filter(Q(Q(organisation=organisation ) & Q(department__name__icontains="Legal") & Q(is_active = True)))
    employee = User_Profile.objects.get(id=user.id)
    managers = User_Profile.objects.filter(Q(organisation__icontains=organisation) & Q(groups__name__icontains='Manager') & Q(is_active = True))
    context = {'employee':employee,'managers':managers,'org_admin':org_admin,'accounting':accounting,'engineering':
               engineering,'it':it,'sales':sales,'marketing':marketing,'legal':legal,'title':'Teams'}
    return render(request, 'myapp/teams1.html',context)

@login_required
def team_leaders(request,id):
    user = request.user
    organisation = user.organisation
    manager = User_Profile.objects.get(id=id)
    print(manager)
    employee = User_Profile.objects.get(id=user.id)
    team_leaders = User_Profile.objects.filter(manager=manager,groups__name='Team Leader',is_active = True)
    print(team_leaders)
    managers = User_Profile.objects.filter(Q(organisation__icontains=organisation) & Q(groups__name__icontains='Manager') & Q(is_active = True))
    context = {'employee':employee,'team_leaders':team_leaders,'managers':managers}
    return render(request, 'myapp/teams.html',context)

@login_required
def team_employees(request,id, mid):
    user = request.user
    organisation = user.organisation
    manager = User_Profile.objects.get(id=mid)
    team_leader = User_Profile.objects.get(id=id)
    print(manager)
    employee = User_Profile.objects.get(id=user.id)
    team_leaders = User_Profile.objects.filter(manager=manager,groups__name='Team Leader', is_active = True)
    team_employees = User_Profile.objects.filter(team_leader=team_leader,groups__name='Employee', is_active = True)
    print(team_leaders)
    managers = User_Profile.objects.filter(Q(organisation__icontains=organisation) & Q(groups__name__icontains='Manager') & Q(is_active = True))
    context = {'employee':employee,'team_leaders':team_leaders,'managers':managers,'team_employees':team_employees}
    return render(request, 'myapp/teams.html',context)

@login_required
@allowd_users(allowd_roles=['Organisation Admin'])
def create_insurance(request):
    if request.method == 'POST':
        
        form = InsuranceCreationForm(data=request.POST)
        if form.is_valid():
            instance = form.save()
            instance.employee = request.user
            instance.save()
            messages.success(request, f'Health Benefit {instance.provider_name} Successfully Created', extra_tags='alert alert-success alert-dismissible show')
            return redirect('create_insurance')
        else:
            messages.error(request, 'Error In Creating Health Benefit', extra_tags='alert alert-danger alert-dismissible show')
            return redirect('create_insurance')

    dataset = dict()
    
    form = InsuranceCreationForm()
    employee = User_Profile.objects.get(id=request.user.id)
    dataset['employee']= employee
    dataset['form'] = form
    dataset['title'] = 'Add Health Benefit'
    return render(request, 'myapp/add_benefit.html', dataset)


@login_required
def show_insurance(request):
    if request.user.is_superuser:
        return HttpResponse("You are not authenticated to view this page")
    user = request.user
    data = Health_Benefit.objects.filter(employee__organisation=user.organisation)
    employee = get_object_or_404(User_Profile,id=user.id)
    paginator = Paginator(data, 8)
    page_number = request.GET.get('page')
    page_obj = paginator.get_page(page_number)
    print(page_obj)
    
    last_page = page_obj.paginator.num_pages
    page_list = [i+1 for i in range(last_page)]
    context = {'data':page_obj,'employee':employee,'title':'Administrative Benefits','last_page':last_page,'page_list':page_list}
    return render(request, 'myapp/benefits.html',context)

@login_required
def create_feedback(request):
    if request.user.is_superuser:
        return HttpResponse('You are not authenticated to view this page')
    employee = User_Profile.objects.get(id=request.user.id)
    if request.method == 'POST':
        form = FeedbackForm(data=request.POST)
        if form.is_valid():
            instance = form.save()
            instance.employee = employee
            instance.save()
            messages.success(request, 'Feedback Successfully Submitted', extra_tags='alert alert-success alert-dismissible show')
            return redirect('create_feedback')
        else:
            messages.error(request, 'Error In Creating Feedback', extra_tags='alert alert-danger alert-dismissible show')
            return redirect('create_feedback')

    dataset = dict()
    form = FeedbackForm()
    
    
    
    dataset['employee']= employee
    dataset['form'] = form
    dataset['title'] = 'Performance & Feedback Form'
    dataset['room_name'] = 'HRMS'
    return render(request, 'myapp/create_feedback1.html', dataset)

@login_required
@allowd_users(allowd_roles=['Organisation Admin'])
def show_feedback(request):
    user = request.user
    employee = get_object_or_404(User_Profile, id=user.id)
    feedbacks = Feedback.objects.filter(employee__organisation=user.organisation)
    title = "All Feedback"
    paginator = Paginator(feedbacks, 10)
    page_number = request.GET.get('page')
    page_obj = paginator.get_page(page_number)
    print(page_obj)
    
    last_page = page_obj.paginator.num_pages
    page_list = [i+1 for i in range(last_page)]
    title = "All Feedback"
    return render(request, 'myapp/show_feedback1.html',{'employee':employee,'feedbacks':page_obj,'title':title,'last_page': last_page,'page_list':page_list})

@login_required
@allowd_users(allowd_roles=['Organisation Admin'])
def delete_feedback(request,id):
    feedback = get_object_or_404(Feedback, id=id)
    feedback.delete()
    messages.success(request, f'Feedback of {feedback.employee.full_name} Deleted Successfully', extra_tags='alert alert-success alert-dismissible show')
    return redirect('show_feedback')

@login_required
@allowd_users(allowd_roles=['Organisation Admin'])
def delete_feedback_confirmation(request,id):
    employee = User_Profile.objects.get(id=request.user.id)
    return render(request, 'myapp/delete_feedback_confirmation.html', {'id':id,'employee':employee})   

@login_required
@allowd_users(allowd_roles=['Organisation Admin'])
def delete_feedback_cancel(request):
    return redirect('show_feedback')  


@login_required
@allowd_users(allowd_roles=['Organisation Admin','HR'])
def create_training(request):
    
    if request.method == 'POST':
        form = TrainingForm(data=request.POST)
        if form.is_valid():
            instance = form.save()
            user = request.user
            instance.user = user
            instance.save()
            msg = f"Training & session of {instance.trainer} is arrange in our company on {instance.date} at {instance.time}"
            Notification.objects.create(organisation=user.organisation,message=msg,notification_users='all',training='training')
            messages.success(request, f'Training of {instance.trainer} Successfully Added', extra_tags='alert alert-success alert-dismissible show')
            return redirect('training_and_sessions')
        else:
            messages.error(request, 'Something Went Wrong In Adding New Training', extra_tags='alert alert-danger alert-dismissible show')
            return redirect('add_training')

    dataset = dict()
    form = TrainingForm()
    employee = User_Profile.objects.get(id=request.user.id)
    
    dataset['employee']= employee
    dataset['form'] = form
    dataset['title'] = 'Add New Training & Sessions'
    return render(request, 'myapp/create_training1.html', dataset)

@login_required
def show_trainings(request):
    if request.user.is_superuser:
        return HttpResponse('You are not authenticated to view this page')
    user = request.user
    today = datetime.date.today()
    
    trainings = Training.objects.filter(Q(user__organisation=user.organisation) & Q(date__gte=today))
    employee = get_object_or_404(User_Profile, id=user.id)

    return render(request, 'myapp/training&session.html',{'trainings':trainings,'employee':employee,'title':'Training & Sessions'})

@login_required
@allowd_users(allowd_roles=['Organisation Admin','HR'])
def edit_training(request,id):
    instance = get_object_or_404(Training,id=id)
    dataset = dict()
    form = TrainingForm(instance=instance)
    employee = User_Profile.objects.get(id=request.user.id)
    
    dataset['employee']= employee
    dataset['form'] = form
    dataset['title'] = 'Update Training & Sessions'
    if request.method == 'POST':
        form = TrainingForm(data=request.POST,instance=instance)
        if form.is_valid():
            instance = form.save()
            user = request.user
            instance.user = user
            instance.save()
            msg = f"Training & session of {instance.trainer} is updated , please check"
            Notification.objects.create(organisation=user.organisation,message=msg,notification_users='all',training='training')
            messages.success(request, f'Training of "{instance.trainer}" Successfully Updated', extra_tags='alert alert-success alert-dismissible show')
            return redirect('edit_training',id=id)
        else:
            dataset['form'] = form
            messages.error(request, 'Something Went Wrong Please Check Below', extra_tags='alert alert-danger alert-dismissible show')
            return render(request, 'myapp/edit_training.html', dataset)

    
    
    return render(request, 'myapp/edit_training.html', dataset)

@login_required
@allowd_users(allowd_roles=['Organisation Admin','HR'])
def delete_training(request,id):
    t = get_object_or_404(Training, id=id)
    t.delete()
    messages.success(request, f'Training of {t.trainer} Deleted Successfully', extra_tags='alert alert-success alert-dismissible show')
    return redirect('training_and_sessions')

@login_required
@allowd_users(allowd_roles=['Organisation Admin','HR'])
def delete_training_confirmation(request,id):
    t = get_object_or_404(Training, id=id)
    employee = User_Profile.objects.get(id=request.user.id)
    return render(request, 'myapp/delete_training_confirmation.html', {'id':id,'employee':employee,'trainer':t.trainer})   

@login_required
@allowd_users(allowd_roles=['Organisation Admin','HR'])
def delete_training_cancel(request):
    return redirect('training_and_sessions')  

@login_required
def read_trainings(request,id):
    if request.user.is_superuser:
        return HttpResponse('You are not authenticated to view this page')
    emp = get_object_or_404(User_Profile,pk=request.user.id)
    data = training_read.objects.filter(Q(training__id=id) & Q(employee=emp))
    
    if data:
        trainer = [i.training.trainer for i in data]
        messages.success(request, f"You already read training of {trainer[0]}", extra_tags='alert alert-warning alert-dismissible show')
        return redirect('training_and_sessions')
    training = get_object_or_404(Training,id=id)
    
    training_read.objects.create(training=training,employee=emp)
    messages.success(request, f"You read training of {training.trainer} successfully", extra_tags='alert alert-success alert-dismissible show')
    return redirect('training_and_sessions')

@login_required
@allowd_users(allowd_roles=['Organisation Admin','HR'])
def training_readers(request):
    employee = get_object_or_404(User_Profile,id=request.user.id)
    organisation = employee.organisation
    print(organisation)
    readers = training_read.objects.filter(employee__organisation=organisation)
    for i in readers:
        print(i.employee)
    print(readers)
    return render(request,'myapp/training_readers.html',{'employee':employee,'readers':readers,'title':'Training Readers'})


# from .slack_service import send_slack_message

def integration(request):
    employee = get_object_or_404(User_Profile,id=request.user.id)

    return render(request, 'myapp/integration.html',{'employee':employee,'title':"Slack Notification"})

def notify_slack(request):
    # today = timezone.localdate()
    # leave_requests = Leave.objects.filter(Q(startdate__lte=today) & Q(enddate__gte=today) & Q(status__icontains='approved'))
    # print(leave_requests)
    # for leave_request in leave_requests:
    #     employee_name = leave_request.user.full_name
        
    #     message = f"{employee_name} is on leave today ({today})."
        
    #     send_slack_message(channel='#arushhr', text=message)
    # employee = get_object_or_404(User_Profile,id=request.user.id)
    # text = "Notification of employees on leave are send successfully in arushhr group"
    # messages.success(request, text, extra_tags='alert alert-success alert-dismissible show')
    return redirect("https://slack.com/signin")

def policy_page(request):
    employee = get_object_or_404(User_Profile, pk=request.user.id)
    policy = privacy_policy.objects.filter(user__organisation=request.user.organisation)
    paginator = Paginator(policy, 8)
    page_number = request.GET.get('page')
    page_obj = paginator.get_page(page_number)
    print(page_obj)
    
    last_page = page_obj.paginator.num_pages
    page_list = [i+1 for i in range(last_page)]
    return render(request, 'myapp/policy.html',{'employee':employee,'policy':page_obj,'title':'Company Policy','last_page':last_page,'page_list':page_list})


def add_policy(request):
    if request.method == 'POST':
        form = privacy_policy_form(data=request.POST)
        policy = request.POST.get('policy_text')
        if policy:

            if form.is_valid():
                instance = form.save()
                instance.user = request.user
                instance.save()
                msg = "Policy Created"
                Notification.objects.create(organisation=request.user.organisation,message=msg,notification_users='all',policy='policy')
                messages.success(request, f'Policy Successfully Added', extra_tags='alert alert-success alert-dismissible show')
                return redirect('add_policy')
        else:
            messages.error(request, f'No Input data can be found', extra_tags='alert alert-warning alert-dismissible show')
            return redirect('add_policy')
    employee = get_object_or_404(User_Profile, pk=request.user.id)
    form = privacy_policy_form()
    return render(request, 'myapp/add_policy.html',{'employee':employee,'form':form})


def add_handbook(request):
    if request.method == 'POST':
        equipments = request.POST.getlist('handbook')
        data = [i for i in equipments]
        # print(list1)
        emp = request.POST['employee']
        # print(emp)
        try:
            emp_obj = get_object_or_404(User_Profile,pk=emp)
            obj1 = Handbook.objects.get(employee=emp_obj)
            
            obj1.equipments = data
            obj1.save()
        except Handbook.DoesNotExist:
            obj1 = Handbook.objects.create(equipments=data,employee=emp_obj)
        
        messages.success(request, f'Handbook Successfully Added of {obj1.employee.full_name}', extra_tags='alert alert-success alert-dismissible show')
        return redirect('add_handbook')
    employee = get_object_or_404(User_Profile, pk=request.user.id)
    
    employees = User_Profile.objects.filter(organisation=employee.organisation, is_active = True)
    # print(employees)
    return render(request, 'myapp/add_handbook.html',{'employee':employee,'employees':employees,'title':'Add Handbook'})    

def equipments(request):
    emp = request.GET.get('employee')
    print(emp)
    equ_obj = Handbook.objects.filter(employee__id=emp)
    json_data = []
    for i in equ_obj:
        for j in i.equipments:
            json_data.append({'equipments':j})
    return JsonResponse({'data':json_data})

@login_required
@allowd_users(allowd_roles=['Organisation Admin','HR'])
def add_vendor(request):
    user = request.user
    employee = get_object_or_404(User_Profile, pk=user.id)
    title = "Add Vendor"
    if request.method == 'POST':
        form = VendorForm(request.POST)
        if form.is_valid():
            obj = form.save()
            obj.user = user
            obj.save()
            messages.success(request, f'The Vendor "{obj.name}" Is Successfully Added', extra_tags='alert alert-success alert-dismissible show')
            return redirect('vendor_list')
        else:
            messages.error(request, f'Something went wrong please check below', extra_tags='alert alert-warning alert-dismissible show')
            return render(request, 'myapp/add_vendor.html', {'form': form,'employee':employee,'title':title})

    else:
        form = VendorForm()
        employees = User_Profile.objects.filter(organisation=employee.organisation, is_active = True)
        form.fields['internal_stakeholders'].queryset = employees
    return render(request, 'myapp/add_vendor.html', {'form': form,'employee':employee,'title':title})

@login_required
def vendor_list(request):
    user = request.user
    employee = get_object_or_404(User_Profile, pk=request.user.id)
    vendors = Vendor.objects.filter(user__organisation=user.organisation)
    title = "All Vendors"
    if request.method == 'POST':
        categories = request.POST.getlist('categories[]')
        print(categories)
        if categories:
            items = Vendor.objects.filter(Q(criticality__in=categories) | Q(status__in=categories))
        else:
            items = Vendor.objects.filter(user__organisation=user.organisation)
        items_data = [
        {
            'id':item.id,
            'name': item.name,
            'internal_stakeholders': [category.full_name if category.full_name else category.email for category in item.internal_stakeholders.all()],
            'complaint_with':item.complaint_with,
            'criticality':item.criticality,
            'status':item.status,
        }
        for item in items
    ]
        return JsonResponse({'items': items_data})
    return render(request, 'myapp/vendor_list.html', {'vendors': vendors,'employee':employee,'title':title})

@login_required
@allowd_users(allowd_roles=['Organisation Admin','HR'])
def edit_vendor(request,id):
    user = request.user
    employee = get_object_or_404(User_Profile, pk=user.id)
    instance = get_object_or_404(Vendor,id=id)
    title = "Update Vendor"
    if request.method == 'POST':
        form = VendorForm(request.POST,instance=instance)
        if form.is_valid():
            obj = form.save()
            obj.user = user
            obj.save()
            messages.success(request, f'The Vendor "{obj.name}" Was Successfully Updated', extra_tags='alert alert-success alert-dismissible show')
            return redirect('vendor_list')
        else:
            messages.error(request, f'Something went wrong please check below', extra_tags='alert alert-warning alert-dismissible show')
            return render(request, 'myapp/add_vendor.html', {'form': form,'employee':employee,'title':title})
    else:
        form = VendorForm(instance=instance)
    return render(request, 'myapp/add_vendor.html', {'form': form,'employee':employee,'title':title})

@login_required
@allowd_users(allowd_roles=['Organisation Admin','HR'])
def delete_vendor(request,id):
    v = get_object_or_404(Vendor, id=id)
    v.delete()
    messages.success(request, f'The Vendor "{v.name}" Is Deleted Successfully', extra_tags='alert alert-success alert-dismissible show')
    return redirect('vendor_list')

@login_required
@allowd_users(allowd_roles=['Organisation Admin','HR'])
def delete_vendor_confirmation(request,id):
    employee = User_Profile.objects.get(id=request.user.id)
    v = get_object_or_404(Vendor, id=id)
    return render(request, 'myapp/delete_vendor_confirmation.html', {'id':id,'employee':employee,'name': v.name})   

@login_required
@allowd_users(allowd_roles=['Organisation Admin','HR'])
def delete_vendor_cancel(request):
    return redirect('vendor_list')

def upload_agreements(request):
    employee = User_Profile.objects.get(id=request.user.id)
    title = "Upload Agreements"
    form = UploadAgreementForm()
    context = {'employee':employee,'title':title,'form':form}
    if request.method == 'POST':
        employee_handbook = request.FILES.get('employee_handbook')
        confidential_agreement = request.FILES.get('confidential_agreement')
        form = UploadAgreementForm(request.POST, request.FILES)
        if form.is_valid:
            obj = form.save()
            obj.title_employee_handbook = employee_handbook.name
            obj.title_confidential_agreement = confidential_agreement.name
            obj.employee = employee
            obj.save()
            messages.success(request, f'Upload agreement document successfully !!', extra_tags='alert alert-success alert-dismissible show')
            return redirect('upload_agreements')
        else:
            messages.warning(request, f'Something went wrong, Please check below', extra_tags='alert alert-warning alert-dismissible show')
            return redirect('upload_agreements')
    return render(request, 'myapp/upload_agreement.html',context=context)

import re

def remove_brackets(text):
    # This function removes curly brackets from the given text
    return re.sub(r'\{(.+?)\}', r'\1', text)

@login_required
def fill_documents(request,id):
    employee = User_Profile.objects.get(id=request.user.id)
    title = "Submit Company Agreements"
    documents = company_agreements.objects.get(id=id)
    # Read DOC file
    document = Document(documents.confidential_agreement.path)
            # Extract form fields from the DOC file
    tokens = []
    
    pattern = r'\{.*?\}'
    for paragraph in document.paragraphs:
        # print(paragraph)
        if paragraph.text.strip():  # Assuming each form field is in a separate paragraph
            token = re.findall(pattern, paragraph.text)
            tokens.extend(token)
    # print(tokens)
    clean_tokens = [token.strip('{}') for token in tokens]
    # print(clean_tokens)
    
    if request.method == 'POST':
        output_folder = os.path.join(settings.MEDIA_ROOT, 'agreement_docx')
        file_name = f"{employee.id}-company-agreement.docx"
        output_path = os.path.join(output_folder, file_name)
        form_data = request.POST
        # print(form_data)
        for paragraph in document.paragraphs:
            for field in form_data:
                # placeholder = f"{{{field}}}"
                
                if field in paragraph.text:
                   print(f"Found placeholder: {field} in paragraph: {paragraph.text}")
                   for run in paragraph.runs:
                      print('run text...', run.text)
                      if field in run.text:
                            run.text = run.text.replace(field, form_data[field])
                            print(f"Replacing {field} with {form_data[field]}")
            paragraph.text = remove_brackets(paragraph.text)
        document.save(output_path)
        

        doc = employee_agreements(employee=employee,
                title_confidential_agreement=documents.title_confidential_agreement)
        doc.save()
        with open(output_path, 'rb') as f:
            doc.confidential_agreement.save(file_name, f, save=True)
        os.remove(output_path)    
        messages.success(request, "form submitted successfully")
        return redirect("employee_detail", id=employee.id)
    context = {'employee':employee,'title':title,'form_fields':clean_tokens}

    return render(request, 'myapp/fill_documents.html',context=context)

import json
from django.core.files.base import ContentFile
import base64
from docx.shared import Cm

@login_required
def sign_documents(request):
    employee = User_Profile.objects.get(id=request.user.id)
    sign_doc = employee_agreements.objects.filter(employee=employee).first()
    context = {'employee':employee,'title':'Make Sign On Company Agreement','sign_doc':sign_doc}
    if request.method == 'POST':
        print('call')
        data = json.loads(request.body)
        print(data)
        image_data = data['image']
        format, imgstr = image_data.split(';base64,')
        ext = format.split('/')[-1]
        file = ContentFile(base64.b64decode(imgstr), name='signature.' + ext)
        document = Document(sign_doc.confidential_agreement.path)
        for paragraph in document.paragraphs:
            if '[signature]' in paragraph.text:
                paragraph.text = paragraph.text.replace('[signature]', '')
                run = paragraph.add_run()
                run.add_picture(file, width=Cm(5), height=Cm(2))
                break
        output_folder = r"/var/www/html/humari/media/agreement_docx"
        file_name = f"{employee.id}-company-agreement.docx"
        output_path = os.path.join(output_folder, file_name)
        document.save(output_path)
        os.remove(sign_doc.confidential_agreement.path)
        with open(output_path, 'rb') as f:
            sign_doc.confidential_agreement.save(file_name, f, save=True)
        sign_doc.is_sign = True
        sign_doc.save() 
        os.remove(output_path)
        return JsonResponse({'success': True})
    return render(request, 'myapp/sign_agreement.html', context=context)

def delete_all_data(request):
    employees = User_Profile.objects.all()
    for i in employees:
        if not i.is_superuser:
            i.delete()
    banks = Bank.objects.all()
    banks.delete()
    holidays = Holiday.objects.all()
    holidays.delete()
    payroll = Payroll.objects.all()
    payroll.delete()
    project = Project.objects.all()
    project.delete()
    attendance = EmployeeAttendance.objects.all()
    attendance.delete()
    benefit = Health_Benefit.objects.all()
    benefit.delete()
    feedback = Feedback.objects.all()
    feedback.delete()
    training = Training.objects.all()
    training.delete()
    
    notifications = Notification.objects.all()
    notifications.delete()
    mark_read = mark_read_notifications.objects.all()
    mark_read.delete()
    subscription = Subscription.objects.all()
    subscription.delete()
    policy = privacy_policy.objects.all()
    policy.delete()
    handbook = Handbook.objects.all()
    handbook.delete()
    vendor = Vendor.objects.all()
    vendor.delete()
    read = training_read.objects.all()
    read.delete()
    education = education_certeficates.objects.all()
    education.delete()
    employement = employement_certeficates.objects.all()
    employement.delete()
    id_doc = id_documents.objects.all()
    id_doc.delete()
    criminal = criminal_documents.objects.all()
    criminal.delete()
    credit = credit_documents.objects.all()
    credit.delete()
    check = background_check.objects.all()
    check.delete()
    desciption = job_description.objects.all()
    desciption.delete()
    company = company_agreements.objects.all()
    company.delete()
    employee = employee_agreements.objects.all()
    employee.delete()
    leaves = Leave.objects.all()
    leaves.delete()
    messages.warning(request, "All companies data deleted!!", extra_tags="alert alert-warning alert-dismissible show")
    return redirect("dashboard")

def show_camera(request):
    return render(request, "myapp/camera.html")