package recruit

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"io/ioutil"
	"mime/multipart"
	"net/http"
	"path/filepath"
	"regexp"
	"strings"
	"sync"
	"time"

	"dubbo.apache.org/dubbo-go/v3/common/logger"
	"github.com/fonchain_enterprise/fonchain-main/api/account"
	"github.com/fonchain_enterprise/fonchain-main/api/department"
	"github.com/fonchain_enterprise/fonchain-main/api/e_card"
	"github.com/fonchain_enterprise/fonchain-main/api/position"
	"github.com/fonchain_enterprise/fonchain-main/api/recruit"
	"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/query"
	"github.com/fonchain_enterprise/fonchain-main/pkg/model/union"
	"github.com/fonchain_enterprise/fonchain-main/pkg/serializer"
	"github.com/fonchain_enterprise/fonchain-main/pkg/service"
	account2 "github.com/fonchain_enterprise/fonchain-main/pkg/service/account"
	"github.com/fonchain_enterprise/fonchain-main/pkg/service/approval"
	employee1 "github.com/fonchain_enterprise/fonchain-main/pkg/utils/employee"
	"github.com/fonchain_enterprise/utils/objstorage"
	"github.com/gin-gonic/gin"
	"github.com/gin-gonic/gin/binding"
	uuid "github.com/satori/go.uuid"
)

var (
	wg sync.WaitGroup
)

