package approval

import (
	"context"
	"dubbo.apache.org/dubbo-go/v3/common/logger"
	"errors"
	"fmt"
	"github.com/360EntSecGroup-Skylar/excelize"
	"github.com/fonchain_enterprise/fonchain-main/api/account"
	api "github.com/fonchain_enterprise/fonchain-main/api/approval"
	artShowApi "github.com/fonchain_enterprise/fonchain-main/api/artShow"
	"github.com/fonchain_enterprise/fonchain-main/api/artistinfoArtshow"
	"github.com/fonchain_enterprise/fonchain-main/api/department"
	oaApi "github.com/fonchain_enterprise/fonchain-main/api/oa"
	"github.com/fonchain_enterprise/fonchain-main/api/position"
	"github.com/fonchain_enterprise/fonchain-main/pkg/cache"
	"github.com/fonchain_enterprise/fonchain-main/pkg/config"
	"github.com/fonchain_enterprise/fonchain-main/pkg/e"
	"github.com/fonchain_enterprise/fonchain-main/pkg/model"
	"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/vo"
	"github.com/fonchain_enterprise/fonchain-main/pkg/serializer"
	"github.com/fonchain_enterprise/fonchain-main/pkg/service"
	m "github.com/fonchain_enterprise/fonchain-main/pkg/service/approval/model"
	"github.com/fonchain_enterprise/fonchain-main/pkg/service/es_service/approval/logic"
	"github.com/getsentry/sentry-go"
	"github.com/gin-gonic/gin"
	"github.com/gin-gonic/gin/binding"
	"github.com/jinzhu/copier"
	"go.uber.org/zap"
	"sort"
	"strconv"
	"strings"
	"time"
)

func CreateV2(c *gin.Context) {
	var req api.CreateRequest
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.Error, errors.New("参数获取错误"))
		return
	}

	userInfo := login.GetUserInfoFromC(c)
	//  创建审批 防止重复提交
	lockKey := fmt.Sprintf("create_approval_%v_%v", userInfo.ID, req.Type)
	reply := cache.RedisClient.SetNX(lockKey, 0, 10*time.Second)
	if !reply.Val() {
		service.Error(c, e.Error, nil, e.ErrorCreateApproval)
		return
	}

	//提交人
	req.SubmitterName = userInfo.NickName
	req.SubmitterID = userInfo.ID
	fmt.Println("====================提交前处理逻辑=========================")
	// 提交之前的逻辑处理
	err := createBefore(userInfo, &req)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}
	fmt.Println("====================获取审批人=========================")
	approvalAndCopy, err := makeApprovalAndUser(userInfo, &req)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	req.ApprovalUsers = make([]*api.ApprovalUser, 0)
	req.CopyUsers = make([]*api.CopyUser, 0)

	req.ApprovalUsers = approvalAndCopy.ApprovalUsers
	req.CopyUsers = approvalAndCopy.CopyUsers

	fmt.Println("____________________ 打印 请求参数 CreateV2 createRequest 1 ________________________")
	fmt.Printf("CreateV2 createRequest : %+v\n", req)
	fmt.Println("____________________ 打印 请求参数 CreateV2 createRequest 1 ________________________")

	res, err := service.ApprovalProvider.Create(c, &req)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}
	fmt.Println("====================创建后=========================")
	// 提交之后的逻辑处理
	err = createAfter(c, userInfo, &req, res)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	createReq := api.DetailRequest{ID: res.ID, Domain: req.Domain}
	createDetail, detailErr := service.ApprovalProvider.Detail(c, &createReq)
	if detailErr != nil {
		service.Error(c, e.Error, err)
	}

	//创建时推送给第一个审批人
	err = service.SendAppMessage("审批通知", "您有一条"+createDetail.TypeName+"审批待处理，点击查看详情 >", createDetail.NowUserId, createDetail.ID, "approval")
	if err != nil {
		fmt.Println("==============APP推送失败=====================")
		fmt.Println(err)
	}

	service.Success(c, res)
}

// 创建 审批之前 要处理的逻辑
func createBefore(userInfo login.Info, req *api.CreateRequest) (err error) {
	if strings.Contains(req.Type, "turnover") {
		reqList := &api.ListRequest{}
		reqList.Domain = req.Domain
		reqList.Type = "turnover"
		reqList.UserID = userInfo.ID
		reqList.Status = 2
		submitRes2, err := service.ApprovalProvider.MySubmit(context.Background(), reqList)
		if err != nil {
			return errors.New("查询离职申请失败")
		}
		reqList.Status = 1
		submitRes1, err := service.ApprovalProvider.MySubmit(context.Background(), reqList)
		if err != nil {
			return errors.New("查询离职申请失败")
		}

		reqList.Status = 6
		submitRes3, err := service.ApprovalProvider.MySubmit(context.Background(), reqList)
		if err != nil {
			return errors.New("查询离职申请失败")
		}

		if len(submitRes1.Data) > 0 || len(submitRes2.Data) > 0 || len(submitRes3.Data) > 0 {
			return errors.New("用户已提交过离职申请")
		}
	}

	if strings.Contains(req.Type, "handover") {
		reqList := &api.ListRequest{}
		reqList.Domain = req.Domain
		reqList.Type = "handover"
		reqList.UserID = userInfo.ID
		reqList.Status = 2
		submitRes2, err := service.ApprovalProvider.MySubmit(context.Background(), reqList)
		if err != nil {
			return errors.New("查询离职交接失败")
		}
		reqList.Status = 1
		submitRes1, err := service.ApprovalProvider.MySubmit(context.Background(), reqList)
		if err != nil {
			return errors.New("查询离职交接失败")
		}

		reqList.Status = 6
		submitRes3, err := service.ApprovalProvider.MySubmit(context.Background(), reqList)
		if err != nil {
			return errors.New("查询离职交接失败")
		}

		if len(submitRes1.Data) > 0 || len(submitRes2.Data) > 0 || len(submitRes3.Data) > 0 {
			return errors.New("用户已提交过离职交接")
		}
	}

	if req.Type == oa_model.TypeGoOut {
		if req.ApprovalOA.GoOut.Hours == 0 {
			return errors.New(e.ErrorTimeIsZero)
		}
	}

	if req.Type == oa_model.TypeBusinessTrip {
		if req.ApprovalOA.BusinessTrip.TotalDays == 0 {
			return errors.New(e.ErrorTimeIsZero)
		}
	}

	if req.Type == oa_model.TypeMakeUp {
		err = CheckMakeUpApplyApproval(req, userInfo)
		if err != nil {
			//service.Error(c, e.Error, err)
			return err
		}
	}

	if req.Type == oa_model.TypeOverTime {
		err = CheckOverTimeApplyApproval(req, userInfo)
		if err != nil {
			return
		}
	}

	if req.Type == oa_model.TypeOutWork {

		if req.ApprovalOA.OutWork.Hours == 0 {
			return errors.New(e.ErrorTimeIsZero)
		}

		err = CheckLeaveTime(req, userInfo)
		if err != nil {
			//service.Error(c, e.Error, err)
			return err
		}
		err = CheckOutWorkTime(req)
		if err != nil {
			//service.Error(c, e.Error, err)
			return err
		}
	}

	if oa_model.LeaveApplyMap[req.Type] != "" {

		if (req.ApprovalOA.Leave != nil && req.ApprovalOA.Leave.Hours == 0 && req.ApprovalOA.Leave.Days == 0) || (req.ApprovalOA.OverTime != nil && req.ApprovalOA.OverTime.Hours == 0) {
			return errors.New(e.ErrorTimeIsZero)
		}

		err = CheckLeaveTime(req, userInfo)
		if err != nil {
			//service.Error(c, e.Error, err)
			return err
		}

		if oa_model.LeaveApplyMap[req.Type] != "" && req.Type != oa_model.TypeOverTime && req.Type != oa_model.TypeLeave {
			err = CheckLeaveApproval(req, userInfo)
			if err != nil {
				//service.Error(c, e.Error, err)
				return err
			}
		}
	}

	if oa_model.LeaveBalanceApplyMap[req.Type] != "" {
		err = CheckLeaveApply(req, userInfo)
		if err != nil {
			//service.Error(c, e.Error, err)
			return err
		}
	}

	if strings.Contains(req.Type, "employ") {
		if req.Employ.ResumeID != "" {
			resumeID, _ := strconv.ParseInt(req.Employ.ResumeID, 10, 64)
			err = resumeHireJudge(userInfo, resumeID)
			if err != nil {
				//service.Error(c, e.Error, err)
				return err
			}
		}

	}

	if (req.Type == "exhibition" || req.Type == "artExhibitionReward") && req.Exhibition != nil {
		showMap := make(map[string]string)
		for _, exhibition := range req.Exhibition.ApprovalExhibitions {
			if _, ok := showMap[exhibition.PackageID]; !ok {
				showMap[exhibition.PackageID] = exhibition.PackageName
			} else {
				return errors.New("请勿提交重复的画展包")
			}
		}
	}

	if req.Type == oa_model.TypeBusinessTrip {
		err = CheckBusinessTripTime(req, userInfo)
		if err != nil {
			return err
		}
	}

	if req.Type == oa_model.TypeGoOut {
		err = CheckLeaveTime(req, userInfo)
		if err != nil {
			return err
		}
	}
	return nil
}

// 创建 审批之后 要处理的逻辑
func createAfter(c *gin.Context, userInfo login.Info, req *api.CreateRequest, res *api.ApprovalResponse) (err error) {

	// 同步至 es
	go func() {
		fmt.Println("同步至 es ")
		// 查询  审批状态已经 更新的 审批信息
		createReq := api.DetailRequest{ID: res.ID, Domain: req.Domain}
		createDetail, detailErr := service.ApprovalProvider.Detail(c, &createReq)
		if detailErr != nil {
			zap.L().Error("同步至 es 查询审批信息失败", zap.Error(detailErr))
			//return
		}
		fmt.Println("==============================  查询 审批 ========================")
		fmt.Printf("approval detail %+v\n", createDetail)
		fmt.Println("==============================  查询 审批 ========================")

		// 同步至 es
		createErr := logic.CreateIndexApprovalDoc(config.ApprovalIndex, createDetail)
		if createErr != nil {
			zap.L().Error("同步至 es 失败 插入 ", zap.Error(createErr))
			//return
		}
		fmt.Println("同步至 es 查询审批信息成功 ")
	}()

	//此处同步到画展包的数据
	if req.Type == "exhibition" {
		applyId, err := synToArtShow(c, req, res)
		if err != nil {
			//service.Error(c, e.Error, err)
			return err
		}

		upReq := &api.UpdateEhApplyIDRequest{
			ApplyId:    applyId,
			ApprovalID: res.ID,
		}

		_, upErr := service.ApprovalProvider.UpdateExhibitionApplyID(c, upReq)
		if upErr != nil {
			//service.Error(c, e.Error, err)
			return upErr
		}
	}

	fmt.Println("==============================  es before 0  ========================")

	// 同步 oa 审批到  oa
	if e.TypeMap[req.Type] == "oa" {
		fmt.Println("同步 oa系统 ")

		// 查询  审批状态已经 更新的 审批信息
		createReq := api.DetailRequest{ID: res.ID, Domain: req.Domain}
		createDetail, detailErr := service.ApprovalProvider.Detail(c, &createReq)
		if detailErr != nil {
			//service.Error(c, e.Error, err)
			return detailErr
		}

		oaRes, err := SyncApprovalToOA(createDetail)
		if err != nil {
			//service.Error(c, e.Error, err)
			return err
		}

		fmt.Println("更新 oa系统 UUID ")
		// 获取到 OA审批的 UUID  更新 approvalOA 中的 UUID
		updateUUID := &api.UpdateApprovalOAUUIDReq{
			UUID:       oaRes.ID, // OA 返回
			ApplyType:  req.Type,
			ApprovalID: res.ID, // approval 返回
		}
		_, updateUUIDErr := service.ApprovalProvider.UpdateApprovalOAUUID(context.Background(), updateUUID)
		if updateUUIDErr != nil {
			fmt.Printf("updateUUIDErr %+v\n", updateUUIDErr)
			//service.Error(c, e.Error, err)
			return updateUUIDErr
		}
		fmt.Println("更新 oa系统 UUID 成功 ")
		//更新假期余额数据
		if req.Type == oa_model.TypeAnnualLeave || req.Type == oa_model.TypeParentalLeave || req.Type == oa_model.TypeNursingLeave {
			if len(req.ApprovalOA.Leave.ApplyTimes) == 0 {
				return errors.New("获取开始日期失败")
			}
			date, _ := time.Parse("2006-01-02", req.ApprovalOA.Leave.ApplyTimes[0].Date)
			year := int32(date.Year())
			_, err = service.GrpcOAImpl.ModifyTheLeaveBalance(context.Background(), &oaApi.ModifyTheLeaveBalanceReq{
				StaffUid:  req.SubmitterID,
				LeaveType: req.Type,
				Movement:  2,
				Year:      year,
				Days:      req.ApprovalOA.Leave.Days,
			})
			if err != nil {
				fmt.Printf("更新假勤余额失败---%v", err)
			}
			//return err
		}

	}
	fmt.Println("==============================  es before 1  ========================")
	//  人才招聘
	if strings.Contains(req.Type, "staffSupply") {
		err = createPostApprove(c, userInfo, res, req.DepartmentID)
		if err != nil {
			//service.Error(c, e.Error, err)
			return err
		}
	}

	fmt.Println("==============================  es before 2  ========================")

	if strings.Contains(req.Type, "employ") {
		if req.Employ.ResumeID != "" {
			err = createOfferApprove(c, userInfo, res, req.DepartmentID)
			if err != nil {
				//service.Error(c, e.Error, err)
				return err
			}
		}
	}
	//提交离职后扣除年假
	if strings.Contains(req.Type, "turnover") {
		UpdateDeductAnnualLeave(req.ApprovalOA.Turnover, userInfo)
	}
	fmt.Println("==============================  es before 3  ========================")

	return nil
}

func MakeApprovalAndUserV2(c *gin.Context) {
	var req api.CreateRequest
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.Error, err)
		return
	}

	res := new(api.ApprovalAndCopy)

	userInfo := login.GetUserInfoFromC(c)

	if len(userInfo.PositionUsers) > 1 && req.DepartmentID == 0 {
		service.Error(c, e.Error, errors.New(e.ErrorNotSelectDepartment))
		return
	}

	res, err := makeApprovalAndUser(userInfo, &req)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	service.Success(c, res)
}

