fonchain-fiee/pkg/service/oa_new/collection.go

package oa_new

import (
	"context"
	"dubbo.apache.org/dubbo-go/v3/common/logger"
	"fmt"
	"github.com/fonchain_enterprise/fonchain-main/api/department"
	"github.com/fonchain_enterprise/fonchain-main/api/employee"
	"github.com/fonchain_enterprise/fonchain-main/api/oa"
	"github.com/fonchain_enterprise/fonchain-main/api/position"
	"github.com/fonchain_enterprise/fonchain-main/pkg/cache"
	appConfig "github.com/fonchain_enterprise/fonchain-main/pkg/config"
	"github.com/fonchain_enterprise/fonchain-main/pkg/e"
	"github.com/fonchain_enterprise/fonchain-main/pkg/model/login"
	"github.com/fonchain_enterprise/fonchain-main/pkg/serializer"
	"github.com/fonchain_enterprise/fonchain-main/pkg/service"
	"github.com/fonchain_enterprise/fonchain-main/pkg/service/account"
	"github.com/fonchain_enterprise/fonchain-main/pkg/service/oa_new/common"
	"github.com/fonchain_enterprise/fonchain-main/pkg/service/oa_new/model"
	"github.com/fonchain_enterprise/fonchain-main/pkg/service/oa_new/oa_logic"
	"github.com/fonchain_enterprise/fonchain-main/pkg/utils/holiday"
	"github.com/gin-gonic/gin"
	"github.com/gin-gonic/gin/binding"
	"strconv"
	"strings"
	"time"
)