func PostSubmit(c *gin.Context) {
	var dealProcessProto recruit.DealProcessProto
	if err := c.ShouldBind(&dealProcessProto); err != nil {
		logger.Errorf("dealProcessProto ShouldBind err", err)
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Data:   nil,
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	//获取环境变量

	rep, err := service.GrpcRecruitClientImpl.PostSubmit(context.Background(), &dealProcessProto)
	if err != nil {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	c.JSON(http.StatusOK, serializer.Response{
		Status: e.Ok,
		Code:   e.SUCCESS,
		Data:   rep,
	})
}

func PostCancelUp(c *gin.Context) {
	var dealProcessProto recruit.DealProcessProto
	if err := c.ShouldBind(&dealProcessProto); err != nil {
		logger.Errorf("dealProcessProto ShouldBind err", err)
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Data:   nil,
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	tempPosition := &recruit.PositionProto{Weigh: 0}
	tempEntity := &recruit.EntityProto{Position: tempPosition}

	dealProcessProto.Entity = tempEntity

	rep, err := service.GrpcRecruitClientImpl.PostSetWeigh(context.Background(), &dealProcessProto)
	if err != nil {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	c.JSON(http.StatusOK, serializer.Response{
		Status: e.Ok,
		Code:   e.SUCCESS,
		Data:   rep,
	})
}

func PostUp(c *gin.Context) {
	var dealProcessProto recruit.DealProcessProto
	if err := c.ShouldBind(&dealProcessProto); err != nil {
		logger.Errorf("dealProcessProto ShouldBind err", err)
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Data:   nil,
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	tempPosition := &recruit.PositionProto{Weigh: int32(time.Now().Unix())}
	tempEntity := &recruit.EntityProto{Position: tempPosition}

	dealProcessProto.Entity = tempEntity

	rep, err := service.GrpcRecruitClientImpl.PostSetWeigh(context.Background(), &dealProcessProto)
	if err != nil {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	c.JSON(http.StatusOK, serializer.Response{
		Status: e.Ok,
		Code:   e.SUCCESS,
		Data:   rep,
	})
}

func PostPass(c *gin.Context) {
	var dealProcessProto recruit.DealProcessProto
	if err := c.ShouldBind(&dealProcessProto); err != nil {
		logger.Errorf("dealProcessProto ShouldBind err", err)
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Data:   nil,
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	rep, err := service.GrpcRecruitClientImpl.PostPass(context.Background(), &dealProcessProto)
	if err != nil {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	c.JSON(http.StatusOK, serializer.Response{
		Status: e.Ok,
		Code:   e.SUCCESS,
		Data:   rep,
	})
}

func PostReject(c *gin.Context) {
	var dealProcessProto recruit.DealProcessProto
	if err := c.ShouldBind(&dealProcessProto); err != nil {
		logger.Errorf("dealProcessProto ShouldBind err", err)
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Data:   nil,
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	rep, err := service.GrpcRecruitClientImpl.PostReject(context.Background(), &dealProcessProto)
	if err != nil {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	c.JSON(http.StatusOK, serializer.Response{
		Status: e.Ok,
		Code:   e.SUCCESS,
		Data:   rep,
	})
}

func PostCheck(c *gin.Context) {
	var dealProcessProto recruit.DealProcessProto
	if err := c.ShouldBind(&dealProcessProto); err != nil {
		logger.Errorf("dealProcessProto ShouldBind err", err)
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Data:   nil,
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	rep, err := service.GrpcRecruitClientImpl.PostCheck(context.Background(), &dealProcessProto)
	if err != nil {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	c.JSON(http.StatusOK, serializer.Response{
		Status: e.Ok,
		Code:   e.SUCCESS,
		Data:   rep,
	})
}

func PostClose(c *gin.Context) {
	var postCloseReq req
	if err := c.ShouldBind(&postCloseReq); err != nil {
		logger.Errorf("postCloseReq ShouldBind err", err)
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Data:   nil,
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	var dealProcessProto recruit.DealProcessProto

	if mLoginInfoAny, exists := c.Get("mLoginInfo"); exists {
		userInfo := mLoginInfoAny.(model.LoginInfo)
		user := &recruit.UserProto{
			Id:       int64(userInfo.ID),
			Nickname: userInfo.NickName,
		}
		dealProcessProto.User = user
	} else {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Data:   nil,
			Msg:    errors.New("未获取到用户信息").Error(),
			Status: e.Failed,
		})
		return
	}

	dealProcessProto.Type = "post-approve"
	dealProcessProto.Command = "position-terminate"
	dealProcessProto.Id = postCloseReq.Id

	rep, err := service.GrpcRecruitClientImpl.PostCheck(context.Background(), &dealProcessProto)
	if err != nil {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	if rep.Code == 1 {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    rep.Msg,
			Status: e.Failed,
		})
		return
	}
	c.JSON(http.StatusOK, serializer.Response{
		Status: e.Ok,
		Code:   e.SUCCESS,
		Data:   rep,
	})
}

type resume struct {
	ResumeFile     string `json:"resumeFile"`
	ResumeFileName string `json:"resumeFileName"`
	Files          []File `json:"files"` //附件
}

type File struct {
	File     string `json:"file"`
	FileName string `json:"fileName"`
}

type req struct {
	Id              int64    `json:"id"`
	PositionId      int64    `json:"positionId"`
	ResumeFile      []string `json:"resumeFile"`
	InterviewTime   string   `json:"interviewTime"`
	TerminateReason string   `json:"terminateReason"`
	Name            string   `json:"name"`
	Mobile          string   `json:"mobile"`
	EmployeeType    string   `json:"employeeType"`
	EmployeeNo      string   `json:"employeeNo"`
	EntryTime       string   `json:"entryTime"`
	InterviewFile   string   `json:"interviewFile"`
	Resumes         []resume `json:"resumes"`
}

func ResumeSubmitV2(c *gin.Context) {

	var resumeSubmitReq req
	if err := c.ShouldBind(&resumeSubmitReq); err != nil {
		logger.Errorf("dealProcessProto ShouldBind err", err)
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Data:   nil,
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	var dealProcessProto recruit.DealProcessProto
	entityProto := &recruit.EntityProto{}

	if mLoginInfoAny, exists := c.Get("mLoginInfo"); exists {
		userInfo := mLoginInfoAny.(model.LoginInfo)
		user := &recruit.UserProto{
			Id:       int64(userInfo.ID),
			Nickname: userInfo.NickName,
		}
		dealProcessProto.User = user
	} else {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Data:   nil,
			Msg:    errors.New("未获取到用户信息").Error(),
			Status: e.Failed,
		})
		return
	}
	//user := &recruit.UserProto{
	//	Id:       1,
	//	Nickname: "张三",
	//}
	//dealProcessProto.User = user

	dealProcessProto.Type = "resume-approve"
	dealProcessProto.Command = "resume-submit"

	for _, v := range resumeSubmitReq.Resumes {
		resumeProto := &recruit.ResumeProto{
			PositionId:     resumeSubmitReq.PositionId,
			ResumeFile:     v.ResumeFile,
			ResumeFileName: v.ResumeFileName,
		}

		//增加附件
		if len(v.Files) > 0 {
			for _, f := range v.Files {
				resumeProto.Files = append(resumeProto.Files, &recruit.FileProto{
					File:     f.File,
					FileName: f.FileName,
				})
			}
		}

		entityProto.Resume = append(entityProto.Resume, resumeProto)
	}

	dealProcessProto.Entity = entityProto

	rep, err := service.GrpcRecruitClientImpl.ResumeSubmit(context.Background(), &dealProcessProto)
	if err != nil {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	if rep.Code == 1 {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    rep.Msg,
			Status: e.Failed,
		})
		return
	}
	c.JSON(http.StatusOK, serializer.Response{
		Status: e.Ok,
		Code:   e.SUCCESS,
		Data:   rep,
	})
}

func ResumeSubmit(c *gin.Context) {

	var resumeSubmitReq req
	if err := c.ShouldBind(&resumeSubmitReq); err != nil {
		logger.Errorf("dealProcessProto ShouldBind err", err)
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Data:   nil,
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	var dealProcessProto recruit.DealProcessProto
	entityProto := &recruit.EntityProto{}

	if mLoginInfoAny, exists := c.Get("mLoginInfo"); exists {
		userInfo := mLoginInfoAny.(model.LoginInfo)
		user := &recruit.UserProto{
			Id:       int64(userInfo.ID),
			Nickname: userInfo.NickName,
		}
		dealProcessProto.User = user
	} else {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Data:   nil,
			Msg:    errors.New("未获取到用户信息").Error(),
			Status: e.Failed,
		})
		return
	}
	//user := &recruit.UserProto{
	//	Id:       1,
	//	Nickname: "张三",
	//}
	//dealProcessProto.User = user

	dealProcessProto.Type = "resume-approve"
	dealProcessProto.Command = "resume-submit"

	for _, v := range resumeSubmitReq.ResumeFile {
		resumeProto := &recruit.ResumeProto{
			PositionId: resumeSubmitReq.PositionId,
			ResumeFile: v,
		}
		entityProto.Resume = append(entityProto.Resume, resumeProto)
	}

	dealProcessProto.Entity = entityProto

	rep, err := service.GrpcRecruitClientImpl.ResumeSubmit(context.Background(), &dealProcessProto)
	if err != nil {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	if rep.Code == 1 {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    rep.Msg,
			Status: e.Failed,
		})
		return
	}
	c.JSON(http.StatusOK, serializer.Response{
		Status: e.Ok,
		Code:   e.SUCCESS,
		Data:   rep,
	})
}

func GiveResumeOffer(c *gin.Context) {
	var resumePassReq req
	if err := c.ShouldBind(&resumePassReq); err != nil {
		logger.Errorf("resumePassReq ShouldBind err", err)
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Data:   nil,
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	userInfo := login.GetUserInfoFromC(c)

	resumeReq := recruit.ResumeReq{ResumeId: resumePassReq.Id, PageSize: 1, CurPage: 1}

	rep, err := service.GrpcRecruitClientImpl.ResumePageQuery(context.Background(), &resumeReq)

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

	if len(rep.Resumes) <= 0 {
		service.Error(c, e.Error, errors.New("没有对应的简历"))
		return
	}

	resumeRes := rep.Resumes[0]
	positionInfo, err := service.GrpcRecruitClientImpl.PositionDetail(context.Background(), &recruit.PositionDetailReq{Id: int32(resumeRes.PositionId)})
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	if positionInfo.Code != 0 {
		service.Error(c, e.Error, errors.New(positionInfo.Msg))
		return
	}
	fmt.Println("岗位和部门", positionInfo.Position.ApplierPosition, positionInfo.Position.ApplierDepartment)

	err = approval.PassOfferApprove(userInfo, uint64(resumePassReq.Id))
	if err != nil {
		logger.Errorf("resumePassReq ShouldBind err", err)
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Data:   nil,
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	registerUser := union.User{
		Domain:        "fontree",
		NickName:      resumeRes.Name,
		TelNum:        resumeRes.Mobile,
		Status:        "notactive",
		EnterDate:     time.Now().Format(model.DateFormat),
		PositionUsers: nil,
		JobNum:        resumeRes.EmployeeNo,
		Password:      e.DEFAULT_PWD,
		Source:        "entryApplication",
	}

	registerUser.Operator = &account.Operator{
		ID:   uint32(positionInfo.Position.ApplierId),
		Name: positionInfo.Position.Applier,
	}

	registerUser.PositionUsers = make([]*position.PositionUser, 0)

	if positionInfo.Position != nil && positionInfo.Position.ApplyPositionId != 0 && positionInfo.Position.ApplyDepartmentId != 0 {
		logger.Error("招聘-----------使用部门岗位id创建帐号")
		fmt.Println("招聘-----------使用部门岗位id创建帐号")
		registerUser.PositionUsers = append(registerUser.PositionUsers, &position.PositionUser{PositionID: uint64(positionInfo.Position.ApplyPositionId), DepartmentID: uint64(positionInfo.Position.ApplyDepartmentId)})
	} else {
		logger.Error("招聘-----------使用部门岗位名称创建帐号")
		fmt.Println("招聘-----------使用部门岗位名称创建帐号")
		registerUser.PositionUsers = append(registerUser.PositionUsers, &position.PositionUser{PositionName: positionInfo.Position.Post, DepartmentName: positionInfo.Position.ApplierDepartment})
	}

	err, user := account2.UserRegisters(c, registerUser)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}
	//创建员工档案
	err = employee1.CreateAnEmployeeProfile(c, user.ID, registerUser, rep, registerUser.Operator)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	// 生成员工电子名片
	var addChainRequest *e_card.AddChainRequest
	addChainRequest, err = account2.GetECardInfo(user.ID, "人才招聘-确认入职")
	if err != nil {
		return
	}

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

	_, err = service.ECardProvider.AddChain(context.Background(), addChainRequest)

	c.JSON(http.StatusOK, serializer.Response{
		Status: e.Ok,
		Code:   e.SUCCESS,
		Data:   nil,
	})

	return
}

func ResumePass(c *gin.Context) {
	var resumePassReq req
	if err := c.ShouldBind(&resumePassReq); err != nil {
		logger.Errorf("resumePassReq ShouldBind err", err)
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Data:   nil,
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	var dealProcessProto recruit.DealProcessProto

	if mLoginInfoAny, exists := c.Get("mLoginInfo"); exists {
		userInfo := mLoginInfoAny.(model.LoginInfo)
		user := &recruit.UserProto{
			Id:       int64(userInfo.ID),
			Nickname: userInfo.NickName,
		}
		dealProcessProto.User = user
	} else {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Data:   nil,
			Msg:    errors.New("未获取到用户信息").Error(),
			Status: e.Failed,
		})
		return
	}

	dealProcessProto.Id = resumePassReq.Id
	dealProcessProto.Type = "resume-approve"
	dealProcessProto.Command = "resume-pass"

	rep, err := service.GrpcRecruitClientImpl.ResumePass(context.Background(), &dealProcessProto)
	fmt.Println("err", err)
	if err != nil {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	if rep.Code == 1 {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    rep.Msg,
			Status: e.Failed,
		})
		return
	}
	c.JSON(http.StatusOK, serializer.Response{
		Status: e.Ok,
		Code:   e.SUCCESS,
		Data:   rep,
	})
}

func ResumeReject(c *gin.Context) {
	var resumeRejectReq req
	if err := c.ShouldBind(&resumeRejectReq); err != nil {
		logger.Errorf("resumeRejectReq ShouldBind err", err)
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Data:   nil,
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	var dealProcessProto recruit.DealProcessProto

	if mLoginInfoAny, exists := c.Get("mLoginInfo"); exists {
		userInfo := mLoginInfoAny.(model.LoginInfo)
		user := &recruit.UserProto{
			Id:       int64(userInfo.ID),
			Nickname: userInfo.NickName,
		}
		dealProcessProto.User = user
	} else {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Data:   nil,
			Msg:    errors.New("未获取到用户信息").Error(),
			Status: e.Failed,
		})
		return
	}

	dealProcessProto.Id = resumeRejectReq.Id
	dealProcessProto.Type = "resume-approve"
	dealProcessProto.Command = "resume-reject"

	rep, err := service.GrpcRecruitClientImpl.ResumeReject(context.Background(), &dealProcessProto)
	if err != nil {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	if rep.Code == 1 {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    rep.Msg,
			Status: e.Failed,
		})
		return
	}
	c.JSON(http.StatusOK, serializer.Response{
		Status: e.Ok,
		Code:   e.SUCCESS,
		Data:   rep,
	})
}

func ResumeInterviewTime(c *gin.Context) {
	var resumeInterviewTimeReq req
	if err := c.ShouldBind(&resumeInterviewTimeReq); err != nil {
		logger.Errorf("resumeInterviewTimeReq ShouldBind err", err)
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Data:   nil,
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	var dealProcessProto recruit.DealProcessProto

	if mLoginInfoAny, exists := c.Get("mLoginInfo"); exists {
		userInfo := mLoginInfoAny.(model.LoginInfo)
		user := &recruit.UserProto{
			Id:       int64(userInfo.ID),
			Nickname: userInfo.NickName,
		}
		dealProcessProto.User = user
	} else {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Data:   nil,
			Msg:    errors.New("未获取到用户信息").Error(),
			Status: e.Failed,
		})
		return
	}

	dealProcessProto.Id = resumeInterviewTimeReq.Id
	dealProcessProto.Type = "resume-approve"
	dealProcessProto.Command = "resume-edit"

	entity := &recruit.EntityProto{}
	resume := &recruit.ResumeProto{
		InterviewTime: resumeInterviewTimeReq.InterviewTime, //面试时间传参 虽然是数组但是只有一个面试时间
	}
	entity.Resume = append(entity.Resume, resume)
	dealProcessProto.Entity = entity

	rep, err := service.GrpcRecruitClientImpl.ResumeInterviewTime(context.Background(), &dealProcessProto)
	if err != nil {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	if rep.Code == 1 {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    rep.Msg,
			Status: e.Failed,
		})
		return
	}
	c.JSON(http.StatusOK, serializer.Response{
		Status: e.Ok,
		Code:   e.SUCCESS,
		Data:   rep,
	})
}

func ResumeModifyInterviewTime(c *gin.Context) {
	var resumeModifyInterviewTimeReq req
	if err := c.ShouldBind(&resumeModifyInterviewTimeReq); err != nil {
		logger.Errorf("resumeModifyInterviewTimeReq ShouldBind err", err)
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Data:   nil,
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	var dealProcessProto recruit.DealProcessProto

	if mLoginInfoAny, exists := c.Get("mLoginInfo"); exists {
		userInfo := mLoginInfoAny.(model.LoginInfo)
		user := &recruit.UserProto{
			Id:       int64(userInfo.ID),
			Nickname: userInfo.NickName,
		}
		dealProcessProto.User = user
	} else {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Data:   nil,
			Msg:    errors.New("未获取到用户信息").Error(),
			Status: e.Failed,
		})
		return
	}

	dealProcessProto.Id = resumeModifyInterviewTimeReq.Id
	dealProcessProto.Type = "resume-approve"
	dealProcessProto.Command = "resume-modify-interview-time"

	entity := &recruit.EntityProto{}
	resume := &recruit.ResumeProto{
		InterviewTime: resumeModifyInterviewTimeReq.InterviewTime, //修改面试时间传参
	}
	entity.Resume = append(entity.Resume, resume)
	dealProcessProto.Entity = entity

	rep, err := service.GrpcRecruitClientImpl.ResumeModifyInterviewTime(context.Background(), &dealProcessProto)
	if err != nil {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	if rep.Code == 1 {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    rep.Msg,
			Status: e.Failed,
		})
		return
	}
	c.JSON(http.StatusOK, serializer.Response{
		Status: e.Ok,
		Code:   e.SUCCESS,
		Data:   rep,
	})
}

