import json

import numpy as np
import pandas as pd
from django.http import HttpResponse
from django.views.decorators.csrf import csrf_exempt
from rest_framework.decorators import api_view, authentication_classes, permission_classes
from rest_framework.permissions import IsAuthenticated

from payrollservice.data.request.graderequest import GradeRequest
from payrollservice.data.request.payrollmasterrequest import PayrollComponentRequest, CompanyContributionRequest, \
    PaycomponentFlagmasterRequest, EmpPFStructureRequest, PayrollDeductionRequest, ComponentTypeRequest, \
    SegmentMasterRequest
from payrollservice.data.response.payrollmasterresponse import CompanyContributionResponse
from payrollservice.service.paycomponentsegmentmappingservice import PayrollSegementMappingService
from payrollservice.service.payrollmastermappingservice import PayrollmastermappingService
from payrollservice.service.payrollmastersservice import PayrollComponentService, CompanyContributionService, \
    PaycomponentFlagmasterService, EmployeePFService, PayrollDeductionService, ComponentTypeService, \
    SegmentMasterService, payrollGradeService
from payrollservice.service.payrolltemplateservice import PayrollTemplateService
from payrollservice.util.payrollutil import master_validation, PayrollValidation, payrolldeduction_type, \
    category_dropdown_, FlagRef_Type, Comptype_Category
from utilityservice.data.response.nwisefinsuccess import NWisefinSuccess
from common_middleware.request_middleware import NWisefinAuthentication
from utilityservice.service.nwisefinpermission import NWisefinPermission
from utilityservice.data.response.nwisefinpage import NWisefinPage


@csrf_exempt
@api_view(['POST','GET'])
@authentication_classes([NWisefinAuthentication])
@permission_classes([IsAuthenticated, NWisefinPermission])
def payroll_component(request):
    scope = request.scope
    serv = PayrollComponentService(scope)
    if request.method == 'POST':
        emp_id = request.employee_id
        resp_data = json.loads(request.body)
        if resp_data['from_date'] < resp_data['to_date'] or resp_data['from_date'] == resp_data['to_date']:
            validation_response = master_validation(resp_data)
            if PayrollValidation.status == 'Success':
                resp_obj = PayrollComponentRequest(resp_data)
                resp = serv.create_payroll_component(resp_obj, emp_id)
                response = HttpResponse(resp.get(), content_type="application/json")
                return response
            else:
                json_data = json.dumps(validation_response)
                return HttpResponse(json_data, content_type='application/json')
        else:
            response1 = json.dumps({'date_message':"select valid from_date and to_date"})
            response = HttpResponse(response1, content_type="application/json")
            return response
    elif request.method == 'GET':
        resp_obj=None
        action = request.GET.get('action', None)
        name = request.GET.get('name', None)
        grade = request.GET.get('grade', None)
        page = request.GET.get('page', 1)
        page = int(page)
        vys_page = NWisefinPage(page, 10)
        if action == None:
            resp_obj = serv.payroll_component_summary(name, vys_page, grade)
        elif int(action) == Comptype_Category.CUSTOM_DEDUCTION or int(action) == Comptype_Category.CUSTOM_EARNINGS:
            resp_obj = serv.payroll_component_summary1(name, grade,action)
        response = HttpResponse(resp_obj.get(), content_type="application/json")
        return response

@csrf_exempt
@api_view(['GET', 'DELETE'])
@authentication_classes([NWisefinAuthentication])
@permission_classes([IsAuthenticated, NWisefinPermission])
def get_payroll_component(request, comp_id):
    scope = request.scope
    serv = PayrollComponentService(scope)
    if request.method == 'GET':
        resp = serv.get_payroll_component(comp_id)
        response = HttpResponse(resp.get(), content_type="application/json")
        return response
    elif request.method == 'DELETE':
        resp = serv.delete_payroll_component(comp_id)
        response = HttpResponse(resp.get(), content_type="application/json")
        return response


