fonchain-fiee/pkg/service/employee/employee.go

package employee

import (
	"encoding/json"
	"errors"
	"fmt"
	"github.com/fonchain_enterprise/fonchain-main/api/account"
	"github.com/fonchain_enterprise/fonchain-main/api/department"
	"github.com/fonchain_enterprise/fonchain-main/api/e_card"
	"github.com/fonchain_enterprise/fonchain-main/api/employee"
	oaApi "github.com/fonchain_enterprise/fonchain-main/api/oa"
	"github.com/fonchain_enterprise/fonchain-main/api/position"
	"github.com/fonchain_enterprise/fonchain-main/api/rule"
	"github.com/fonchain_enterprise/fonchain-main/pkg/e"
	"github.com/fonchain_enterprise/fonchain-main/pkg/logic"
	employeeMod "github.com/fonchain_enterprise/fonchain-main/pkg/model/employee"
	"github.com/fonchain_enterprise/fonchain-main/pkg/model/login"
	"github.com/fonchain_enterprise/fonchain-main/pkg/model/oa_model"
	"github.com/fonchain_enterprise/fonchain-main/pkg/model/union"
	"github.com/fonchain_enterprise/fonchain-main/pkg/model/vo/turnstile"
	"github.com/fonchain_enterprise/fonchain-main/pkg/service"

	account1 "github.com/fonchain_enterprise/fonchain-main/pkg/service/account"
	"github.com/fonchain_enterprise/fonchain-main/pkg/utils"
	employee1 "github.com/fonchain_enterprise/fonchain-main/pkg/utils/employee"
	"github.com/fonchain_enterprise/fonchain-main/pkg/utils/excel"
	"github.com/gin-gonic/gin"
	"github.com/gin-gonic/gin/binding"
	"os"
	"sort"
	"strconv"
	"strings"
	"time"
)

func SearchDictionaryList(c *gin.Context) {
	req := &employee.SearchDictionaryRequest{}
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := service.GrpcEmployeeProvider.SearchDictionaryList(c, req)
	if err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	service.Success(c, res)
	return
}

func CreateEmployeeFile(c *gin.Context) {
	req := &employee.CreateEmployeeFileRequest{}
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	status, err := determineStatus(c, req.WorkingConditionId)
	var PositionUsers []*position.PositionUser
	var LeaveBalancePositionList []*oaApi.LeaveBalancePosition
	for i := 0; i < len(req.DepartmentPostList); i++ {
		dep := &position.PositionUser{
			DepartmentID: req.DepartmentPostList[i].DepartmentId,
			PositionID:   req.DepartmentPostList[i].PostId,
			UserName:     req.Name,
		}
		LeaveBalancePosition := &oaApi.LeaveBalancePosition{
			DepartmentUID: strconv.FormatUint(req.DepartmentPostList[i].DepartmentId, 10),
			PositionUID:   strconv.FormatUint(req.DepartmentPostList[i].PostId, 10),
		}
		PositionUsers = append(PositionUsers, dep)
		LeaveBalancePositionList = append(LeaveBalancePositionList, LeaveBalancePosition)
	}
	user := &union.User{
		Domain:        "fontree",
		NickName:      req.Name,
		TelNum:        req.InPersonTel,
		Password:      e.DEFAULT_PWD,
		Status:        status,
		EnterDate:     req.DateOfEntry,
		PositionUsers: PositionUsers,
		JobNum:        req.JobNumber,
		BirthDate:     req.DateOfBirth,
		Sex:           req.SexId,
		LeftDate:      req.ResignationDate,
		ICNum:         req.CardNumber,
		Source:        "employeeFile",
	}
	err, userRes := account1.UserRegisters(c, *user)
	if err != nil {
		if err.Error() == "账号已存在" {
			service.Error(c, e.InvalidParams, errors.New("手机号已存在"))
			return
		}
		service.Error(c, e.InvalidParams, err)
		return
	}
	req.UserId = userRes.ID
	req.Source = "employeeFile"
	userInfo := login.GetUserInfoFromC(c)
	req.Operator = userInfo.ID
	req.OperatorName = userInfo.NickName
	res, err := service.GrpcEmployeeProvider.CreateEmployeeFile(c, req)
	if err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	if res.Massage != "" {
		service.Error(c, e.InvalidParams, errors.New(res.Massage))
		return
	}
	//查询员工档案
	basicInfo, err := service.GrpcEmployeeProvider.QueryBasicInfoAboutEmployees(c, &employee.QueryBasicInfoAboutEmployeesRequest{
		EmployeeFileId: []uint64{res.Id},
	})
	if err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	_, err = service.GrpcEmployeeProvider.CreateContractRecord(c, &employee.CreateContractRecordRequest{
		EmployeeFileId:     res.Id,
		UserName:           basicInfo.List[0].Name,
		JobNum:             basicInfo.List[0].JobNumber,
		Department:         basicInfo.List[0].DepartmentNames,
		Post:               basicInfo.List[0].PositionNames,
		Company:            basicInfo.List[0].CompanyName,
		CostCenter:         basicInfo.List[0].CostCenterName,
		IdNumber:           basicInfo.List[0].IdNumber,
		DateOfEntry:        basicInfo.List[0].DateOfEntry,
		StartLaborContract: req.LaborContractStart,
		EndLaborContract:   req.LaborContractEnd,
		ContractTypeId:     req.ContractTypeId,
		ContractAnnex:      req.ContractForm,
	})
	if err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	//绑定考勤组
	_ = employee1.BindTheDefaultAttendanceGroup(c, res.Id, req.DepartmentPostList)

	//创建假勤余额
	err = employee1.CreateAFalseAttendanceBalance(c, req, res.Id)
	if err != nil {
		fmt.Printf("创建假勤余额错误%+v --------", err)
	}
	// 新增员工电子名片
	addChainRequest, err := account1.GetECardInfo(userRes.ID, "员工档案-新增员工")
	if err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}

	_, err = service.ECardProvider.AddChain(c, addChainRequest)
	if err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	_, _ = employee1.CreateAMallAccount(req, res.Id)
	service.Success(c, res)
	return
}

func UpdateEmployeeFile(c *gin.Context) {
	req := &employee.SaveEmployeeFileRequest{}
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	//查询员工档案
	infoRes, err := service.GrpcEmployeeProvider.QueryBasicInfoAboutEmployees(c, &employee.QueryBasicInfoAboutEmployeesRequest{
		EmployeeFileId: []uint64{req.Id},
	})
	if err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	if len(infoRes.List) == 0 {
		service.Error(c, e.NOTDATA, err)
		return
	}
	employeeList, err := service.GrpcEmployeeProvider.FindEmployeeFileList(c, &employee.FindEmployeeFileListRequest{
		PrecisionJobNumber: req.JobNumber,
	})
	// 检查工号重复的条件：如果有多条记录，或有一条记录但其ID与当前请求的ID不同，则视为重复
	isDuplicate := false
	if employeeList.EmployeeFileList != nil {
		for _, emp := range employeeList.EmployeeFileList {
			if emp.Id != req.Id {
				isDuplicate = true
				break
			}
		}
	}
	if isDuplicate {
		service.Error(c, e.InvalidParams, errors.New("工号重复"))
		return
	}
	userReq := &account.InfoRequest{
		ID: infoRes.List[0].UserId,
	}
	userInfo, err := service.AccountProvider.Info(c, userReq)
	if err != nil {
		service.Error(c, e.InvalidParams, errors.New("获取用户信息失败"))
		return
	}
	// 更新用户信息（如果需要）
	err = updateUserIfNeeded(c, userInfo, req, userInfo.Info.ID)
	if err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	//更新员工档案
	user := login.GetUserInfoFromC(c)
	req.Operator = user.ID
	req.OperatorName = user.NickName
	res, err := service.GrpcEmployeeProvider.SaveEmployeeFile(c, req)
	if err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	//更新部门岗位关系
	if len(req.DepartmentPostList) != 0 {
		var departmentPost []*employee.DepartmentalPosition
		for _, i := range req.DepartmentPostList {
			departmentPost = append(departmentPost, &employee.DepartmentalPosition{
				DepartmentId: i.DepartmentId,
				PostId:       i.PostId,
			})
		}
		_, _ = service.GrpcEmployeeProvider.UpdateDepartmentPostAssociation(c, &employee.DepartmentPostRequest{
			EmployeeFileId:       req.Id,
			DepartmentalPosition: departmentPost,
		})

	}
	//创建合同信息
	_, err = service.GrpcEmployeeProvider.CreateContractRecord(c, &employee.CreateContractRecordRequest{
		EmployeeFileId:     req.Id,
		UserName:           infoRes.List[0].Name,
		JobNum:             infoRes.List[0].JobNumber,
		Department:         infoRes.List[0].DepartmentNames,
		Post:               infoRes.List[0].PositionNames,
		Company:            infoRes.List[0].CompanyName,
		CostCenter:         infoRes.List[0].CostCenterName,
		IdNumber:           infoRes.List[0].IdNumber,
		DateOfEntry:        infoRes.List[0].DateOfEntry,
		StartLaborContract: req.LaborContractStart,
		EndLaborContract:   req.LaborContractEnd,
		ContractTypeId:     req.ContractTypeId,
		ContractAnnex:      req.ContractForm,
	})
	if err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	modifyContent, _ := json.Marshal(req)
	PreModifiedContent, _ := json.Marshal(infoRes)
	//创建修改记录
	_, _ = service.GrpcEmployeeProvider.CreateAChangeLog(c, &employee.CreateAChangeLogRequest{
		EmployeeFileId:     req.Id,
		UserId:             user.ID,
		UserName:           user.NickName,
		ModifyContent:      string(modifyContent),
		PreModifiedContent: string(PreModifiedContent),
	})
	// 手机号码发生修改，则更新用户电子名片
	if userInfo.Info.TelNum != req.InPersonTel || userInfo.Info.EnterDate != req.DateOfEntry {
		var addChainRequest *e_card.AddChainRequest
		var err2 error
		addChainRequest, err2 = account1.GetECardInfo(infoRes.List[0].UserId, "员工档案-编辑")
		if err2 != nil {
			service.Error(c, e.InvalidParams, err2)
			return
		}

		_, err = service.ECardProvider.AddChain(c, addChainRequest)
		if err != nil {
			service.Error(c, e.InvalidParams, err)
			return
		}
	}

	service.Success(c, res)
	return
}