func ResumeModifyInfo(c *gin.Context) {
	var resumeModifyInfoReq req
	if err := c.ShouldBind(&resumeModifyInfoReq); err != nil {
		logger.Errorf("resumeModifyInfoReq ShouldBind err", err)
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Data:   nil,
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	var dealProcessProto recruit.DealProcessProto

	if mLoginInfoAny, exists := c.Get("mLoginInfo"); exists {
		userInfo := mLoginInfoAny.(model.LoginInfo)
		user := &recruit.UserProto{
			Id:       int64(userInfo.ID),
			Nickname: userInfo.NickName,
		}
		dealProcessProto.User = user
	} else {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Data:   nil,
			Msg:    errors.New("未获取到用户信息").Error(),
			Status: e.Failed,
		})
		return
	}

	dealProcessProto.Id = resumeModifyInfoReq.Id
	dealProcessProto.Type = "resume-approve"
	dealProcessProto.Command = "resume-modify-info"

	entity := &recruit.EntityProto{}
	resume := &recruit.ResumeProto{
		Name:          resumeModifyInfoReq.Name,
		Mobile:        resumeModifyInfoReq.Mobile,
		EmployeeType:  resumeModifyInfoReq.EmployeeType,
		EmployeeNo:    resumeModifyInfoReq.EmployeeNo,
		EntryTime:     resumeModifyInfoReq.EntryTime,
		InterviewFile: resumeModifyInfoReq.InterviewFile,
	}
	entity.Resume = append(entity.Resume, resume)
	dealProcessProto.Entity = entity

	rep, err := service.GrpcRecruitClientImpl.ResumeModifyInfo(context.Background(), &dealProcessProto)
	if err != nil {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	if rep.Code == 1 {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    rep.Msg,
			Status: e.Failed,
		})
		return
	}
	c.JSON(http.StatusOK, serializer.Response{
		Status: e.Ok,
		Code:   e.SUCCESS,
		Data:   rep,
	})
}

func ResumeInterviewPass(c *gin.Context) {

	var resumeInterviewPassReq req
	if err := c.ShouldBind(&resumeInterviewPassReq); err != nil {
		logger.Errorf("resumeInterviewPassReq ShouldBind err", err)
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Data:   nil,
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	var dealProcessProto recruit.DealProcessProto

	if mLoginInfoAny, exists := c.Get("mLoginInfo"); exists {
		userInfo := mLoginInfoAny.(model.LoginInfo)
		user := &recruit.UserProto{
			Id:       int64(userInfo.ID),
			Nickname: userInfo.NickName,
		}
		dealProcessProto.User = user
	} else {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Data:   nil,
			Msg:    errors.New("未获取到用户信息").Error(),
			Status: e.Failed,
		})
		return
	}

	dealProcessProto.Id = resumeInterviewPassReq.Id
	dealProcessProto.Type = "resume-approve"
	dealProcessProto.Command = "resume-interview-pass"

	rep, err := service.GrpcRecruitClientImpl.ResumeInterviewPass(context.Background(), &dealProcessProto)
	if err != nil {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	if rep.Code == 1 {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    rep.Msg,
			Status: e.Failed,
		})
		return
	}
	c.JSON(http.StatusOK, serializer.Response{
		Status: e.Ok,
		Code:   e.SUCCESS,
		Data:   rep,
	})
}