func makeApprovalAndUser(userInfo login.Info, req *api.CreateRequest) (res *api.ApprovalAndCopy, err error) {

	res = new(api.ApprovalAndCopy)

	// 提交人
	req.SubmitterName = userInfo.NickName
	req.SubmitterID = userInfo.ID

	// 查看 审批类型 的 审批人 以及 抄送人
	settingReq := new(api.DetailSettingRequest)
	settingReq.KeyWord = req.Type
	if req.Domain == "" {
		return nil, errors.New("domain为空（必传）")
	} else {
		settingReq.Domain = req.Domain
	}
	settingRes, err := service.ApprovalProvider.DetailSetting(context.Background(), settingReq)
	if err != nil {
		//service.Error(c, e.Error, errors.New(e.ErrorApprovalUser))
		return nil, errors.New(e.ErrorApprovalUser)
	}

	fmt.Println("=============================================   获取 审批  审批人  ===============================================")
	fmt.Printf("settingRes %+v\n", settingRes)
	fmt.Println("=========================================================================================================================")

	// 判断是否是 特殊的 提交人
	isSpecialSubmitter := false
	if result := cache.RedisClient.Get(fmt.Sprintf(cache.SpecialSubmitter+"_%v", userInfo.TelNum)); result.Err() == nil && result.Val() == "1" {
		isSpecialSubmitter = true
	}

	if m.GetOaType(req.Type) != "" { //OA审批

		fmt.Println("=============================================   进入 OA审批  ===============================================")
		if !isSpecialSubmitter {
			//耿阳接口的doamin是环境，写死
			departmentDomain := "fontree"
			approvaluser, isLeader := DepartmentBossesV3(new(gin.Context), departmentDomain, req.DepartmentID, req.SubmitterID)
			if len(approvaluser) > 0 {
				for index, user := range approvaluser {
					user.Level = uint64(index + 1)
					user.Tier = settingRes.ApprovalUsers[0].Tier
					user.IsDirect = settingRes.ApprovalUsers[0].IsDirect
					user.Signature = "AND"
					user.IsLive = settingRes.ApprovalUsers[0].IsLive
					user.BalanceFillIn = settingRes.ApprovalUsers[0].BalanceFillIn
				}
			}
			req.ApprovalUsers = approvaluser
			req.IsLeader = isLeader
			fmt.Printf("req approvalUsers %+v\n", req.ApprovalUsers)
			fmt.Printf("req leader %+v\n", req.IsLeader)
		}
		res.ApprovalUsers, res.CopyUsers = buildApprovalUsers(userInfo, req, settingRes.ApprovalUsers, settingRes.CopyUsers, settingRes)
		fmt.Println("=============================================    OA审批   获取 审批  审批人  剔除 离职 审批人之前 ===============================================")
		fmt.Printf("res approvalUsers %+v\n", res.ApprovalUsers)
		fmt.Printf("res CopyUsers %+v\n", res.CopyUsers)
		fmt.Println("=============================================================================================================================")
	} else if strings.Contains(req.Type, "staffSupply") || strings.Contains(req.Type, "position") {

		if !isSpecialSubmitter {
			//耿阳接口的doamin是环境，写死
			departmentDomain := "fontree"
			approvaluser, isLeader := DepartmentBossesV3(new(gin.Context), departmentDomain, req.DepartmentID, req.SubmitterID)
			if len(approvaluser) > 0 {
				for index, user := range approvaluser {
					user.Level = uint64(index + 1)
					user.Tier = settingRes.ApprovalUsers[0].Tier
					user.IsDirect = settingRes.ApprovalUsers[0].IsDirect
					user.Signature = "AND"
					user.IsLive = settingRes.ApprovalUsers[0].IsLive
					user.BalanceFillIn = settingRes.ApprovalUsers[0].BalanceFillIn
				}
			}
			req.ApprovalUsers = approvaluser
			req.IsLeader = isLeader
			fmt.Printf("req approvalUsers %+v\n", req.ApprovalUsers)
			fmt.Printf("req leader %+v\n", req.IsLeader)
		}
		res.ApprovalUsers, res.CopyUsers = buildApprovalUsers(userInfo, req, settingRes.ApprovalUsers, settingRes.CopyUsers, settingRes)

		fmt.Println("=============================================   进入 人员增补审批  ===============================================")
		//去重
		//原逻辑：把直属领导追加到审批人后面，去掉前面的重复数据
		//var result []*api.ApprovalUser
		//approvalUserMap := make(map[uint64]*api.ApprovalUser)
		//
		//for _, userReq := range req.ApprovalUsers {
		//	approvalUserMap[userReq.ID] = userReq
		//}
		//for _, userRes := range res.ApprovalUsers {
		//	if _, exists := approvalUserMap[userRes.ID]; !exists {
		//		result = append(result, userRes)
		//	}
		//}
		//res.ApprovalUsers = result
		//res.ApprovalUsers = append(res.ApprovalUsers, req.ApprovalUsers...)
		//for index, ret := range res.ApprovalUsers {
		//	ret.Level = uint64(index + 1)
		//
		//}
		fmt.Printf("把审批人追加到直属领导后面 %+v\n", res.ApprovalUsers)

	} else {

		fmt.Println("=============================================   进入 其他审批  ===============================================")
		/*组装 从配置中获取的 审批人*/
		// 获取任命审批的 审批人
		req.ApprovalUsers = make([]*api.ApprovalUser, 0)
		//approvalUser, err := buildPromotionApprovalUser(req)
		//if err != nil {
		//	return nil, err
		//}
		//
		//if approvalUser != nil {
		//	req.ApprovalUsers = approvalUser
		//}

		// 直属 和 指定部门 需要去查询 account
		res.ApprovalUsers, res.CopyUsers = buildApprovalUsers(userInfo, req, settingRes.ApprovalUsers, settingRes.CopyUsers, settingRes)

		if len(res.ApprovalUsers) == 0 {
			return nil, errors.New(e.ErrorQueryDirectOrDepartmentApprovalUser)
		}

	}

	// 剔除 离职 的 审批人
	res.ApprovalUsers, err = verifyApprovalUserIsActive(res.ApprovalUsers)
	if err != nil {
		//service.Error(c, e.Error, err)
		return nil, err
	}

	fmt.Println("=============================================    OA审批   获取 审批  审批人   剔除 离职 审批人之后 ===============================================")
	fmt.Printf("res approvalUsers %+v\n", res.ApprovalUsers)
	fmt.Printf("res CopyUsers %+v\n", res.CopyUsers)
	fmt.Println("=============================================================================================================================")

	return res, nil
}

// buildApprovalUsers 组装 审批流程
func buildApprovalUsers(userInfo login.Info, req *api.CreateRequest, approvalUsers []*api.ApprovalUser, inCopyUsers []*api.CopyUser, setting *api.SettingRequest) (retApprovalUsers []*api.ApprovalUser, copyUsers []*api.CopyUser) {

	fmt.Println("============   获取 审批 审批人 组装前  ==============")
	fmt.Printf("approvalUsers %+v\n", approvalUsers)
	fmt.Println("============   获取 审批 审批人 组装前  ==============")
	fmt.Println()

	approvalUsers = MakeRetApprovalUser(req, approvalUsers)

	fmt.Println("============   获取 审批 审批人 根据 OA   请假  天数  筛选 审判人 后  ==============")
	fmt.Printf("approvalUsers %+v\n", approvalUsers)
	fmt.Println("============   获取 审批 审批人 根据 OA   请假  天数  筛选 审判人 后  ==============")
	fmt.Println()

	var currentLevel uint64 = 0 // 当前审批节点
	//var approvalUserLevel uint64 = 0 // 审批人节点

	retApprovalUsers = make([]*api.ApprovalUser, 0)
	//signalUsers := make([]*api.ApprovalUser, 0) //指定人员
	retApprovalUsers = append(retApprovalUsers, req.ApprovalUsers...)
	if len(retApprovalUsers) > 0 {
		currentLevel = uint64(len(retApprovalUsers))
	}
	copyUsers = make([]*api.CopyUser, 0)
	retApprovalUsersMap := make(map[uint64]*api.ApprovalUser)
	copyUsersMap := make(map[uint64]*api.CopyUser)
	for _, user := range req.ApprovalUsers {
		retApprovalUsersMap[user.ID] = user
	}
	for i := 0; i < len(approvalUsers); i++ {
		// 判断当前审批节点是否是指定人员 如果不是指定人员 则需要查询 department 获取审批人
		if approvalUsers[i].ID == 0 {

			currentLevel++

			if approvalUsers[i].DepartmentUID != "" && approvalUsers[i].PositionUID != "" {
				listReq := new(account.ListV2Request)
				departmentId, err := strconv.ParseUint(approvalUsers[i].DepartmentUID, 0, 64)
				positionId, err := strconv.ParseUint(approvalUsers[i].PositionUID, 0, 64)
				if err != nil {
					return nil, nil
				}
				listReq.DepartmentId = uint32(departmentId)
				listReq.PositionId = uint32(positionId)
				// 查询部门下的审批人
				listRes, err := service.AccountProvider.ListV2(context.Background(), listReq)
				if err != nil {
					return nil, nil
				}

				fmt.Println("============   获取 审批  指定部门  审批人  ==============")
				fmt.Printf("listRes %+v\n", listRes)
				fmt.Println("============   获取 审批  指定部门  审批人  ==============")
				fmt.Println()

				for j := 0; j < len(listRes.Data); j++ {
					if listRes.Data[j].ID == userInfo.ID && req.Type != "nursingLeaveApply" && req.Type != "parentalLeaveApply" {
						if j == len(listRes.Data)-1 {
							currentLevel--
						}
						continue
					}

					if retApprovalUsersMap[listRes.Data[j].ID] != nil {

						//if req.Type == "nursingLeaveApply" || req.Type == "parentalLeaveApply" {
						//	if req.Domain != "8fa1d8936af32f97aae832a3224bc93d" {
						//		for _, user := range retApprovalUsers {
						//			if user.ID == listRes.Data[j].ID {
						//				retApprovalUsers = DeleteApprovalUser(listRes.Data[j].ID, retApprovalUsers)
						//			}
						//		}
						//	} else {
						//		if j == len(listRes.Data)-1 {
						//			currentLevel--
						//		}
						//		continue
						//	}
						//
						//} else {
						if j == len(listRes.Data)-1 {
							currentLevel--
						}
						continue
						//}
					}
					approvalUser := new(api.ApprovalUser)
					approvalUser.ID = listRes.Data[j].ID
					approvalUser.Name = listRes.Data[j].NickName
					//指定部门有多个审批人，会签时等级++
					if approvalUsers[i].Signature == "AND" && j > 0 {
						currentLevel++
					}
					approvalUser.Level = currentLevel
					approvalUser.Signature = approvalUsers[i].Signature
					approvalUser.Type = approvalUsers[i].Type
					approvalUser.Tier = approvalUsers[i].Tier
					approvalUser.BalanceFillIn = approvalUsers[i].BalanceFillIn
					retApprovalUsers = append(retApprovalUsers, approvalUser)
					retApprovalUsersMap[listRes.Data[j].ID] = approvalUser
				}

			} else if approvalUsers[i].IsDirect == 1 {
				myBossReq := new(department.MyBossesReq)
				if strings.Contains(req.Type, "employ") {
					departmentId, _ := strconv.ParseUint(req.Employ.DepartmentId, 10, 32)
					myBossReq.DepartmentId = uint32(departmentId)
				} else {
					myBossReq.UserId = uint32(userInfo.ID)
					myBossReq.DepartmentId = uint32(req.DepartmentID)
				}

				myBossReq.Level = uint32(approvalUsers[i].Level)
				if approvalUsers[i].IsDesignate == 1 {
					myBossReq.IsDesignate = true
				} else {
					myBossReq.IsDesignate = false
				}

				fmt.Println("============   获取 审批  直属领导  审批人 请求参数 ==============")
				fmt.Printf("myBossReq %+v\n", myBossReq)
				fmt.Println("============   获取 审批  直属领导  审批人 请求参数 ==============")

				myBossRes, err := service.DepartmentProvider.MyBosses(context.Background(), myBossReq)
				if err != nil {
					return nil, nil
				}

				//if req.Type == "position" && len(myBossRes.List) > 1 {
				//	myBossRes.List = myBossRes.List[:1]
				//}

				fmt.Println("============   获取 审批  直属领导  审批人  ==============")
				fmt.Printf("myBossRes %+v\n", myBossRes)
				fmt.Println("============   获取 审批  直属领导  审批人  ==============")
				fmt.Println()

				flag := 0
				for j := 0; j < len(myBossRes.List); j++ {
					if j > 0 && approvalUsers[i].Signature == "OR" {
						currentLevel++
					}
					for k := 0; k < len(myBossRes.List[j].Bosses); k++ {
						if myBossRes.List[j].Bosses[k].ID == uint32(userInfo.ID) {
							if j > 0 && approvalUsers[i].Signature == "OR" {
								currentLevel--
							} else if j == 0 {
								currentLevel--
							}
							if k > 0 {
								currentLevel++
							}
							continue
						}
						if retApprovalUsersMap[uint64(myBossRes.List[j].Bosses[k].ID)] != nil {
							if j > 0 && approvalUsers[i].Signature == "OR" {
								currentLevel--
							} else if j == 0 {
								currentLevel--
							}
							if k > 0 {
								currentLevel++
							}
							continue
						}
						approvalUser := new(api.ApprovalUser)
						approvalUser.ID = uint64(myBossRes.List[j].Bosses[k].ID)
						approvalUser.Name = myBossRes.List[j].Bosses[k].Name
						//直属有多个审批人，会签时等级++
						if approvalUsers[i].Signature == "AND" && flag > 0 {
							currentLevel++
						}

						approvalUser.Level = currentLevel
						fmt.Println("========================currentLevel=========================================")
						fmt.Println(approvalUser.Level)
						fmt.Println(currentLevel)
						approvalUser.IsDirect = approvalUsers[i].IsDirect
						approvalUser.Signature = approvalUsers[i].Signature
						approvalUser.Type = approvalUsers[i].Type
						approvalUser.BalanceFillIn = approvalUsers[i].BalanceFillIn
						approvalUser.IsDesignate = approvalUsers[i].IsDesignate
						approvalUser.Tier = approvalUsers[i].Tier
						retApprovalUsers = append(retApprovalUsers, approvalUser)
						retApprovalUsersMap[uint64(myBossRes.List[j].Bosses[k].ID)] = approvalUser
						flag++
					}
					if myBossRes.List[j].Bosses == nil {
						currentLevel--
					}
				}
				//currentLevel = currentLevel + uint64(len(myBossRes.List)-1)

			}
		} else {
			currentLevel++

			if approvalUsers[i].ID == userInfo.ID {
				currentLevel--
				continue
			}

			if retApprovalUsersMap[approvalUsers[i].ID] != nil {
				currentLevel--
				continue
			}

			approvalUser := new(api.ApprovalUser)
			approvalUser.ID = approvalUsers[i].ID
			approvalUser.Name = approvalUsers[i].Name
			if len(retApprovalUsers) > 0 {
				if approvalUsers[i].Signature == "OR" && retApprovalUsers[len(retApprovalUsers)-1].Type == "designatedPersonnel" && retApprovalUsers[len(retApprovalUsers)-1].Signature == "OR" && approvalUsers[i].Tier == retApprovalUsers[len(retApprovalUsers)-1].Tier {
					approvalUser.Level = retApprovalUsers[len(retApprovalUsers)-1].Level
					currentLevel--
				} else if approvalUsers[i].Signature == "OR" && retApprovalUsers[len(retApprovalUsers)-1].Type == "designatedPersonnel" && retApprovalUsers[len(retApprovalUsers)-1].Signature != "OR" {
					approvalUser.Level = retApprovalUsers[len(retApprovalUsers)-1].Level + 1
				} else {
					approvalUser.Level = currentLevel
				}
			} else {
				approvalUser.Level = currentLevel
			}
			approvalUser.Signature = approvalUsers[i].Signature
			approvalUser.IsDesignate = approvalUsers[i].IsDesignate
			approvalUser.IsDirect = approvalUsers[i].IsDirect
			approvalUser.Tier = approvalUsers[i].Tier
			if approvalUsers[i].Type == "" {
				approvalUser.Type = e.AndSignType
			} else {
				approvalUser.Type = approvalUsers[i].Type
			}
			retApprovalUsers = append(retApprovalUsers, approvalUser)
			retApprovalUsersMap[approvalUsers[i].ID] = approvalUser

		}
	}

	//OA
	// 病假 事假
	// 又要改，完犊子了
	if m.GetOaType(req.Type) != "" {
		if req.Type == "nursingLeaveApply" || req.Type == "parentalLeaveApply" {
			//去重,究极特殊处理，我人晕了
			//if req.IsLeader {
			//	retApprovalUsers = GetCombineOaApproveUsers(setting, retApprovalUsers)
			//} else {
			var result []*api.ApprovalUser
			approvalUserMap := make(map[uint64]*api.ApprovalUser)

			for _, userReq := range setting.OaApprovalUsers {
				approvalUserMap[userReq.ID] = userReq
			}
			for _, userRes := range retApprovalUsers {
				if _, exists := approvalUserMap[userRes.ID]; !exists {
					result = append(result, userRes)
				}
			}
			retApprovalUsers = result
			retApprovalUsers = append(retApprovalUsers, setting.OaApprovalUsers...)
			//var tmpAppUser *api.ApprovalUser
			//tmpAppUser = retApprovalUsers[len(retApprovalUsers)-1]
			//retApprovalUsers[len(retApprovalUsers)-1] = retApprovalUsers[len(retApprovalUsers)-2]
			//retApprovalUsers[len(retApprovalUsers)-2] = tmpAppUser
			//}
			//retApprovalUsers = GetCombineOaApproveUsers(setting, retApprovalUsers)
			//retApprovalUsers[len(retApprovalUsers)-2].BalanceFillIn = 0

			inCopyUsers = GetCombineOaCopyUsers(setting, inCopyUsers)

			//新逻辑：加班/外勤 丧假 陪产假 婚假 育儿假 独生子女护理假 哺乳假 孕检假 年假 调休 出差 外出=====》直属1级
		} else if req.Type == "overTime" ||
			req.Type == "makeUp" ||
			req.Type == "breastFeedingLeave" ||
			req.Type == "dayOff" {
			//if in.IsLeader {
			retApprovalUsers = GetCombineOaApproveUsers(setting, retApprovalUsers)
			if len(retApprovalUsers) > 1 && req.Domain != "8fa1d8936af32f97aae832a3224bc93d" {
				for _, user := range retApprovalUsers[1:] {
					delete(retApprovalUsersMap, user.ID)
				}
				retApprovalUsers = retApprovalUsers[:1]
			}

		}
	}

	// 抄送人，岗位与人员混合，老子真晕了
	// 无特殊处理，与设置保持一致
	for _, copyUser := range inCopyUsers {
		if copyUser.ID == 0 {
			//指定岗位
			if copyUser.DepartmentUID != "" && copyUser.PositionUID != "" {
				listReq := new(account.ListV2Request)
				departmentId, err := strconv.ParseUint(copyUser.DepartmentUID, 0, 64)
				positionId, err := strconv.ParseUint(copyUser.PositionUID, 0, 64)
				if err != nil {
					return nil, nil
				}
				listReq.DepartmentId = uint32(departmentId)
				listReq.PositionId = uint32(positionId)
				// 查询部门下的审批人
				listRes, err := service.AccountProvider.ListV2(context.Background(), listReq)
				if err != nil {
					return nil, nil
				}

				fmt.Println("============   获取 审批  指定部门  抄送人  ==============")
				fmt.Printf("listRes %+v\n", listRes)
				fmt.Println("============   获取 审批  指定部门  抄送人  ==============")
				for _, res := range listRes.Data {
					tmpCopyUser := &api.CopyUser{
						ID:       res.ID,
						Name:     res.NickName,
						IsLive:   copyUser.IsLive,
						Type:     copyUser.Type,
						IsViewed: copyUser.IsViewed,
					}
					if _, exists := copyUsersMap[tmpCopyUser.ID]; !exists {
						if _, existsApproval := retApprovalUsersMap[tmpCopyUser.ID]; !existsApproval {
							if tmpCopyUser.ID != userInfo.ID {
								copyUsers = append(copyUsers, tmpCopyUser)
								copyUsersMap[tmpCopyUser.ID] = tmpCopyUser
							}
						}
					}

				}
			}
		} else {
			//指定人员
			if _, exists := copyUsersMap[copyUser.ID]; !exists {
				if _, existsApproval := retApprovalUsersMap[copyUser.ID]; !existsApproval {
					if copyUser.ID != userInfo.ID {
						copyUsers = append(copyUsers, copyUser)
						copyUsersMap[copyUser.ID] = copyUser
					}

				}
			}
		}

	}

	//剔除掉离职的抄送人
	filterCopyUsers := make([]*api.CopyUser, 0)

	for _, copyU := range copyUsers {
		req1 := new(account.ListByIDsRequest)
		req1.IDs = []uint64{copyU.ID}
		res1, err := service.AccountProvider.ListByIDs(context.Background(), req1)
		if err != nil {
			return nil, nil
		}
		if res1.Data[0].Status == "notactive" {
			filterCopyUsers = append(filterCopyUsers, copyU)
		}
	}
	copyUsers = filterCopyUsers

	for index, singleCopy := range copyUsers {
		singleCopy.Level = uint64(index + 1)
	}

	//for index2, user := range retApprovalUsers {
	//	user.Level = uint64(index2 + 1)
	//}

	fmt.Println("============   获取 审批 审批人 组装后  ==============")
	fmt.Printf("retApprovalUsers %+v\n", retApprovalUsers)
	fmt.Printf("copyUsers %+v\n", copyUsers)
	fmt.Println("============   获取 审批 审批人 组装后  ==============")
	fmt.Println()
	return
}