// StaffCollectionDetail 考勤详情
func StaffCollectionDetail(c *gin.Context) {
	req := new(model.CollectionDetailReq)
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	fmt.Println("================ StaffCollectionDetail =======================")
	res := new(model.CollectionDetailRes)
	var err error

	var userInfo login.Info

	if req.StaffUID != 0 {
		userResponse, getUserInfoByIdErr := account.GetUserInfoById(c, req.StaffUID, "")
		if getUserInfoByIdErr != nil {
			msg := ""
			if getUserInfoByIdErr.Error() == "record not found" {
				msg = "查询当前人员信息不存在"
			} else {
				msg = getUserInfoByIdErr.Error()
			}
			service.ResponseMsg(c, e.SUCCESS, serializer.Response{
				Msg:    msg,
				Status: e.Failed,
			})
			return
		}
		userInfo.PositionUsers = userResponse.PositionUsers
	} else {
		userInfo = login.GetUserInfoFromC(c)
	}

	// 查询 考勤信息
	workingTime, workingTimeErr := oa_logic.QueryWorkingTimeInUse(userInfo.PositionUsers, userInfo.ID)
	if workingTimeErr != nil {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    workingTimeErr.Error(),
			Status: e.Failed,
		})
		return
	}

	if req.Month == "" {
		req.Month = holiday.CurrentMonth()
	}

	req.Dates = holiday.SplitMonthV1(req.Month+"-25", common.YYMMDD)

	switch req.CollectionType {
	case model.WorkDay:
		res.Status, res.AllDayLeave, res.AllDayLeaveNum, res.NeedAttendanceDayNum, res.AttendanceDayNum, res.AttendanceRestDayNum, res.AttendanceHolidayNum, res.AttendanceWorkDayNum, res.WorkDay, err = oa_logic.WorkDayMonth(req, workingTime)
		// 剔除 特殊情况的记录
		//res.WorkDay = oa_logic.RemoveRecord(res.WorkDay)
		res.CollectionType = model.WorkDay
	case model.AverageHour:
		res.AverageHour = make([]*model.AverageHourDetail, 0)
		res.TotalHours, res.AverageHourNum, res.AverageHour, err = oa_logic.AverageHour(req, workingTime)
		res.CollectionType = model.AverageHour
	case model.RestDay:
		res.RestDay = make([]*model.RestDayDetail, 0)
		res.RestDayNum, res.RestDay, err = oa_logic.RestDay(req, workingTime)
		res.CollectionType = model.RestDay
	case model.Miss:
		res.Miss = make([]*model.MissDetail, 0)
		res.MissNum, res.Miss, err = oa_logic.MissRecord(req, workingTime)
		res.CollectionType = model.Miss
	case model.MakeUp:
		res.MakeUp = make([]*model.MakeUpDetail, 0)
		res.MakeUpNum, res.MakeUp, err = oa_logic.MakeUpRecord(req, workingTime)
		res.CollectionType = model.MakeUp
	case model.Late:
		res.Late = make([]*model.LateDetail, 0)
		res.LateNum, res.CommonLateNum, res.CommonLateDuration, res.ExtremeLateNum, res.ExtremeLateDuration, res.Late, err = oa_logic.LateRecord(req, workingTime)
		res.CollectionType = model.Late
	case model.Before:
		res.Before = make([]*model.BeforeDetail, 0)
		res.BeforeNum, res.CommonBeforeDuration, res.Before, err = oa_logic.BeforeRecord(req, workingTime)
		res.CollectionType = model.Before
	case model.AbsentDay:
		res.MissDay = make([]*model.MissDayDetail, 0)
		res.MissDayNum, res.MissDay, err = oa_logic.AbsentRecord(req, workingTime)
		res.CollectionType = model.AbsentDay
	case model.OutWork:
		res.OutWork = make([]*model.OutWorkDetail, 0)
		res.OutWorkNum, res.OutWork, err = oa_logic.OutWorkRecord(req, workingTime)
		res.CollectionType = model.OutWork
	case model.OverTime:
		res.OverTimeNum, res.OverTimeDoingNum, res.OverTime, err = oa_logic.OverTimeRecord(req, workingTime)
		res.CollectionType = model.OverTime
	case model.Leave:
		res.Leave = make([]*model.LeaveDetail, 0)
		res.LeaveNum, res.LeaveDoingNum, res.Leave, err = oa_logic.LeaveRecord(req, workingTime)
		res.CollectionType = model.Leave
	case model.AnnualLeave:
		res.AnnualLeave = make([]*model.LeaveDetail, 0)
		res.AnnualLeaveNum, res.AnnualLeaveDoingNum, res.AnnualLeave, err = oa_logic.AnnualLeave(req, workingTime)
		res.CollectionType = model.AnnualLeave
	case model.Sick:
		res.Sick = make([]*model.LeaveDetail, 0)
		res.SickDayNum, res.SickDayDoingNum, res.Sick, err = oa_logic.Sick(req, workingTime)
		res.CollectionType = model.Sick
	case model.BreastFeedingLeave:
		res.BreastFeedingLeave = make([]*model.LeaveDetail, 0)
		res.BreastFeedingLeaveNum, res.BreastFeedingLeaveDoingNum, res.BreastFeedingLeave, err = oa_logic.BreastFeedingLeave(req, workingTime)
		res.CollectionType = model.BreastFeedingLeave
	case model.PaternityLeave:
		res.PaternityLeave = make([]*model.LeaveDetail, 0)
		res.PaternityLeaveNum, res.PaternityLeaveDoingNum, res.PaternityLeave, err = oa_logic.PaternityLeave(req, workingTime)
		res.CollectionType = model.PaternityLeave
	case model.MaritalLeave:
		res.MaritalLeave = make([]*model.LeaveDetail, 0)
		res.MaritalLeaveNum, res.MaritalLeaveDoingNum, res.MaritalLeave, err = oa_logic.MaritalLeave(req, workingTime)
		res.CollectionType = model.MaritalLeave
	case model.FuneralLeave:
		res.FuneralLeave = make([]*model.LeaveDetail, 0)
		res.FuneralLeaveNum, res.FuneralLeaveDoingNum, res.FuneralLeave, err = oa_logic.FuneralLeave(req, workingTime)
		res.CollectionType = model.FuneralLeave
	case model.DayOff:
		res.DayOff = make([]*model.LeaveDetail, 0)
		res.DayOffNum, res.DayOffDoingNum, res.DayOffHours, res.DayOff, err = oa_logic.DayOffRecord(req, workingTime)
		res.CollectionType = model.DayOff
	case model.MaternityLeave:
		res.MaternityLeave = make([]*model.LeaveDetail, 0)
		res.MaternityLeaveNum, res.MaternityLeaveDoingNum, res.MaternityLeave, err = oa_logic.MaternityLeave(req, workingTime)
		res.CollectionType = model.MaternityLeave
	case model.GoOut:
		res.GoOut = make([]*model.LeaveDetail, 0)
		res.GoOutDuration, res.GoOutDurationDoing, res.GoOut, err = oa_logic.GoOutRecord(req, workingTime)
		res.CollectionType = model.GoOut
	case model.BusinessTrip:
		res.BusinessTrip = make([]*model.LeaveDetail, 0)
		res.BusinessTripDuration, res.BusinessTripDurationDoing, res.BusinessTrip, err = oa_logic.BusinessTripRecord(req, workingTime)
		res.CollectionType = model.BusinessTrip
	case model.ParentalLeave:
		res.ParentalLeave = make([]*model.LeaveDetail, 0)
		res.ParentalLeaveNum, res.ParentalLeaveDoingNum, res.ParentalLeave, err = oa_logic.ParentalLeave(req, workingTime)
		res.CollectionType = model.PaternityLeave
	case model.NursingLeave:
		res.NursingLeave = make([]*model.LeaveDetail, 0)
		res.NursingLeaveNum, res.NursingLeaveDoingNum, res.NursingLeave, err = oa_logic.NursingLeave(req, workingTime)
		res.CollectionType = model.NursingLeave
	case model.AbortLeave:
		res.AbortLeave = make([]*model.LeaveDetail, 0)
		res.AbortLeaveNum, res.AbortLeaveDoingNum, res.AbortLeave, err = oa_logic.AbortLeave(req, workingTime)
		res.CollectionType = model.AbortLeave
	case model.MatingCheckLeave:
		res.MatingCheckLeave = make([]*model.LeaveDetail, 0)
		res.MatingCheckLeaveNum, res.MatingCheckLeaveDoingNum, res.MatingCheckLeave, err = oa_logic.MatingCheckLeave(req, workingTime)
		res.CollectionType = model.MatingCheckLeave
	case model.AllLeave:
		res.AllLeaveDetail = make([]*model.AllLeaveDetail, 0)
		res.AllLeaveNum, res.AllLeaveDetail, err = oa_logic.AllLeaveRecord(req, workingTime)
		res.CollectionType = model.AllLeave
	case model.All:
		fmt.Println("================ StaffCollectionDetail  model.All  =======================")
		res, err = oa_logic.AllRecord(req, workingTime)
		// 剔除 特殊情况的记录
		//res.WorkDay = oa_logic.RemoveRecord(res.WorkDay)

		res.CollectionType = model.All
		fmt.Printf("res %+v\n", res)
		fmt.Printf("err %+v\n", err)
	}

	if err != nil {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	res.Month = req.Month
	res.StaffUID = req.StaffUID

	service.ResponseMsg(c, e.SUCCESS, serializer.Response{
		Data:   res,
		Status: e.Ok,
	})

}