@csrf_exempt
@api_view(['POST','GET'])
@authentication_classes([NWisefinAuthentication])
@permission_classes([IsAuthenticated, NWisefinPermission])
def company_contribution(request):
    scope = request.scope
    serv = CompanyContributionService(scope)
    if request.method == 'POST':
        emp_id = request.employee_id
        resp_data = json.loads(request.body)
        validation_response = master_validation(resp_data)
        if PayrollValidation.status == 'Success':
            resp_obj = CompanyContributionRequest(resp_data)
            flag_arr = resp_data.get("paycomponentflagmaster")
            resp = serv.create_entry(resp_obj, emp_id)
            map_id = resp.id
            for flag_data in flag_arr:
                if len(flag_data) > 0:
                    data_obj = PaycomponentFlagmasterRequest(flag_data)
                    flag_service = PaycomponentFlagmasterService(scope)
                    res_obj = flag_service.create_paycomponentflag(data_obj, emp_id, FlagRef_Type.COMPANYCONTRIBUTION, map_id)
            response = HttpResponse(resp.get(), content_type="application/json")
            return response
        else:
            json_data = json.dumps(validation_response)
            return HttpResponse(json_data, content_type='application/json')
    elif request.method == 'GET':
        name = request.GET.get('name', None)
        page = request.GET.get('page', 1)
        page = int(page)
        vys_page = NWisefinPage(page, 10)
        resp_obj = serv.company_contribution_summary(name, vys_page)
        response = HttpResponse(resp_obj.get(), content_type="application/json")
        return response

#
# @csrf_exempt
# @api_view(['GET'])
# @authentication_classes([NWisefinAuthentication])
# @permission_classes([IsAuthenticated, NWisefinPermission])
# def pf_structure(request):
#     scope = request.scope
#     serv = EmployeePFService(scope)
#     if request.method == 'GET':
#         query = request.GET.get('query', None)
#         page = request.GET.get('page', 1)
#         page = int(page)
#         vys_page = NWisefinPage(page, 10)
#         resp_obj = serv.employee_pf_dd(vys_page, query)
#         response = HttpResponse(resp_obj.get(), content_type="application/json")
#         return response


@csrf_exempt
@api_view(['GET', 'DELETE'])
@authentication_classes([NWisefinAuthentication])
@permission_classes([IsAuthenticated, NWisefinPermission])
def get_contribution(request, con_id):
    scope = request.scope
    serv = CompanyContributionService(scope)
    if request.method == 'GET':
        resp = serv.get_contribution_info(con_id)
        response = HttpResponse(resp.get(), content_type="application/json")
        return response
    elif request.method == 'DELETE':
        resp = serv.delete_contribution(con_id)
        response = HttpResponse(resp.get(), content_type="application/json")
        return response


@csrf_exempt
@api_view(['POST','GET'])
@authentication_classes([NWisefinAuthentication])
@permission_classes([IsAuthenticated, NWisefinPermission])
def employee_pf_structure(request):
    scope = request.scope
    serv = EmployeePFService(scope)
    flag_service = PaycomponentFlagmasterService(scope)
    if request.method == 'POST':
        emp_id = request.employee_id
        resp_data = json.loads(request.body)
        validation_response = master_validation(resp_data)
        if PayrollValidation.status == 'Success':
            resp_obj = EmpPFStructureRequest(resp_data)
            flag_arr = resp_data.get("paycomponentflagmaster")
            resp = serv.create_employee_pf(resp_obj, emp_id)
            map_id = resp.id
            for flag_data in flag_arr:
                if len(flag_data) > 0:
                    data_obj = PaycomponentFlagmasterRequest(flag_data)
                    res_obj = flag_service.create_paycomponentflag(data_obj, emp_id, FlagRef_Type.PF,map_id)
            response = HttpResponse(resp.get(), content_type="application/json")
            return response
        else:
            json_data = json.dumps(validation_response)
            return HttpResponse(json_data, content_type='application/json')
    elif request.method == 'GET':
        query = request.GET.get('query', None)
        page = request.GET.get('page', 1)
        page = int(page)
        vys_page = NWisefinPage(page, 10)
        resp_obj = serv.employee_pf_dd(vys_page, query)
        response = HttpResponse(resp_obj.get(), content_type="application/json")
        return response