// 备份
func buildApprovalUsersV2(userInfo login.Info, req *api.CreateRequest, approvalUsers []*api.ApprovalUser, inCopyUsers []*api.CopyUser, setting *api.SettingRequest) (retApprovalUsers []*api.ApprovalUser, copyUsers []*api.CopyUser) {

	fmt.Println("============   获取 审批 审批人 组装前  ==============")
	fmt.Printf("approvalUsers %+v\n", approvalUsers)
	fmt.Println("============   获取 审批 审批人 组装前  ==============")
	fmt.Println()

	var currentLevel uint64 = 0      // 当前审批节点
	var approvalUserLevel uint64 = 0 // 审批人节点

	retApprovalUsers = make([]*api.ApprovalUser, 0)
	copyUsers = make([]*api.CopyUser, 0)
	retApprovalUsersMap := make(map[uint64]*api.ApprovalUser)
	for i := 0; i < len(approvalUsers); i++ {
		// 判断当前审批节点是否是指定人员 如果不是指定人员 则需要查询 department 获取审批人
		if approvalUsers[i].ID == 0 {

			currentLevel++

			if approvalUsers[i].DepartmentUID != "" && approvalUsers[i].PositionUID != "" {
				listReq := new(account.ListV2Request)
				departmentId, err := strconv.ParseUint(approvalUsers[i].DepartmentUID, 0, 64)
				positionId, err := strconv.ParseUint(approvalUsers[i].PositionUID, 0, 64)
				if err != nil {
					return nil, nil
				}
				listReq.DepartmentId = uint32(departmentId)
				listReq.PositionId = uint32(positionId)
				// 查询部门下的审批人
				listRes, err := service.AccountProvider.ListV2(context.Background(), listReq)
				if err != nil {
					return nil, nil
				}

				fmt.Println("============   获取 审批  指定部门  审批人  ==============")
				fmt.Printf("listRes %+v\n", listRes)
				fmt.Println("============   获取 审批  指定部门  审批人  ==============")
				fmt.Println()

				for j := 0; j < len(listRes.Data); j++ {
					if listRes.Data[j].ID == userInfo.ID && req.Type != "nursingLeaveApply" && req.Type != "parentalLeaveApply" {
						continue
					}
					if retApprovalUsersMap[listRes.Data[j].ID] != nil {
						continue
					}
					approvalUser := new(api.ApprovalUser)
					approvalUser.ID = listRes.Data[j].ID
					approvalUser.Name = listRes.Data[j].NickName
					approvalUser.Level = currentLevel
					approvalUser.Signature = approvalUsers[i].Signature
					approvalUser.Type = approvalUsers[i].Type
					approvalUser.BalanceFillIn = approvalUsers[i].BalanceFillIn
					retApprovalUsers = append(retApprovalUsers, approvalUser)
					retApprovalUsersMap[listRes.Data[j].ID] = approvalUser
				}

			} else if approvalUsers[i].IsDirect == 1 {
				myBossReq := new(department.MyBossesReq)
				if strings.Contains(req.Type, "employ") {
					departmentId, _ := strconv.ParseUint(req.Employ.DepartmentId, 10, 32)
					myBossReq.DepartmentId = uint32(departmentId)
				} else {
					myBossReq.UserId = uint32(userInfo.ID)
					myBossReq.DepartmentId = uint32(req.DepartmentID)
				}
				//这不怪我，我也不想这么写
				if req.Type == "outWork" ||
					req.Type == "funeralLeave" ||
					req.Type == "paternityLeave" ||
					req.Type == "maritalLeave" ||
					req.Type == "parentalLeave" ||
					req.Type == "nursingLeave" ||
					req.Type == "matingCheckLeave" ||
					req.Type == "annualLeave" ||
					req.Type == "businessTrip" ||
					req.Type == "sick" ||
					req.Type == "leave" ||
					req.Type == "maternityLeave" ||
					req.Type == "abortLeave" ||
					req.Type == "goOut" {
					var days float32
					if req.ApprovalOA.Leave != nil {
						days = req.ApprovalOA.Leave.Days
					}
					if req.ApprovalOA.BusinessTrip != nil {
						days = req.ApprovalOA.BusinessTrip.TotalDays
					}
					if req.ApprovalOA.GoOut != nil {
						days = req.ApprovalOA.GoOut.Hours / 8
					}
					if req.ApprovalOA.OutWork != nil {
						days = req.ApprovalOA.OutWork.Hours / 8
					}

					//不同时长直属级数不同（晕）
					if days > 1 {
						myBossReq.Level = uint32(approvalUsers[i].Level)
					} else {
						myBossReq.Level = 1
					}

				} else {
					myBossReq.Level = uint32(approvalUsers[i].Level)
				}

				fmt.Println("============   获取 审批  直属领导  审批人 请求参数 ==============")
				fmt.Printf("myBossReq %+v\n", myBossReq)
				fmt.Println("============   获取 审批  直属领导  审批人 请求参数 ==============")

				myBossRes, err := service.DepartmentProvider.MyBosses(context.Background(), myBossReq)
				if err != nil {
					return nil, nil
				}

				if strings.Contains(req.Type, "position") && len(myBossRes.List) > 1 {
					myBossRes.List = myBossRes.List[:1]
				}

				fmt.Println("============   获取 审批  直属领导  审批人  ==============")
				fmt.Printf("myBossRes %+v\n", myBossRes)
				fmt.Println("============   获取 审批  直属领导  审批人  ==============")
				fmt.Println()

				for j := 0; j < len(myBossRes.List); j++ {
					for k := 0; k < len(myBossRes.List[j].Bosses); k++ {
						if myBossRes.List[j].Bosses[k].ID == uint32(userInfo.ID) {
							continue
						}
						if retApprovalUsersMap[uint64(myBossRes.List[j].Bosses[k].ID)] != nil {
							continue
						}
						approvalUser := new(api.ApprovalUser)
						approvalUser.ID = uint64(myBossRes.List[j].Bosses[k].ID)
						approvalUser.Name = myBossRes.List[j].Bosses[k].Name
						approvalUser.Level = currentLevel + uint64(j)
						approvalUser.IsDirect = approvalUsers[i].IsDirect
						approvalUser.Signature = approvalUsers[i].Signature
						approvalUser.Type = approvalUsers[i].Type
						approvalUser.BalanceFillIn = approvalUsers[i].BalanceFillIn
						retApprovalUsers = append(retApprovalUsers, approvalUser)
						retApprovalUsersMap[uint64(myBossRes.List[j].Bosses[k].ID)] = approvalUser
					}
				}
				currentLevel = currentLevel + uint64(len(myBossRes.List)-1)

			}
		} else {

			if approvalUserLevel != approvalUsers[i].Level {
				currentLevel++
			}

			approvalUserLevel = approvalUsers[i].Level

			if approvalUsers[i].ID == userInfo.ID {
				continue
			}

			if retApprovalUsersMap[approvalUsers[i].ID] != nil {
				continue
			}

			approvalUser := new(api.ApprovalUser)
			approvalUser.ID = approvalUsers[i].ID
			approvalUser.Name = approvalUsers[i].Name
			approvalUser.Level = currentLevel
			approvalUser.Signature = approvalUsers[i].Signature
			if approvalUsers[i].Type == "" {
				approvalUser.Type = e.AndSignType
			} else {
				approvalUser.Type = approvalUsers[i].Type
			}
			retApprovalUsers = append(retApprovalUsers, approvalUser)
			retApprovalUsersMap[approvalUsers[i].ID] = approvalUser

		}
	}

	//OA
	// 病假 事假
	// 又要改，完犊子了
	if m.GetOaType(req.Type) != "" {
		//又是新逻辑，事假/年假/出差/外出
		if req.Type == "leave" || req.Type == "annualLeave" || req.Type == "businessTrip" || req.Type == "goOut" {
			var days float32
			if req.ApprovalOA.Leave != nil {
				days = req.ApprovalOA.Leave.Days
			}
			if req.ApprovalOA.BusinessTrip != nil {
				days = req.ApprovalOA.BusinessTrip.TotalDays
			}
			if req.ApprovalOA.GoOut != nil {
				days = req.ApprovalOA.GoOut.Hours / 8
			}
			retApprovalUsers = GetCombineOaApproveUsers(setting, retApprovalUsers)
			inCopyUsers = GetCombineOaCopyUsers(setting, inCopyUsers)
			if days <= 3 {
				retApprovalUsers = retApprovalUsers[:len(retApprovalUsers)-1]
			}

			//if req.ApprovalOA.Leave.Days >= 2 {
			//	retApprovalUsers = GetCombineOaApproveUsers(setting, retApprovalUsers)
			//	inCopyUsers = GetCombineOaCopyUsers(setting, inCopyUsers)
			//} else {
			//
			//	retApprovalUsers = GetCombineOaApproveUsers(setting, retApprovalUsers)
			//	if len(retApprovalUsers) > 1 {
			//		for _, user := range retApprovalUsers[1:] {
			//			delete(retApprovalUsersMap, user.ID)
			//		}
			//		retApprovalUsers = retApprovalUsers[:1]
			//	}
			//	inCopyUsers = GetCombineOaCopyUsers(setting, inCopyUsers)
			//	if len(inCopyUsers) > 1 {
			//		inCopyUsers = inCopyUsers[:len(inCopyUsers)-1]
			//	}
			//	//}
			//
			//}

			for index, ret := range retApprovalUsers {
				ret.Level = uint64(index + 1)
			}

			//新逻辑：独生子女护理假申请 育儿假申请====》直属3级+指定岗位
			//TODO离职暂时放着（in.Type == "turnover"）
		} else if req.Type == "nursingLeaveApply" || req.Type == "parentalLeaveApply" {
			//去重,究极特殊处理，我人晕了
			//if req.IsLeader {
			//	retApprovalUsers = GetCombineOaApproveUsers(setting, retApprovalUsers)
			//} else {
			var result []*api.ApprovalUser
			approvalUserMap := make(map[uint64]*api.ApprovalUser)

			for _, userReq := range setting.OaApprovalUsers {
				approvalUserMap[userReq.ID] = userReq
			}
			for _, userRes := range retApprovalUsers {
				if _, exists := approvalUserMap[userRes.ID]; !exists {
					result = append(result, userRes)
				}
			}
			retApprovalUsers = result
			retApprovalUsers = append(retApprovalUsers, setting.OaApprovalUsers...)
			//var tmpAppUser *api.ApprovalUser
			//tmpAppUser = retApprovalUsers[len(retApprovalUsers)-1]
			//retApprovalUsers[len(retApprovalUsers)-1] = retApprovalUsers[len(retApprovalUsers)-2]
			//retApprovalUsers[len(retApprovalUsers)-2] = tmpAppUser
			//}
			retApprovalUsers = GetCombineOaApproveUsers(setting, retApprovalUsers)
			retApprovalUsers[len(retApprovalUsers)-2].BalanceFillIn = 1

			inCopyUsers = GetCombineOaCopyUsers(setting, inCopyUsers)

			//新逻辑：加班/外勤 丧假 陪产假 婚假 育儿假 独生子女护理假 哺乳假 孕检假 年假 调休 出差 外出=====》直属1级
		} else if req.Type == "outWork" ||
			req.Type == "funeralLeave" ||
			req.Type == "paternityLeave" ||
			req.Type == "maritalLeave" ||
			req.Type == "parentalLeave" ||
			req.Type == "nursingLeave" ||
			req.Type == "matingCheckLeave" ||
			req.Type == "maternityLeave" ||
			req.Type == "abortLeave" ||
			req.Type == "sick" {
			var days float32
			if req.ApprovalOA.Leave != nil {
				days = req.ApprovalOA.Leave.Days
			}
			if req.ApprovalOA.OutWork != nil {
				days = req.ApprovalOA.OutWork.Hours / 8
			}
			retApprovalUsers = GetCombineOaApproveUsers(setting, retApprovalUsers)
			inCopyUsers = GetCombineOaCopyUsers(setting, inCopyUsers)
			//if days > 1 && days <= 3 {
			//	retApprovalUsers = retApprovalUsers[:len(retApprovalUsers)-1]
			//} else if days <= 1 {
			//	retApprovalUsers = retApprovalUsers[:len(retApprovalUsers)-2]
			//}
			if days <= 3 {
				retApprovalUsers = retApprovalUsers[:len(retApprovalUsers)-1]
			}
			//加班外勤 不是主管截取掉最后一个
			if req.Type == "outWork" {
				inCopyUsers = GetCombineOaCopyUsers(setting, inCopyUsers)
				if !req.IsLeader {
					if len(inCopyUsers) > 1 {
						inCopyUsers = inCopyUsers[:len(inCopyUsers)-1]
					}
				}

			}

		} else if req.Type == "overTime" ||
			req.Type == "makeUp" ||
			req.Type == "breastFeedingLeave" ||
			req.Type == "dayOff" {
			//if in.IsLeader {
			retApprovalUsers = GetCombineOaApproveUsers(setting, retApprovalUsers)
			if len(retApprovalUsers) > 1 {
				for _, user := range retApprovalUsers[1:] {
					delete(retApprovalUsersMap, user.ID)
				}
				retApprovalUsers = retApprovalUsers[:1]
			}
			//加班外勤 不是主管截取掉最后一个
			if req.Type == "overTime" {
				inCopyUsers = GetCombineOaCopyUsers(setting, inCopyUsers)
				if !req.IsLeader {
					if len(inCopyUsers) > 1 {
						inCopyUsers = inCopyUsers[:len(inCopyUsers)-1]
					}
				}

			}

		}

		//// 去重 审批人 剔除 提交人    抄送人 剔除  审批人
		//approvalUsers, copyUsers = UniqueUsersV2(in.SubmitterID, approvalUsers, copyUsers)
		index := 0
		for i := 0; i < len(retApprovalUsers); i++ {
			index++
			retApprovalUsers[i].Level = uint64(index)
		}
		fmt.Println("------------t5---------- start ")
		fmt.Println("1-----", retApprovalUsers)
		fmt.Println("2-----", inCopyUsers)
		fmt.Println("------------t5---------- end ")
	}

	if len(inCopyUsers) > 0 {
		for i := 0; i < len(inCopyUsers); i++ {
			if inCopyUsers[i].ID == userInfo.ID {
				continue
			} else if _, ok := retApprovalUsersMap[inCopyUsers[i].ID]; ok {
				continue
			} else {
				copyUsers = append(copyUsers, inCopyUsers[i])
			}
		}
	}

	for index2, user := range retApprovalUsers {
		user.Level = uint64(index2 + 1)
	}

	fmt.Println("============   获取 审批 审批人 组装后  ==============")
	fmt.Printf("retApprovalUsers %+v\n", retApprovalUsers)
	fmt.Printf("copyUsers %+v\n", copyUsers)
	fmt.Println("============   获取 审批 审批人 组装后  ==============")
	fmt.Println()
	return
}