// MoreNewChanges 添加异动记录
func MoreNewChanges(c *gin.Context) {
	req := &employee.MoreNewChangesRequest{}
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	//查询员工档案
	info := &employee.FindEmployeeFileListRequest{}
	info.Id = req.Id
	infoRes, err := service.GrpcEmployeeProvider.QueryBasicInfoAboutEmployees(c, &employee.QueryBasicInfoAboutEmployeesRequest{
		EmployeeFileId: []uint64{req.Id},
	})
	if err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	if len(infoRes.List) == 0 {
		service.Error(c, e.NOTDATA, err)
		return
	}
	userReq := &rule.RulesRequest{
		AccountID: infoRes.List[0].UserId,
	}
	qres, err := service.RuleProvider.UserInfo(c, userReq)
	if err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	err = updatePosition(c, qres.PositionUsers, req, infoRes.List[0].UserId, infoRes.List[0].Name)
	if err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	if req.TransferRecord.TransactionItem == 1 || req.TransferRecord.TransactionItem == 2 {
		// 获取当前部门和岗位的拼接字符串
		currentDepartments := infoRes.List[0].DepartmentNames
		currentPositions := infoRes.List[0].PositionNames
		req.TransferRecord.BeforeDepartmentName = infoRes.List[0].DepartmentNames
		req.TransferRecord.BeforePostName = infoRes.List[0].PositionNames
		switch req.TransferRecord.TransactionItem {
		case 1: // 岗位相关
			switch req.TransferRecord.TransferType {
			case 1: // 调岗
				currentPositions = strings.Replace(currentPositions, req.TransferRecord.BeforePostName, "", 1)
				req.TransferRecord.LaterPostName = strings.Trim(currentPositions, ",") + "," + req.TransferRecord.LaterPostName
			case 2: // 新增岗位
				req.TransferRecord.LaterPostName = strings.Trim(currentPositions, ",") + "," + req.TransferRecord.LaterPostName
			case 3: // 取消岗位
				req.TransferRecord.LaterDepartmentName = strings.Replace(currentDepartments, req.TransferRecord.LaterDepartmentName, "", 1)
				req.TransferRecord.LaterPostName = strings.Replace(currentPositions, req.TransferRecord.LaterPostName, "", 1)
				req.TransferRecord.LaterDepartmentName = strings.Trim(req.TransferRecord.LaterDepartmentName, ",")
				req.TransferRecord.LaterPostName = strings.Trim(req.TransferRecord.LaterPostName, ",")

			}
		case 2: // 部门相关
			switch req.TransferRecord.TransferType {
			case 1: // 调部门
				currentPositions = strings.Replace(currentDepartments, req.TransferRecord.BeforePostName, "", 1)
				currentDepartments = strings.Replace(currentDepartments, req.TransferRecord.BeforeDepartmentName, "", 1)
				req.TransferRecord.LaterDepartmentName = strings.Trim(currentDepartments, ",") + "," + req.TransferRecord.LaterDepartmentName
				req.TransferRecord.LaterPostName = strings.Trim(currentPositions, ",") + "," + req.TransferRecord.LaterPostName
			case 2: // 新增部门
				req.TransferRecord.LaterDepartmentName = strings.Trim(currentDepartments, ",") + "," + req.TransferRecord.LaterDepartmentName
				req.TransferRecord.LaterPostName = strings.Trim(currentPositions, ",") + "," + req.TransferRecord.LaterPostName
			case 3: // 取消部门
				req.TransferRecord.LaterDepartmentName = strings.Replace(currentDepartments, req.TransferRecord.BeforeDepartmentName, "", 1)
				req.TransferRecord.LaterDepartmentName = strings.Trim(req.TransferRecord.LaterDepartmentName, ",")
				req.TransferRecord.LaterPostName = strings.Replace(currentDepartments, req.TransferRecord.BeforePostName, "", 1)
				req.TransferRecord.LaterPostName = strings.Trim(req.TransferRecord.LaterPostName, ",")
			}
		}
	}

	res, err := service.GrpcEmployeeProvider.MoreNewChanges(c, req)
	if err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	if req.TransferRecord.ContractTypeId != 0 {
		_, err = service.GrpcEmployeeProvider.CreateContractRecord(c, &employee.CreateContractRecordRequest{
			EmployeeFileId:     req.Id,
			UserName:           infoRes.List[0].Name,
			JobNum:             infoRes.List[0].JobNumber,
			Department:         infoRes.List[0].DepartmentNames,
			Post:               infoRes.List[0].PositionNames,
			Company:            infoRes.List[0].CompanyName,
			CostCenter:         infoRes.List[0].CostCenterName,
			IdNumber:           infoRes.List[0].IdNumber,
			DateOfEntry:        infoRes.List[0].DateOfEntry,
			StartLaborContract: req.TransferRecord.StartLaborContract,
			EndLaborContract:   req.TransferRecord.EndLaborContract,
			ContractTypeId:     req.TransferRecord.ContractTypeId,
			ContractAnnex:      req.TransferRecord.ContractAnnex,
		})
		if err != nil {
			service.Error(c, e.InvalidParams, err)
			return
		}
	}
	// 存在岗位和部门变动，进行新建电子名片操作
	if req.TransferRecord.TransactionItem == 1 || req.TransferRecord.TransactionItem == 2 {
		// 新增员工电子名片
		addChainRequest, err := account1.GetECardInfo(infoRes.List[0].UserId, "员工档案-异动")
		if err != nil {
			service.Error(c, e.InvalidParams, err)
			return
		}

		_, err = service.ECardProvider.AddChain(c, addChainRequest)
		if err != nil {
			service.Error(c, e.InvalidParams, err)
			return
		}
	}

	service.Success(c, res)
	return
}

// TheAttendanceGroupIsSet 设置考勤组
func TheAttendanceGroupIsSet(c *gin.Context) {
	req := &employee.AttendanceGroupRequest{}
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := service.GrpcEmployeeProvider.TheAttendanceGroupIsSet(c, req)
	if err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	service.Success(c, res)
	return
}
func FindEmployeeFileList(c *gin.Context) {
	req := &employee.FindEmployeeFileListRequest{}
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	isLeader, employeeIds, err := employee1.IsHaveEmployeeAuth(c)
	if err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	if isLeader == false {
		req.Ids = employeeIds
	}

	res, err := service.GrpcEmployeeProvider.FindEmployeeFileList(c, req)
	if err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	if len(res.EmployeeFileList) == 0 {
		service.Success(c, res)
		return
	}
	departmentIDs := logic.GetUniqueDepartmentIDs(res.EmployeeFileList)
	depRes, err := service.DepartmentProvider.Details(c, &department.DetailsRequest{
		IDs: departmentIDs,
	})
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}
	departmentMap := make(map[uint64]string)
	positionMap := make(map[uint64]string)
	for _, detail := range depRes.Data {
		departmentMap[detail.ID] = detail.Name
		for _, i := range detail.AllPositions {
			positionMap[uint64(i.ID)] = i.Name
		}
	}
	logic.FillDepartmentAndPositionNames(res.EmployeeFileList, departmentMap, positionMap)
	service.Success(c, res)
	return
}
func CreateDisplayColumns(c *gin.Context) {
	req := &employee.CreateDisplayColumnsRequest{}
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	userInfo := login.GetUserInfoFromC(c)
	req.UserId = userInfo.ID
	res, err := service.GrpcEmployeeProvider.CreateDisplayColumns(c, req)
	if err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	service.Success(c, res)
	return
}

func DetailsDisplayColumns(c *gin.Context) {
	req := &employee.FindDisplayColumnsRequest{}
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	userInfo := login.GetUserInfoFromC(c)
	req.UserId = userInfo.ID
	allRes, err := service.GrpcEmployeeProvider.DisplayColumnAll(c, &employee.FindDisplayColumnsRequest{
		Type: req.Type,
	})

	res, err := service.GrpcEmployeeProvider.DetailsDisplayColumns(c, req)
	if err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	detailsColumnMap := make(map[string]struct{})
	for _, col := range res.DisplayColumns {
		detailsColumnMap[col.FieldName] = struct{}{}
	}
	// 遍历 DisplayColumnAll，检查是否有不在 DetailsDisplayColumns 中的 fieldName
	for _, col := range allRes.DisplayColumns {
		if _, exists := detailsColumnMap[col.FieldName]; !exists {
			// 如果 DetailsDisplayColumns 中没有此 fieldName，将该列添加到 res 的 DisplayColumns 末尾
			res.DisplayColumns = append(res.DisplayColumns, col)
		}
	}
	service.Success(c, res)
	return
}