@csrf_exempt
@api_view(['GET', 'DELETE'])
@authentication_classes([NWisefinAuthentication])
@permission_classes([IsAuthenticated, NWisefinPermission])
def get_employee_pf(request, comp_id):
    scope = request.scope
    serv = EmployeePFService(scope)
    if request.method == 'GET':
        resp = serv.get_emp_pf_info(comp_id)
        response = HttpResponse(resp.get(), content_type="application/json")
        return response
    elif request.method == 'DELETE':
        resp = serv.delete_emp_pf_structure(comp_id)
        response = HttpResponse(resp.get(), content_type="application/json")
        return response

# payrollcomponent and payrolldeduction create / summary
@csrf_exempt
@api_view(['POST', 'GET'])
@authentication_classes([NWisefinAuthentication])
@permission_classes([IsAuthenticated, NWisefinPermission])
def create_payrolldeduction(request):
    scope = request.scope
    serv = PayrollComponentService(scope)
    serv1 = PayrollDeductionService(scope)
    if request.method == 'POST':
        emp_id = request.employee_id
        resp_data = json.loads(request.body)
        resp_obj = PayrollComponentRequest(resp_data)
        payrolldeduction_arr = resp_data.get("payrolldeduction_data")
        resp_obj = serv.create_payroll_component(resp_obj, emp_id)
        data = resp_obj.id
        if resp_obj.is_deduction == 1:
            for payroll in payrolldeduction_arr:
                data_obj = PayrollDeductionRequest(payroll)
                serv1.create_payrolldeduction(request, data_obj, emp_id, data)
        response = HttpResponse(resp_obj.get(), content_type="application/json")
        return response

    elif request.method == 'GET':
        page = request.GET.get('page', 1)
        page = int(page)
        vys_page = NWisefinPage(page, 10)
        scope = request.scope
        serv = PayrollComponentService(scope)
        # resp_obj = serv.componentdeduction_summary(request, vys_page)
        resp_obj = serv.componentdeduction_summary_data(request, vys_page)
        response = HttpResponse(resp_obj.get(), content_type='application/json')
        return response


@csrf_exempt
@api_view(['POST','GET'])
@authentication_classes([NWisefinAuthentication])
@permission_classes([IsAuthenticated, NWisefinPermission])
def create_componenttype(request):
    scope = request.scope
    serv = ComponentTypeService(scope)
    if request.method == 'POST':
        emp_id = request.employee_id
        resp_data = json.loads(request.body)
        validation_response = master_validation(resp_data)
        if PayrollValidation.status == 'Success':
            resp_obj = ComponentTypeRequest(resp_data)
            resp = serv.create_componenttype(resp_obj, emp_id)
            return HttpResponse(resp.get(), content_type="application/json")
        else:
            json_data = json.dumps(validation_response)
            return HttpResponse(json_data, content_type='application/json')
    elif request.method == 'GET':
        page = request.GET.get('page', 1)
        page = int(page)
        vys_page = NWisefinPage(page, 10)
        resp_obj = serv.summary_componenttype(request, vys_page)
        response = HttpResponse(resp_obj.get(), content_type='application/json')
        return response

@csrf_exempt
@api_view(['GET', 'DELETE'])
@authentication_classes([NWisefinAuthentication])
@permission_classes([IsAuthenticated, NWisefinPermission])
def fetch_componenttype(request, id):
    scope = request.scope
    serv = ComponentTypeService(scope)
    if request.method == 'GET':
        resp = serv.fetch_componenttype(id)
        response = HttpResponse(resp.get(), content_type="application/json")
        return response
    elif request.method == 'DELETE':
        resp = serv.componenttype_delete(id)
        response = HttpResponse(resp.get(), content_type="application/json")
        return response
@csrf_exempt
@api_view(['GET'])
@authentication_classes([NWisefinAuthentication])
@permission_classes([IsAuthenticated, NWisefinPermission])
def payrolldeduction_type_dropdown(request):
        util = payrolldeduction_type()
        response = HttpResponse(util.get(), content_type="application/json")
        return response