// verifyApprovalUserIsActive 检查审批人是否在职 并 用于 审批流程 展示 以及 创建
func verifyApprovalUserIsActive(approvalUsers []*api.ApprovalUser) (retApprovalUsers []*api.ApprovalUser, err error) {
	userIDs := make([]uint64, 0)

	for i := 0; i < len(approvalUsers); i++ {
		userIDs = append(userIDs, approvalUsers[i].ID)
	}

	if len(userIDs) > 0 {
		req := new(account.ListByIDsRequest)
		res := new(account.ListResponse)
		retApprovalUsers = make([]*api.ApprovalUser, 0)
		req.IDs = userIDs
		res, err = service.AccountProvider.ListByIDs(context.Background(), req)
		if err != nil {
			return nil, errors.New(e.ErrorGetUserStatus)
		}

		usersMap := make(map[uint64]*account.AccountInfo)
		for i := 0; i < len(res.Data); i++ {
			fmt.Println("====================================  校验审批人 状态 ============================================")
			fmt.Printf("审批人状态  %+v\n", res.Data[i])
			fmt.Println("====================================  校验审批人 状态 ============================================")
			//if res.Data[i].Status != "notactive" {
			usersMap[res.Data[i].ID] = res.Data[i]
			//}
		}

		if len(usersMap) > 0 {
			isLiveInvalidNum := 0
			for i := 0; i < len(approvalUsers); i++ {
				if usersMap[approvalUsers[i].ID] != nil && usersMap[approvalUsers[i].ID].Status == "notactive" {
					approvalUsers[i].IsLive = e.IsLive
					retApprovalUsers = append(retApprovalUsers, approvalUsers[i])
				} else {
					isLiveInvalidNum++
					approvalUsers[i].IsLive = e.IsLiveInvalid
					retApprovalUsers = append(retApprovalUsers, approvalUsers[i])
				}
			}

			if isLiveInvalidNum == len(approvalUsers) {
				return nil, errors.New(e.ErrorCurrentApprovalIsNotUsed)
			}
		}
	}
	return
}

// 获取 promotion 中的 员工信息
func buildPromotionApprovalUser(req *api.CreateRequest) (approvalUsers []*api.ApprovalUser, err error) {
	if req.Promotion == nil {
		return nil, nil
	} else if req.Promotion.StaffUID == 0 {
		return nil, errors.New(e.ErrorEmptyPromotionStaffUid)
	} else {
		fmt.Println("============   获取 promotion 中的 员工信息  ==============")
		fmt.Printf("req.Promotion %+v\n", req.Promotion)
		fmt.Println("============   获取 promotion 中的 员工信息  ==============")
		staffInfo, err := service.AccountProvider.Info(context.Background(), &account.InfoRequest{ID: req.Promotion.StaffUID})
		fmt.Println("============   获取 account 中的 员工信息  ==============")
		fmt.Printf("staffInfo %+v\n", staffInfo)
		fmt.Printf("err %+v\n", err)
		fmt.Println("============   获取 account 中的 员工信息  ==============")
		if err != nil {
			return nil, errors.New(e.GetMsg(e.ErrorGetUserInfo))
		}
		var departmentUid uint64
		for i := 0; i < len(staffInfo.Info.Departments); i++ {
			if staffInfo.Info.Departments[i].ID != 0 {
				departmentUid = uint64(staffInfo.Info.Departments[i].ID)
				break
			}
		}

		myBossReq := new(department.MyBossesReq)
		myBossReq.UserId = uint32(staffInfo.Info.ID)
		myBossReq.DepartmentId = uint32(departmentUid)
		myBossReq.Level = 1

		myBossRes, err := service.DepartmentProvider.MyBosses(context.Background(), myBossReq)
		if err != nil {
			return nil, nil
		}

		if myBossRes.List == nil || len(myBossRes.List) == 0 {
			return nil, errors.New(e.ErrorNotCatchUserDepartmentBoss)
		}

		approvalUsers = make([]*api.ApprovalUser, 0)
		for i := 0; i < len(myBossRes.List); i++ {
			for j := 0; j < len(myBossRes.List[i].Bosses); j++ {
				approvalUser := new(api.ApprovalUser)
				approvalUser.ID = uint64(myBossRes.List[i].Bosses[j].ID)
				approvalUser.Name = myBossRes.List[i].Bosses[j].Name
				approvalUser.Level = 1
				approvalUsers = append(approvalUsers, approvalUser)
			}
		}

		if req.ApprovalUsers != nil {
			approvalUsers = append(approvalUsers, req.ApprovalUsers...)
		}

		return approvalUsers, nil
	}
}

func UniqueUsers(submitterID uint64, inApprovalUsers []*api.ApprovalUser, inCopyUsers []*api.CopyUser) (newApprovalUsers []*api.ApprovalUser, copyUsers []*api.CopyUser) {
	approvalUsers := make([]*api.ApprovalUser, 0)
	approvalUserMap := make(map[uint64]*api.ApprovalUser)
	copyUsers = make([]*api.CopyUser, 0)
	uniqueUsersMap := make(map[uint64]struct{})

	// 剔除 提交人 在审批人中
	for i := 0; i < len(inApprovalUsers); i++ {
		approvalUser := new(api.ApprovalUser)
		approvalUser = inApprovalUsers[i]
		approvalUserMap[approvalUser.ID] = approvalUser
		if approvalUser.ID == submitterID {
			continue
		} else if _, ok := uniqueUsersMap[approvalUser.ID]; ok {
			continue
		} else {
			uniqueUsersMap[approvalUser.ID] = struct{}{}
			approvalUsers = append(approvalUsers, approvalUser)
		}
	}

	var currentLevel uint64 = 0
	var preLevel uint64 = 0
	for i := 0; i < len(approvalUsers); i++ {
		if i == 0 {
			preLevel = approvalUsers[i].Level
			currentLevel = approvalUsers[i].Level
		} else {
			currentLevel = approvalUsers[i].Level
			if approvalUsers[i].Level == preLevel {
				approvalUsers[i].Level = currentLevel
			} else {
				approvalUsers[i].Level = currentLevel
				preLevel = currentLevel
				currentLevel++
			}
		}
	}

	approvalUsersMap := make(map[uint64][]*api.ApprovalUser)
	levels := make([]int, 0)

	for i := 0; i < len(approvalUsers); i++ {
		approvalUser := new(api.ApprovalUser)
		approvalUser = approvalUsers[i]
		if approvalUsersMap[approvalUser.Level] == nil {
			levels = append(levels, int(approvalUser.Level))
		}
		approvalUsersMap[approvalUser.Level] = append(approvalUsersMap[approvalUser.Level], approvalUser)
	}

	newApprovalUsers = make([]*api.ApprovalUser, 0)
	sort.Ints(levels)

	if len(levels) > 0 {
		for i := 0; i < len(levels); i++ {
			for j := 0; j < len(approvalUsersMap[uint64(levels[i])]); j++ {
				if approvalUsersMap[uint64(levels[i])][j].Level == 0 {
					approvalUsersMap[uint64(levels[i])][j].Level = 1
					approvalUsersMap[uint64(levels[i])][j].Signature = e.AndSignType
				} else if approvalUsersMap[uint64(levels[i])][j].Level == 1 {
					approvalUsersMap[uint64(levels[i])][j].Level = approvalUsersMap[uint64(levels[0])][len(approvalUsersMap[uint64(levels[0])])-1].Level
				} else {
					approvalUsersMap[uint64(levels[i])][j].Level = approvalUsersMap[uint64(levels[i-1])][len(approvalUsersMap[uint64(levels[i])])-1].Level + 1
				}
			}
			newApprovalUsers = append(newApprovalUsers, approvalUsersMap[uint64(levels[i])]...)
		}
	}

	approvalUsers = newApprovalUsers

	if len(inCopyUsers) > 0 {
		for i := 0; i < len(inCopyUsers); i++ {
			if inCopyUsers[i].ID == submitterID {
				continue
			} else if _, ok := approvalUsersMap[inCopyUsers[i].ID]; ok {
				continue
			} else {
				copyUsers = append(copyUsers, inCopyUsers[i])
			}
		}
	}

	return
}

// buildWorkFlow 组装 workflow
func buildWorkFlow(approvalUsers []*api.ApprovalUser) (retWorkFlows []*api.WorkFlow) {
	retWorkFlows = make([]*api.WorkFlow, 0)
	for i := 0; i < len(approvalUsers); i++ {
		workFlow := new(api.WorkFlow)
		workFlow.UserID = approvalUsers[i].ID
		workFlow.Name = approvalUsers[i].Name
		workFlow.Level = approvalUsers[i].Level
		workFlow.Signature = approvalUsers[i].Signature
		retWorkFlows = append(retWorkFlows, workFlow)
	}
	return

}

// verifyWorkflowIsActive 检查审批人是否在职  并 更新审批流程  用于审批流程的更新
func verifyWorkflowIsActive(workflows []*api.WorkFlow) (retWorkFlows []*api.WorkFlow, err error) {
	userIDs := make([]uint64, 0)

	for i := 0; i < len(workflows); i++ {
		userIDs = append(userIDs, workflows[i].UserID)
	}

	if len(userIDs) > 0 {
		req := new(account.ListByIDsRequest)
		res := new(account.ListResponse)
		retWorkFlows = make([]*api.WorkFlow, 0)
		req.IDs = userIDs
		res, err = service.AccountProvider.ListByIDs(context.Background(), req)
		if err != nil {
			return nil, errors.New(e.ErrorGetUserStatus)
		}

		usersMap := make(map[uint64]*account.AccountInfo)
		for i := 0; i < len(res.Data); i++ {
			if res.Data[i].Status != "notactive" {
				usersMap[res.Data[i].ID] = res.Data[i]
			}
		}

		if len(usersMap) > 0 {
			for i := 0; i < len(workflows); i++ {
				if usersMap[workflows[i].UserID] != nil {
					workflows[i].IsLive = e.IsLiveInvalid
					retWorkFlows = append(retWorkFlows, workflows[i])
				}
			}

			updateWorkflowReq := new(api.UpdateWorkflowRequest)
			updateWorkflowReq.WorkFlows = retWorkFlows
			_, err = service.ApprovalProvider.UpdateWorkflow(context.Background(), updateWorkflowReq)
			if err != nil {
				return nil, err
			}
		}
	}
	return
}