func DisplayColumnAll(c *gin.Context) {
	req := &employee.FindDisplayColumnsRequest{}
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := service.GrpcEmployeeProvider.DisplayColumnAll(c, req)
	if err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	service.Success(c, res)
	return
}
func DownloadExcel(c *gin.Context) {
	req := &employee.FindEmployeeFileListRequest{}
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	//默认不导出未报到的人员
	if req.WorkingConditionId == 0 && len(req.Ids) == 0 {
		dictionary, err := service.GrpcEmployeeProvider.SearchDictionaryList(c, &employee.SearchDictionaryRequest{
			Name: "未报到",
			Tag:  "workingCondition",
		})
		if err != nil || len(dictionary.WorkingCondition) == 0 {
			service.Error(c, e.InvalidParams, err)
			return
		}
		req.NotWorkingConditionId = dictionary.WorkingCondition[0].Id
	}
	if len(req.Ids) == 0 {
		isLeader, employeeIds, err := employee1.IsHaveEmployeeAuth(c)
		if err != nil {
			service.Error(c, e.InvalidParams, err)
			return
		}
		if isLeader == false {
			req.Ids = employeeIds
		}
	}

	res, err := service.GrpcEmployeeProvider.FindEmployeeFileList(c, req)
	if err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	dictionaryRes, err := service.GrpcEmployeeProvider.SearchDictionaryList(c, &employee.SearchDictionaryRequest{})

	departmentIDs := logic.GetUniqueDepartmentIDs(res.EmployeeFileList)
	depRes, err := service.DepartmentProvider.Details(c, &department.DetailsRequest{
		IDs: departmentIDs,
	})
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}
	departmentMap := make(map[uint64]string)
	positionMap := make(map[uint64]string)
	for _, detail := range depRes.Data {
		departmentMap[detail.ID] = detail.Name
		for _, i := range detail.AllPositions {
			positionMap[uint64(i.ID)] = i.Name
		}
	}
	userInfo := login.GetUserInfoFromC(c)
	displayRes, err := service.GrpcEmployeeProvider.DetailsDisplayColumns(c, &employee.FindDisplayColumnsRequest{UserId: userInfo.ID, Type: 1})
	logic.FillDepartmentAndPositionNames(res.EmployeeFileList, departmentMap, positionMap)
	err = logic.ExportEmployeeFiles(c, departmentMap, positionMap, res, dictionaryRes, displayRes)
	if err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	return
}
func UpdateUserWorkingCondition(c *gin.Context, userInfo *account.InfoResponse, req *employee.CreateTurnoverRecordRequest) error {
	dictionary, err := service.GrpcEmployeeProvider.SearchDictionaryList(c, &employee.SearchDictionaryRequest{Tag: "workingCondition"})
	m := make(map[string]uint64)
	for _, i := range dictionary.WorkingCondition {
		m[i.Name] = i.Id
	}
	// 比较离职日期和当前日期
	now := time.Now()
	resignationDate, err := time.Parse("2006-01-02", req.ResignationDate)
	if err != nil {
		fmt.Println("日期解析错误:", err)
	}
	nowDate := now.Truncate(24 * time.Hour)
	resignationDate = resignationDate.Truncate(24 * time.Hour)
	// 函数：从映射中获取值，如果键不存在则返回默认值
	getIDOrDefault := func(key string, defaultID uint64) uint64 {
		if id, ok := m[key]; ok {
			return id
		}
		return defaultID
	}
	status := "notactive"
	// 将离职日期字符串解析为时间对象
	if req.ResignationDate != "" && (resignationDate.Before(nowDate) || (resignationDate.Equal(nowDate) && now.Hour() >= 23)) {
		req.WorkingConditionId = getIDOrDefault("离职", 100)
		status = "left"
	} else {
		req.WorkingConditionId = getIDOrDefault("在职", 0)
	}
	//检查是否需要更新用户信息
	if userInfo.Info.Status != status {
		nowOperatorInfo := &account.Operator{Name: "人员档案"}

		operator, err1 := login.GetUserInfoFromCV2(c)
		if err1 == nil && operator != nil {
			nowOperatorInfo.ID = uint32(operator.ID)

			nowOperatorInfo.Name = "人员档案" + operator.NickName
			if strings.Contains(operator.NickName, "审批") {
				nowOperatorInfo.Name = operator.NickName
			}
		}

		// 创建更新请求
		updateUserReq := &account.UpdateRequest{
			Status:   status,
			ID:       userInfo.Info.ID,
			Operator: nowOperatorInfo,
		}

		// 发送更新请求
		_, err = service.AccountProvider.Update(c, updateUserReq)
		if err != nil {
			return err
		}
		return nil
	}
	return nil
}
func updateUserIfNeeded(c *gin.Context, userInfo *account.InfoResponse, req *employee.SaveEmployeeFileRequest, userId uint64) error {
	dictionary, err := service.GrpcEmployeeProvider.SearchDictionaryList(c, &employee.SearchDictionaryRequest{Tag: "workingCondition"})
	if err != nil {
		return err
	}
	m := make(map[string]uint64)
	for _, i := range dictionary.WorkingCondition {
		m[i.Name] = i.Id
	}
	getIDOrDefault := func(key string, defaultID uint64) uint64 {
		if id, ok := m[key]; ok {
			return id
		}
		return defaultID
	}
	status := "left"
	if req.WorkingConditionId == getIDOrDefault("在职", 9999) {
		status = "notactive"
	}
	if len(req.DepartmentPostList) != 0 {
		var PositionUsers []*position.PositionUser
		for _, i := range req.DepartmentPostList {
			PositionUsers = append(PositionUsers, &position.PositionUser{
				PositionID:     i.PostId,
				DepartmentID:   i.DepartmentId,
				UserId:         userId,
				UserName:       userInfo.Info.NickName,
				DepartmentName: i.DepartmentName,
				PositionName:   i.PostName,
			})
		}
		// 创建绑定请求
		positionReq := &position.BindUserRequest{
			Domain:        "fontree",
			UserID:        userId,
			UserName:      userInfo.Info.NickName,
			PositionUsers: PositionUsers,
		}
		// 绑定用户和岗位
		_, err := service.PositionProvider.BindUser(c, positionReq)
		if err != nil {
			return errors.New("岗位绑定失败")
		}
	}
	// 检查是否需要更新用户信息
	if userInfo.Info.TelNum != req.InPersonTel ||
		userInfo.Info.EnterDate != req.DateOfEntry ||
		userInfo.Info.Status != status ||
		userInfo.Info.RecentImg != req.RecentImg ||
		userInfo.Info.JobNum != req.JobNumber ||
		userInfo.Info.NickName != req.Name ||
		userInfo.Info.ICNum != req.CardNumber {
		// 创建更新请求
		updateUserReq := &account.UpdateRequest{
			ID:        userId,
			TelNum:    req.InPersonTel,
			EnterDate: req.DateOfEntry,
			Status:    status,
			RecentImg: req.RecentImg,
			ICNum:     req.CardNumber,
			NickName:  req.Name,
			JobNum:    req.JobNumber,
		}

		nowOperatorInfo := &account.Operator{Name: "人员档案"}

		operator, err1 := login.GetUserInfoFromCV2(c)
		if err1 == nil && operator != nil {
			nowOperatorInfo.ID = uint32(operator.ID)
			nowOperatorInfo.Name = "人员档案:" + operator.NickName
		}

		updateUserReq.Operator = nowOperatorInfo

		// 发送更新请求
		_, err = service.AccountProvider.Update(c, updateUserReq)
		if err != nil {
			return err
		}

		if req.RecentImg != "" && (userInfo.Info.RecentImg != req.RecentImg || userInfo.Info.ICNum != req.CardNumber) {
			list, err := service.AccountProvider.ClockDeviceBatchList(c, &account.ClockBatchBindRequest{
				UserId: []uint64{userId},
			})
			if err != nil {
				fmt.Println("查询打卡机用户失败")
				return err
			}
			var dataSet []turnstile.DeviceUserData
			if len(list.Data) == 0 {
				return nil
			}
			for _, i := range list.Data {
				dataSet = append(dataSet, turnstile.DeviceUserData{
					JobNum:     i.UserId,
					RecentImg:  req.RecentImg,
					DeviceNum:  i.DeviceNum,
					NickName:   userInfo.Info.NickName,
					Phone:      userInfo.Info.TelNum,
					DeviceName: i.DeviceName,
					IcNum:      req.CardNumber,
				})
			}
			err = account1.ConcurrentUpdateDeviceUser(c, dataSet, 10)
			return nil
		}

	}
	return nil
}
func updatePosition(c *gin.Context, currentPositions []*rule.PositionUser, req *employee.MoreNewChangesRequest, userId uint64, userName string) error {
	if req.TransferRecord.TransactionItem != 1 && req.TransferRecord.TransactionItem != 2 {
		return nil
	}
	currentPositionMap := make(map[uint64]uint64)
	for _, pos := range currentPositions {
		currentPositionMap[pos.PositionID] = pos.DepartmentId
	}
	if req.TransferRecord.TransactionItem == 1 {
		switch req.TransferRecord.TransferType {
		case 1: // 调岗
			delete(currentPositionMap, req.TransferRecord.BeforePostId)
			currentPositionMap[req.TransferRecord.LaterPostId] = req.TransferRecord.LaterDepartmentId
		case 2: // 新增岗位
			currentPositionMap[req.TransferRecord.LaterPostId] = req.TransferRecord.LaterDepartmentId
		case 3: // 删除
			delete(currentPositionMap, req.TransferRecord.LaterPostId)
		}
	} else if req.TransferRecord.TransactionItem == 2 {
		switch req.TransferRecord.TransferType {
		case 1: // 调部门
			removeKeysWithValue(currentPositionMap, req.TransferRecord.BeforeDepartmentId) // 删除部门
			//delete(currentPositionMap, req.TransferRecord.BeforePostId)
			currentPositionMap[req.TransferRecord.LaterPostId] = req.TransferRecord.LaterDepartmentId
		case 2: // 新增部门
			currentPositionMap[req.TransferRecord.LaterPostId] = req.TransferRecord.LaterDepartmentId
		case 3: // 删除部门
			removeKeysWithValue(currentPositionMap, req.TransferRecord.LaterDepartmentId) // 删除部门
		}
	}
	// 构建新的 PositionUsers 列表
	var PositionUsers []*position.PositionUser
	for postId, depId := range currentPositionMap {
		PositionUsers = append(PositionUsers, &position.PositionUser{
			PositionID:   postId,
			DepartmentID: depId,
			UserId:       userId,
			UserName:     userName,
		})
	}
	// 创建绑定请求
	positionReq := &position.BindUserRequest{
		Domain:        "fontree",
		UserID:        userId,
		UserName:      userName,
		PositionUsers: PositionUsers,
	}
	// 绑定用户和岗位
	_, err := service.PositionProvider.BindUser(c, positionReq)
	if err != nil {
		return err
	}
	return nil
}
func removeKeysWithValue(m map[uint64]uint64, valueToRemove uint64) {
	for key, value := range m {
		if value == valueToRemove {
			delete(m, key)
		}
	}
}
func determineStatus(c *gin.Context, workingConditionId uint64) (string, error) {
	status := "left"
	dictionary, err := service.GrpcEmployeeProvider.SearchDictionaryList(c, &employee.SearchDictionaryRequest{Id: workingConditionId})
	if err != nil {
		return "", err
	}
	if dictionary.WorkingCondition == nil {
		return "", errors.New("无效的工作状态")
	} else if dictionary.WorkingCondition[0].Name == "在职" {
		status = "notactive"
	}
	return status, nil
}
func DownloadDocx(c *gin.Context) {
	now := time.Now()
	currentYear, currentMonth, _ := now.Date()
	thisMonth25 := time.Date(currentYear, currentMonth, 25, 0, 0, 0, 0, now.Location())
	// 计算上个月的26日
	lastMonth := now.AddDate(0, -1, 0)
	lastMonth26 := time.Date(lastMonth.Year(), lastMonth.Month(), 26, 0, 0, 0, 0, now.Location())
	userInfoAny, _ := c.Get("jwtInfo")
	userInfo := userInfoAny.(login.Info)
	ApplyType := []string{
		oa_model.TypeOverTime,
		oa_model.TypeDayOff,
	}
	ApplyRecordReq := &oaApi.ApplyRecordReq{
		StaffUID:    userInfo.ID,
		BeginTime:   lastMonth26.Format("2006-01-02"),
		EndTime:     thisMonth25.Format("2006-01-02"),
		ApplyType:   ApplyType,
		ApplyStatus: []int32{e.ApprovalWorkStatusOk, e.ApprovalWorkStatusDoing},
		Page:        1,
		PageSize:    100,
	}
	applyRes, _ := service.GrpcOAImpl.QueryOaApply(c, ApplyRecordReq)
	// 遍历并筛选申请记录
	if applyRes.Data == nil {
		service.Error(c, e.InvalidParams, errors.New("无申请记录"))
		return
	}
	filteredApplyData := make([]*oaApi.OAApply, 0)
	for _, record := range applyRes.Data {
		if len(record.ApplyTimes) > 0 {
			validRecord := false // 标志位，初始化为 false
			for _, applyTime := range record.ApplyTimes {
				applyDate, err := time.Parse("2006-01-02", applyTime.Date)
				if err != nil {
					continue
				}
				location, err := time.LoadLocation("Asia/Shanghai")
				if err != nil {
					continue
				}
				// 检查是否是26号凌晨4点之前的记录
				if applyDate.Format("2006-01-02") <= lastMonth26.Format("2006-01-02") {
					applyTimeOfDay, err := time.ParseInLocation("2006-01-02 15:04", applyTime.Date+" "+applyTime.Hour, location)
					if err != nil {
						continue
					}
					if applyTimeOfDay.Before(lastMonth26.Add(4 * time.Hour)) {
						fmt.Println("跳过26号凌晨4点之前的加班记录", applyTimeOfDay, lastMonth26.Add(4*time.Hour))
						continue // 跳过26号凌晨4点之前的加班记录
					}
				}
				validRecord = true
			}
			if validRecord {
				filteredApplyData = append(filteredApplyData, record)
			}
		}
	}
	// 更新applyRes.Data为筛选后的结果
	applyRes.Data = filteredApplyData
	if applyRes.Data == nil {
		service.Error(c, e.InvalidParams, errors.New("无申请记录"))
		return
	}
	// Sorting applyRes.Data based on ApplyTimes.Date
	sort.Slice(applyRes.Data, func(i, j int) bool {
		if len(applyRes.Data[i].ApplyTimes) == 0 {
			return true
		}
		if len(applyRes.Data[j].ApplyTimes) == 0 {
			return false
		}
		timeI, errI := time.Parse("2006-01-02", applyRes.Data[i].ApplyTimes[0].Date)
		timeJ, errJ := time.Parse("2006-01-02", applyRes.Data[j].ApplyTimes[0].Date)
		if errI != nil {
			return true
		}
		if errJ != nil {
			return false
		}
		return timeI.Before(timeJ)
	})
	normalDuration, weekendLength, holidayDuration, totalDuration, compensatoryHours := logic.CalculateDurations(applyRes.Data, ApplyRecordReq.BeginTime, ApplyRecordReq.EndTime)
	var argument strings.Builder
	weekdays := []string{"日", "一", "二", "三", "四", "五", "六"}
	for _, apply := range applyRes.Data {
		if len(apply.ApplyTimes) >= 2 && apply.ApplyType == oa_model.TypeOverTime {
			date, err := time.Parse("2006-01-02", apply.ApplyTimes[0].Date) // 根据你的日期格式调整
			if err != nil {
				fmt.Println("日期解析错误:", err)
				continue
			}
			weekday := date.Weekday()
			argument.WriteString(fmt.Sprintf(
				"%s (周%s) %s-%s（时长：%.1f小时） %s\n",
				apply.ApplyTimes[0].Date,
				weekdays[weekday], // 添加星期几
				apply.ApplyTimes[0].Hour,
				apply.ApplyTimes[1].Hour,
				apply.Hours,
				apply.Reason,
			))
			fmt.Println(argument)
		} else {
			fmt.Println("ApplyTimes 不足以构建 Argument 字符串")
		}
	}
	// 格式化年份、月份和日期
	repl := map[string]string{
		"Name":              userInfo.NickName,
		"Year":              fmt.Sprintf("%d", now.Year()),
		"Month":             fmt.Sprintf("%02d", now.Month()),
		"Day":               fmt.Sprintf("%02d", now.Day()),
		"Argument":          argument.String(), //理由
		"NormalDuration":    normalDuration,    //工作日时长
		"WeekendLength":     weekendLength,     //周末时长
		"HolidayDuration":   holidayDuration,   //节假日时长
		"TotalDuration":     totalDuration,     //总时长
		"CompensatoryHours": compensatoryHours, //总调休时长
	}
	mapImage := make(map[string][]string, 0)
	outputFilePath := "./data/1.docx"
	excel.JinJa2("./data/加班单申请表.docx", outputFilePath, repl, mapImage, map[string][]map[string]string{})
	defer func() {
		err := os.Remove(outputFilePath)
		if err != nil {
			fmt.Println("删除文件失败:", err)
		}
	}()
	// 返回文件给前端
	// 设置正确的 MIME 类型并返回文件
	c.Header("Content-Description", "File Transfer")
	c.Header("Content-Disposition", "attachment; filename=加班单申请表.docx")
	c.Header("Content-Type", "application/vnd.openxmlformats-officedocument.wordprocessingml.document")
	c.File(outputFilePath)
	return
}