@csrf_exempt
@api_view(['GET'])
@authentication_classes([NWisefinAuthentication])
@permission_classes([IsAuthenticated, NWisefinPermission])
def deduction_payrollcomponent(request):
    scope = request.scope
    serv = PayrollComponentService(scope)
    if request.method == 'GET':
        is_deduction = request.GET.get('is_deduction')
        page = request.GET.get('page', 1)
        page = int(page)
        vys_page = NWisefinPage(page, 30)
        resp_obj = serv.deduction_payrollcomponent(is_deduction, vys_page)
        response = HttpResponse(resp_obj.get(), content_type="application/json")
        return response


# create PaycomponentFlagmaster
@csrf_exempt
@api_view(['POST'])
@authentication_classes([NWisefinAuthentication])
@permission_classes([IsAuthenticated, NWisefinPermission])
def create_paycomponentflagmaster(request):
    if request.method == 'POST':
        scope = request.scope
        emp_id = request.employee_id
        resp_data = json.loads(request.body)
        flag_service = PaycomponentFlagmasterService(scope)
        resp_obj = PaycomponentFlagmasterRequest(resp_data)
        res_obj = flag_service.create_paycomponentflagmaster(resp_obj, emp_id)
        response = HttpResponse(res_obj.get(), content_type="application/json")
        return response


@csrf_exempt
@api_view(['DELETE'])
@authentication_classes([NWisefinAuthentication])
@permission_classes([IsAuthenticated, NWisefinPermission])
def inactive_paycomponentflagmaster(request, id):
    if request.method == 'DELETE':
        scope = request.scope
        flag_service = PaycomponentFlagmasterService(scope)
        map_id = request.GET.get('map_id')
        resp = flag_service.inactive_paycomponentflagmaster(id,map_id)
        response = HttpResponse(resp.get(), content_type="application/json")
        return response



@csrf_exempt
@api_view(['GET'])
@authentication_classes([NWisefinAuthentication])
@permission_classes([IsAuthenticated, NWisefinPermission])
def grade_paycomponent(request,grade):
    scope = request.scope
    if request.method == 'GET':
        page = request.GET.get('page', 1)
        page = int(page)
        vys_page = NWisefinPage(page, 30)
        grade_data = PayrollComponentService(scope).emp_grade_paycomonent_get(request, grade, vys_page)
        response = HttpResponse(grade_data.get(), content_type="application/json")
        return response


@csrf_exempt
@api_view(['POST','GET'])
@authentication_classes([NWisefinAuthentication])
@permission_classes([IsAuthenticated, NWisefinPermission])
def create_segmentmaster(request):
    scope = request.scope
    seg_serv = SegmentMasterService(scope)
    if request.method == 'POST':
        emp_id = request.employee_id
        resp_data = json.loads(request.body)
        # validation_response = master_validation(resp_data)
        # if PayrollValidation.status == 'Success':
        resp_obj = SegmentMasterRequest(resp_data)
        resp = seg_serv.create_segmentmaster(resp_obj, emp_id)
        response = HttpResponse(resp.get(), content_type="application/json")
        # else:
            # json_data = json.dumps(validation_response)
            # return HttpResponse(json_data, content_type='application/json')
        return response
    elif request.method == 'GET':
        page = request.GET.get('page', 1)
        page = int(page)
        vys_page = NWisefinPage(page, 10)
        resp_obj = seg_serv.segmentmaster_summary(request, vys_page)
        response = HttpResponse(resp_obj.get(), content_type='application/json')
        return response

@csrf_exempt
@api_view(['GET', 'DELETE'])
@authentication_classes([NWisefinAuthentication])
@permission_classes([IsAuthenticated, NWisefinPermission])
def segment_get(request, id_val):
    scope = request.scope
    seg_serv = SegmentMasterService(scope)
    if request.method == 'GET':
        resp_obj = seg_serv.get_segmentmaster(id_val)
        return HttpResponse(resp_obj.get(), content_type='application/json')
    elif request.method == 'DELETE':
        resp_obj = seg_serv.inactive_segmentmaster(id_val)
        return HttpResponse(resp_obj.get(), content_type='application/json')


