2551 lines
67 KiB
Go
2551 lines
67 KiB
Go
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,
|
|
})
|
|
}
|