// CreateRewardsAndPunishments 创建奖惩记录
func CreateRewardsAndPunishments(c *gin.Context) {
	req := &employee.CreateRewardsAndPunishmentsRequest{}
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	basicInfo, err := service.GrpcEmployeeProvider.QueryBasicInfoAboutEmployees(c, &employee.QueryBasicInfoAboutEmployeesRequest{
		EmployeeFileId: []uint64{req.EmployeeFileId},
	})
	if err != nil && len(basicInfo.List) == 0 {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := service.GrpcEmployeeProvider.CreateRewardsAndPunishments(c, &employee.CreateRewardsAndPunishmentsRequest{
		EmployeeFileId: req.EmployeeFileId,
		Type:           req.Type,
		Amount:         req.Amount,
		Month:          req.Month,
		Date:           req.Date,
		Reason:         req.Reason,
		Department:     basicInfo.List[0].DepartmentNames,
		Post:           basicInfo.List[0].PositionNames,
		Company:        basicInfo.List[0].CompanyName,
		CostCenter:     basicInfo.List[0].CostCenterName,
		UserName:       basicInfo.List[0].Name,
		JobNum:         basicInfo.List[0].JobNumber,
		Tel:            basicInfo.List[0].InPersonTel,
	})
	if err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	service.Success(c, res)
	return
}
func FindRewardsAndPunishments(c *gin.Context) {
	req := &employee.FindRewardsAndPunishmentsListRequest{}
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	isLeader, employeeIds, err := employee1.IsHaveEmployeeAuth(c)
	if err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	if isLeader == false {
		req.EmployeeFileIds = employeeIds
	}
	res, err := service.GrpcEmployeeProvider.FindRewardsAndPunishmentsList(c, req)
	if err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	service.Success(c, res)
	return
}
func DownloadRewardsAndPunishments(c *gin.Context) {
	req := &employee.FindRewardsAndPunishmentsListRequest{}
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	if len(req.Ids) == 0 {
		isLeader, employeeIds, err := employee1.IsHaveEmployeeAuth(c)
		if err != nil {
			service.Error(c, e.InvalidParams, err)
			return
		}
		if isLeader == false {
			req.EmployeeFileIds = employeeIds
		}
	}
	res, err := service.GrpcEmployeeProvider.FindRewardsAndPunishmentsList(c, req)
	if err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	ty := "奖励"
	if req.Type == 2 {
		ty = "扣款"
	}
	titleList := []string{
		"员工姓名", "工号", "部门", "岗位", "公司别", "成本中心", ty + "金额", ty + "月份", ty + "日期", ty + "原因",
	}
	var dataList []interface{}
	for _, i := range res.List {
		data := []any{
			i.UserName,
			i.JobNum,
			i.Department,
			i.Post,
			i.Company,
			i.CostCenter,
			i.Amount,
			i.Month,
			i.Date,
			i.Reason,
		}
		dataList = append(dataList, &data)
	}
	content, err := utils.ToExcelByType(titleList, dataList, "slice", "")
	if err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	utils.ResponseXls(c, content, "奖惩记录")
	return
}
func CreateRewardsAndPunishmentsExcel(c *gin.Context) {
	file, err := c.FormFile("file")
	types := c.PostForm("type")
	if err != nil {
		service.Error(c, e.Error, err)
	}
	safeFilename := fmt.Sprintf("%d", time.Now().Unix()) + "_" + file.Filename
	userInfo := login.GetUserInfoFromC(c)
	fileDir := fmt.Sprintf("/rewards_punish/excel/%s/%s_%s", time.Now().Format("2006-01-02"), userInfo.NickName, safeFilename)
	// 保存上传的文件到本地
	if err = c.SaveUploadedFile(file, safeFilename); err != nil {
		service.Error(c, e.Error, err)
		return
	}
	defer func() {
		if err := os.Remove(safeFilename); err != nil {
			// 处理删除文件失败的情况
			fmt.Println("Failed to delete file:", err)
		}
	}()
	inputUrl, err := service.PutBosWithName(safeFilename, false, fileDir)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}
	employeeList, err := logic.ImportEmployee(c, safeFilename)
	jobNumList := []string{}
	for _, i := range employeeList {
		jobNumList = append(jobNumList, i.JobNumber)
	}
	employeeIdList, err := service.GrpcEmployeeProvider.FindEmployeeFileIDForJobNum(c, &employee.FindEmployeeFileIDForJobNumRequest{JobNumber: jobNumList})
	if err != nil || len(employeeIdList.List) == 0 {
		service.Error(c, e.Error, errors.New("员工档案信息不存在"))
		return
	}
	dictionaryList, err := service.GrpcEmployeeProvider.SearchDictionaryList(c, &employee.SearchDictionaryRequest{})
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}
	employeeCreate, employeeNotin := logic.CombineByJobNumber(employeeList, employeeIdList, dictionaryList)
	employeeFileIds := ""
	CreateRewardsAndPunish := logic.BuildRewardsAndPunishToExcel(employeeCreate, types)
	if CreateRewardsAndPunish == nil {
		service.Error(c, e.Error, errors.New("导入失败，请检查导入文件格式是否正确"))
		return
	}
	for _, i := range CreateRewardsAndPunish {
		_, err = service.GrpcEmployeeProvider.CreateRewardsAndPunishments(c, i)
		if err != nil {
			employeeNotin = append(employeeNotin, &employeeMod.ErrChangesRes{
				Name:      i.UserName,
				JobNumber: i.JobNum,
				Remark:    err.Error(),
			})
		} else {
			employeeFileIds += strconv.FormatUint(i.EmployeeFileId, 10) + ";"
		}
	}
	outUrl := ""
	Status := uint64(0)
	// 生成错误信息
	if len(employeeNotin) > 0 {
		Status = 1
		var sheet1Columns = []string{"姓名", "工号", "备注"}
		var sheet1 = excel.NewSheet("Sheet1", employeeNotin, sheet1Columns)
		ex, err := excel.NewExcelCreatorFromTemplate("demo.xlsx", "./", "", sheet1)
		ex.UseOption(excel.OptionFileNameSuffixWithUnixTime)
		path, _, err := ex.WriteToFile()
		outUrl, err = service.PutBos(path, "", false)
		if err != nil {
			service.Error(c, e.Error, err)
			return
		}
		defer func() {
			os.Remove(path)
		}()
	}
	//创建导入记录
	_, err = service.GrpcEmployeeProvider.CreateImportRecord(c, &employee.CreateImportRecordRequest{
		EmployeeFiles: employeeFileIds,
		Status:        Status,
		UserId:        userInfo.ID,
		ToLeadUrl:     inputUrl,
		DeriveUrl:     outUrl,
		Type:          "rewards_punish",
	})
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}
	service.Success(c, outUrl)
	return
	//res, err := service.GrpcEmployeeProvider.CreateRewardsAndPunishments(c, req)
	//if err != nil {
	//	service.Error(c, e.InvalidParams, err)
	//	return
	//}
	//service.Success(c, res)
}