// StaffCollectionDetailDate 考勤详情 指定 某一天
func StaffCollectionDetailDate(c *gin.Context) {
	req := new(model.CollectionDetailReq)
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	fmt.Println("================ StaffCollectionDetailDate =======================")
	res := new(model.WorkDayDetail)
	var err error

	if req.Date == "" {
		req.Date = common.CheckIsBeforeFour()
	}

	var userInfo login.Info

	if req.StaffUID != 0 {
		userResponse, getUserInfoByIdErr := account.GetUserInfoById(c, req.StaffUID, "")
		if getUserInfoByIdErr != nil {
			msg := ""
			if getUserInfoByIdErr.Error() == "record not found" {
				msg = "查询当前人员信息不存在"
			} else {
				msg = getUserInfoByIdErr.Error()
			}
			service.ResponseMsg(c, e.SUCCESS, serializer.Response{
				Msg:    msg,
				Status: e.Failed,
			})
			return
		}
		userInfo.PositionUsers = userResponse.PositionUsers
	} else {
		userInfo = login.GetUserInfoFromC(c)
	}

	if req.StaffUID == 0 {
		req.StaffUID = userInfo.ID
	}

	// 查询 考勤信息
	workingTime, workingTimeErr := oa_logic.QueryWorkingTimeInUse(userInfo.PositionUsers, userInfo.ID)
	if workingTimeErr != nil {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    workingTimeErr.Error(),
			Status: e.Failed,
		})
		return
	}

	res, err = oa_logic.WorkDayDate(req, workingTime)

	if err != nil {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	service.ResponseMsg(c, e.SUCCESS, serializer.Response{
		Data:   res,
		Status: e.Ok,
	})

}