@csrf_exempt
@api_view(['POST','GET'])
@authentication_classes([NWisefinAuthentication])
@permission_classes([IsAuthenticated, NWisefinPermission])
def create_grade(request):
   scope = request.scope
   grade_service = payrollGradeService(scope)
   if request.method =='POST':
       body_data=json.loads(request.body)
       grade_request=GradeRequest(body_data)
       user_id=request.employee_id
       resp_obj=grade_service.create_grade(grade_request,user_id)
       response = HttpResponse(resp_obj.get(), content_type="application/json")
       return response
   elif request.method == 'GET':
       page = request.GET.get('page', 1)
       page = int(page)
       vys_page = NWisefinPage(page, 10)
       resp_obj = grade_service.summary_grade(request, vys_page,page=page)
       return HttpResponse(resp_obj, content_type="application/json")

@csrf_exempt
@api_view(['GET', 'DELETE'])
@authentication_classes([NWisefinAuthentication])
@permission_classes([IsAuthenticated, NWisefinPermission])
def get_grade_details(request,id):
    scope = request.scope
    grade_service = payrollGradeService(scope)
    if request.method == 'GET':
        resp_obj = grade_service.get_grade_details(id)
        return HttpResponse(resp_obj.get(), content_type='application/json')
    elif request.method == 'DELETE':
        resp_obj = grade_service.grade_inactive(id)
        return HttpResponse(resp_obj.get(), content_type='application/json')


@csrf_exempt
@api_view(['GET'])
@authentication_classes([NWisefinAuthentication])
@permission_classes([IsAuthenticated, NWisefinPermission])
def cc_epf_paycom_details(request):
    scope = request.scope
    if request.method == 'GET':
        data = CompanyContributionResponse()
        cc_service = CompanyContributionService(scope).get_cc_paycom_details()
        emp_pf_service = EmployeePFService(scope).get_employeepfstruct_details()
        data.company_contribution = cc_service
        data.employee_contribution = emp_pf_service
        response = HttpResponse(data.get(), content_type='application/json')
        return response


##category_dropdown
@csrf_exempt
@api_view(['GET'])
@authentication_classes([NWisefinAuthentication])
@permission_classes([IsAuthenticated,NWisefinPermission])
def category_dropdown(request):
    if request.method == 'GET':
        util = category_dropdown_()
        response = HttpResponse(util.get(),content_type='application/json')
        return response