func MyWorkV2(c *gin.Context) {
	var req api.ListRequest
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.Error, err)
		return
	}

	userInfo := login.GetUserInfoFromC(c)
	req.UserID = userInfo.ID

	req.Domain = "all"

	//if req.Status == 0 {
	//	for i := 0; i < len(userInfo.PositionUsers); i++ {
	//		if userInfo.PositionUsers[i].DepartmentName == "超级管理员" {
	//			req.UserID = 0
	//		}
	//	}
	//}

	if req.OrderBy == "" {
		req.OrderBy = "desc"
	}

	if req.StartTime != "" && req.EndTime != "" {
		req.StartTime = req.StartTime + " 00:00:00"
		req.EndTime = req.EndTime + " 23:59:59"
		req.OrderBy = "asc"
	}
	// 范围搜索
	//
	//positionList, dataErr := service.GrpcApprovalDataImpl.DetailApprovalData(context.Background(), &approvalData.DetailApprovalDataReq{UserId: userInfo.ID})
	//if dataErr != nil {
	//	service.Error(c, e.Error, dataErr)
	//	return
	//}
	//
	//if len(positionList.Data) > 0 {
	//	userList := make([]uint64, 0)
	//	for _, position := range positionList.Data {
	//		positionId, _ := strconv.ParseUint(position.PositionUID, 10, 32)
	//		userRes, userErr := service.AccountProvider.ListV2(context.Background(), &account.ListV2Request{Page: 1, PageSize: 99999, PositionId: uint32(positionId)})
	//		if userErr != nil {
	//			service.Error(c, e.Error, userErr)
	//			return
	//		}
	//		if len(userRes.Data) > 0 {
	//			for _, user := range userRes.Data {
	//				userList = append(userList, user.ID)
	//			}
	//		}
	//	}
	//	req.UserList = userList
	//}

	var authRes = new(position.DoIHavaAuthResponse)
	authRes.Hava = false

	if req.IsSpecial {
		var authReq position.DoIHavaAuthRequest
		var authErr error

		authReq.Url = "moceapp/mywork/category/"
		authReq.Type = "button"

		authRes, authErr = service.PositionProvider.DoIHavaAuth(c, &authReq)
		if authErr != nil {
			zap.L().Error("DoIHavaAuth", zap.Error(authErr))
		}

		if authRes.Hava {
			req.PageSize = 9999
		}
	}

	res, err := service.ApprovalProvider.MyWorkV2(c, &req)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	//全局搜索过滤
	if len(res.Data) > 0 && req.AllQuery != "" {
		fmt.Println("========================全局搜索过滤==============================")
		filterData := make([]*api.CreateRequest, 0)
		for _, approvalItem := range res.Data {
			flag := 0
			if strings.Contains(approvalItem.Content, req.AllQuery) ||
				strings.Contains(approvalItem.Reply, req.AllQuery) ||
				strings.Contains(approvalItem.SubmitterName, req.AllQuery) ||
				strings.Contains(approvalItem.NowUserName, req.AllQuery) ||
				strings.Contains(approvalItem.CreatedAt, req.AllQuery) ||
				strings.Contains(approvalItem.TypeName, req.AllQuery) {
				flag = flag + 1
			}
			if approvalItem.Work != nil {
				if len(approvalItem.Work.ApprovalWorks) > 0 {
					for _, work := range approvalItem.Work.ApprovalWorks {
						if strings.Contains(work.ArtworkName, req.AllQuery) ||
							strings.Contains(work.ArtistShowCount, req.AllQuery) ||
							strings.Contains(work.ArtworkCover, req.AllQuery) {
							flag = flag + 1
							break
						}
					}
				}
			}
			if len(approvalItem.Show) > 0 {
				for _, show := range approvalItem.Show {
					if strings.Contains(show.Address, req.AllQuery) {
						flag = flag + 1
						break
					}
				}
			}
			if approvalItem.Exhibition != nil {
				if strings.Contains(approvalItem.Exhibition.Address, req.AllQuery) {
					flag = flag + 1
				}
				if len(approvalItem.Exhibition.ApprovalExhibitions) > 0 {

					for _, exhibition := range approvalItem.Exhibition.ApprovalExhibitions {
						if len(exhibition.Artworks) > 0 {
							for _, artwork := range exhibition.Artworks {
								if strings.Contains(artwork.ArtworkName, req.AllQuery) ||
									strings.Contains(artwork.ArtistShowCount, req.AllQuery) ||
									strings.Contains(artwork.SaleAddress, req.AllQuery) ||
									strings.Contains(artwork.Reward, req.AllQuery) ||
									strings.Contains(artwork.Tfnum, req.AllQuery) {
									flag = flag + 1
									break
								}
							}
						}
						if exhibition.ArtExhibitionDetail != nil {
							if strings.Contains(exhibition.ArtExhibitionDetail.ArtistShowCount, req.AllQuery) ||
								strings.Contains(exhibition.ArtExhibitionDetail.ShowTime, req.AllQuery) ||
								strings.Contains(exhibition.ArtExhibitionDetail.ShowName, req.AllQuery) ||
								strings.Contains(exhibition.ArtExhibitionDetail.Address, req.AllQuery) {
								flag = flag + 1
								break
							}
						}
					}
				}
			}
			if len(approvalItem.WorkFlows) > 0 {
				for _, user := range approvalItem.WorkFlows {
					if strings.Contains(user.Name, req.AllQuery) {
						flag = flag + 1
						break
					}
				}
			}
			if len(approvalItem.CopyUsers) > 0 {
				for _, copyUser := range approvalItem.CopyUsers {
					if strings.Contains(copyUser.Name, req.AllQuery) {
						flag = flag + 1
						break
					}
				}
			}
			if len(approvalItem.CustomizeInfo) > 0 {
				for _, keyInfo := range approvalItem.CustomizeInfo {
					if strings.Contains(keyInfo.ApprovalValue, req.AllQuery) {
						flag = flag + 1
						break
					}
				}
			}
			if approvalItem.BundlePayPrice != nil {
				if strings.Contains(approvalItem.BundlePayPrice.ShowName, req.AllQuery) ||
					strings.Contains(approvalItem.BundlePayPrice.ArtistShowCount, req.AllQuery) ||
					strings.Contains(approvalItem.BundlePayPrice.ShowLowPrice, req.AllQuery) ||
					strings.Contains(approvalItem.BundlePayPrice.ArtworkSize, req.AllQuery) ||
					strings.Contains(approvalItem.BundlePayPrice.ShowAddress, req.AllQuery) ||
					strings.Contains(approvalItem.BundlePayPrice.ShowDate, req.AllQuery) {
					flag = flag + 1
				}
			}
			if approvalItem.ApprovalOA != nil {
				if strings.Contains(approvalItem.ApprovalOA.RevokeReason, req.AllQuery) {
					flag = flag + 1
				}
				if approvalItem.ApprovalOA.LeaveApply != nil {
					if strings.Contains(approvalItem.ApprovalOA.LeaveApply.StaffName, req.AllQuery) ||
						strings.Contains(approvalItem.ApprovalOA.LeaveApply.Reason, req.AllQuery) ||
						strings.Contains(approvalItem.ApprovalOA.LeaveApply.StaffNum, req.AllQuery) ||
						strings.Contains(approvalItem.ApprovalOA.LeaveApply.ActionTime, req.AllQuery) {
						flag = flag + 1
					}
				}
				if approvalItem.ApprovalOA.OutWork != nil {

					if strings.Contains(approvalItem.ApprovalOA.OutWork.StaffName, req.AllQuery) ||
						strings.Contains(approvalItem.ApprovalOA.OutWork.Reason, req.AllQuery) ||
						strings.Contains(approvalItem.ApprovalOA.OutWork.StaffNum, req.AllQuery) ||
						strings.Contains(approvalItem.ApprovalOA.OutWork.OutWorkAddress, req.AllQuery) ||
						strings.Contains(approvalItem.ApprovalOA.OutWork.Vehicle, req.AllQuery) ||
						strings.Contains(approvalItem.ApprovalOA.OutWork.ActionTime, req.AllQuery) {
						flag = flag + 1
					}
					for _, applyTime := range approvalItem.ApprovalOA.OutWork.ApplyTimes {
						if strings.Contains(applyTime.Date, req.AllQuery) {
							flag = flag + 1
							break
						}
					}
				}
				if approvalItem.ApprovalOA.MakeUp != nil {
					if strings.Contains(approvalItem.ApprovalOA.MakeUp.StaffName, req.AllQuery) ||
						strings.Contains(approvalItem.ApprovalOA.MakeUp.Reason, req.AllQuery) ||
						strings.Contains(approvalItem.ApprovalOA.MakeUp.StaffNum, req.AllQuery) ||
						strings.Contains(approvalItem.ApprovalOA.MakeUp.ActionTime, req.AllQuery) {
						flag = flag + 1
					}
					for _, applyTime := range approvalItem.ApprovalOA.MakeUp.ApplyTimes {
						if strings.Contains(applyTime.Date, req.AllQuery) {
							flag = flag + 1
							break
						}
					}
				}
				if approvalItem.ApprovalOA.Turnover != nil {
					fmt.Println("=====================turnover=====================")
					fmt.Println(approvalItem.ApprovalOA.Turnover)
					if strings.Contains(approvalItem.ApprovalOA.Turnover.StaffName, req.AllQuery) ||
						strings.Contains(approvalItem.ApprovalOA.Turnover.Reason, req.AllQuery) ||
						strings.Contains(approvalItem.ApprovalOA.Turnover.StaffNum, req.AllQuery) ||
						strings.Contains(approvalItem.ApprovalOA.Turnover.HandoverName, req.AllQuery) ||
						strings.Contains(approvalItem.ApprovalOA.Turnover.JoinTime, req.AllQuery) ||
						strings.Contains(approvalItem.ApprovalOA.Turnover.LeftTime, req.AllQuery) ||
						strings.Contains(approvalItem.ApprovalOA.Turnover.ContactInfo, req.AllQuery) ||
						strings.Contains(approvalItem.ApprovalOA.Turnover.HandoverNum, req.AllQuery) ||
						strings.Contains(approvalItem.ApprovalOA.Turnover.Address, req.AllQuery) ||
						strings.Contains(approvalItem.ApprovalOA.Turnover.SuperviseName, req.AllQuery) ||
						strings.Contains(approvalItem.ApprovalOA.Turnover.SuperviseNum, req.AllQuery) ||
						strings.Contains(approvalItem.ApprovalOA.Turnover.WorkItems, req.AllQuery) ||
						strings.Contains(approvalItem.ApprovalOA.Turnover.FinanceItems, req.AllQuery) ||
						strings.Contains(approvalItem.ApprovalOA.Turnover.ActionTime, req.AllQuery) {
						flag = flag + 1
					}
					for _, applyTime := range approvalItem.ApprovalOA.Turnover.ApplyTimes {
						if strings.Contains(applyTime.Date, req.AllQuery) {
							flag = flag + 1
							break
						}
					}
					fmt.Println("=====================flag=====================")
					fmt.Println(flag)
				}
				if approvalItem.ApprovalOA.OverTime != nil {
					if strings.Contains(approvalItem.ApprovalOA.OverTime.StaffName, req.AllQuery) ||
						strings.Contains(approvalItem.ApprovalOA.OverTime.Reason, req.AllQuery) ||
						strings.Contains(approvalItem.ApprovalOA.OverTime.StaffNum, req.AllQuery) ||
						strings.Contains(approvalItem.ApprovalOA.OverTime.ActionTime, req.AllQuery) {
						flag = flag + 1
					}
					for _, applyTime := range approvalItem.ApprovalOA.OverTime.ApplyTimes {
						if strings.Contains(applyTime.Date, req.AllQuery) {
							flag = flag + 1
							break
						}
					}
				}
				if approvalItem.ApprovalOA.Leave != nil {
					if strings.Contains(approvalItem.ApprovalOA.Leave.StaffName, req.AllQuery) ||
						strings.Contains(approvalItem.ApprovalOA.Leave.Reason, req.AllQuery) ||
						strings.Contains(approvalItem.ApprovalOA.Leave.StaffNum, req.AllQuery) ||
						strings.Contains(approvalItem.ApprovalOA.Leave.DateOfBrith, req.AllQuery) ||
						strings.Contains(approvalItem.ApprovalOA.Leave.ActionTime, req.AllQuery) {
						flag = flag + 1
					}
					for _, applyTime := range approvalItem.ApprovalOA.Leave.ApplyTimes {
						if strings.Contains(applyTime.Date, req.AllQuery) {
							flag = flag + 1
							break
						}
					}
				}
				if approvalItem.ApprovalOA.GoOut != nil {
					if strings.Contains(approvalItem.ApprovalOA.GoOut.StaffName, req.AllQuery) ||
						strings.Contains(approvalItem.ApprovalOA.GoOut.Reason, req.AllQuery) ||
						strings.Contains(approvalItem.ApprovalOA.GoOut.StaffNum, req.AllQuery) ||
						strings.Contains(approvalItem.ApprovalOA.GoOut.DateOfBrith, req.AllQuery) ||
						strings.Contains(approvalItem.ApprovalOA.GoOut.ActionTime, req.AllQuery) {
						flag = flag + 1
					}
					for _, applyTime := range approvalItem.ApprovalOA.GoOut.ApplyTimes {
						if strings.Contains(applyTime.Date, req.AllQuery) {
							flag = flag + 1
							break
						}
					}
				}
				if approvalItem.ApprovalOA.BusinessTrip != nil {
					if strings.Contains(approvalItem.ApprovalOA.BusinessTrip.StaffName, req.AllQuery) ||
						strings.Contains(approvalItem.ApprovalOA.BusinessTrip.Reason, req.AllQuery) ||
						strings.Contains(approvalItem.ApprovalOA.BusinessTrip.StaffNum, req.AllQuery) ||
						strings.Contains(approvalItem.ApprovalOA.BusinessTrip.ActionTime, req.AllQuery) {
						flag = flag + 1
					}
					for _, itinerary := range approvalItem.ApprovalOA.BusinessTrip.ItineraryList {
						if strings.Contains(itinerary.Vehicle, req.AllQuery) ||
							strings.Contains(itinerary.EndAddress, req.AllQuery) ||
							strings.Contains(itinerary.StartAddress, req.AllQuery) {
							flag = flag + 1
							break
						}
					}
				}
			}
			if approvalItem.FinancialForm != nil {
				if strings.Contains(approvalItem.FinancialForm.PaymentCompany, req.AllQuery) ||
					strings.Contains(approvalItem.FinancialForm.TransactionDepartment, req.AllQuery) ||
					strings.Contains(approvalItem.FinancialForm.Payee, req.AllQuery) ||
					strings.Contains(approvalItem.FinancialForm.BeneficiaryBank, req.AllQuery) ||
					strings.Contains(approvalItem.FinancialForm.BankNo, req.AllQuery) ||
					strings.Contains(approvalItem.FinancialForm.PaymentMethod, req.AllQuery) {
					flag = flag + 1
				}
				for _, costInfo := range approvalItem.FinancialForm.CostInfo {
					if strings.Contains(costInfo.Description, req.AllQuery) ||
						strings.Contains(costInfo.UnitPrice, req.AllQuery) ||
						strings.Contains(costInfo.CostUnit, req.AllQuery) ||
						strings.Contains(costInfo.UsedDepartment, req.AllQuery) ||
						strings.Contains(costInfo.TotalPrice, req.AllQuery) {
						flag = flag + 1
						break
					}
				}
				for _, invoiceInfo := range approvalItem.FinancialForm.InvoiceInfo {
					if strings.Contains(invoiceInfo.InvoiceDate, req.AllQuery) ||
						strings.Contains(invoiceInfo.InvoiceNo, req.AllQuery) ||
						strings.Contains(invoiceInfo.InvoiceProvider, req.AllQuery) ||
						strings.Contains(invoiceInfo.Amount, req.AllQuery) ||
						strings.Contains(invoiceInfo.Applicant, req.AllQuery) ||
						strings.Contains(invoiceInfo.PaymentMethod, req.AllQuery) ||
						strings.Contains(invoiceInfo.PaymentObj, req.AllQuery) ||
						strings.Contains(invoiceInfo.InvoiceType, req.AllQuery) ||
						strings.Contains(invoiceInfo.Notes, req.AllQuery) ||
						strings.Contains(invoiceInfo.UseTo, req.AllQuery) {
						flag = flag + 1
						break
					}
				}
			}
			if approvalItem.ExhibitionHis != nil {
				if strings.Contains(approvalItem.ExhibitionHis.Address, req.AllQuery) {
					flag = flag + 1
				}
				if len(approvalItem.ExhibitionHis.ApprovalExhibitionHiss) > 0 {
					for _, exhibition := range approvalItem.ExhibitionHis.ApprovalExhibitionHiss {
						if len(exhibition.Artworks) > 0 {
							for _, artwork := range exhibition.Artworks {
								if strings.Contains(artwork.ArtworkName, req.AllQuery) ||
									strings.Contains(artwork.ArtistShowCount, req.AllQuery) ||
									strings.Contains(artwork.SaleAddress, req.AllQuery) ||
									strings.Contains(artwork.Reward, req.AllQuery) ||
									strings.Contains(artwork.Tfnum, req.AllQuery) {
									flag = flag + 1
									break
								}
							}
						}
						if exhibition.ArtExhibitionDetail != nil {
							if strings.Contains(exhibition.ArtExhibitionDetail.ArtistShowCount, req.AllQuery) ||
								strings.Contains(exhibition.ArtExhibitionDetail.ShowTime, req.AllQuery) ||
								strings.Contains(exhibition.ArtExhibitionDetail.ShowName, req.AllQuery) ||
								strings.Contains(exhibition.ArtExhibitionDetail.Address, req.AllQuery) {
								flag = flag + 1
								break
							}
						}
					}
				}
			}
			if approvalItem.Promotion != nil {
				if strings.Contains(approvalItem.Promotion.StaffName, req.AllQuery) ||
					strings.Contains(approvalItem.Promotion.StaffNum, req.AllQuery) ||
					strings.Contains(approvalItem.Promotion.FileName, req.AllQuery) ||
					strings.Contains(approvalItem.Promotion.NewJob, req.AllQuery) ||
					strings.Contains(approvalItem.Promotion.EffectiveTime, req.AllQuery) ||
					strings.Contains(approvalItem.Promotion.OldJob, req.AllQuery) {
					flag = flag + 1
				}

			}
			if approvalItem.StaffSupply != nil {
				if strings.Contains(approvalItem.StaffSupply.PositionName, req.AllQuery) ||
					strings.Contains(approvalItem.StaffSupply.JobAsk, req.AllQuery) ||
					strings.Contains(approvalItem.StaffSupply.JoinInTime, req.AllQuery) ||
					strings.Contains(approvalItem.StaffSupply.DepartmentName, req.AllQuery) {
					flag = flag + 1
				}

			}
			if approvalItem.Employ != nil {
				if strings.Contains(approvalItem.Employ.Post, req.AllQuery) ||
					strings.Contains(approvalItem.Employ.BelongDepartment, req.AllQuery) ||
					strings.Contains(approvalItem.Employ.Name, req.AllQuery) ||
					strings.Contains(approvalItem.Employ.EmployeeType, req.AllQuery) ||
					strings.Contains(approvalItem.Employ.EmployeeNo, req.AllQuery) ||
					strings.Contains(approvalItem.Employ.EntryTime, req.AllQuery) ||
					strings.Contains(approvalItem.Employ.CloseReason, req.AllQuery) ||
					strings.Contains(approvalItem.Employ.ConfirmDate, req.AllQuery) ||
					strings.Contains(approvalItem.Employ.Remark, req.AllQuery) ||
					strings.Contains(approvalItem.Employ.Mobile, req.AllQuery) {
					flag = flag + 1
				}

			}
			if approvalItem.CheckIn != nil {
				if strings.Contains(approvalItem.CheckIn.SaleAddress, req.AllQuery) ||
					strings.Contains(approvalItem.CheckIn.DetailAddress, req.AllQuery) {
					flag = flag + 1
				}

			}
			if flag > 0 {
				filterData = append(filterData, approvalItem)
			}
		}
		fmt.Println("========================匹配所有字段结束，匹配结果==============================")
		fmt.Println(filterData)
		res.Data = filterData

	}

	//字段国际化
	if len(res.Data) > 0 {
		lang := c.Request.Header.Get("Accept-Language")
		for _, one := range res.Data {
			one.TypeName = m.GetLanguageType(lang, one.TypeName)

			if one.ApprovalOA != nil {
				if one.ApprovalOA.Leave != nil {
					for _, applyTime := range one.ApprovalOA.Leave.ApplyTimes {
						applyTime.M = m.GetLanguageType(lang, applyTime.M)
					}
				}
				if one.ApprovalOA.Turnover != nil {
					for _, applyTime := range one.ApprovalOA.Turnover.ApplyTimes {
						applyTime.M = m.GetLanguageType(lang, applyTime.M)
					}
				}
				if one.ApprovalOA.BusinessTrip != nil {
					for _, itinerary := range one.ApprovalOA.BusinessTrip.ItineraryList {
						for _, applyTime := range itinerary.ApplyTimes {
							applyTime.M = m.GetLanguageType(lang, applyTime.M)
						}
					}
				}
				if one.ApprovalOA.GoOut != nil {
					for _, applyTime := range one.ApprovalOA.GoOut.ApplyTimes {
						applyTime.M = m.GetLanguageType(lang, applyTime.M)
					}
				}
				if one.ApprovalOA.OutWork != nil {
					for _, applyTime := range one.ApprovalOA.OutWork.ApplyTimes {
						applyTime.M = m.GetLanguageType(lang, applyTime.M)
					}
				}
				if one.ApprovalOA.OverTime != nil {
					for _, applyTime := range one.ApprovalOA.OverTime.ApplyTimes {
						applyTime.M = m.GetLanguageType(lang, applyTime.M)
					}
				}
				if one.ApprovalOA.MakeUp != nil {
					for _, applyTime := range one.ApprovalOA.MakeUp.ApplyTimes {
						applyTime.M = m.GetLanguageType(lang, applyTime.M)
					}
				}

			}

		}
	}

	if authRes.Hava && req.IsSpecial {
		retApproval := new(m.RetApproval)
		categoryApproval := new(m.CategoryApproval)
		categoryApproval.ClaimsApply = make([]*api.CreateRequest, 0)
		categoryApproval.PaymentsApply = make([]*api.CreateRequest, 0)
		categoryApproval.DeploymentApply = make([]*api.CreateRequest, 0)
		categoryApproval.ContractApply = make([]*api.CreateRequest, 0)
		categoryApproval.SealApply = make([]*api.CreateRequest, 0)
		categoryApproval.OaApply = make([]*api.CreateRequest, 0)
		categoryApproval.OtherApply = make([]*api.CreateRequest, 0)

		var (
			claimsEnv     map[string]string
			PaymentsEnv   map[string]string
			DeploymentEnv map[string]string
			ContractEnv   map[string]string
			SealEnv       map[string]string
			OAEnv         map[string]string
		)

		if config.Env == "prod" {
			claimsEnv = m.ProdClaims
			PaymentsEnv = m.ProdPayments
			DeploymentEnv = m.ProdDeployment
			ContractEnv = m.ProdContract
			SealEnv = m.ProdSeal
			OAEnv = m.ProdOA
		} else {
			claimsEnv = m.DevClaims
			PaymentsEnv = m.DevPayments
			DeploymentEnv = m.DevDeployment
			ContractEnv = m.DevContract
			SealEnv = m.DevSeal
			OAEnv = m.DevOA
		}

		// 做分类
		for i := 0; i < len(res.Data); i++ {
			if res.Data[i].Type == claimsEnv[res.Data[i].Type] {
				categoryApproval.ClaimsApply = append(categoryApproval.ClaimsApply, res.Data[i])
				categoryApproval.Claims++
				continue
			} else if res.Data[i].Type == PaymentsEnv[res.Data[i].Type] {
				categoryApproval.PaymentsApply = append(categoryApproval.PaymentsApply, res.Data[i])
				categoryApproval.Payments++
				continue
			} else if res.Data[i].Type == DeploymentEnv[res.Data[i].Type] {
				categoryApproval.DeploymentApply = append(categoryApproval.DeploymentApply, res.Data[i])
				categoryApproval.Deployment++
				continue
			} else if res.Data[i].Type == ContractEnv[res.Data[i].Type] {
				categoryApproval.ContractApply = append(categoryApproval.ContractApply, res.Data[i])
				categoryApproval.Contract++
				continue
			} else if res.Data[i].Type == SealEnv[res.Data[i].Type] {
				categoryApproval.SealApply = append(categoryApproval.SealApply, res.Data[i])
				categoryApproval.Seal++
				continue
			} else if res.Data[i].Type == OAEnv[res.Data[i].Type] {
				categoryApproval.OaApply = append(categoryApproval.OaApply, res.Data[i])
				categoryApproval.Oa++
				continue
			} else {
				categoryApproval.OtherApply = append(categoryApproval.OtherApply, res.Data[i])
				categoryApproval.Other++
				continue
			}
		}

		retApproval.Data = categoryApproval
		retApproval.Count = res.Count

		service.Success(c, retApproval)
	} else {
		service.Success(c, res)
	}

}