// CreateTurnoverRecord 创建离职记录
func CreateTurnoverRecord(c *gin.Context) {
	req := &employee.CreateTurnoverRecordRequest{}
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	//查询员工档案
	infoRes, err := service.GrpcEmployeeProvider.QueryBasicInfoAboutEmployees(c, &employee.QueryBasicInfoAboutEmployeesRequest{
		EmployeeFileId: []uint64{req.EmployeeFileId},
	})
	if err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	if len(infoRes.List) == 0 {
		service.Error(c, e.NOTDATA, err)
		return
	}
	userReq := &account.InfoRequest{
		ID: infoRes.List[0].UserId,
	}
	userInfo, err := service.AccountProvider.Info(c, userReq)
	// 更新用户信息（如果需要）
	err = UpdateUserWorkingCondition(c, userInfo, req)
	if err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	basicInfo, err := service.GrpcEmployeeProvider.CreateTurnoverRecord(c, req)
	if err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	service.Success(c, basicInfo)
	return

}

// FindTurnoverRecord 查询离职列表
func FindTurnoverRecord(c *gin.Context) {
	req := &employee.FindTurnoverRecordListRequest{}
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	isLeader, employeeIds, err := employee1.IsHaveEmployeeAuth(c)
	if err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	if isLeader == false {
		req.Ids = employeeIds
	}
	res, err := service.GrpcEmployeeProvider.FindTurnoverRecordList(c, req)
	if err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	if len(res.List) == 0 {
		service.Success(c, res)
		return
	}
	// 提取员工档案ID
	employeeIdS := []uint64{}
	for _, i := range res.List {
		employeeIdS = append(employeeIdS, i.EmployeeFileId)
	}
	// 查询员工档案信息
	infoRes, err := service.GrpcEmployeeProvider.QueryBasicInfoAboutEmployees(c, &employee.QueryBasicInfoAboutEmployeesRequest{
		EmployeeFileId: employeeIdS,
	})
	for _, i := range res.List {
		for _, s := range infoRes.List {
			if i.EmployeeFileId == s.EmployeeFileId {
				i.DepartmentNames = s.DepartmentNames
				i.PositionNames = s.PositionNames
			}
		}
	}
	service.Success(c, res)
	return
}