#npayroll master UPLOAD
@csrf_exempt
@api_view(['POST'])
@authentication_classes([NWisefinAuthentication])
@permission_classes([IsAuthenticated, NWisefinPermission])
def payrollmaster_upload(request):
    scope = request.scope
    if request.method == 'POST':
        action = request.GET.get('action', None)
        user_id = request.employee_id
        if action == 'payrollmaster_grade_upload':
            excel_data = pd.read_excel(request.FILES['file'], engine='openpyxl',sheet_name=None)
            df1 = excel_data['Sheet1']#grade upload
            final_df1 = pd.DataFrame(df1)
            grade_obj = final_df1.fillna(np.nan).replace([np.nan], [None]).to_dict(orient='records')
            print(grade_obj)
            for grade_data in grade_obj:
                data_obj = payrollGradeService(scope).payrollmaster_grade_upload(grade_data, user_id)
            response = HttpResponse(data_obj.get(), content_type="application/json")
        elif action == 'payollmaster_componenttype_upload':
            excel_data = pd.read_excel(request.FILES['file'], engine='openpyxl', sheet_name=None)
            df1 = excel_data['Sheet1']  # component_type upload
            final_df1 = pd.DataFrame(df1)
            componenttye_obj = final_df1.fillna(np.nan).replace([np.nan], [None]).to_dict(orient='records')
            print(componenttye_obj)
            for componenttye_data in componenttye_obj:
                data_obj = ComponentTypeService(scope).payollmaster_componenttype_upload(componenttye_data, user_id)
            response = HttpResponse(data_obj.get(), content_type="application/json")
        elif action == 'payrollmaster_payrollcomponent_upload':
            excel_data = pd.read_excel(request.FILES['file'], engine='openpyxl', sheet_name=None)
            df1 = excel_data['Sheet1']  # payrollcomponent upload
            final_df1 = pd.DataFrame(df1)
            payrollcomponent_obj = final_df1.fillna(np.nan).replace([np.nan], [None]).to_dict(orient='records')
            print(payrollcomponent_obj)
            for payrollcomponent_data in payrollcomponent_obj:
                data_obj = PayrollComponentService(scope).payrollmaster_payrollcomponent_upload(payrollcomponent_data,user_id)
            response = HttpResponse(data_obj.get(), content_type="application/json")
        elif action == 'payollmaster_companycontribution_upload':
            excel_data = pd.read_excel(request.FILES['file'], engine='openpyxl', sheet_name=None)
            df1 = excel_data['Sheet1']  # companycontribution upload
            final_df1 = pd.DataFrame(df1)
            companycontribution_obj = final_df1.fillna(np.nan).replace([np.nan], [None]).to_dict(orient='records')
            print(companycontribution_obj)
            for companycontribution_data in companycontribution_obj:
                data_obj = CompanyContributionService(scope).payrollmaster_companycontribution_upload(companycontribution_data, user_id)
                if data_obj.message != 'INVALID_DATA':
                    data = data_obj.id
                    df2 = excel_data['Sheet2']  # payrollflagmaster
                    dfsheet2 = pd.DataFrame(df2)
                    flagmaster_obj = dfsheet2.fillna(np.nan).replace([np.nan], [None]).to_dict(orient='records')
                    for flagmaster_data in flagmaster_obj:
                        if companycontribution_data['ID'] == flagmaster_data['C_ID']:
                            data_obj1 = PaycomponentFlagmasterService(scope).payrollmaster_paycomflag_upload(flagmaster_data, user_id, FlagRef_Type.COMPANYCONTRIBUTION, data)
            response = HttpResponse(data_obj.get(), content_type="application/json")
        elif action == 'payollmaster_employeepfstructure_upload':
            excel_data = pd.read_excel(request.FILES['file'], engine='openpyxl', sheet_name=None)
            df1 = excel_data['Sheet1']  # employeepfstructure upload
            final_df1 = pd.DataFrame(df1)
            employeepfstructure_obj = final_df1.fillna(np.nan).replace([np.nan], [None]).to_dict(orient='records')
            print(employeepfstructure_obj)
            for employeepfstructure_data in employeepfstructure_obj:
                data_obj = EmployeePFService(scope).payollmaster_employeepfstructure_upload(employeepfstructure_data, user_id)
                if data_obj.message != 'INVALID_DATA':
                    data = data_obj.id
                    df2 = excel_data['Sheet2']  # payrollflagmaster
                    dfsheet2 = pd.DataFrame(df2)
                    flagmaster_obj = dfsheet2.fillna(np.nan).replace([np.nan], [None]).to_dict(orient='records')
                    for flagmaster_data in flagmaster_obj:
                        if employeepfstructure_data['ID'] == flagmaster_data['C_ID']:
                            data_obj1 = PaycomponentFlagmasterService(scope).payrollmaster_paycomflag_upload(flagmaster_data, user_id, FlagRef_Type.PF, data)
            response = HttpResponse(data_obj.get(), content_type="application/json")
        elif action == 'payrollmaster_segment_upload':
            excel_data = pd.read_excel(request.FILES['file'], engine='openpyxl', sheet_name=None)
            df1 = excel_data['Sheet1']  # segment upload
            final_df1 = pd.DataFrame(df1)
            segment_obj = final_df1.fillna(np.nan).replace([np.nan], [None]).to_dict(orient='records')
            print(segment_obj)
            for segment_data in segment_obj:
                data_obj = SegmentMasterService(scope).payrollmaster_segment_upload(segment_data, user_id)
            response = HttpResponse(data_obj.get(), content_type="application/json")
        elif action == 'payrollmaster_segmentmapping_upload':
            excel_data = pd.read_excel(request.FILES['file'], engine='openpyxl', sheet_name=None)
            df1 = excel_data['Sheet1']  # PaycomponentSegmentmapping upload
            final_df1 = pd.DataFrame(df1)
            paycomsegment_mappingobj = final_df1.fillna(np.nan).replace([np.nan], [None]).to_dict(orient='records')
            print(paycomsegment_mappingobj)
            for paycomsegment_mapping_data in paycomsegment_mappingobj:
                data_obj = PayrollSegementMappingService(scope).segmentmapping_upload(paycomsegment_mapping_data,user_id)
            response = HttpResponse(data_obj.get(), content_type="application/json")
        elif action == 'payrolltemplate_upload':
            excel_data = pd.read_excel(request.FILES['file'], engine='openpyxl', sheet_name=None)
            df1 = excel_data['Sheet1']  # payrolltemplate upload
            final_df1 = pd.DataFrame(df1)
            payrolltemplate_obj = final_df1.fillna(np.nan).replace([np.nan], [None]).to_dict(orient='records')
            print(payrolltemplate_obj)
            for payrolltemplate_data in payrolltemplate_obj:
                data_obj = PayrollTemplateService(scope).payrolltemplate_upload(payrolltemplate_data, user_id)
                if data_obj.message != 'INVALID_DATA':
                    data = data_obj.id
                    df2 = excel_data['Sheet2']  # payrollflagmaster
                    dfsheet2 = pd.DataFrame(df2)
                    flagmaster_obj = dfsheet2.fillna(np.nan).replace([np.nan], [None]).to_dict(orient='records')
                    for flagmaster_data in flagmaster_obj:
                        if payrolltemplate_data['ID'] == flagmaster_data['C_ID']:
                            data_obj1 = PaycomponentFlagmasterService(scope).payrollmaster_paycomflag_upload(
                                flagmaster_data, user_id, FlagRef_Type.PAYROLLTEMPLATE, data)
                            paysegmapping = PayrollSegementMappingService(scope).get_segment_and_paycomponent_id(data_obj1.ref_id)
                            for j in paysegmapping:
                                template_creation = PayrollmastermappingService(scope).auto_create_mastermapping(data,j.segment, j.paycomponent, j.segment_percentage, user_id)
            response = HttpResponse(data_obj.get(), content_type="application/json")
        elif action == 'payrollmaster_reportcolumns_upload':
            excel_data = pd.read_excel(request.FILES['file'], engine='openpyxl', sheet_name=None)
            df1 = excel_data['Sheet1']  # reportcolumns upload
            final_df1 = pd.DataFrame(df1)
            reportcolumns_obj = final_df1.fillna(np.nan).replace([np.nan], [None]).to_dict(orient='records')
            print(reportcolumns_obj)
            for reportcolumns_data in reportcolumns_obj:
                data_obj = payrollGradeService(scope).payrollmaster_reportcolumns_upload(reportcolumns_data, user_id)
            response = HttpResponse(data_obj.get(), content_type="application/json")
        elif action == 'payollmaster_reporttemplate_upload':
            excel_data = pd.read_excel(request.FILES['file'], engine='openpyxl', sheet_name=None)
            df1 = excel_data['Sheet1']  # reporttemplate upload
            final_df1 = pd.DataFrame(df1)
            reporttemplate_obj = final_df1.fillna(np.nan).replace([np.nan], [None]).to_dict(orient='records')
            print(reporttemplate_obj)
            for reporttemplate_data in reporttemplate_obj:
                data_obj = payrollGradeService(scope).payollmaster_reporttemplate_upload(reporttemplate_data, user_id)
                if data_obj.message != 'INVALID_DATA':
                    temp_id = data_obj.id
                    df2 = excel_data['Sheet2']  # reporttemplate details
                    dfsheet2 = pd.DataFrame(df2)
                    flagmaster_obj = dfsheet2.fillna(np.nan).replace([np.nan], [None]).to_dict(orient='records')
                    for flagmaster_data in flagmaster_obj:
                        if reporttemplate_data['ID'] == flagmaster_data['C_ID']:
                            data_obj1 = payrollGradeService(scope).reporttemplate_details_upload(flagmaster_data, user_id,temp_id)
            response = HttpResponse(data_obj.get(), content_type="application/json")
        return response