func ResumeInterviewReject(c *gin.Context) {
	var resumeInterviewRejectReq req
	if err := c.ShouldBind(&resumeInterviewRejectReq); err != nil {
		logger.Errorf("resumeInterviewRejectReq ShouldBind err", err)
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Data:   nil,
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	var dealProcessProto recruit.DealProcessProto

	if mLoginInfoAny, exists := c.Get("mLoginInfo"); exists {
		userInfo := mLoginInfoAny.(model.LoginInfo)
		user := &recruit.UserProto{
			Id:       int64(userInfo.ID),
			Nickname: userInfo.NickName,
		}
		dealProcessProto.User = user
	} else {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Data:   nil,
			Msg:    errors.New("未获取到用户信息").Error(),
			Status: e.Failed,
		})
		return
	}

	dealProcessProto.Id = resumeInterviewRejectReq.Id
	dealProcessProto.Type = "resume-approve"
	dealProcessProto.Command = "resume-interview-reject"

	rep, err := service.GrpcRecruitClientImpl.ResumeInterviewReject(context.Background(), &dealProcessProto)
	if err != nil {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	if rep.Code == 1 {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    rep.Msg,
			Status: e.Failed,
		})
		return
	}
	c.JSON(http.StatusOK, serializer.Response{
		Status: e.Ok,
		Code:   e.SUCCESS,
		Data:   rep,
	})
}
func ResumeTerminate(c *gin.Context) {
	var resumeTerminateReq req
	if err := c.ShouldBind(&resumeTerminateReq); err != nil {
		logger.Errorf("resumeTerminateReq ShouldBind err", err)
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Data:   nil,
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	//查看用户是否已经入职，如果是已经入职了再终止简历，需要删除用户账户
	var resumeReq recruit.ResumeReq
	resumeReq.CurPage = 1
	resumeReq.PageSize = 1
	resumeReq.ResumeId = resumeTerminateReq.Id
	resumePageQueryRep, err := service.GrpcRecruitClientImpl.ResumePageQuery(context.Background(), &resumeReq)
	if err != nil {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	if resumePageQueryRep.Code == 1 {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    resumePageQueryRep.Msg,
			Status: e.Failed,
		})
		return
	}

	//如果是已入职了,需要删除用户账户
	if len(resumePageQueryRep.Resumes) != 0 {
		if resumePageQueryRep.Resumes[0].StatusName == "已入职" {
			//获取到用户id

			//电话存在
			if resumePageQueryRep.Resumes[0].Mobile != "" {
				//先根据用户电话查询到id
				var userByTelRequest account.UserByTelRequest
				userByTelRequest.Tel = resumePageQueryRep.Resumes[0].Mobile
				userByTelRep, err := service.AccountProvider.UserByTel(context.Background(), &userByTelRequest)
				if err != nil {
					service.ResponseMsg(c, e.SUCCESS, serializer.Response{
						Msg:    err.Error(),
						Status: e.Failed,
					})
					return
				}

				//删除用户
				var removeRequest account.RemoveRequest
				if userByTelRep.Info != nil {
					removeRequest.ID = userByTelRep.Info.ID
				} else {
					service.ResponseMsg(c, e.SUCCESS, serializer.Response{
						Data:   nil,
						Msg:    errors.New("账户系统用户信息不存在").Error(),
						Status: e.Failed,
					})
					return
				}

				_, err = service.AccountProvider.Remove(context.Background(), &removeRequest)
				if err != nil {
					service.Error(c, e.Error, err)
					return
				}

				//岗位删除
				positionReq := &position.RemoveUserRequest{
					Domain: "",
					ID:     removeRequest.ID,
				}

				_, err1 := service.PositionProvider.RemoveUser(c, positionReq)
				if err1 != nil {
					service.Error(c, e.Error, err1)
					return
				}

				//部门删除
				DepartmentReq := &department.RemoveUserRequest{
					Domain:   "",
					LeaderID: removeRequest.ID,
				}

				_, err2 := service.DepartmentProvider.RemoveUser(c, DepartmentReq)
				if err2 != nil {
					service.Error(c, e.Error, err2)
					return
				}

				// 简历终止
				var dealProcessProto recruit.DealProcessProto

				if mLoginInfoAny, exists := c.Get("mLoginInfo"); exists {
					userInfo := mLoginInfoAny.(model.LoginInfo)
					user := &recruit.UserProto{
						Id:       int64(userInfo.ID),
						Nickname: userInfo.NickName,
					}
					dealProcessProto.User = user
				} else {
					service.ResponseMsg(c, e.SUCCESS, serializer.Response{
						Data:   nil,
						Msg:    errors.New("未获取到用户信息").Error(),
						Status: e.Failed,
					})
					return
				}

				dealProcessProto.Id = resumeTerminateReq.Id
				dealProcessProto.Type = "resume-approve"
				dealProcessProto.Command = "resume-terminate"

				entity := &recruit.EntityProto{}
				resume := &recruit.ResumeProto{
					TerminateReason: resumeTerminateReq.TerminateReason,
				}
				entity.Resume = append(entity.Resume, resume)
				dealProcessProto.Entity = entity

				rep, err := service.GrpcRecruitClientImpl.ResumeTerminate(context.Background(), &dealProcessProto)
				if err != nil {
					service.ResponseMsg(c, e.SUCCESS, serializer.Response{
						Msg:    err.Error(),
						Status: e.Failed,
					})
					return
				}
				if rep.Code == 1 {
					service.ResponseMsg(c, e.SUCCESS, serializer.Response{
						Msg:    rep.Msg,
						Status: e.Failed,
					})
					return
				}
			} else {
				service.ResponseMsg(c, e.SUCCESS, serializer.Response{
					Data:   nil,
					Msg:    errors.New("用户简历信息缺失").Error(),
					Status: e.Failed,
				})
				return
			}
		} else {
			// 简历终止
			var dealProcessProto recruit.DealProcessProto

			if mLoginInfoAny, exists := c.Get("mLoginInfo"); exists {
				userInfo := mLoginInfoAny.(model.LoginInfo)
				user := &recruit.UserProto{
					Id:       int64(userInfo.ID),
					Nickname: userInfo.NickName,
				}
				dealProcessProto.User = user
			} else {
				service.ResponseMsg(c, e.SUCCESS, serializer.Response{
					Data:   nil,
					Msg:    errors.New("未获取到用户信息").Error(),
					Status: e.Failed,
				})
				return
			}

			dealProcessProto.Id = resumeTerminateReq.Id
			dealProcessProto.Type = "resume-approve"
			dealProcessProto.Command = "resume-terminate"

			entity := &recruit.EntityProto{}
			resume := &recruit.ResumeProto{
				TerminateReason: resumeTerminateReq.TerminateReason,
			}
			entity.Resume = append(entity.Resume, resume)
			dealProcessProto.Entity = entity

			rep, err := service.GrpcRecruitClientImpl.ResumeTerminate(context.Background(), &dealProcessProto)
			if err != nil {
				service.ResponseMsg(c, e.SUCCESS, serializer.Response{
					Msg:    err.Error(),
					Status: e.Failed,
				})
				return
			}
			if rep.Code == 1 {
				service.ResponseMsg(c, e.SUCCESS, serializer.Response{
					Msg:    rep.Msg,
					Status: e.Failed,
				})
				return
			}
		}
	} else {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Data:   nil,
			Msg:    errors.New("用户简历信息缺失").Error(),
			Status: e.Failed,
		})
		return
	}

	c.JSON(http.StatusOK, serializer.Response{
		Status: e.Ok,
		Code:   e.SUCCESS,
		Data:   resumePageQueryRep,
	})
}

type resumeUploadDetail struct {
	Id            int64  `json:"id"`
	Name          string `json:"name"`
	Mobile        string `json:"mobile"`
	EmployeeType  string `json:"employeeType"`
	EmployeeNo    string `json:"employeeNo"`
	EntryTime     string `json:"entryTime"`
	InterviewFile string `json:"interviewFile"`
	InterviewTime string `json:"interviewTime"`
}

func ResumeUploadDetail(c *gin.Context) {
	var resumeUploadDetailReq resumeUploadDetail
	if err := c.ShouldBind(&resumeUploadDetailReq); err != nil {
		logger.Errorf("resumeUploadDetailReq ShouldBind err", err)
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Data:   nil,
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	listRes, err := service.AccountProvider.ListV2(c, &account.ListV2Request{JobNum: resumeUploadDetailReq.EmployeeNo})

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

	if listRes.Count >= 1 {
		service.Error(c, e.Error, errors.New("当前工号已经被占用"))
		return
	}

	var dealProcessProto recruit.DealProcessProto
	if mLoginInfoAny, exists := c.Get("mLoginInfo"); exists {
		userInfo := mLoginInfoAny.(model.LoginInfo)
		user := &recruit.UserProto{
			Id:       int64(userInfo.ID),
			Nickname: userInfo.NickName,
		}
		dealProcessProto.User = user
	} else {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Data:   nil,
			Msg:    errors.New("未获取到用户信息").Error(),
			Status: e.Failed,
		})
		return
	}

	dealProcessProto.Id = resumeUploadDetailReq.Id
	dealProcessProto.Type = "resume-approve"
	dealProcessProto.Command = "resume-edit"

	entityProto := &recruit.EntityProto{}
	resumeProto := &recruit.ResumeProto{}

	resumeProto.Name = resumeUploadDetailReq.Name
	resumeProto.Mobile = resumeUploadDetailReq.Mobile
	resumeProto.EmployeeType = resumeUploadDetailReq.EmployeeType
	resumeProto.EmployeeNo = resumeUploadDetailReq.EmployeeNo
	resumeProto.EntryTime = resumeUploadDetailReq.EntryTime
	resumeProto.InterviewFile = resumeUploadDetailReq.InterviewFile
	resumeProto.InterviewTime = resumeUploadDetailReq.InterviewTime
	entityProto.Resume = append(entityProto.Resume, resumeProto)
	dealProcessProto.Entity = entityProto

	rep, err := service.GrpcRecruitClientImpl.ResumeUploadDetail(context.Background(), &dealProcessProto)
	if err != nil {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	if rep.Code == 1 {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    rep.Msg,
			Status: e.Failed,
		})
		return
	}
	c.JSON(http.StatusOK, serializer.Response{
		Status: e.Ok,
		Code:   e.SUCCESS,
		Data:   rep,
	})
}