// DownloadTurnoverRecord 下载离职记录
func DownloadTurnoverRecord(c *gin.Context) {
	req := &employee.FindTurnoverRecordListRequest{}
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	if len(req.Ids) == 0 {
		isLeader, employeeIds, err := employee1.IsHaveEmployeeAuth(c)
		if err != nil {
			service.Error(c, e.InvalidParams, err)
			return
		}
		if isLeader == false {
			req.Ids = employeeIds
		}
	}
	// 获取离职记录列表
	res, err := service.GrpcEmployeeProvider.FindTurnoverRecordList(c, req)
	if err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	// 提取员工档案ID
	employeeIds := []uint64{}
	for _, i := range res.List {
		employeeIds = append(employeeIds, i.EmployeeFileId)
	}
	// 查询员工档案信息
	infoRes, err := service.GrpcEmployeeProvider.QueryBasicInfoAboutEmployees(c, &employee.QueryBasicInfoAboutEmployeesRequest{
		EmployeeFileId: employeeIds,
	})
	if err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	// 定义标题列表
	titleList := []string{
		"员工姓名", "工号", "部门", "岗位", "公司别", "成本中心", "入职日期", "离职日期", "离职原因", "备注",
	}
	// 定义数据结构
	type DataInfo struct {
		UserName    string
		JobNum      string
		Department  string
		Post        string
		Company     string
		CostCenter  string
		DateOfEntry string
		LeaveDate   string
		Reason      string
		Remark      string
	}
	// 创建员工ID到DataInfo的映射
	dataMap := make(map[uint64]*DataInfo)
	for _, info := range infoRes.List {
		dataMap[info.EmployeeFileId] = &DataInfo{
			UserName:    info.Name,
			JobNum:      info.JobNumber,
			Department:  info.DepartmentNames,
			Post:        info.PositionNames,
			Company:     info.CompanyName,
			CostCenter:  info.CostCenterName,
			DateOfEntry: info.DateOfEntry,
		}
	}
	// 填充离职记录的相关信息
	for _, record := range res.List {
		if data, exists := dataMap[record.EmployeeFileId]; exists {
			data.LeaveDate = record.ResignationDate
			data.Reason = record.ReasonForResignation
			data.Remark = record.Remark
		}
	}
	// 生成最终数据列表
	var dataList []interface{}
	for _, data := range dataMap {
		dataList = append(dataList, &[]any{
			data.UserName,
			data.JobNum,
			data.Department,
			data.Post,
			data.Company,
			data.CostCenter,
			data.DateOfEntry,
			data.LeaveDate,
			data.Reason,
			data.Remark,
		})
	}

	// 生成Excel文件
	content, err := utils.ToExcelByType(titleList, dataList, "slice", "")
	if err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}

	// 返回Excel文件
	utils.ResponseXls(c, content, "离职记录")
	return
}

// DownloadPayrollRecordList 下载薪资记录
func DownloadPayrollRecordList(c *gin.Context) {
	req := &employee.FindPayrollRecordListRequest{}
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	if len(req.Ids) == 0 {
		isLeader, employeeIds, err := employee1.IsHaveEmployeeAuth(c)
		if err != nil {
			service.Error(c, e.InvalidParams, err)
			return
		}
		if isLeader == false {
			req.Ids = employeeIds
		}
	}
	res, err := service.GrpcEmployeeProvider.FindPayrollRecordList(c, req)
	if err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	// 提取员工档案ID
	employeeIds := []uint64{}
	for _, i := range res.PayrollRecordList {
		employeeIds = append(employeeIds, i.Id)
	}
	// 查询员工档案信息
	infoRes, err := service.GrpcEmployeeProvider.QueryBasicInfoAboutEmployees(c, &employee.QueryBasicInfoAboutEmployeesRequest{
		EmployeeFileId: employeeIds,
	})
	if err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	// 定义标题列表
	titleList := []string{
		"员工姓名", "工号", "部门", "岗位", "公司别", "成本中心", "工作状态", "基本工资（元）", "主管加给（元）",
		"岗位工资（元）", "绩效工资（元）", "其他津贴（元）", "职称补助（元）", "技能补助（元）", "税前总薪（元）",
	}
	// 定义数据结构
	type DataInfo struct {
		UserName                 string
		JobNum                   string
		Department               string
		Post                     string
		Company                  string
		CostCenter               string
		WorkStatus               string
		BasicPay                 string
		ChiefAddition            string
		PostWage                 string
		MeritPay                 string
		OtherAllowances          string
		ProfessionalTitleSubsidy string
		SkillGrant               string
		PreTaxSalary             string
	}
	// 创建员工ID到DataInfo的映射
	dataMap := make(map[uint64]*DataInfo)
	for _, info := range infoRes.List {
		dataMap[info.EmployeeFileId] = &DataInfo{
			UserName:   info.Name,
			JobNum:     info.JobNumber,
			Department: info.DepartmentNames,
			Post:       info.PositionNames,
			Company:    info.CompanyName,
			CostCenter: info.CostCenterName,
			WorkStatus: info.WorkingCondition,
		}
	}
	// 填充离职记录的相关信息
	for _, record := range res.PayrollRecordList {
		if data, exists := dataMap[record.Id]; exists {
			data.BasicPay = logic.Float64ToString(float64(record.BasicPay))
			data.ChiefAddition = logic.Float64ToString(float64(record.ChiefAddition))
			data.PostWage = logic.Float64ToString(float64(record.PostWage))
			data.MeritPay = logic.Float64ToString(float64(record.MeritPay))
			data.OtherAllowances = logic.Float64ToString(float64(record.OtherAllowances))
			data.ProfessionalTitleSubsidy = logic.Float64ToString(float64(record.ProfessionalTitleSubsidy))
			data.SkillGrant = logic.Float64ToString(float64(record.SkillGrant))
			data.PreTaxSalary = logic.Float64ToString(float64(record.PreTaxSalary))
		}
	}
	// 生成最终数据列表
	var dataList []interface{}
	for _, i := range dataMap {
		data := []any{
			i.UserName,
			i.JobNum,
			i.Department,
			i.Post,
			i.Company,
			i.CostCenter,
			i.WorkStatus,
			i.BasicPay,
			i.ChiefAddition,
			i.PostWage,
			i.MeritPay,
			i.OtherAllowances,
			i.ProfessionalTitleSubsidy,
			i.SkillGrant,
			i.PreTaxSalary,
		}
		dataList = append(dataList, &data)
	}

	// 生成Excel文件
	content, err := utils.ToExcelByType(titleList, dataList, "slice", "")
	if err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}

	// 返回Excel文件
	utils.ResponseXls(c, content, "薪资记录")
	return
}

// FindPayrollRecordList 查询薪资记录
func FindPayrollRecordList(c *gin.Context) {
	req := &employee.FindPayrollRecordListRequest{}
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	isLeader, employeeIds, err := employee1.IsHaveEmployeeAuth(c)
	if err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	if isLeader == false {
		req.Ids = employeeIds
	}
	res, err := service.GrpcEmployeeProvider.FindPayrollRecordList(c, req)
	if err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	if len(res.PayrollRecordList) == 0 {
		service.Success(c, res)
		return
	}
	// 提取员工档案ID
	employeeIdS := []uint64{}
	for _, i := range res.PayrollRecordList {
		employeeIdS = append(employeeIdS, i.Id)
	}
	// 查询员工档案信息
	infoRes, err := service.GrpcEmployeeProvider.QueryBasicInfoAboutEmployees(c, &employee.QueryBasicInfoAboutEmployeesRequest{
		EmployeeFileId: employeeIdS,
	})
	for _, i := range res.PayrollRecordList {
		for _, s := range infoRes.List {
			if i.Id == s.EmployeeFileId {
				i.DepartmentNames = s.DepartmentNames
				i.PositionNames = s.PositionNames
			}
		}
	}
	service.Success(c, res)
	return
}

// CreateContractRecord 创建合同记录
func CreateContractRecord(c *gin.Context) {
	req := &employee.CreateContractRecordRequest{}
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	basicInfo, err := service.GrpcEmployeeProvider.QueryBasicInfoAboutEmployees(c, &employee.QueryBasicInfoAboutEmployeesRequest{
		EmployeeFileId: []uint64{req.EmployeeFileId},
	})
	if err != nil && len(basicInfo.List) == 0 {
		service.Error(c, e.InvalidParams, err)
		return
	}
	res, err := service.GrpcEmployeeProvider.CreateContractRecord(c, &employee.CreateContractRecordRequest{
		EmployeeFileId:     req.EmployeeFileId,
		UserName:           basicInfo.List[0].Name,
		JobNum:             basicInfo.List[0].JobNumber,
		Department:         basicInfo.List[0].DepartmentNames,
		Post:               basicInfo.List[0].PositionNames,
		Company:            basicInfo.List[0].CompanyName,
		CostCenter:         basicInfo.List[0].CostCenterName,
		IdNumber:           basicInfo.List[0].IdNumber,
		DateOfEntry:        basicInfo.List[0].DateOfEntry,
		StartLaborContract: req.StartLaborContract,
		EndLaborContract:   req.EndLaborContract,
		ContractTypeId:     req.ContractTypeId,
		ContractAnnex:      req.ContractAnnex,
	})
	if err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	service.Success(c, res)
	return
}