# payrollmaster template upload
@csrf_exempt
@api_view(['POST'])
@authentication_classes([NWisefinAuthentication])
@permission_classes([IsAuthenticated, NWisefinPermission])
def payrollmaster_template_upload(request):
    if request.method == 'POST':
        action = request.GET.get('action', None)
        sheet = request.GET.get('sheet', None)
        if sheet == '1':
            if action == 'payrollmaster_grade_upload':
                finaldf = ['NAME','POINTS','MIN_AMOUNT','MAX_AMOUNT']
                file_name = 'payrollmaster_grade_upload'
            elif action == 'payollmaster_componenttype_upload':
                finaldf = ['NAME','PERCENTAGE','CATEGORY']
                file_name = 'payollmaster_componenttype_upload'
            elif action == 'payrollmaster_payrollcomponent_upload':
                finaldf = ['NAME','ALLOWANCE_TYPE','PERCENTAGE','GRADE','CAT_ID','SUBCAT_ID','GL_NO','FROM_DATE','TO_DATE']
                file_name = 'payrollmaster_payrollcomponent_upload'
            elif action == 'payrollmaster_segment_upload':
                finaldf = ['NAME','COMPONENT_TYPE','TYPE','PERCENTAGE']
                file_name = 'payrollmaster_segment_upload'
            elif action == 'payrollmaster_segmentmapping_upload':
                finaldf = ['PAYCOMPONENT','SEGMENT']
                file_name = 'payrollmaster_segmentmapping_upload'
            elif action == 'payrollmaster_reportcolumns_upload':
                finaldf = ['NAME','TYPE']
                file_name = 'payrollmaster_reportcolumns_upload'
            df = pd.DataFrame(columns=finaldf)
            excel = 'application/vnd.ms-excel'
            format = HttpResponse(content_type=excel)
            writer = pd.ExcelWriter(format, engine='xlsxwriter')
            df.to_excel(writer, sheet_name='Sheet1', index=False)
            writer.close()
            filename = file_name
            format['Content-Disposition'] = 'attachment; filename="' + filename + '.xlsx"'
            return format
        elif sheet == '2':
            if action == 'payollmaster_companycontribution_upload':
                finaldf = ['ID','NAME','PERCENTAGE','EFFECTIVE_FROM','EFFECTIVE_TO','AMOUNT','CAT_ID','SUBCAT_ID','GLNO']
                finaldf1 = ['C_ID','PAYCOMPONENT']
                filename = 'payollmaster_companycontribution_upload'
            elif action == 'payollmaster_employeepfstructure_upload':
                finaldf = ['ID','NAME','PERCENTAGE','AMOUNT','CAT_ID','SUBCAT_ID','GLNO']
                finaldf1 = ['C_ID','PAYCOMPONENT']
                filename = 'payollmaster_employeepfstructure_upload'
            elif action == 'payrolltemplate_upload':
                finaldf = ['ID','NAME','GRADE','GLNO']
                finaldf1 = ['C_ID','SEGMENT']
                filename = 'payrolltemplate_upload'
            elif action == 'payollmaster_reporttemplate_upload':
                finaldf = ['ID','BANK','NAME']
                finaldf1 = ['C_ID','REPORTCOLUMNS','ORDER']
                filename = 'payollmaster_reporttemplate_upload'
            df = pd.DataFrame(columns=finaldf)
            df1 = pd.DataFrame(columns=finaldf1)
            excel = 'application/vnd.ms-excel'
            format = HttpResponse(content_type=excel)
            writer = pd.ExcelWriter(format, engine='xlsxwriter')
            df.to_excel(writer, sheet_name='Sheet1', index=False)
            df1.to_excel(writer, sheet_name='Sheet2', index=False)
            writer.close()
            filename = filename
            format['Content-Disposition'] = 'attachment; filename="' + filename + '.xlsx"'
            return format