// SetStatusBatchV2 批量审批
func SetStatusBatchV2(c *gin.Context) {
	//var setStatusBatchReq vo.SetStatusBatchReq
	setStatusBatchReq := make([]vo.SetStatus, 0)
	if err := c.ShouldBindBodyWith(&setStatusBatchReq, binding.JSON); err != nil {
		service.Error(c, e.Error, err)
		return
	}

	fmt.Println("============   获取 审批  批量  审批  ==============")
	fmt.Printf("batch %+v\n", setStatusBatchReq)
	logger.Errorf("batch %+v\n", setStatusBatchReq)
	fmt.Println("============   获取 审批  批量  审批  ==============")

	if len(setStatusBatchReq) < 1 {
		service.Error(c, e.Error, errors.New("当前无审批"))
		return
	}

	userInfo := login.GetUserInfoFromC(c)
	for i := 0; i < len(setStatusBatchReq); i++ {
		req := api.StatusRequest{}
		req.Domain = setStatusBatchReq[i].Domain
		req.ID = setStatusBatchReq[i].ID
		req.Reply = setStatusBatchReq[i].Reply
		req.WorkFlowId = setStatusBatchReq[i].WorkFlowId
		req.Status = setStatusBatchReq[i].Status
		req.Level = setStatusBatchReq[i].Level
		req.Title = setStatusBatchReq[i].Title
		req.UserId = userInfo.ID
		req.LeaveBalance = setStatusBatchReq[i].LeaveBalance
		req.Tips = setStatusBatchReq[i].Tips

		levelReq := api.NowLevelByInfoRequestV2{
			ApprovalID: req.ID,
			NowUserId:  userInfo.ID,
		}
		fmt.Println("============== 开始查询审批流程 ==============")
		levelRes, err := service.ApprovalProvider.NowLevelByInfoV2(context.Background(), &levelReq)
		if err != nil {
			service.Error(c, e.Error, err)
			return
		}
		fmt.Printf("levelRes %+v\n", levelRes)
		fmt.Println("============== 开始查询审批流程 ==============")

		if req.UserId != levelRes.UserID {
			service.Error(c, e.Error, errors.New("本次审批人出现错误"))
			return
		}

		req.WorkFlowId = levelRes.ID

		// 查询 未审批前的审批
		beforeApproval := QueryApprovalSetStatusBefore(req.ID)
		if beforeApproval == nil {
			service.Error(c, e.Error, errors.New(e.ErrorQueryApprovalContent))
			return
		}

		if strings.Contains(beforeApproval.Type, "handover") {
			reqList := &api.ListRequest{}
			reqList.Domain = beforeApproval.Domain
			reqList.Type = "turnover"
			reqList.UserID = beforeApproval.SubmitterID
			reqList.Status = 2
			submitRes2, err := service.ApprovalProvider.MySubmit(context.Background(), reqList)
			if err != nil {
				service.Error(c, e.Error, errors.New("查询已提交的离职审批失败"))
				return
			}

			if len(submitRes2.Data) < 1 {
				service.Error(c, e.Error, errors.New("离职申请未完成"))
				return
			}
		}

		fmt.Println("++++++++++++++++++++ QueryApprovalSetStatusBefore =============================")
		fmt.Printf("beforeApproval : %+v\n", beforeApproval)
		fmt.Println("++++++++++++++++++++ QueryApprovalSetStatusBefore =============================")

		_, err = service.ApprovalProvider.SetStatusV2(context.Background(), &req)
		if err != nil {
			service.Error(c, e.Error, err)
			return
		}

		detailReq := api.DetailRequest{ID: req.ID}
		detail, err := service.ApprovalProvider.Detail(context.Background(), &detailReq)
		if err != nil {
			service.Error(c, e.Error, err)
			return
		}

		fmt.Println("++++++++++++++++++++ QueryApprovalSetStatusAfter =============================")
		fmt.Printf("Detail : %+v\n", detail)
		fmt.Println("++++++++++++++++++++ QueryApprovalSetStatusAfter =============================")

		// 同步至 es
		go func() {
			updateErr := logic.UpdateIndexApprovalDoc(config.ApprovalIndex, detail)
			if updateErr != nil {
				zap.L().Error("同步至 es 失败 更新", zap.Error(updateErr))
				//return
			}
		}()

		_, err = verifyWorkflowIsActive(detail.WorkFlows)
		if err != nil {
			service.Error(c, e.Error, err)
			return
		}

		//如果审批通过，推送给全部抄送人
		if beforeApproval.Status == 1 && detail.Status == 2 && len(detail.CopyUsers) > 0 {
			for _, user := range detail.CopyUsers {
				//审批过后推送给下一个审批人
				err = service.SendAppMessage("审批通知", "有一条<"+detail.TypeName+">已抄送给您，点击查看详情 >", user.ID, detail.ID, "copy")
				if err != nil {
					fmt.Println("==============APP推送失败=====================")
					fmt.Println(err)
				}
			}

		} else {
			//审批过后推送给下一个审批人
			err = service.SendAppMessage("审批通知", "您有一条<"+detail.TypeName+">审批待处理，点击查看详情 >", detail.NowUserId, detail.ID, "approval")
			if err != nil {
				fmt.Println("==============APP推送失败=====================")
				fmt.Println(err)
			}
		}

		if detail.TypeName == "任命审批" {
			StoreBaiduChainApprovalFile(req.ID)
		}

		// 审批成功查询用户部门的信息，提交画作服修改画作仓库状态

		if detail.TypeName == "画作申请审批" {
			var ids []int32
			for _, tt := range detail.Work.ApprovalWorks {
				ids = append(ids, int32(tt.ArtworkID))
			}

			fmt.Println("请求画作申请审批", ids)
			if len(ids) > 0 {
				err = submitArtwork(req.UserId, ids)
				if err != nil {
					service.Error(c, e.Error, err)
					return
				}
			}
		}

		if strings.Contains(beforeApproval.Type, "turnover") && beforeApproval.Status == e.ApprovalWorkStatusDoing && detail.Status == e.ApprovalWorkStatusOk {
			err = turnoverUpdateAccountEmployee(c, detail.ApprovalOA.Turnover)
			if err != nil {
				service.Error(c, e.Error, err)
				return
			}
		}
		if strings.Contains(beforeApproval.Type, "turnover") && (detail.Status == e.ApprovalWorkStatusRevokeOk || detail.Status == e.ApprovalWorkStatusFail) {
			updateDeductAnnualLeaveZeroClearing(detail.ApprovalOA.Turnover)
		}
		// approval 审批状态  同步到 oa 审批
		if e.TypeMap[detail.Type] == "oa" {
			// 查询  审批状态已经 更新的 审批信息
			updatedReq := api.DetailRequest{ID: req.ID}
			updatedDetail, detailErr := service.ApprovalProvider.Detail(context.Background(), &updatedReq)
			if detailErr != nil {
				service.Error(c, e.Error, detailErr)
				return
			}

			if req.LeaveBalance != 0 && updatedDetail.ApprovalOA.LeaveApply != nil {
				//leaveBalance, _ := strconv.ParseFloat(req.LeaveBalance, 10)
				updatedDetail.ApprovalOA.LeaveApply.LeaveBalance = req.LeaveBalance
			}
			// 育儿假申请  独生子女护理假申请 撤销成功
			if updatedDetail.Status == 7 && (detail.Type == "parentalLeaveApply" || detail.Type == "nursingLeaveApply") {
				updatedDetail.ApprovalOA.LeaveApply.LeaveBalance = 0
			}

			_, updateErr := UpdateApprovalStatusToOAStatus(updatedDetail)
			if updateErr != nil {
				service.Error(c, e.Error, updateErr)
				return
			}
		}

		// 画展包审批
		logger.Errorf("================================================= %s 1 ======================================", "进入 画展包审批")
		logger.Errorf("batch %+v\n", setStatusBatchReq)
		if detail.Type == TypeExhibition {
			logger.Errorf("================================================= %s 2======================================", "进入 画展包审批")
			logger.Errorf("beforeApproval %+v\n", beforeApproval)
			logger.Errorf("detail %+v\n", detail)
			err = ExhibitionApproveEnter(beforeApproval, detail)
			if err != nil {
				service.Error(c, e.Error, err)
				return
			}
		}

		// 画展包润格审批
		if detail.Type == TypeArtExhibitionReward {
			err = ExhibitionRewordApproveEnter(beforeApproval, detail)
			if err != nil {
				service.Error(c, e.Error, err)
				return
			}
		}

		// 画展包修改审批
		if detail.Type == TypeShowUpdate {
			err = ShowUpdateApproveEnter(beforeApproval, detail)
			if err != nil {
				service.Error(c, e.Error, err)
				return
			}
		}

		if strings.Contains(detail.TypeName, "人员增补申请") {
			err = postApproveSetStatusEnter(userInfo, detail)
			if err != nil {
				service.Error(c, e.Error, err)
				return
			}
		}

		if strings.Contains(detail.Type, "employ") {
			err := offerApproveSetStatusEnter(c, userInfo, &req, detail)
			if err != nil {
				service.Error(c, e.Error, err)
				return
			}
		}

		if detail.Type == "checkIn" && detail.Status == e.ApprovalWorkStatusOk {
			err = passSendInfoToSiteSignIn(detail.CheckIn)
			if err != nil {
				service.Error(c, e.Error, err)
				return
			}
		}
		if detail.Status == e.ApprovalWorkStatusOk && strings.Contains(detail.Type, "position") {
			err = processPositionApprovals(detail)
			if err != nil {
				service.Error(c, e.Error, err)
				return
			}
		}

		//黑名单画展包生成审批,只有审批通过才生成画展包，其他情况不予处理
		if detail.Type == "banShow" && beforeApproval.Status == e.ApprovalWorkStatusDoing && detail.Status == e.ApprovalWorkStatusOk {
			for _, artShow := range detail.Exhibition.ApprovalExhibitions {
				var saveShowReq artShowApi.SaveShowReq
				artworks := make([]*artShowApi.ArtworkDetail, 0)
				saveShowReq.ShowName = artShow.PackageName
				saveShowReq.ArtistUID = artShow.ArtExhibitionDetail.ArtistUID
				saveShowReq.ArtistName = artShow.ArtExhibitionDetail.ArtistName
				saveShowReq.ArtworkNum = int32(artShow.ArtExhibitionDetail.ArtworkNum)
				saveShowReq.CreateTime = artShow.ArtExhibitionDetail.CreateTime
				saveShowReq.ExhibitionType = artShow.ArtExhibitionDetail.ExhibitionType
				saveShowReq.IsInvite = artShow.ArtExhibitionDetail.IsInvite
				saveShowReq.Operator = artShow.ArtExhibitionDetail.Operator
				saveShowReq.PreTime = artShow.ArtExhibitionDetail.ShowTime
				saveShowReq.Ruler = int32(artShow.ArtExhibitionDetail.Ruler)
				saveShowReq.ShowSeq = artShow.ArtExhibitionDetail.ShowSeq

				for _, artworkOne := range artShow.Artworks {
					item := &artShowApi.ArtworkDetail{
						ArtworkUID:  artworkOne.ArtworkUID,
						ArtworkName: artworkOne.ArtworkName,
						ArtistName:  artworkOne.ArtistName,
						Length:      int32(artworkOne.Length),
						Width:       int32(artworkOne.Width),
						Ruler:       int32(artworkOne.Ruler),
						SmallPic:    artworkOne.SmallPic,
						Tfnum:       artworkOne.Tfnum,
					}

					artworks = append(artworks, item)
				}
				saveShowReq.Artwork = artworks

				saveShowRes, err := service.GrpcArtShowImpl.CreateShow(context.Background(), &saveShowReq)
				if err != nil {
					service.Error(c, e.Error, err)
					return
				}

				out := serializer.BuildSyncArtShowUID(&saveShowReq, saveShowRes.ShowUID, nil)
				if len(out.Data) > 0 {
					syncArtShowIDRes, err := service.GrpcArtworkQueryImpl.SyncArtShowId(context.Background(), &out)
					if err != nil {
						logger.Errorf("SyncArtShowId Response err", err)
						service.Error(c, e.Error, errors.New(syncArtShowIDRes.Msg))
						return
					}
				}

				// 更新 推荐人信息
				if saveShowRes.ShowUID != "" {
					bindAndGetArtPackageRequest := new(artistinfoArtshow.BindAndGetArtPackageRequest)
					bindAndGetArtPackageRequest.ArtPackageUid = saveShowRes.ShowUID
					bindAndGetArtPackageRequest.ArtistUid = saveShowReq.ArtistUID
					bindAndGetArtPackageResponse, err := service.GrpcArtistInfoArtshowImpl.BindAndGetArtPackageAndBrokerSupplement(context.Background(), bindAndGetArtPackageRequest)
					if err != nil {
						service.Success(c, nil)
					}
					if bindAndGetArtPackageResponse.Data.Name != "" {
						artShowAgent := new(artShowApi.ArtShowAgent)
						artShowAgent.Agent = bindAndGetArtPackageResponse.Data.Name
						artShowAgent.ShowUID = saveShowRes.ShowUID
						updateArtShowAgentReq := new(artShowApi.UpdateArtShowAgentReq)
						updateArtShowAgentReq.Data = make([]*artShowApi.ArtShowAgent, 0)
						updateArtShowAgentReq.Data = append(updateArtShowAgentReq.Data, artShowAgent)
						_, err := service.GrpcArtShowImpl.UpdateArtShowAgent(context.Background(), updateArtShowAgentReq)
						if err != nil {
							service.Success(c, nil)
						}

					}
				}
			}
		}

	}

	service.Success(c, nil)
}