// FindContractRecord 查询合同记录
func FindContractRecord(c *gin.Context) {
	req := &employee.FindContractRecordListRequest{}
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	isLeader, employeeIds, err := employee1.IsHaveEmployeeAuth(c)
	if err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	if isLeader == false {
		req.EmployeeFileIds = employeeIds
	}
	res, err := service.GrpcEmployeeProvider.FindContractRecordList(c, req)
	if err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	service.Success(c, res)
	return
}
func CreateContractExcel(c *gin.Context) {
	file, err := c.FormFile("file")
	if err != nil {
		service.Error(c, e.Error, err)
	}
	safeFilename := fmt.Sprintf("%d", time.Now().Unix()) + "_" + file.Filename
	userInfo := login.GetUserInfoFromC(c)
	fileDir := fmt.Sprintf("/contract/excel/%s/%s_%s", time.Now().Format("2006-01-02"), userInfo.NickName, safeFilename)
	// 保存上传的文件到本地
	if err = c.SaveUploadedFile(file, safeFilename); err != nil {
		service.Error(c, e.Error, err)
		return
	}
	defer func() {
		if err := os.Remove(safeFilename); err != nil {
			// 处理删除文件失败的情况
			fmt.Println("Failed to delete file:", err)
		}
	}()
	inputUrl, err := service.PutBosWithName(safeFilename, false, fileDir)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}
	employeeList, err := logic.ImportEmployee(c, safeFilename)
	jobNumList := []string{}
	for _, i := range employeeList {
		jobNumList = append(jobNumList, i.JobNumber)
	}
	employeeIdList, err := service.GrpcEmployeeProvider.FindEmployeeFileIDForJobNum(c, &employee.FindEmployeeFileIDForJobNumRequest{JobNumber: jobNumList})
	if err != nil || len(employeeIdList.List) == 0 {
		service.Error(c, e.Error, errors.New("员工档案信息不存在"))
		return
	}
	dictionaryList, err := service.GrpcEmployeeProvider.SearchDictionaryList(c, &employee.SearchDictionaryRequest{})
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}
	employeeCreate, employeeNotin := logic.CombineByJobNumber(employeeList, employeeIdList, dictionaryList)
	employeeFileIds := ""
	for _, i := range employeeCreate {
		_, err = service.GrpcEmployeeProvider.CreateContractForExcel(c, i)
		if err != nil {
			employeeNotin = append(employeeNotin, &employeeMod.ErrChangesRes{
				Name:      i.Name,
				JobNumber: i.JobNumber,
				Remark:    err.Error(),
			})
		} else {
			employeeFileIds += strconv.FormatUint(i.EmployeeFileId, 10) + ";"
		}
	}
	outUrl := ""
	Status := uint64(0)
	// 生成错误信息
	if len(employeeNotin) > 0 {
		Status = 1
		var sheet1Columns = []string{"姓名", "工号", "备注"}
		var sheet1 = excel.NewSheet("Sheet1", employeeNotin, sheet1Columns)
		ex, err := excel.NewExcelCreatorFromTemplate("demo.xlsx", "./", "", sheet1)
		ex.UseOption(excel.OptionFileNameSuffixWithUnixTime)
		path, _, err := ex.WriteToFile()
		outUrl, err = service.PutBos(path, "", false)
		if err != nil {
			service.Error(c, e.Error, err)
			return
		}
		defer func() {
			os.Remove(path)
		}()
	}
	//创建导入记录
	_, err = service.GrpcEmployeeProvider.CreateImportRecord(c, &employee.CreateImportRecordRequest{
		EmployeeFiles: employeeFileIds,
		Status:        Status,
		UserId:        userInfo.ID,
		ToLeadUrl:     inputUrl,
		DeriveUrl:     outUrl,
		Type:          "contract",
	})
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}
	service.Success(c, outUrl)
	return
}

// DownloadContractRecord 下载合同记录
func DownloadContractRecord(c *gin.Context) {
	req := &employee.FindContractRecordListRequest{}
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	if len(req.Ids) == 0 {
		isLeader, employeeIds, err := employee1.IsHaveEmployeeAuth(c)
		if err != nil {
			service.Error(c, e.InvalidParams, err)
			return
		}
		if isLeader == false {
			req.EmployeeFileIds = employeeIds
		}
	}
	res, err := service.GrpcEmployeeProvider.FindContractRecordList(c, req)
	if err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	dictionaryRes, err := service.GrpcEmployeeProvider.SearchDictionaryList(c, &employee.SearchDictionaryRequest{
		Tag: "contractType",
	})
	contractTypeMap := logic.CreateDictionaryMap(dictionaryRes.ContractType)
	titleList := []string{
		"员工姓名", "工号", "部门", "岗位", "公司别", "成本中心", "身份证号", "入职日期", "劳动合同（起时间）", "劳动合同（止时间）", "合同类型", "合同附件",
	}
	var dataList []interface{}

	for _, i := range res.ContractRecordInfo {
		ContractAnnexUrl := ""
		if i.ContractAnnex != nil {
			ContractAnnexUrl = i.ContractAnnex.Url
		}
		data := []any{
			i.UserName,
			i.JobNum,
			i.Department,
			i.Post,
			i.Company,
			i.CostCenter,
			i.IdNumber,
			i.DateOfEntry,
			i.StartLaborContract,
			i.EndLaborContract,
			contractTypeMap[i.ContractTypeId],
			ContractAnnexUrl,
		}
		dataList = append(dataList, &data)
	}
	content, err := utils.ToExcelByType(titleList, dataList, "slice", "")
	if err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	utils.ResponseXls(c, content, "奖惩记录")
	return
}
func UpdateContractAttachment(c *gin.Context) {
	req := &employee.UpdateContractAttachmentRequest{}
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
	}
	res, err := service.GrpcEmployeeProvider.UpdateContractAttachment(c, req)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}
	service.Success(c, res)
	return
}
func UpdateChangesAttachment(c *gin.Context) {
	req := &employee.UpdateContractAttachmentRequest{}
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	transferRes, err := service.GrpcEmployeeProvider.FindTransferRecordList(c, &employee.FindTransferRecordListRequest{
		Ids: []uint64{req.Id},
	})
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}
	if len(transferRes.List) == 0 {
		service.Error(c, e.Error, errors.New("未找到变更记录"))
		return
	}
	res, err := service.GrpcEmployeeProvider.UpdateChangesAttachment(c, req)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	if req.ContractTypeId != 0 {
		infoRes, err := service.GrpcEmployeeProvider.QueryBasicInfoAboutEmployees(c, &employee.QueryBasicInfoAboutEmployeesRequest{
			EmployeeFileId: []uint64{transferRes.List[0].EmployeeFileId},
		})
		if err != nil {
			service.Error(c, e.Error, err)
			return
		}
		_, err = service.GrpcEmployeeProvider.CreateContractRecord(c, &employee.CreateContractRecordRequest{
			EmployeeFileId:     infoRes.List[0].EmployeeFileId,
			UserName:           infoRes.List[0].Name,
			JobNum:             infoRes.List[0].JobNumber,
			Department:         infoRes.List[0].DepartmentNames,
			Post:               infoRes.List[0].PositionNames,
			Company:            infoRes.List[0].CompanyName,
			CostCenter:         infoRes.List[0].CostCenterName,
			IdNumber:           infoRes.List[0].IdNumber,
			DateOfEntry:        infoRes.List[0].DateOfEntry,
			StartLaborContract: req.StartLaborContract,
			EndLaborContract:   req.EndLaborContract,
			ContractTypeId:     req.ContractTypeId,
			ContractAnnex:      req.Attachment,
		})
		if err != nil {
			service.Error(c, e.InvalidParams, err)
			return
		}
	}
	service.Success(c, res)
	return
}
func FindChangesRecord(c *gin.Context) {
	req := &employee.FindTransferRecordListRequest{}
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	isLeader, employeeIds, err := employee1.IsHaveEmployeeAuth(c)
	if err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	if isLeader == false {
		req.EmployeeFileIds = employeeIds
	}
	res, err := service.GrpcEmployeeProvider.FindTransferRecordList(c, req)
	if err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	service.Success(c, res)
	return
}

// DownloadChangesRecord 下载异动记录
func DownloadChangesRecord(c *gin.Context) {
	req := &employee.FindTransferRecordListRequest{}
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	if len(req.Ids) == 0 {
		isLeader, employeeIds, err := employee1.IsHaveEmployeeAuth(c)
		if err != nil {
			service.Error(c, e.InvalidParams, err)
			return
		}
		if isLeader == false {
			req.EmployeeFileIds = employeeIds
		}
	}
	res, err := service.GrpcEmployeeProvider.FindTransferRecordList(c, req)
	if err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	dictionaryRes, err := service.GrpcEmployeeProvider.SearchDictionaryList(c, &employee.SearchDictionaryRequest{})

	userInfo := login.GetUserInfoFromC(c)
	displayRes, err := service.GrpcEmployeeProvider.DetailsDisplayColumns(c, &employee.FindDisplayColumnsRequest{UserId: userInfo.ID, Type: 2})
	err = logic.ExportTransferRecord(c, res, dictionaryRes, displayRes)
	if err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	return
}
func CreateChangesExcel(c *gin.Context) {
	file, err := c.FormFile("file")
	if err != nil {
		service.Error(c, e.Error, err)
	}
	safeFilename := fmt.Sprintf("%d", time.Now().Unix()) + "_" + file.Filename
	userInfo := login.GetUserInfoFromC(c)
	fileDir := fmt.Sprintf("/changes/excel/%s/%s_%s", time.Now().Format("2006-01-02"), userInfo.NickName, safeFilename)
	// 保存上传的文件到本地
	if err = c.SaveUploadedFile(file, safeFilename); err != nil {
		service.Error(c, e.Error, err)
		return
	}
	defer func() {
		if err := os.Remove(safeFilename); err != nil {
			// 处理删除文件失败的情况
			fmt.Println("Failed to delete file:", err)
		}
	}()
	inputUrl, err := service.PutBosWithName(safeFilename, false, fileDir)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}
	employeeList, err := logic.ImportEmployee(c, safeFilename)
	jobNumList := []string{}
	for _, i := range employeeList {
		jobNumList = append(jobNumList, i.JobNumber)
	}
	employeeIdList, err := service.GrpcEmployeeProvider.FindEmployeeFileIDForJobNum(c, &employee.FindEmployeeFileIDForJobNumRequest{JobNumber: jobNumList})
	if err != nil || len(employeeIdList.List) == 0 {
		service.Error(c, e.Error, errors.New("员工档案信息不存在"))
		return
	}
	dictionaryList, err := service.GrpcEmployeeProvider.SearchDictionaryList(c, &employee.SearchDictionaryRequest{})
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}
	employeeCreate, employeeNotin := logic.CombineByJobNumber(employeeList, employeeIdList, dictionaryList)
	employeeFileIds := ""
	for _, i := range employeeCreate {
		_, err = service.GrpcEmployeeProvider.CreateChangesForExcel(c, i)
		if err != nil {
			employeeNotin = append(employeeNotin, &employeeMod.ErrChangesRes{
				Name:      i.Name,
				JobNumber: i.JobNumber,
				Remark:    err.Error(),
			})
		} else {
			employeeFileIds += strconv.FormatUint(i.EmployeeFileId, 10) + ";"
		}
	}
	outUrl := ""
	Status := uint64(0)
	// 生成错误信息
	if len(employeeNotin) > 0 {
		Status = 1
		var sheet1Columns = []string{"姓名", "工号", "备注"}
		var sheet1 = excel.NewSheet("Sheet1", employeeNotin, sheet1Columns)
		ex, err := excel.NewExcelCreatorFromTemplate("demo.xlsx", "./", "", sheet1)
		ex.UseOption(excel.OptionFileNameSuffixWithUnixTime)
		path, _, err := ex.WriteToFile()
		outUrl, err = service.PutBos(path, "", false)
		if err != nil {
			service.Error(c, e.Error, err)
			return
		}
		defer func() {
			os.Remove(path)
		}()
	}
	//创建导入记录
	_, err = service.GrpcEmployeeProvider.CreateImportRecord(c, &employee.CreateImportRecordRequest{
		EmployeeFiles: employeeFileIds,
		Status:        Status,
		UserId:        userInfo.ID,
		ToLeadUrl:     inputUrl,
		DeriveUrl:     outUrl,
		Type:          "changes",
	})
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}
	service.Success(c, outUrl)
	return
}