func OfferSubmit(c *gin.Context) {
	var dealProcessProto recruit.DealProcessProto
	if err := c.ShouldBind(&dealProcessProto); err != nil {
		logger.Errorf("dealProcessProto ShouldBind err", err)
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Data:   nil,
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	rep, err := service.GrpcRecruitClientImpl.OfferSubmit(context.Background(), &dealProcessProto)
	if err != nil {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	c.JSON(http.StatusOK, serializer.Response{
		Status: e.Ok,
		Code:   e.SUCCESS,
		Data:   rep,
	})
}

func OfferPass(c *gin.Context) {
	var dealProcessProto recruit.DealProcessProto
	if err := c.ShouldBind(&dealProcessProto); err != nil {
		logger.Errorf("dealProcessProto ShouldBind err", err)
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Data:   nil,
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	rep, err := service.GrpcRecruitClientImpl.OfferPass(context.Background(), &dealProcessProto)
	if err != nil {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	c.JSON(http.StatusOK, serializer.Response{
		Status: e.Ok,
		Code:   e.SUCCESS,
		Data:   rep,
	})
}

func OfferReject(c *gin.Context) {
	var dealProcessProto recruit.DealProcessProto
	if err := c.ShouldBind(&dealProcessProto); err != nil {
		logger.Errorf("dealProcessProto ShouldBind err", err)
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Data:   nil,
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	rep, err := service.GrpcRecruitClientImpl.OfferReject(context.Background(), &dealProcessProto)
	if err != nil {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	c.JSON(http.StatusOK, serializer.Response{
		Status: e.Ok,
		Code:   e.SUCCESS,
		Data:   rep,
	})
}

func OfferCheck(c *gin.Context) {
	var dealProcessProto recruit.DealProcessProto
	if err := c.ShouldBind(&dealProcessProto); err != nil {
		logger.Errorf("dealProcessProto ShouldBind err", err)
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Data:   nil,
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	rep, err := service.GrpcRecruitClientImpl.OfferCheck(context.Background(), &dealProcessProto)
	if err != nil {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	c.JSON(http.StatusOK, serializer.Response{
		Status: e.Ok,
		Code:   e.SUCCESS,
		Data:   rep,
	})
}

type Data struct {
	Id                int64   `json:"id"`
	Applier           string  `json:"applier"`
	ApplierId         int64   `json:"applierId"`
	ApplierPosition   string  `json:"applierPosition"`
	ApplierDepartment string  `json:"applierDepartment"`
	Approver          string  `json:"approver"`
	Copied            string  `json:"copied"`
	Post              string  `json:"post"`
	PostCapacity      int32   `json:"postCapacity"`
	PostRequirement   string  `json:"postRequirement"`
	WantedDate        string  `json:"wantedDate"`
	ApproveCountLast  int32   `json:"approveCountLast"`
	PostCountLast     int32   `json:"postCountLast"`
	ApproverIds       []int64 `json:"approverIds"`
	CopiedIds         []int64 `json:"copiedIds"`
	Status            int32   `json:"status"`
	ApplyPositionId   int32   `json:"applyPositionId"`
	ApplyDepartmentId int32   `json:"applyDepartmentId"`
	SourceId          int64   `json:"sourceId"`
	CreatedTime       string  `json:"createdTime"`
	CreatedBy         string  `json:"createdBy"`
	UpdatedTime       string  `json:"updatedTime"`
	UpdatedBy         string  `json:"updatedBy"`
	StatusName        string  `json:"statusName"`
	Weigh             int32   `json:"weigh"`
	RedNum            int32   `json:"redNum"`
}

type DataRep struct {
	Code  int32   `json:"code"`
	Msg   string  `json:"msg"`
	Data  []*Data `json:"data"`
	Count int32   `json:"count"`
}

//func PostQuery(c *gin.Context) {
//	var postReq recruit.PostReq
//	if err := c.ShouldBind(&postReq); err != nil {
//		logger.Errorf("postReq ShouldBind err", err)
//		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
//			Data:   nil,
//			Msg:    err.Error(),
//			Status: e.Failed,
//		})
//		return
//	}
//	rep, err := service.GrpcRecruitClientImpl.PostQuery(context.Background(), &postReq)
//	if err != nil {
//		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
//			Msg:    err.Error(),
//			Status: e.Failed,
//		})
//		return
//	}
//	if rep.Code == 1 {
//		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
//			Msg:    rep.Msg,
//			Status: e.Failed,
//		})
//		return
//	}
//
//	//将返回的数据构造为符合规范的数据
//	dataRep := &DataRep{}
//
//	if rep != nil {
//		dataRep.Code = rep.Code
//		dataRep.Msg = rep.Msg
//		dataRep.Count = rep.Count
//		if len(rep.Posts) != 0 {
//			for _, v := range rep.Posts {
//				data := &Data{
//					Id:                v.Position.Id,
//					Applier:           v.Position.Applier,
//					ApplierId:         v.Position.ApplierId,
//					ApplierPosition:   v.Position.ApplierPosition,
//					ApplierDepartment: v.Position.ApplierDepartment,
//					Approver:          v.Position.Approver,
//					Copied:            v.Position.Copied,
//					Post:              v.Position.Post,
//					PostCapacity:      v.Position.PostCapacity,
//					PostRequirement:   v.Position.PostRequirement,
//					WantedDate:        v.Position.WantedDate,
//					ApproveCountLast:  v.Position.ApproveCountLast,
//					PostCountLast:     v.Position.PostCountLast,
//					ApproverIds:       v.Position.ApproverIds,
//					CopiedIds:         v.Position.CopiedIds,
//					Status:            v.Position.Status,
//					//SourceId:          v.Position.SourceId,
//				}
//				dataRep.Data = append(dataRep.Data, data)
//			}
//		}
//	}
//
//	c.JSON(http.StatusOK, serializer.Response{
//		Status: e.Ok,
//		Code:   e.SUCCESS,
//		Data:   dataRep,
//	})
//}
//
//func ResumeQuery(c *gin.Context) {
//	var postReq recruit.PostReq
//	if err := c.ShouldBind(&postReq); err != nil {
//		logger.Errorf("postReq ShouldBind err", err)
//		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
//			Data:   nil,
//			Msg:    err.Error(),
//			Status: e.Failed,
//		})
//		return
//	}
//	rep, err := service.GrpcRecruitClientImpl.ResumeQuery(context.Background(), &postReq)
//	if err != nil {
//		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
//			Msg:    err.Error(),
//			Status: e.Failed,
//		})
//		return
//	}
//	if rep.Code == 1 {
//		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
//			Msg:    rep.Msg,
//			Status: e.Failed,
//		})
//		return
//	}
//	c.JSON(http.StatusOK, serializer.Response{
//		Status: e.Ok,
//		Code:   e.SUCCESS,
//		Data:   rep,
//	})
//}

type OfferQueryData struct {
	Id               int64   `json:"id"`
	ResumeId         int64   `json:"resumeId"`
	Applier          string  `json:"applier"`
	BelongDepartment string  `json:"belongDepartment"`
	Post             string  `json:"post"`
	Approver         string  `json:"approver"`
	Copied           string  `json:"copied"`
	Name             string  `json:"name"`
	Mobile           string  `json:"mobile"`
	EmployeeType     string  `json:"employeeType"`
	EmployeeNo       string  `json:"employeeNo"`
	EntryTime        string  `json:"entryTime"`
	InterviewFile    string  `json:"interviewFile"`
	ApproveCountLast int32   `json:"approveCountLast"`
	ApproverIds      []int64 `json:"approverIds"`
	CopiedIds        []int64 `json:"copiedIds"`
	ResumeFile       string  `json:"resumeFile"`
	Status           int32   `json:"status"`
	StatusName       string  `json:"statusName"`
}

type OfferQueryRep struct {
	Code  int32             `json:"code"`
	Msg   string            `json:"msg"`
	Data  []*OfferQueryData `json:"data"`
	Count int32             `json:"count"`
}

func OfferQuery(c *gin.Context) {
	var offerReq recruit.OfferReq
	if err := c.ShouldBind(&offerReq); err != nil {
		logger.Errorf("offerReq ShouldBind err", err)
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Data:   nil,
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	rep, err := service.GrpcRecruitClientImpl.OfferQuery(context.Background(), &offerReq)
	if err != nil {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	if rep.Code == 1 {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    rep.Msg,
			Status: e.Failed,
		})
		return
	}

	//将返回的数据构造为符合规范的数据
	dataRep := &OfferQueryRep{}

	if rep != nil {
		dataRep.Code = rep.Code
		dataRep.Msg = rep.Msg
		dataRep.Count = rep.Count
		if len(rep.Offers) != 0 {
			for _, v := range rep.Offers {
				data := &OfferQueryData{
					Id:               v.Id,
					ResumeId:         v.ResumeId,
					Applier:          v.Applier,
					BelongDepartment: v.BelongDepartment,
					Post:             v.Post,
					Approver:         v.Approver,
					Copied:           v.Copied,
					Name:             v.Name,
					Mobile:           v.Mobile,
					EmployeeType:     v.EmployeeType,
					EmployeeNo:       v.EmployeeNo,
					EntryTime:        v.EntryTime,
					InterviewFile:    v.InterviewFile,
					ApproveCountLast: v.ApproveCountLast,
					ApproverIds:      v.ApproverIds,
					CopiedIds:        v.CopiedIds,
					ResumeFile:       v.ResumeFile,
					Status:           v.Status,
					StatusName:       v.StatusName,
				}
				dataRep.Data = append(dataRep.Data, data)
			}
		}
	}

	c.JSON(http.StatusOK, serializer.Response{
		Status: e.Ok,
		Code:   e.SUCCESS,
		Data:   dataRep,
	})
}

type DetailQueryData struct {
	Id           int64  `json:"id"`
	Approver     int64  `json:"approver"`
	ApplyId      int64  `json:"applyId"`
	Status       string `json:"status"`
	QueryType    string `json:"type"`
	Result       string `json:"result"`
	RejectReason string `json:"employeeType"`
}

type DetailQueryRep struct {
	Code  int32              `json:"code"`
	Msg   string             `json:"msg"`
	Data  []*DetailQueryData `json:"data"`
	Count int32              `json:"count"`
}

func DetailQuery(c *gin.Context) {

	var detailReq recruit.DetailReq
	if err := c.ShouldBind(&detailReq); err != nil {
		logger.Errorf("detailReq ShouldBind err", err)
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Data:   nil,
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	rep, err := service.GrpcRecruitClientImpl.DetailQuery(context.Background(), &detailReq)
	if err != nil {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	if rep.Code == 1 {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    rep.Msg,
			Status: e.Failed,
		})
		return
	}

	//将返回的数据构造为符合规范的数据
	dataRep := &DetailQueryRep{}

	if rep != nil {
		dataRep.Code = rep.Code
		dataRep.Msg = rep.Msg
		dataRep.Count = rep.Count
		if len(rep.Details) != 0 {
			for _, v := range rep.Details {
				data := &DetailQueryData{
					Id: v.Id,

					Approver:     v.Approver,
					ApplyId:      v.ApplyId,
					Status:       v.Status,
					QueryType:    v.Type,
					Result:       v.Result,
					RejectReason: v.RejectReason,
				}
				dataRep.Data = append(dataRep.Data, data)
			}
		}
	}

	c.JSON(http.StatusOK, serializer.Response{
		Status: e.Ok,
		Code:   e.SUCCESS,
		Data:   dataRep,
	})
}

type CopiedQueryData struct {
	Id      int64  `json:"id"`
	Copied  int64  `json:"copied"`
	ApplyId int64  `json:"applyId"`
	Status  string `json:"status"`
	RepType string `json:"type"`
}

type CopiedQueryRep struct {
	Code  int32              `json:"code"`
	Msg   string             `json:"msg"`
	Data  []*CopiedQueryData `json:"data"`
	Count int32              `json:"count"`
}

func CopiedQuery(c *gin.Context) {
	var copiedReq recruit.CopiedReq
	if err := c.ShouldBind(&copiedReq); err != nil {
		logger.Errorf("copiedReq ShouldBind err", err)
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Data:   nil,
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	rep, err := service.GrpcRecruitClientImpl.CopiedQuery(context.Background(), &copiedReq)
	if err != nil {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	if rep.Code == 1 {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    rep.Msg,
			Status: e.Failed,
		})
		return
	}

	//将返回的数据构造为符合规范的数据
	dataRep := &CopiedQueryRep{}

	if rep != nil {
		dataRep.Code = rep.Code
		dataRep.Msg = rep.Msg
		dataRep.Count = rep.Count
		if len(rep.Copies) != 0 {
			for _, v := range rep.Copies {
				data := &CopiedQueryData{
					Id:      v.Id,
					Copied:  v.Copied,
					ApplyId: v.ApplyId,
					Status:  v.Status,
					RepType: v.Type,
				}
				dataRep.Data = append(dataRep.Data, data)
			}
		}
	}

	c.JSON(http.StatusOK, serializer.Response{
		Status: e.Ok,
		Code:   e.SUCCESS,
		Data:   dataRep,
	})
}

type ChangeRecordQueryData struct {
	Id          int64  `json:"id"`
	ChangeId    int64  `json:"changeId"`
	ChangeTable string `json:"changeTable"`
	ChangeField string `json:"changeField"`
	Original    string `json:"original"`
	Present     string `json:"present"`
	Remark      string `json:"remark"`
	CreatedTime string `json:"createdTime"`
	CreatedBy   string `json:"createdBy"`
	UpdatedTime string `json:"updatedTime"`
	UpdatedBy   string `json:"updatedBy"`
}

type ChangeRecordQueryRep struct {
	Code int32                    `json:"code"`
	Msg  string                   `json:"msg"`
	Data []*ChangeRecordQueryData `json:"data"`
}

func ChangeRecordQuery(c *gin.Context) {
	var changeRecordReq recruit.ChangeRecordReq
	if err := c.ShouldBind(&changeRecordReq); err != nil {
		logger.Errorf("changeRecordReq ShouldBind err", err)
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Data:   nil,
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	rep, err := service.GrpcRecruitClientImpl.ChangeRecordQuery(context.Background(), &changeRecordReq)
	if err != nil {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	if rep.Code == 1 {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    rep.Msg,
			Status: e.Failed,
		})
		return
	}

	//将返回的数据构造为符合规范的数据
	dataRep := &ChangeRecordQueryRep{}

	if rep != nil {
		dataRep.Code = rep.Code
		dataRep.Msg = rep.Msg

		if len(rep.Records) != 0 {
			for _, v := range rep.Records {
				data := &ChangeRecordQueryData{
					Id:          v.Id,
					ChangeId:    v.ChangeId,
					ChangeTable: v.ChangeTable,
					ChangeField: v.ChangeField,
					Original:    v.Original,
					Present:     v.Present,
					Remark:      v.Remark,
					CreatedTime: v.CreatedTime,
					CreatedBy:   v.CreatedBy,
					UpdatedTime: v.UpdatedTime,
					UpdatedBy:   v.UpdatedBy,
				}
				dataRep.Data = append(dataRep.Data, data)
			}
		}
	}

	c.JSON(http.StatusOK, serializer.Response{
		Status: e.Ok,
		Code:   e.SUCCESS,
		Data:   dataRep,
	})
}

type StatusQueryData struct {
	Type  string `json:"type"`
	State int32  `json:"state"`
	Name  string `json:"name"`
	Alias string `json:"alias"`
}

type StatusQueryRep struct {
	Code int32              `json:"code"`
	Msg  string             `json:"msg"`
	Data []*StatusQueryData `json:"data"`
}

func DataInfo(c *gin.Context) {

	var req *recruit.UserDataReq

	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}

	userInfo := login.GetUserInfoFromC(c)
	req.UserId = int32(userInfo.ID)

	rep, err := service.GrpcRecruitClientImpl.UserData(context.Background(), req)
	fmt.Println(rep, err)
	fmt.Println("1-------------", err)
	if err != nil {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	c.JSON(http.StatusOK, serializer.Response{
		Status: e.Ok,
		Code:   e.SUCCESS,
		Data:   rep.Data,
	})
}

func StatusQuery(c *gin.Context) {
	var statusReq recruit.StatusReq
	if err := c.ShouldBind(&statusReq); err != nil {
		logger.Errorf("changeRecordReq ShouldBind err", err)
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Data:   nil,
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	rep, err := service.GrpcRecruitClientImpl.StatusQuery(context.Background(), &statusReq)
	if err != nil {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	if rep.Code == 1 {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    rep.Msg,
			Status: e.Failed,
		})
		return
	}

	//将返回的数据构造为符合规范的数据
	dataRep := &StatusQueryRep{}

	if rep != nil {
		dataRep.Code = rep.Code
		dataRep.Msg = rep.Msg

		if len(rep.Status) != 0 {
			for _, v := range rep.Status {
				data := &StatusQueryData{
					Type:  v.Type,
					State: v.State,
					Name:  v.Name,
					Alias: v.Alias,
				}
				dataRep.Data = append(dataRep.Data, data)
			}
		}
	}

	c.JSON(http.StatusOK, serializer.Response{
		Status: e.Ok,
		Code:   e.SUCCESS,
		Data:   rep,
	})
}

func PositionQuery(c *gin.Context) {
	var positionReq recruit.PositionReq
	if err := c.ShouldBind(&positionReq); err != nil {
		logger.Errorf("changeRecordReq ShouldBind err", err)
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Data:   nil,
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	//查看岗位功能增加个人查看自己的招聘员工的信息的接口
	if positionReq.ReqType == 2 {
		if mLoginInfoAny, exists := c.Get("mLoginInfo"); exists {
			userInfo := mLoginInfoAny.(model.LoginInfo)

			//传递  UserID 就行
			req := &position.CreateResponse{ID: userInfo.ID}
			puRes, err := service.PositionProvider.UserInfoV2(c, req)
			if err != nil {
				logger.Errorf("PositionProvider.UserInfoV2 err", err)
				service.ResponseMsg(c, e.SUCCESS, serializer.Response{
					Data:   nil,
					Msg:    err.Error(),
					Status: e.Failed,
				})
				return
			}

			//是否是部门领导
			isleader := isDepartmentLeader(puRes.DepPositions)
			fmt.Println("是否是领导:", isleader)
			if isleader {
				//获取管理的部门id数组
				depIds := getControlDepId(puRes.DepPositions)
				fmt.Println("部门------", depIds)

				//根据部门ids 获取 用户id
				res, err := service.DepartmentProvider.UserIdsByFatherDepIds(c, &department.UserIdsByFatherDepIdRequest{
					FatherIds: depIds,
				})
				if err != nil {
					logger.Errorf("DepartmentProvider.UserIdsByFatherDepIds err", err)
					service.ResponseMsg(c, e.SUCCESS, serializer.Response{
						Data:   nil,
						Msg:    err.Error(),
						Status: e.Failed,
					})
					return
				}
				fmt.Println("用户ids------", res.UserIds)
				positionReq.ApplierIds = make([]int64, 0)
				for _, v := range res.UserIds {
					positionReq.ApplierIds = append(positionReq.ApplierIds, int64(v))
				}
			} else {
				positionReq.ApplierId = int64(userInfo.ID)
			}

		} else {
			service.ResponseMsg(c, e.SUCCESS, serializer.Response{
				Data:   nil,
				Msg:    errors.New("未获取到用户信息").Error(),
				Status: e.Failed,
			})
			return
		}
	}

	rep, err := service.GrpcRecruitClientImpl.PositionQuery(context.Background(), &positionReq)
	if err != nil {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	if rep.Code == 1 {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    rep.Msg,
			Status: e.Failed,
		})
		return
	}

	//将返回的数据构造为符合规范的数据
	dataRep := &DataRep{}

	if rep != nil {
		dataRep.Code = rep.Code
		dataRep.Msg = rep.Msg
		dataRep.Count = rep.Count

		if len(rep.Positions) != 0 {
			for _, v := range rep.Positions {
				data := &Data{
					Id:                v.Id,
					Applier:           v.Applier,
					ApplierId:         v.ApplierId,
					ApplierPosition:   v.ApplierPosition,
					ApplierDepartment: v.ApplierDepartment,
					Approver:          v.Approver,
					Copied:            v.Copied,
					Post:              v.Post,
					PostCapacity:      v.PostCapacity,
					PostRequirement:   v.PostRequirement,
					PostCountLast:     v.PostCountLast,
					WantedDate:        v.WantedDate,
					ApproveCountLast:  v.ApproveCountLast,
					CreatedTime:       v.CreatedTime,
					CreatedBy:         v.CreatedBy,
					UpdatedTime:       v.UpdatedTime,
					UpdatedBy:         v.UpdatedBy,
					Status:            v.Status,
					ApplyPositionId:   v.ApplyPositionId,
					ApplyDepartmentId: v.ApplyDepartmentId,
					StatusName:        v.StatusName,
					Weigh:             v.Weigh,
					RedNum:            v.RedNum,
				}
				dataRep.Data = append(dataRep.Data, data)
			}
		}
	}

	c.JSON(http.StatusOK, serializer.Response{
		Status: e.Ok,
		Code:   e.SUCCESS,
		Data:   dataRep,
	})
}

type ResumePageQueryData struct {
	Id                int64                `json:"id"`
	PositionId        int64                `json:"positionId"`
	Name              string               `json:"name"`
	Mobile            string               `json:"mobile"`
	ResumeFile        string               `json:"resumeFile"`
	InterviewTime     string               `json:"interviewTime"`
	InterviewFile     string               `json:"interviewFile"`
	EmployeeType      string               `json:"employeeType"`
	EmployeeNo        string               `json:"employeeNo"`
	EntryTime         string               `json:"entryTime"`
	TerminateReason   string               `json:"terminateReason"`
	CreatedTime       string               `json:"createdTime"`
	CreatedBy         string               `json:"createdBy"`
	UpdatedTime       string               `json:"updatedTime"`
	UpdatedBy         string               `json:"updatedBy"`
	Status            int32                `json:"status"`
	StatusName        string               `json:"statusName"`
	Files             []*recruit.FileProto `json:"files"`
	ResumeFileName    string               `json:"resumeFileName"`
	ApplyPositionId   int32                `json:"applyPositionId"`
	ApplyDepartmentId int32                `json:"applyDepartmentId"`
}

type ResumePageQueryRep struct {
	Code  int32                  `json:"code"`
	Msg   string                 `json:"msg"`
	Data  []*ResumePageQueryData `json:"data"`
	Count int32                  `json:"count"`
}

func ResumePageQuery(c *gin.Context) {
	var resumeReq recruit.ResumeReq
	if err := c.ShouldBind(&resumeReq); err != nil {
		logger.Errorf("resumeReq ShouldBind err", err)
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Data:   nil,
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	//查看父级 岗位信息
	positionRes, err := service.GrpcRecruitClientImpl.PositionDetail(context.Background(), &recruit.PositionDetailReq{Id: int32(resumeReq.PositionId)})
	if err != nil {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	rep, err := service.GrpcRecruitClientImpl.ResumePageQuery(context.Background(), &resumeReq)
	if err != nil {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	if rep.Code == 1 {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    rep.Msg,
			Status: e.Failed,
		})
		return
	}

	//将返回的数据构造为符合规范的数据
	dataRep := &ResumePageQueryRep{}

	if rep != nil {
		dataRep.Code = rep.Code
		dataRep.Msg = rep.Msg
		dataRep.Count = rep.Count

		if len(rep.Resumes) != 0 {
			for _, v := range rep.Resumes {
				fmt.Println(v.ResumeFileName)
				fmt.Println(v.ResumeFile)
				fmt.Println()
				data := &ResumePageQueryData{
					Id:              v.Id,
					PositionId:      v.PositionId,
					Name:            v.Name,
					Mobile:          v.Mobile,
					ResumeFile:      v.ResumeFile,
					InterviewTime:   v.InterviewTime,
					InterviewFile:   v.InterviewFile,
					EmployeeType:    v.EmployeeType,
					EmployeeNo:      v.EmployeeNo,
					EntryTime:       v.EntryTime,
					TerminateReason: v.TerminateReason,
					CreatedTime:     v.CreatedTime,
					CreatedBy:       v.CreatedBy,
					UpdatedTime:     v.UpdatedTime,
					UpdatedBy:       v.UpdatedBy,
					Status:          v.Status,
					StatusName:      v.StatusName,
					ResumeFileName:  v.ResumeFileName, // 增加
					Files:           v.Files,
				}

				if positionRes != nil && positionRes.Position != nil {
					data.ApplyPositionId = positionRes.Position.ApplyPositionId
					data.ApplyDepartmentId = positionRes.Position.ApplyDepartmentId
				}

				dataRep.Data = append(dataRep.Data, data)
			}
		}
	}
	c.JSON(http.StatusOK, serializer.Response{
		Status: e.Ok,
		Code:   e.SUCCESS,
		Data:   dataRep,
	})
}

// UploadMulti 批量上传
func UploadMultiNew(c *gin.Context) {
	form, err := c.MultipartForm()
	source := c.PostForm("source")
	mask := c.PostForm("mask")
	mediaType := c.PostForm("type")
	if mask == "" {
		mask = "0"
	}
	if mediaType == "" || mediaType == "image" {
		mediaType = "image"
	}
	if source == "" {
		service.ResponseQuickMsg(c, e.Failed, e.GetMsg(e.InvalidParams), nil)
		return
	}
	if err != nil {
		logger.Errorf("UploadMulti err", err)
		service.ResponseMsg(c, e.InvalidParams, serializer.Response{
			Msg:   err.Error(),
			Code:  e.Failed,
			Error: err,
		})
		return
	}
	var data = make(map[string]string, len(form.File))
	wg.Add(len(form.File))
	var fileCh = make(chan string, len(form.File))
	for _, files := range form.File {
		for _, file := range files {
			go func() {
				defer wg.Done()
				var uploadInfo model.UploadInfo
				disp := file.Header["Content-Disposition"]
				if len(disp) > 0 {
					dispKv := strings.Split(disp[0], ";")
					for _, vv := range dispKv {
						vv = strings.Trim(vv, " ")
						if vv[:4] == "name" {
							uploadInfo.FileKName = vv[strings.Index(vv, "\"")+1 : strings.LastIndex(vv, "\"")]
						}
					}
				}
				newFile, _ := file.Open()
				defer newFile.Close()
				uuids, _ := uuid.NewV4()
				filePath := fmt.Sprintf("%s/%s/%s/%s%s", mediaType, mask, source, uuids, filepath.Ext(file.Filename))
				fileBytes, _ := ioutil.ReadAll(newFile)
				if mediaType == "image" {
					if err = service.BaiduCheckImage(fileBytes); err != nil {
						uploadInfo.Err = err.Error()
						return
					}
				}
				var objectName string = fmt.Sprintf("%s/%s/%s", config.ConfigData.Oss.BaseDir, config.Env, filePath)
				BOSClient, _ := objstorage.NewOSS(config.ConfigData.Oss.AccessKeyId, config.ConfigData.Oss.AccessKeySecret, config.ConfigData.Oss.Endpoint)
				_, err = BOSClient.PutObjectFromBytes(config.ConfigData.Oss.BucketName, objectName, fileBytes)
				if err != nil {
					logger.Errorf("quickBos err", err)
					return
				}
				//uploadInfo.Url = fmt.Sprintf("%s%s%s/%s", config.BosHttp, config.BosBucketName, config.BosUrl, objectName)
				uploadInfo.Url = fmt.Sprintf("%s/%s", config.ConfigData.Oss.CdnHost, objectName)
				infoByte, _ := json.Marshal(uploadInfo)
				fileCh <- string(infoByte)
			}()
		}
	}
	wg.Wait()
	close(fileCh)
	for v := range fileCh {
		if v != "" {
			var uploadInfo model.UploadInfo
			if err = json.Unmarshal([]byte(v), &uploadInfo); err == nil {
				data[uploadInfo.FileKName] = uploadInfo.Url
			}
		}
	}
	service.ResponseMsg(c, e.UpdatePasswordSuccess, serializer.Response{
		Msg:    e.GetMsg(e.SUCCESS),
		Status: e.Ok,
		Data:   data,
	})
}

// UploadMulti 批量上传
func UploadMulti(c *gin.Context) {
	/*var form query.RecruitUploadReq

	// 注意：请确保请求头中的 content-type 为 multipart/form-data
	if err := c.ShouldBind(&form); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}
	*/
	var warningInfo string
	form, err := c.MultipartForm()
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}

	source := c.PostForm("source")
	mask := c.PostForm("mask")
	mediaType := c.PostForm("type")
	if mask == "" {
		mask = "0"
	}
	if mediaType == "" || mediaType == "image" {
		mediaType = "image"
	}
	if source == "" {
		service.ResponseQuickMsg(c, e.Failed, e.GetMsg(e.InvalidParams), nil)
		return
	}

	files := form.File
	docMap := make(map[string][]*query.DocFile, len(files))
	resumesMap := make(map[string]*query.Resume, len(files))

	for key, fileHeaders := range files {
		for _, fileHeader := range fileHeaders {
			//有resumes 和file 是最外层
			if strings.Contains(key, "resumes") && strings.Contains(key, "[files]") { //附件

				re := regexp.MustCompile(`resumes\[(\d+)\]\[files\]`)
				// 查找子匹配的字符串
				matches := re.FindStringSubmatch(key)

				fmt.Println("2------------", matches)
				fmt.Println("2------------", matches)
				if len(matches) != 2 {
					// 输出第一个子匹配（即中括号中的数字）
					service.Error(c, e.Error, errors.New("files key"+key+"匹配失败"))
					return
				}

				docMap[matches[1]] = append(docMap[matches[1]], &query.DocFile{Obj: fileHeader})

			} else if strings.Contains(key, "resumes") && strings.Contains(key, "]file") { //简历

				re := regexp.MustCompile(`resumes\[(\d+)\]file`)
				// 查找子匹配的字符串
				matches := re.FindStringSubmatch(key)

				if len(matches) != 2 {
					// 输出第一个子匹配（即中括号中的数字）
					service.Error(c, e.Error, errors.New("file key "+key+"匹配失败"))
					return
				}

				resumesMap[matches[1]] = &query.Resume{Obj: fileHeader}

			} else {
				service.Error(c, e.Error, errors.New("key"+key+"匹配失败"))
				return
			}
		}
	}

	wgLen := 0
	for i, _ := range resumesMap {
		wgLen++
		if _, ok := docMap[i]; ok {
			resumesMap[i].Files = docMap[i]
			wgLen += len(resumesMap[i].Files)
		}
	}

	/*
		for i, f := range resumesMap {
			fmt.Println("2----", i, f.File.Filename, f.Files)
		}
	*/

	//上传
	for i, f := range resumesMap {
		fmt.Println("2----", i, f.Obj.Filename, f.Files)
	}

	var tempWg sync.WaitGroup

	tempWg.Add(wgLen)
	var fileCh = make(chan string, wgLen)

	for i, f := range resumesMap {
		resumesMap[i].ResumeFileName = resumesMap[i].Obj.Filename
		go uploadFile(resumesMap[i].Obj, mediaType, mask, source, resumesMap[i], nil, fileCh, &tempWg)
		for i1, t := range f.Files {
			resumesMap[i].Files[i1].FileName = t.Obj.Filename
			go uploadFile(t.Obj, mediaType, mask, source, nil, resumesMap[i].Files[i1], fileCh, &tempWg)
		}
	}

	tempWg.Wait()
	close(fileCh)
	if len(fileCh) >= 1 {
		for ch := range fileCh {
			warningInfo += ch + "\n"
		}

		/*
			//删除图片,一荣俱荣，一损俱损
			for i, f := range resumesMap {
				//del resumesMap[i].ResumeFile
				for i1, t := range f.Files {
					//del resumesMap[i].Files[i1].File
				}
			}
		*/

		service.Error(c, e.Error, errors.New(warningInfo))
		return
	}

	res := query.RecruitUploadRes{}
	for i, _ := range resumesMap {
		res.Resume = append(res.Resume, resumesMap[i])
	}

	service.Success(c, res)
	return
}

func uploadFile(file *multipart.FileHeader, mediaType, mask, source string, resume *query.Resume, docFile *query.DocFile, fileCh chan<- string, tempWg *sync.WaitGroup) {
	var err error
	defer tempWg.Done()

	netUrl, err := uploadFileCore(file, mediaType, mask, source)
	if err != nil {
		fileCh <- fmt.Sprintf("%s上传失败,提示:%s", file.Filename, err.Error())
		return
	}

	if resume != nil {
		resume.ResumeFile = netUrl
	}

	if docFile != nil {
		docFile.File = netUrl
	}

	return
}

func uploadFileCore(file *multipart.FileHeader, mediaType, mask, source string) (netUrl string, err error) {
	var uploadInfo model.UploadInfo
	disp := file.Header["Content-Disposition"]

	if len(disp) > 0 {
		dispKv := strings.Split(disp[0], ";")
		for _, vv := range dispKv {
			vv = strings.Trim(vv, " ")
			if vv[:4] == "name" {
				uploadInfo.FileKName = vv[strings.Index(vv, "\"")+1 : strings.LastIndex(vv, "\"")]
			}
		}
	}
	newFile, _ := file.Open()
	defer newFile.Close()
	uuids, _ := uuid.NewV4()
	filePath := fmt.Sprintf("%s/%s/%s/%s%s", mediaType, mask, source, uuids, filepath.Ext(file.Filename))
	fileBytes, _ := ioutil.ReadAll(newFile)
	if mediaType == "image" {
		if err = service.BaiduCheckImage(fileBytes); err != nil {
			uploadInfo.Err = err.Error()
			return
		}
	}
	var objectName string = fmt.Sprintf("%s/%s/%s", config.ConfigData.Oss.BaseDir, config.Env, filePath)
	BOSClient, _ := objstorage.NewOSS(config.ConfigData.Oss.AccessKeyId, config.ConfigData.Oss.AccessKeySecret, config.ConfigData.Oss.Endpoint)
	_, err = BOSClient.PutObjectFromBytes(config.ConfigData.Oss.BucketName, objectName, fileBytes)
	if err != nil {
		logger.Errorf("quickBos err", err)
		return
	}
	//uploadInfo.Url = fmt.Sprintf("%s%s%s/%s", config.BosHttp, config.BosBucketName, config.BosUrl, objectName)
	netUrl = fmt.Sprintf("%s/%s", config.ConfigData.Oss.CdnHost, objectName)

	return
}

func isDepartmentLeader(list []*position.DepPosition) bool {
	for _, v := range list {
		if v.IsLeader == true {
			return true
		}

	}

	return false
}

func getControlDepId(list []*position.DepPosition) []uint32 {
	var controlDepIds []uint32
	for _, v := range list {
		if v.IsLeader == true {
			controlDepIds = append(controlDepIds, v.ID)
		}

	}

	return controlDepIds
}

func CheckResumeExist(c *gin.Context) {
	req := new(recruit.CheckResumeExistReq)
	if err := c.ShouldBind(&req); err != nil {
		logger.Errorf("CheckResumeExist ShouldBind err", err)
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Data:   nil,
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	fmt.Println("当前语言：", c.GetHeader("Accept-Language"))
	req.Language = c.GetHeader("Accept-Language")
	rep, err := service.GrpcRecruitClientImpl.CheckResumeExist(context.Background(), req)
	if err != nil {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	if rep.Code == 1 {
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    rep.Msg,
			Status: e.Failed,
		})
		return
	}
	c.JSON(http.StatusOK, serializer.Response{
		Status: e.Ok,
		Code:   e.SUCCESS,
		Data:   rep,
	})
}