// SetStatusBatchExV2 催办后的批量审批
func SetStatusBatchExV2(c *gin.Context) {
	var setStatusBatchReq vo.SetStatusBatchReq
	if err := c.ShouldBindBodyWith(&setStatusBatchReq, binding.JSON); err != nil {
		service.Error(c, e.Error, err)
		return
	}

	if len(setStatusBatchReq.Batch) < 1 {
		service.Error(c, e.Error, errors.New("当前无审批"))
		return
	}

	for i := 0; i < len(setStatusBatchReq.Batch); i++ {
		req := api.StatusRequest{}
		_ = copier.CopyWithOption(&req, setStatusBatchReq.Batch[i], copier.Option{DeepCopy: false})

		infoReq := account.InfoRequest{ID: req.UserId}

		infoRes, err := service.AccountProvider.Info(context.Background(), &infoReq)
		if err != nil {
			service.Error(c, e.Error, errors.New(e.GetMsg(e.ErrorGetUserInfo)))
			return
		}

		if infoRes.Info.ID == 0 || infoRes.Info.NickName == "" || infoRes.Info.Domain == "" {
			service.Error(c, e.Error, errors.New(e.GetMsg(e.ErrorGetUserInfo)))
			return
		}

		userInfo := login.Info{
			ID:       req.UserId,
			NickName: infoRes.Info.NickName,
		}

		levelReq := api.NowLevelByInfoRequestV2{
			ApprovalID: req.ID,
			NowUserId:  userInfo.ID,
		}
		fmt.Println("============== 开始查询审批流程 ==============")
		levelRes, err := service.ApprovalProvider.NowLevelByInfoV2(context.Background(), &levelReq)
		if err != nil {
			service.Error(c, e.Error, err)
			return
		}
		fmt.Printf("levelRes %+v\n", levelRes)
		fmt.Println("============== 开始查询审批流程 ==============")

		if req.UserId != levelRes.UserID {
			service.Error(c, e.Error, errors.New("本次审批人出现错误"))
			return
		}

		req.WorkFlowId = levelRes.ID

		// 查询 未审批前的审批
		beforeApproval := QueryApprovalSetStatusBefore(req.ID)
		if beforeApproval == nil {
			service.Error(c, e.Error, errors.New(e.ErrorQueryApprovalContent))
			return
		}

		_, err = service.ApprovalProvider.SetStatusV2(context.Background(), &req)
		if err != nil {
			service.Error(c, e.Error, err)
			return
		}

		detailReq := api.DetailRequest{ID: req.ID}
		detail, err := service.ApprovalProvider.Detail(context.Background(), &detailReq)
		if err != nil {
			service.Error(c, e.Error, err)
			return
		}

		// 同步至 es
		go func() {
			updateErr := logic.UpdateIndexApprovalDoc(config.ApprovalIndex, detail)
			if updateErr != nil {
				zap.L().Error("同步至 es 失败 更新", zap.Error(updateErr))
				//return
			}
		}()

		if detail.TypeName == "任命审批" {
			StoreBaiduChainApprovalFile(req.ID)
		}

		// 审批成功查询用户部门的信息，提交画作服修改画作仓库状态

		if detail.TypeName == "画作申请审批" {
			var ids []int32
			for _, tt := range detail.Work.ApprovalWorks {
				ids = append(ids, int32(tt.ArtworkID))
			}

			fmt.Println("请求画作申请审批", ids)
			if len(ids) > 0 {
				err = submitArtwork(req.UserId, ids)
				if err != nil {
					service.Error(c, e.Error, err)
					return
				}
			}
		}

		if strings.Contains(beforeApproval.Type, "turnover") && beforeApproval.Status == e.ApprovalWorkStatusDoing && detail.Status == e.ApprovalWorkStatusOk {
			loginInfo := login.Info{
				ID:       userInfo.ID,
				NickName: "离职审批:" + userInfo.NickName,
			}

			if infoRes.Info.Extend != nil {
				loginInfo.JumpTo = infoRes.Info.Extend.JumpTo
			}

			c.Set("jwtInfo", loginInfo)

			err = turnoverUpdateAccountEmployee(c, detail.ApprovalOA.Turnover)
			if err != nil {
				service.Error(c, e.Error, err)
				return
			}
		}
		if strings.Contains(beforeApproval.Type, "turnover") && (detail.Status == e.ApprovalWorkStatusRevokeOk || detail.Status == e.ApprovalWorkStatusFail) {
			updateDeductAnnualLeaveZeroClearing(detail.ApprovalOA.Turnover)
		}

		// approval 审批状态  同步到 oa 审批
		if e.TypeMap[detail.Type] == "oa" {
			// 查询  审批状态已经 更新的 审批信息
			updatedReq := api.DetailRequest{ID: req.ID}
			updatedDetail, detailErr := service.ApprovalProvider.Detail(context.Background(), &updatedReq)
			if detailErr != nil {
				service.Error(c, e.Error, detailErr)
				return
			}

			if req.LeaveBalance != 0 && updatedDetail.ApprovalOA.LeaveApply != nil {
				//leaveBalance, _ := strconv.ParseFloat(req.LeaveBalance, 10)
				updatedDetail.ApprovalOA.LeaveApply.LeaveBalance = req.LeaveBalance
			}

			_, updateErr := UpdateApprovalStatusToOAStatus(updatedDetail)
			if updateErr != nil {
				service.Error(c, e.Error, updateErr)
				return
			}
		}

		// 画展包审批
		if detail.Type == TypeExhibition {
			err = ExhibitionApproveEnter(beforeApproval, detail)
			if err != nil {
				service.Error(c, e.Error, err)
				return
			}
		}

		// 画展包润格审批
		if detail.Type == TypeArtExhibitionReward {
			err = ExhibitionRewordApproveEnter(beforeApproval, detail)
			if err != nil {
				service.Error(c, e.Error, err)
				return
			}
		}

		// 画展包修改审批
		if detail.Type == TypeShowUpdate {
			err = ShowUpdateApproveEnter(beforeApproval, detail)
			if err != nil {
				service.Error(c, e.Error, err)
				return
			}
		}

		if strings.Contains(detail.TypeName, "人员增补申请") {
			err = postApproveSetStatusEnter(userInfo, detail)
			if err != nil {
				service.Error(c, e.Error, err)
				return
			}
		}

		if strings.Contains(detail.Type, "employ") {
			err := offerApproveSetStatusEnter(c, userInfo, &req, detail)
			if err != nil {
				service.Error(c, e.Error, err)
				return
			}
		}

		if detail.Type == "checkIn" && detail.Status == e.ApprovalWorkStatusOk {
			err = passSendInfoToSiteSignIn(detail.CheckIn)
			if err != nil {
				service.Error(c, e.Error, err)
				return
			}
		}
		if detail.Status == e.ApprovalWorkStatusOk && strings.Contains(detail.Type, "position") {
			err = processPositionApprovals(detail)
			if err != nil {
				service.Error(c, e.Error, err)
				return
			}
		}

	}

	service.Success(c, nil)
}

func MakeApprovalAndCopy(in *api.CreateRequest, setting *api.SettingRequest) (*api.ApprovalAndCopy, error) {
	response := &api.ApprovalAndCopy{}

	approvalUsers, copyUsers, err := MakeApprovalAndCopyUsers(in, setting)
	if err != nil {
		return response, errors.New("组装审批人失败")
	}
	fmt.Println("------------t5---------- start ")
	fmt.Println("1-----", approvalUsers)
	fmt.Println("2-----", copyUsers)
	fmt.Println("------------t5---------- end ")
	index := 0
	for i := 0; i < len(approvalUsers); i++ {
		index++
		approvalUsers[i].Level = uint64(index)
	}
	response.ApprovalUsers = approvalUsers
	response.CopyUsers = copyUsers
	return response, nil
}

func MakeApprovalAndCopyUsers(in *api.CreateRequest, setting *api.SettingRequest) ([]*api.ApprovalUser, []*api.CopyUser, error) {
	approvalUsers := make([]*api.ApprovalUser, 0)
	copyUsers := make([]*api.CopyUser, 0)

	approvalUsers = in.ApprovalUsers
	copyUsers = in.CopyUsers

	// 病假 事假
	if in.Type == "leave" || in.Type == "sick" {
		if in.ApprovalOA.Leave.Days >= 2 {
			approvalUsers = GetCombineOaApproveUsers(setting, approvalUsers)
			copyUsers = GetCombineOaCopyUsers(setting, copyUsers)
		} else {
			//if in.IsLeader {
			approvalUsers = GetCombineOaApproveUsers(setting, approvalUsers)
			if len(approvalUsers) > 1 {
				approvalUsers = approvalUsers[:1]
			}
			//}

		}

		//新逻辑：产假 流产 独生子女护理假申请 育儿假申请====》直属2级+指定岗位
		//TODO离职暂时放着（in.Type == "turnover"）
	} else if in.Type == "maternityLeave" || in.Type == "abortLeave" || in.Type == "nursingLeaveApply" || in.Type == "parentalLeaveApply" {
		approvalUsers = GetCombineOaApproveUsers(setting, approvalUsers)
		copyUsers = GetCombineOaCopyUsers(setting, copyUsers)

		//新逻辑：加班/外勤 丧假 陪产假 婚假 育儿假 独生子女护理假 哺乳假 孕检假 年假 调休=====》直属1级
	} else if in.Type == "outWork" ||
		in.Type == "overTime" ||
		in.Type == "funeralLeave" ||
		in.Type == "makeUp" ||
		in.Type == "paternityLeave" ||
		in.Type == "maritalLeave" ||
		in.Type == "parentalLeaveApply" ||
		in.Type == "parentalLeave" ||
		in.Type == "nursingLeave" ||
		in.Type == "breastFeedingLeave" ||
		in.Type == "matingCheckLeave" ||
		in.Type == "annualLeave" ||
		in.Type == "dayOff" {
		//if in.IsLeader {
		approvalUsers = GetCombineOaApproveUsers(setting, approvalUsers)
		if len(approvalUsers) > 1 {
			approvalUsers = approvalUsers[:1]
		}

	}

	fmt.Println("------------t4---------- start ")
	fmt.Println("1-----", approvalUsers)
	fmt.Println("2-----", copyUsers)
	fmt.Println("------------t4---------- end ")

	if len(approvalUsers) < 1 {
		return nil, nil, errors.New("组装审批人失败")
	}

	//// 去重 审批人 剔除 提交人    抄送人 剔除  审批人
	//approvalUsers, copyUsers = UniqueUsersV2(in.SubmitterID, approvalUsers, copyUsers)
	fmt.Println("------------t5---------- start ")
	fmt.Println("1-----", approvalUsers)
	fmt.Println("2-----", copyUsers)
	fmt.Println("------------t5---------- end ")
	return approvalUsers, copyUsers, nil
}

// GetCombineOaApproveUsers oa审批 混合获取
func GetCombineOaApproveUsers(setting *api.SettingRequest, approvalUser []*api.ApprovalUser) []*api.ApprovalUser {
	approvalUserMap := make(map[uint64]*api.ApprovalUser)
	fmt.Println("------------oa approvalUser  t1----------")
	// copyer
	if len(approvalUser) > 0 {
		for _, tt := range approvalUser {
			if _, ok := approvalUserMap[tt.ID]; ok == false {
				approvalUserMap[tt.ID] = tt
			}
		}
	}
	fmt.Printf("oa approvalUser  t1 %+v\n----------", approvalUser)
	fmt.Println("------------oa approvalUser  t2----------")
	for _, tt := range setting.OaApprovalUsers {
		if _, ok := approvalUserMap[tt.ID]; ok == false {
			approvalUserMap[tt.ID] = tt
			approvalUser = append(approvalUser, tt)
		}
	}
	fmt.Printf("oa approvalUser  t2 %+v\n----------", approvalUser)

	return approvalUser
}

// GetCombineOaCopyUsers oa审批 抄送人 混合获取
func GetCombineOaCopyUsers(setting *api.SettingRequest, copyUser []*api.CopyUser) []*api.CopyUser {
	copyUserMap := make(map[uint64]*api.CopyUser)
	fmt.Println("------------oa copyUser  t1----------")
	// copyer
	if len(copyUser) > 0 {
		for _, tt := range copyUser {
			if _, ok := copyUserMap[tt.ID]; ok == false {
				copyUserMap[tt.ID] = tt
			}
		}
	}
	fmt.Printf("oa copyUser  t1 %+v\n----------", copyUser)
	fmt.Println("------------oa copyUser  t2----------")
	for _, tt := range setting.OaCopyUsers {
		if _, ok := copyUserMap[tt.ID]; ok == false {
			copyUserMap[tt.ID] = tt
			copyUser = append(copyUser, tt)
		}
	}
	fmt.Printf("oa copyUser  t2 %+v\n----------", copyUser)

	return copyUser
}

func UniqueUsersV2(submitterID uint64, inApprovalUsers []*api.ApprovalUser, inCopyUsers []*api.CopyUser) (approvalUsers []*api.ApprovalUser, copyUsers []*api.CopyUser) {
	approvalUsers = make([]*api.ApprovalUser, 0)
	approvalUserMap := make(map[uint64]*api.ApprovalUser, 0)
	copyUsers = make([]*api.CopyUser, 0)
	//transitionCopyUsers := make([]CopyUser, 0)

	for i := 0; i < len(inApprovalUsers); i++ {
		approvalUserMap[inApprovalUsers[i].ID] = inApprovalUsers[i]
		if inApprovalUsers[i].ID == submitterID {
			continue
		} else {
			approvalUsers = append(approvalUsers, inApprovalUsers[i])
		}
	}

	var currentLevel uint64 = 0
	var preLevel uint64 = 0
	for i := 0; i < len(approvalUsers); i++ {
		if i == 0 {
			preLevel = approvalUsers[i].Level
			currentLevel = approvalUsers[i].Level
		} else {
			currentLevel = approvalUsers[i].Level
			if approvalUsers[i].Level == preLevel {
				approvalUsers[i].Level = currentLevel
			} else {
				approvalUsers[i].Level = currentLevel
				preLevel = currentLevel
				currentLevel++
			}
		}
	}

	approvalUsersMap := make(map[uint64][]*api.ApprovalUser)
	levels := make([]int, 0)

	for i := 0; i < len(approvalUsers); i++ {
		if approvalUsersMap[approvalUsers[i].Level] == nil {
			levels = append(levels, int(approvalUsers[i].Level))
		}
		approvalUsersMap[approvalUsers[i].Level] = append(approvalUsersMap[approvalUsers[i].Level], approvalUsers[i])
	}

	newApprovalUsers := make([]*api.ApprovalUser, 0)
	sort.Ints(levels)

	if len(levels) > 0 {
		for i := 0; i < len(levels); i++ {
			for j := 0; j < len(approvalUsersMap[uint64(levels[i])]); j++ {
				if approvalUsersMap[uint64(levels[i])][j].Level == 0 {
					//approvalUsersMap[uint64(levels[i])][j].Level = uint64(j + 1)
					approvalUsersMap[uint64(levels[i])][j].Level = 1
					approvalUsersMap[uint64(levels[i])][j].Signature = m.AndSignType
				} else {
					approvalUsersMap[uint64(levels[i])][j].Level = approvalUsersMap[uint64(levels[i-1])][len(approvalUsersMap[uint64(levels[i])])-1].Level + 1
				}
			}
			newApprovalUsers = append(newApprovalUsers, approvalUsersMap[uint64(levels[i])]...)
		}
	}

	approvalUsers = newApprovalUsers

	if len(inCopyUsers) > 0 {
		for i := 0; i < len(inCopyUsers); i++ {
			if inCopyUsers[i].ID == submitterID {
				continue
			} else if _, ok := approvalUsersMap[inCopyUsers[i].ID]; ok {
				continue
			} else {
				copyUsers = append(copyUsers, inCopyUsers[i])
			}
		}
	}

	return
}