// FindReminderList 查询提醒列表
func FindReminderList(c *gin.Context) {
	req := &employee.QueryReminderListRequest{}
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
	}
	isLeader, employeeIds, err := employee1.IsHaveEmployeeAuth(c)
	if err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	if isLeader == false {
		req.EmployeeFileIds = employeeIds
	}
	res, err := service.GrpcEmployeeProvider.QueryReminderList(c, req)
	if err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	service.Success(c, res)
	return
}

// ProcessingReminder 处理提醒
func ProcessingReminder(c *gin.Context) {
	req := &employee.ProcessingReminderRequest{}
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
	}
	res, err := service.GrpcEmployeeProvider.ProcessingReminder(c, req)
	if err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	service.Success(c, res)
	return
}

// QueryOutstanding 处理提醒
func QueryOutstanding(c *gin.Context) {
	req := &employee.QueryOutstandingReq{}
	isLeader, employeeIds, err := employee1.IsHaveEmployeeAuth(c)
	if err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	if isLeader == false {
		req.EmployeeFileIds = employeeIds
	}
	res, err := service.GrpcEmployeeProvider.QueryOutstanding(c, req)
	if err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	service.Success(c, res)
	return
}
func CreateExcel(c *gin.Context) {
	file, err := c.FormFile("file")
	if err != nil {
		service.Error(c, e.Error, err)
	}
	safeFilename := fmt.Sprintf("%d", time.Now().Unix()) + "_" + file.Filename
	userInfo := login.GetUserInfoFromC(c)
	fileDir := fmt.Sprintf("/employee/excel/%s/%s_%s", time.Now().Format("2006-01-02"), userInfo.NickName, safeFilename)
	// 保存上传的文件到本地
	if err = c.SaveUploadedFile(file, safeFilename); err != nil {
		service.Error(c, e.Error, err)
		return
	}
	defer func() {
		if err := os.Remove(safeFilename); err != nil {
			// 处理删除文件失败的情况
			fmt.Println("Failed to delete file:", err)
		}
	}()
	inputUrl, err := service.PutBosWithName(safeFilename, false, fileDir)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}
	employeeList, err := logic.ImportEmployee(c, safeFilename)
	jobNumList := []string{}
	for _, i := range employeeList {
		jobNumList = append(jobNumList, i.JobNumber)
	}
	//userList, err := service.AccountProvider.UsersByTel(c, &account.UsersByTelRequest{
	//	Domain: "fontree",
	//	Tels:   jobNumList,
	//})
	userList, err := service.AccountProvider.UsersByJobNum(c, &account.UsersByJobNumRequest{
		Domain: "fontree",
		JobNum: jobNumList,
	})
	if err != nil || len(userList.Data) == 0 {
		service.Error(c, e.Error, errors.New("用户信息不存在"))
		return
	}

	dictionaryList, err := service.GrpcEmployeeProvider.SearchDictionaryList(c, &employee.SearchDictionaryRequest{})
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}
	for _, i := range userList.Data {
		//获取用户的岗位信息
		uReq := rule.RulesRequest{
			AccountID: i.ID,
		}
		qres, err := service.RuleProvider.UserInfo(c, &uReq)
		if err != nil || len(qres.PositionUsers) == 0 {
			continue
		}
		for _, s := range qres.PositionUsers {
			i.Positions = append(i.Positions, &account.PositionUser{
				PositionID:   s.PositionID,
				DepartmentId: s.DepartmentId,
				UserId:       s.UserId,
			})
		}
	}
	employeeCreate, employeeNotin := logic.CombineByPhone(employeeList, userList, dictionaryList)
	employeeFileIds := ""
	for _, i := range employeeCreate {
		if i.DateOfEntry == "" {
			employeeNotin = append(employeeNotin, &employeeMod.ErrEmployeeRes{
				Name:      i.Name,
				TelNumber: i.InPersonTel,
				JobNumber: i.JobNumber,
				Remark:    "入职日期错误",
			})
			continue
		}
		i.Operator = userInfo.ID
		i.OperatorName = userInfo.NickName
		employeeID, err := service.GrpcEmployeeProvider.CreateEmployeeFile(c, i)
		if err != nil && err.Error() != "此用户已创建员工档案" {
			employeeNotin = append(employeeNotin, &employeeMod.ErrEmployeeRes{
				Name:      i.Name,
				TelNumber: i.InPersonTel,
				JobNumber: i.JobNumber,
				Remark:    err.Error(),
			})
		}
		if err == nil && employeeID.Massage == "此用户已创建员工档案" {
			saveEmployee := employee1.BuildSaveEmployeeFile(i, employeeID.Id)
			saveEmployee.Operator = userInfo.ID
			saveEmployee.OperatorName = userInfo.NickName
			_, err = service.GrpcEmployeeProvider.SaveEmployeeFile(c, saveEmployee)
			if err != nil {
				employeeNotin = append(employeeNotin, &employeeMod.ErrEmployeeRes{
					Name:      i.Name,
					TelNumber: i.InPersonTel,
					JobNumber: i.JobNumber,
					Remark:    err.Error(),
				})
			}
		}
		if err == nil {
			//绑定默认考勤组
			_ = employee1.BindTheDefaultAttendanceGroup(c, employeeID.Id, i.DepartmentPostList)
			employeeFileIds += strconv.FormatUint(employeeID.Id, 10) + ";"
			//创建假勤余额
			err = employee1.CreateAFalseAttendanceBalance(c, i, employeeID.Id)
			if err != nil {
				fmt.Printf("创建假勤余额错误%+v --------", err)
			}
		}
	}
	outUrl := ""
	Status := uint64(0)
	// 生成错误信息
	if len(employeeNotin) > 0 {
		Status = 1
		var sheet1Columns = []string{"姓名", "手机号", "工号", "备注"}
		var sheet1 = excel.NewSheet("Sheet1", employeeNotin, sheet1Columns)
		ex, err := excel.NewExcelCreatorFromTemplate("./mistake.xlsx", "./employee/excel/", "", sheet1)
		ex.UseOption(excel.OptionFileNameSuffixWithUnixTime)
		path, _, err := ex.WriteToFile()
		outUrl, err = service.PutBos(path, "", false)
		if err != nil {
			service.Error(c, e.Error, err)
			return
		}
		defer func() {
			os.Remove(path)
		}()
	}
	//创建导入记录
	_, err = service.GrpcEmployeeProvider.CreateImportRecord(c, &employee.CreateImportRecordRequest{
		EmployeeFiles: employeeFileIds,
		Status:        Status,
		UserId:        userInfo.ID,
		ToLeadUrl:     inputUrl,
		DeriveUrl:     outUrl,
		Type:          "employee",
	})
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}
	service.Success(c, outUrl)
	return
}

// QueryStatistics 查询统计
func QueryStatistics(c *gin.Context) {
	req := &employee.QueryStatisticsRequest{}
	isLeader, employeeIds, err := employee1.IsHaveEmployeeAuth(c)
	if err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	if isLeader == false {
		req.Ids = employeeIds
	}
	res, err := service.GrpcEmployeeProvider.QueryStatistics(c, req)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}
	service.Success(c, res)
	return
}

// InitRedisAttendance 初始化考勤组
func InitRedisAttendance(c *gin.Context) {
	req := &employee.InitRedisRequest{}
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
	}
	res, err := service.GrpcEmployeeProvider.InitRedisAttendanceSection(c, req)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}
	service.Success(c, res)
	return
}

// InitRedisRecentImg 初始化近照
func InitRedisRecentImg(c *gin.Context) {
	req := &employee.InitRedisRequest{}
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
	}
	res, err := service.GrpcEmployeeProvider.InitRedisRecentImg(c, req)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}
	service.Success(c, res)
	return
}