// StaffCollectionDetailDates 考勤详情 指定 某些天
func StaffCollectionDetailDates(c *gin.Context) {
	req := new(model.CollectionDetailReq)
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	fmt.Println("================ StaffCollectionDetailDates =======================")
	res := new(model.CollectionDetailRes)
	var err error

	var userInfo login.Info

	if req.StaffUID != 0 {
		userResponse, getUserInfoByIdErr := account.GetUserInfoById(c, req.StaffUID, "")
		if getUserInfoByIdErr != nil {
			msg := ""
			if getUserInfoByIdErr.Error() == "record not found" {
				msg = "查询当前人员信息不存在"
			} else {
				msg = getUserInfoByIdErr.Error()
			}
			service.ResponseMsg(c, e.SUCCESS, serializer.Response{
				Msg:    msg,
				Status: e.Failed,
			})
			return
		}
		userInfo.PositionUsers = userResponse.PositionUsers
	} else {
		userInfo = login.GetUserInfoFromC(c)
	}

	// 查询 考勤信息
	workingTime, workingTimeErr := oa_logic.QueryWorkingTimeInUse(userInfo.PositionUsers, userInfo.ID)
	if workingTimeErr != nil {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    workingTimeErr.Error(),
			Status: e.Failed,
		})
		return
	}

	res.Status, res.AllDayLeave, res.AllDayLeaveNum, res.NeedAttendanceDayNum, res.AttendanceDayNum, res.AttendanceRestDayNum, res.AttendanceHolidayNum, res.AttendanceWorkDayNum, res.WorkDay, err = oa_logic.WorkDayDates(req, workingTime)
	res.CollectionType = req.CollectionType

	// 剔除 特殊情况的记录
	//res.WorkDay = oa_logic.RemoveRecord(res.WorkDay)

	if err != nil {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	res.StaffUID = req.StaffUID

	service.ResponseMsg(c, e.SUCCESS, serializer.Response{
		Data:   res,
		Status: e.Ok,
	})

}