func FindEmploy(c *gin.Context) {
	var req api.Employ
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.Error, errors.New("参数获取错误"))
		return
	}

	res, err := service.ApprovalProvider.FindEmployJobNum(c, &req)
	if err != nil {
		sentry.CaptureException(err)
		service.Error(c, e.Error, err)
		return
	}

	service.Success(c, res)
}

func UpdatesOldData(c *gin.Context) {
	var req api.CommonResponse
	//if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
	//	service.Error(c, e.Error, errors.New("参数获取错误"))
	//	return
	//}

	res, err := service.ApprovalProvider.UpdatesOldData(c, &req)
	if err != nil {
		sentry.CaptureException(err)
		service.Error(c, e.Error, err)
		return
	}

	service.Success(c, res)
}

func ExportDetailSetting(c *gin.Context) {
	var req api.CreateRequest
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.Error, err)
		return
	}
	userInfo := login.GetUserInfoFromC(c)
	//resGroup, err1 := service.ApprovalProvider.OnlyGroupList(c, &api.ApprovalGroupListRequest{Page: 1, PageSize: 99, Domain: "0"})
	//if err1 != nil {
	//	sentry.CaptureException(err1)
	//	service.Error(c, e.Error, err1)
	//	return
	//}
	settingList := make([]*api.CreateApprovalTypeRequest, 0)

	//for _, request := range resGroup.GroupList {
	resSetting, err1 := service.ApprovalProvider.ApprovalTypeList(c, &api.ApprovalTypeListRequest{PageSize: 9999, Page: 1, Domain: req.Domain, GroupId: req.ID})
	if err1 != nil {
		service.Error(c, e.Error, err1)
		return
	}

	if len(resSetting.TypeList) > 0 {
		settingList = append(settingList, resSetting.TypeList...)
	}
	//}
	var err error
	var xlsx *excelize.File
	var exportUrl string

	xlsx, err = excelize.OpenFile(model.TplPath + "审批流程导出.xlsx")
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	for index, setting := range settingList {
		xlsx.SetCellValue("Sheet1", fmt.Sprintf("A%v", index+2), setting.GroupName)
		xlsx.SetCellValue("Sheet1", fmt.Sprintf("B%v", index+2), setting.Title)

		//authMap := make(map[string]*api.ApprovalAuth)
		//departmentName := ""
		//for _, auth := range setting.Auths {
		//	departmentName = departmentName + "/" + auth.DepartmentName + "-" + auth.PositionName
		//}
		//xlsx.SetCellValue("Sheet1", fmt.Sprintf("C%v", index+2), departmentName)
		approvalUser := ""
		for _, user1 := range setting.ApprovalUsers {
			if user1.ID == 0 {
				//指定部门岗位
				if user1.DepartmentUID != "" && user1.PositionUID != "" {
					listReq := new(account.ListV2Request)
					departmentId, _ := strconv.ParseUint(user1.DepartmentUID, 0, 64)
					positionId, _ := strconv.ParseUint(user1.PositionUID, 0, 64)
					listReq.DepartmentId = uint32(departmentId)
					listReq.PositionId = uint32(positionId)
					// 查询部门下的审批人
					listRes, err3 := service.AccountProvider.ListV2(context.Background(), listReq)
					if err3 != nil {
						sentry.CaptureException(err3)
						service.Error(c, e.Error, err3)
						return
					}
					for _, datum := range listRes.Data {
						if approvalUser == "" {
							approvalUser = datum.NickName
						} else {
							approvalUser = approvalUser + "/" + datum.NickName
						}
					}
				} else if user1.IsDirect == 1 {
					myBossReq := new(department.MyBossesReq)
					if strings.Contains(setting.KeyWord, "employ") {
						myBossReq.DepartmentId = uint32(req.DepartmentID)
					} else {
						myBossReq.UserId = uint32(userInfo.ID)
						myBossReq.DepartmentId = uint32(req.DepartmentID)
					}

					myBossReq.Level = uint32(user1.Level)
					if user1.IsDesignate == 1 {
						myBossReq.IsDesignate = true
					} else {
						myBossReq.IsDesignate = false
					}

					fmt.Println("============   获取 审批  直属领导  审批人 请求参数 ==============")
					fmt.Printf("myBossReq %+v\n", myBossReq)
					fmt.Println("============   获取 审批  直属领导  审批人 请求参数 ==============")

					myBossRes, err := service.DepartmentProvider.MyBosses(context.Background(), myBossReq)
					if err != nil {
						sentry.CaptureException(err)
						service.Error(c, e.Error, err)
						return
					}
					for _, datum := range myBossRes.List {
						for _, boss := range datum.Bosses {
							if approvalUser == "" {
								approvalUser = boss.Name
							} else {
								approvalUser = approvalUser + "/" + boss.Name
							}
						}
					}
				}
				//指定人员
			} else {
				if approvalUser == "" {
					approvalUser = user1.Name
				} else {
					approvalUser = approvalUser + "/" + user1.Name
				}

			}

			//if user.ID == 0 {
			//	isDesignate := ""
			//	if user.IsDesignate == 1 {
			//		isDesignate = "第"
			//	}
			//	if user.DepartmentUID == "" || user.PositionUID == "" {
			//		approvalUser = approvalUser + "/" + "直属" + isDesignate + strconv.FormatUint(user.Level, 10) + "级"
			//	} else {
			//		approvalUser = approvalUser + "/" + user.DepartmentName + "-" + user.PositionName
			//	}
			//
			//} else {
			//
			//	approvalUser = approvalUser + "/" + user.Name
			//}
		}
		xlsx.SetCellValue("Sheet1", fmt.Sprintf("D%v", index+2), approvalUser)

		copyUserName := ""
		for _, copyUser := range setting.CopyUsers {
			if copyUser.ID == 0 {
				listReq := new(account.ListV2Request)
				departmentId, _ := strconv.ParseUint(copyUser.DepartmentUID, 0, 64)
				positionId, _ := strconv.ParseUint(copyUser.PositionUID, 0, 64)
				listReq.DepartmentId = uint32(departmentId)
				listReq.PositionId = uint32(positionId)
				// 查询部门下的审批人
				listRes, err3 := service.AccountProvider.ListV2(context.Background(), listReq)
				if err3 != nil {
					sentry.CaptureException(err3)
					service.Error(c, e.Error, err3)
					return
				}
				for _, datum := range listRes.Data {
					if copyUserName == "" {
						copyUserName = datum.NickName
					} else {
						copyUserName = copyUserName + "/" + datum.NickName
					}
				}

			} else {
				if copyUserName == "" {
					copyUserName = copyUser.Name
				} else {
					copyUserName = copyUserName + "/" + copyUser.Name
				}

			}
		}
		xlsx.SetCellValue("Sheet1", fmt.Sprintf("E%v", index+2), copyUserName)

		status := "启用"
		if setting.Status != 1 {
			status = "禁用"
		}
		xlsx.SetCellValue("Sheet1", fmt.Sprintf("F%v", index+2), status)
	}
	fileName := "审批流程导出" + ".xlsx"
	var httpType string
	if config.IsHttps {
		httpType = model.HttpsType
	} else {
		httpType = model.HttpType
	}
	if err = xlsx.SaveAs(model.MediaPath + fileName); err != nil {
		return
	}
	exportUrl = fmt.Sprintf("%s%s/static/%s", httpType, c.Request.Host, fileName)
	service.Success(c, map[string]string{
		"ExportUrl": exportUrl,
	})

}

func CreateAuthQuick(c *gin.Context) {
	var req api.QkCreAuthReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.Error, errors.New("参数获取错误"))
		return
	}

	res, err := service.ApprovalProvider.CreateAuthQuick(c, &req)
	if err != nil {
		sentry.CaptureException(err)
		service.Error(c, e.Error, err)
		return
	}

	service.Success(c, res)
}

func FindTurnoverAndHandover(c *gin.Context) {
	var req api.ApprovalGroupListRequest
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.Error, errors.New("参数获取错误"))
		return
	}

	res, err := service.ApprovalProvider.FindTurnoverAndHandover(c, &req)
	if err != nil {
		sentry.CaptureException(err)
		service.Error(c, e.Error, err)
		return
	}

	service.Success(c, res)
}

/*
// 查询部门
	puRequest := &rule.PositionUserListRequest{}
	puRes, err := service.RuleProvider.PositionUserList(context.Background(), puRequest)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	// 关联职位和部门信息
	for j := range puRes.Data {
		if userInfo.ID == puRes.Data[j].UserId {
			userInfo.PositionUsers = append(userInfo.PositionUsers, &rule.PositionUser{
				PositionID:     puRes.Data[j].PositionID,
				PositionName:   puRes.Data[j].PositionName,
				DepartmentId:   puRes.Data[j].DepartmentId,
				DepartmentCode: puRes.Data[j].DepartmentCode,
				DepartmentName: puRes.Data[j].DepartmentName,
				UserId:         puRes.Data[j].UserId,
				UserName:       puRes.Data[j].UserName,
			})
		}
	}
*/

func ExportDetailSettingV2(c *gin.Context) {
	var req api.CreateRequest
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.Error, err)
		return
	}
	userInfo := login.GetUserInfoFromC(c)
	//resGroup, err1 := service.ApprovalProvider.OnlyGroupList(c, &api.ApprovalGroupListRequest{Page: 1, PageSize: 99, Domain: "0"})
	//if err1 != nil {
	//	sentry.CaptureException(err1)
	//	service.Error(c, e.Error, err1)
	//	return
	//}
	fileName := "审批流程导出" + ".xlsx"
	//var exportUrl string

	go func(userInfo login.Info, req *api.CreateRequest) {
		var err error
		var xlsx *excelize.File

		xlsx, err = excelize.OpenFile(model.TplPath + "审批流程导出.xlsx")
		if err != nil {
			service.Error(c, e.Error, err)
			return
		}

		// 查询部门
		//puRequest := &rule.PositionUserListRequest{}
		//puRes, positionUserListErr := service.RuleProvider.PositionUserList(context.Background(), puRequest)
		//if positionUserListErr != nil {
		//	service.Error(c, e.Error, positionUserListErr)
		//	return
		//}

		// 关联职位和部门信息
		//for j := range puRes.Data {
		//	if userInfo.ID == puRes.Data[j].UserId {
		//		userInfo.PositionUsers = append(userInfo.PositionUsers, &rule.PositionUser{
		//			PositionID:     puRes.Data[j].PositionID,
		//			PositionName:   puRes.Data[j].PositionName,
		//			DepartmentId:   puRes.Data[j].DepartmentId,
		//			DepartmentCode: puRes.Data[j].DepartmentCode,
		//			DepartmentName: puRes.Data[j].DepartmentName,
		//			UserId:         puRes.Data[j].UserId,
		//			UserName:       puRes.Data[j].UserName,
		//		})
		//	}
		//}

		typeList := &api.ApprovalTypeListRequest{PageSize: 9999, Page: 1, Domain: req.Domain, GroupId: req.ID}

		if userInfo.PositionUsers == nil || len(userInfo.PositionUsers) < 1 {
			typeList.Positions = make([]*api.ApprovalTypeListRequest_Position, 0)
			for i := 0; i < len(userInfo.PositionUsers); i++ {
				typeList.Positions = append(typeList.Positions, &api.ApprovalTypeListRequest_Position{
					PositionUID:   strconv.FormatUint(userInfo.PositionUsers[i].PositionID, 10),
					DepartmentUID: strconv.FormatUint(userInfo.PositionUsers[i].DepartmentId, 10),
				})
			}
		}

		//for _, request := range resGroup.GroupList {
		resSetting, err1 := service.ApprovalProvider.ApprovalTypeList(c, typeList)
		if err1 != nil {
			service.Error(c, e.Error, err1)
			return
		}

		//创建  插入表格的 内容
		rowIndex := 2

		for i := 0; i < len(userInfo.PositionUsers); i++ {

			position := userInfo.PositionUsers[i]
			//  组装 审批人 和 抄送人
			for j := 0; j < len(resSetting.TypeList); j++ {
				if m.GetOaType(resSetting.TypeList[j].KeyWord) != "" {
					continue
				}
				makeApprovalUserReq := new(api.CreateRequest)
				makeApprovalUserReq.Domain = resSetting.TypeList[j].Domain
				makeApprovalUserReq.Type = resSetting.TypeList[j].KeyWord
				makeApprovalUserReq.DepartmentID = int64(position.DepartmentId)
				if strings.Contains(makeApprovalUserReq.Type, "employ") {
					makeApprovalUserReq.Employ = new(api.Employ)
					makeApprovalUserReq.Employ.DepartmentId = strconv.FormatInt(makeApprovalUserReq.DepartmentID, 10)
				}

				fmt.Println("====================获取审批人=========================")
				approvalAndCopy, makeApprovalAndUserErr := makeApprovalAndUser(userInfo, makeApprovalUserReq)
				if err != nil {
					//service.Error(c, e.Error, err)
					//return
					fmt.Println("makeApprovalAndUserErr", makeApprovalAndUserErr)
					continue
				}

				if approvalAndCopy == nil {
					continue
				}

				if approvalAndCopy.ApprovalUsers == nil {
					continue
				}

				if approvalAndCopy.CopyUsers == nil {
					continue
				}

				approvalUsers := make([]string, 0)
				for k := 0; k < len(approvalAndCopy.ApprovalUsers); k++ {
					approvalUsers = append(approvalUsers, approvalAndCopy.ApprovalUsers[k].Name)
				}

				copyUsers := make([]string, 0)

				for k := 0; k < len(approvalAndCopy.CopyUsers); k++ {
					copyUsers = append(copyUsers, approvalAndCopy.CopyUsers[k].Name)
				}

				value := make([]interface{}, 0)
				value = append(value, userInfo.PositionUsers[i].DepartmentName)
				value = append(value, resSetting.TypeList[j].Title)
				value = append(value, "")
				if approvalUsers != nil && len(approvalUsers) > 0 {
					value = append(value, strings.Join(approvalUsers, "/"))
				} else {
					value = append(value, "")
				}

				if copyUsers != nil && len(copyUsers) > 0 {
					value = append(value, strings.Join(copyUsers, "/"))
				} else {
					value = append(value, "")
				}

				status := "启用"
				if resSetting.TypeList[j].Status != 1 {
					status = "禁用"
				}
				//value = append(value, "")
				value = append(value, status)

				xlsx.SetSheetRow("Sheet1", fmt.Sprintf("A%v", rowIndex), &value)

				rowIndex++
			}
		}

		rowIndex = rowIndex + 2
		now := time.Now().Format("2006-01-02 15:04:05")
		xlsx.SetSheetRow("Sheet1", fmt.Sprintf("A%v", rowIndex), &now)

		if err = xlsx.SaveAs(model.MediaPath + fileName); err != nil {
			return
		}
		//exportUrl = fmt.Sprintf("%s%s/static/%s", httpType, c.Request.Host, fileName)
	}(userInfo, &req)

	service.ResponseMsg(c, e.SUCCESS, serializer.Response{
		Data:   "执行完成",
		Status: e.Ok,
	})

}

func FindSuperType(c *gin.Context) {
	var req api.ListRequest
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.Error, errors.New("参数获取错误"))
		return
	}

	res, err := service.ApprovalProvider.FindSuperType(c, &req)
	if err != nil {
		sentry.CaptureException(err)
		service.Error(c, e.Error, err)
		return
	}

	service.Success(c, res)
}

func CreateAuthBatch(c *gin.Context) {
	var req api.CreAuthBatchReq
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.Error, errors.New("参数获取错误"))
		return
	}

	res, err := service.ApprovalProvider.CreateAuthBatch(c, &req)
	if err != nil {
		sentry.CaptureException(err)
		service.Error(c, e.Error, err)
		return
	}

	service.Success(c, res)
}