// StaffCollectionDetailMonth 员工考勤详情
func StaffCollectionDetailMonth(c *gin.Context) {
	req := oa.OaMonthReq{}
	if err := c.ShouldBind(&req); err != nil {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	isLeader, staffUids, err := IsCollectionDetailAuth(c)
	if err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	if isLeader == false {
		req.StaffUID = staffUids
	}

	if req.Month != "" {
		staffCollectionDetailMonthWithMonth(c, &req)
	} else {
		staffCollectionDetailMonthWithDates(c, &req)
	}

}
func StaffCollectionMonthDownloadDel(c *gin.Context) {
	req := oa.ExportRecordRes{}
	if err := c.ShouldBind(&req); err != nil {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	res, err := service.GrpcOAImpl.DeleteExportRecord(context.Background(), &req)
	if err != nil {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	service.ResponseMsg(c, e.SUCCESS, serializer.Response{
		Data:   res,
		Status: e.Ok,
	})
	return
}
func StaffCollectionMonthDownloadList(c *gin.Context) {
	req := oa.ExportRecordListReq{}
	if err := c.ShouldBind(&req); err != nil {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	userInfo := login.GetUserInfoFromC(c)
	req.UserId = userInfo.ID
	res, err := service.GrpcOAImpl.ExportRecordList(context.Background(), &req)
	if err != nil {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	service.ResponseMsg(c, e.SUCCESS, serializer.Response{
		Data:   res,
		Status: e.Ok,
	})
	return

}
func StaffCollectionMonthDownload(c *gin.Context) {
	req := oa.OaMonthReq{}
	fieldReq := new(oa.OaMonthFieldReq)
	if err := c.ShouldBind(&req); err != nil {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	userInfo := login.GetUserInfoFromC(c)
	fieldReq.StaffUID = int64(userInfo.ID)
	layout := "2006-01"
	parsedMonth, _ := time.Parse(layout, req.Month)
	startDate := time.Date(parsedMonth.Year(), parsedMonth.Month()-1, 26, 0, 0, 0, 0, time.Local)
	endDate := time.Date(parsedMonth.Year(), parsedMonth.Month(), 25, 0, 0, 0, 0, time.Local)
	fileName := fmt.Sprintf("月度汇总%s~%s.xlsx", startDate.Format("20060102"), endDate.Format("20060102"))
	exportRecordReq := &oa.ExportRecordReq{
		UserId:   userInfo.ID,
		FileName: fileName,
		TaskType: "attendance",
		Status:   2,
		FilePath: "",
	}
	exportRecord, _ := service.GrpcOAImpl.CreateExportRecord(context.Background(), exportRecordReq)
	fmt.Println("=====exportRecord======", exportRecord)
	// 使用 goroutine 异步处理导出任务
	go func() {
		oaMonth, err := service.GrpcOAImpl.QueryOaMonthInfoIsBatch(context.Background(), &req)
		if err != nil {
			exportRecordReq.Status = 3
			exportRecordReq.Id = exportRecord.Id
			exportRecord, _ := service.GrpcOAImpl.UpdateExportRecord(context.Background(), exportRecordReq)
			fmt.Println(exportRecord)
			return
		}
		oaMonthField, err := service.GrpcOAImpl.QueryOaMonthField(context.Background(), fieldReq)
		if err != nil {
			exportRecordReq.Status = 3
			exportRecordReq.Id = exportRecord.Id
			exportRecord, _ := service.GrpcOAImpl.UpdateExportRecord(context.Background(), exportRecordReq)
			fmt.Println(exportRecord)
			return
		}

		//workingTime, workingTimeErr := oa_logic.QueryWorkingTimeInUse(userInfo.PositionUsers, userInfo.ID)
		//if workingTimeErr != nil {
		//	exportRecordReq.Status = 3
		//	exportRecordReq.Id = exportRecord.Id
		//	exportRecord, _ := service.GrpcOAImpl.UpdateExportRecord(context.Background(), exportRecordReq)
		//	fmt.Println(exportRecord)
		//	return
		//}
		var oaMonthList = oa_logic.OaMonthList{
			OaMonth:        oaMonth.OaMonths,
			AttendanceList: make(map[uint64][]oa_logic.ExcelAttendanceInfo),
			AllRecord:      make(map[uint64]model.CollectionDetailRes),
		}
		for _, i := range oaMonth.OaMonths {
			allRecord := &model.CollectionDetailReq{
				StaffUID: i.StaffUID,
				Month:    req.Month,
			}
			workingTime, workingTimeErr := oa_logic.QueryWorkingTimeInUse(nil, i.StaffUID)
			if workingTimeErr != nil {
				continue
				//exportRecordReq.Status = 3
				//exportRecordReq.Id = exportRecord.Id
				//exportRecord, _ := service.GrpcOAImpl.UpdateExportRecord(context.Background(), exportRecordReq)
				//fmt.Println(exportRecord)
				//return
			}
			WorkDay, workDayErr := oa_logic.AllRecord(allRecord, workingTime)
			if workDayErr != nil {
				{
					exportRecordReq.Status = 3
					exportRecordReq.Id = exportRecord.Id
					exportRecord, _ := service.GrpcOAImpl.UpdateExportRecord(context.Background(), exportRecordReq)
					fmt.Println(exportRecord)
					return
				}
			}
			// 生成该员工的考勤信息
			AttendanceList := oa_logic.GenerateAttendanceInfo(WorkDay.WorkDay, i.StaffUID, req.Month)

			// 使用员工的 StaffUID 作为键，存储考勤信息
			oaMonthList.AttendanceList[i.StaffUID] = AttendanceList
			oaMonthList.AllRecord[i.StaffUID] = *WorkDay
		}
		url, err := oa_logic.GenerateExcelFile(c, oaMonthList, oaMonthField, req.Month)
		if err != nil {
			exportRecordReq.Status = 3
			exportRecordReq.Id = exportRecord.Id
			exportRecord, _ := service.GrpcOAImpl.UpdateExportRecord(context.Background(), exportRecordReq)
			fmt.Println(exportRecord)
			return
		}
		exportRecordReq.Status = 1
		exportRecordReq.FilePath = url
		exportRecordReq.Id = exportRecord.Id
		exportRecordReq.DerivationTime = time.Now().Format("2006-01-02 15:04:05")
		exportRecord, _ = service.GrpcOAImpl.UpdateExportRecord(context.Background(), exportRecordReq)
		fmt.Println(exportRecord)
		return
	}()
	service.ResponseMsg(c, e.SUCCESS, serializer.Response{
		Msg:    e.GetMsg(e.SUCCESS),
		Data:   "导出任务已提交，稍后可查看导出结果。",
		Status: e.Ok,
	})
}
func StaffCollectionMonthDownloadOld(c *gin.Context) {
	//req := oa.OaMonthReq{}
	//fieldReq := new(oa.OaMonthFieldReq)
	//if err := c.ShouldBind(&req); err != nil {
	//	service.ResponseMsg(c, e.SUCCESS, serializer.Response{
	//		Msg:    err.Error(),
	//		Status: e.Failed,
	//	})
	//	return
	//}
	//
	//fieldReq.StaffUID = int64(-3)
	//
	//oaMonth, err := service.GrpcOAImpl.QueryOaMonthInfoIsBatch(context.Background(), &req)
	//if err != nil {
	//	service.ResponseMsg(c, e.SUCCESS, serializer.Response{
	//		Msg:    e.ErrQueryOaMonth,
	//		Status: e.Failed,
	//	})
	//	return
	//}
	//oaMonthField, err := service.GrpcOAImpl.QueryOaMonthField(context.Background(), fieldReq)
	//if err != nil {
	//	service.ResponseMsg(c, e.SUCCESS, serializer.Response{
	//		Msg:    e.ErrQueryOaMonth,
	//		Status: e.Failed,
	//	})
	//	return
	//}
	//oa_logic.GenerateExcelFile(c, oaMonth, oaMonthField, req.Month)
}

// 查询员工考勤信息  按照 考勤周期查询
func staffCollectionDetailMonthWithMonth(c *gin.Context, req *oa.OaMonthReq) {

	//if !common.IsBeforeOrEqualCollectionMonth(req.Month) {
	//	service.ResponseMsg(c, e.SUCCESS, serializer.Response{
	//		Msg:    e.ErrorIsNotBeforeOrEqualCollectionMonth,
	//		Status: e.Failed,
	//	})
	//	return
	//}

	go func(req *oa.OaMonthReq) {

		//  创建审批 防止重复提交
		lockKey := fmt.Sprintf("collection_detail_month_%s", req.Month)
		reply := cache.RedisClient.SetNX(lockKey, 0, 15*time.Minute)
		if !reply.Val() {
			return
		}

		// 获取所有员工的信息   分页 默认给 最大值
		accountData, err := oa_logic.GetAllEmployeesInfoForEmployees(nil)
		if err != nil {
			logger.Errorf("GetAllEmployeesInfo err: %v", err)
			return
		}

		// 获取考勤信息
		saveOaMonths, err := oa_logic.GetAttendanceInfoForEmployees(req.Month, accountData)
		if err != nil {
			logger.Errorf("GetAttendanceInfo err: %v", err)
			return
		}

		batch := &oa.SaveOaMonthIsBatch{OaMonths: saveOaMonths}
		saveRes, saveErr := service.GrpcOAImpl.SaveOaMonthInfoIsBatch(context.Background(), batch)
		if saveErr != nil {
			logger.Errorf("SaveOaMonthInfoIsBatch interface err: %v", saveErr.Error())
			return
		}

		if saveRes.Msg != "" {
			logger.Errorf("SaveOaMonthInfoIsBatch return err: %v", saveRes.Msg)
		}
	}(req)

	oaMonth, err := service.GrpcOAImpl.QueryOaMonthInfoIsBatch(context.Background(), req)
	if err != nil {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    e.ErrQueryOaMonth,
			Status: e.Failed,
		})
		return
	}
	// 如果没有OA月度数据，直接返回
	if len(oaMonth.OaMonths) == 0 {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    e.ErrQueryOaMonth,
			Status: e.Failed,
		})
		return
	}

	// 提取EmployeeFileIds
	employeeFileIds := make([]uint64, len(oaMonth.OaMonths))
	for i, oaMonthItem := range oaMonth.OaMonths {
		employeeFileIds[i] = uint64(oaMonthItem.EmployeeID)
	}
	yearStr := strings.Split(req.Month, "-")[0] // 提取年份
	year, err := strconv.ParseInt(yearStr, 10, 32)
	if err != nil {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    e.ErrNotInCurrentYear,
			Status: e.Failed,
		})
		return
	}
	// 获取请假余额列表
	leaveBalance, err := service.GrpcOAImpl.GetLeaveBalanceList(context.Background(), &oa.LeaveBalanceListReq{
		Year:            int32(year),
		EmployeeFileIds: employeeFileIds,
		Page:            1,
		PageSize:        9999,
	})
	if err != nil {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    e.ErrQueryLeaveBalance,
			Status: e.Failed,
		})
		return
	}

	leaveBalanceMap := make(map[uint64]float32)
	for _, leaveItem := range leaveBalance.Data {
		leaveBalanceMap[leaveItem.EmployeeFileId] = leaveItem.AnnualLeave
	}

	// 更新oaMonth中的AnnualLeaveRemaining
	for i := range oaMonth.OaMonths {
		if annualLeave, exists := leaveBalanceMap[uint64(oaMonth.OaMonths[i].EmployeeID)]; exists {
			oaMonth.OaMonths[i].AnnualLeaveRemaining = annualLeave
		}
	}
	oaMonthRes := &model.OaMonthRes{OaMonth: oaMonth}

	service.ResponseMsg(c, e.SUCCESS, serializer.Response{
		Msg:    e.GetMsg(e.SUCCESS),
		Data:   oaMonthRes,
		Status: e.Ok,
	})
}

// 查询员工考勤信息  按照 日期查询
func staffCollectionDetailMonthWithDates(c *gin.Context, req *oa.OaMonthReq) {
	// 获取所有员工的信息  分页 按照前端传递的分页参数
	accountData, err := oa_logic.GetAllEmployeesInfoForEmployees(req.StaffUID)
	if err != nil {
		logger.Errorf("GetAllEmployeesInfo err: %v", err)
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    e.ErrorWorkingTimeFindUser,
			Status: e.Failed,
		})
		return
	}

	// 根据 req 的 DepartmentName 筛选员工
	accountData = oa_logic.FilterEmployeesInfoEmployee(accountData, req.StaffName, req.DepartmentUID, req.Month, req.StartDate, req.EndDate)

	oaMonthRes := new(model.OaMonthRes)
	oaMonthRes.OaDate = new(model.CollectionDetailAllRes)

	collectionDetails := oa_logic.MakeOaMonthByDatesEmployee(req, accountData)
	oaMonthRes.OaDate.OaDates = collectionDetails
	oaMonthRes.OaDate.Page = req.Page
	oaMonthRes.OaDate.PageSize = req.PageSize
	oaMonthRes.OaDate.Total = len(accountData)
	oaMonthRes.OaDate.UpdateTime = common.CurrentTimeStr()

	service.ResponseMsg(c, e.SUCCESS, serializer.Response{
		Msg:    e.GetMsg(e.SUCCESS),
		Data:   oaMonthRes,
		Status: e.Ok,
	})

}

// 员工考勤 权限
func IsCollectionDetailAuth(c *gin.Context) (bool, []uint64, error) {
	userInfo := login.GetUserInfoFromC(c)
	departmentIDs := make([]uint64, len(userInfo.PositionUsers))
	for idx, posUser := range userInfo.PositionUsers {
		departmentIDs[idx] = posUser.DepartmentId
	}
	//判断人是否有员工档案权限
	req := position.SearchDepartmentRequest{
		Domain: "fontree",
		UserId: userInfo.ID,
		Urls:   []string{e.AuthCollectionAllDetailKey},
	}
	res, err := service.PositionProvider.SearchDepartment(c, &req)
	if err == nil && len(res.List) > 0 {
		return true, nil, nil
	}
	if err != nil {
		return false, nil, err
	}
	//查询是否有亿麦权限 Todo 特殊处理数字科技中心的权限  需要优化 暂时写死部门id
	reqMai := position.SearchDepartmentRequest{
		Domain: "fontree",
		UserId: userInfo.ID,
		Urls:   []string{e.AuthCollectionMaiDetailKey},
	}
	resMai, err := service.PositionProvider.SearchDepartment(c, &reqMai)
	if err == nil && len(resMai.List) > 0 {
		departmentID := uint64(0)
		if appConfig.Env == "prod" {
			departmentID = 161
			departmentIDs = append(departmentIDs, departmentID)
		} else if appConfig.Env == "dev" || appConfig.Env == "test" {
			fmt.Println("==========>> 有数字科技中心数据权限")
			departmentID = 161
			fmt.Println("==========>> 当前部门id:", departmentIDs)
			departmentIDs = append(departmentIDs, departmentID)
			fmt.Println("==========>> 添加后的部门id:", departmentIDs)
		}
	}
	departmentU32 := make([]uint32, len(departmentIDs))
	for idx, depID := range departmentIDs {
		departmentU32[idx] = uint32(depID)
	}

	// 获取当前及下属部门
	departmentReq := &department.BaseListV2Request{
		UserId:        uint32(userInfo.ID),
		DepartmentIds: departmentU32,
	}
	//获取当前及下属部门
	departmentRes, err := service.DepartmentProvider.BaseListV2(c, departmentReq)
	if err != nil {
		return false, nil, err
	}
	subDepartmentIDs := make([]uint64, len(departmentRes.List))
	for idx, dep := range departmentRes.List {
		subDepartmentIDs[idx] = dep.ID
	}
	fmt.Println("==========>> 去重后的部门ids:", subDepartmentIDs)
	employeeFile, err := service.GrpcEmployeeProvider.CheckEmployeeFilesByDepartmentID(c, &employee.CheckEmployeeFilesByDepartmentIDRequest{
		DepartmentIds: subDepartmentIDs,
	})
	if err != nil {
		return false, nil, err
	}
	if employeeFile.UserIds == nil {
		employeeFile.UserIds = append(employeeFile.UserIds, 0)
	}
	fmt.Println("==========>> 能查看的档案id:", employeeFile.EmployeeFileId)
	return false, employeeFile.UserIds, nil
}