290 lines
9.8 KiB
Go
290 lines
9.8 KiB
Go
package manage
|
|
|
|
import (
|
|
"SciencesServer/app/api/admin/model"
|
|
"SciencesServer/app/basic/config"
|
|
model2 "SciencesServer/app/common/model"
|
|
"SciencesServer/app/service"
|
|
"SciencesServer/app/session"
|
|
config2 "SciencesServer/config"
|
|
cache2 "SciencesServer/serve/cache"
|
|
"SciencesServer/serve/orm"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"gorm.io/gorm"
|
|
"time"
|
|
)
|
|
|
|
type Examine struct {
|
|
*session.Admin
|
|
}
|
|
|
|
type ExamineHandle func(session *session.Admin) *Examine
|
|
|
|
type ExamineManageInfo struct {
|
|
IModel model2.IModel
|
|
IUserModel model2.IModel
|
|
UIDs []uint64 // 用户表UUID
|
|
Name string
|
|
Keywords, Industrys, Researchs []string
|
|
}
|
|
|
|
// examineHandle 审核处理
|
|
var examineHandle = map[int]func(id, tenantID uint64) (*ExamineManageInfo, error){
|
|
config.TenantUserIdentityForCompany: examineCompany,
|
|
config.TenantUserIdentityForExpert: examineExpert,
|
|
config.TenantUserIdentityForResearch: examineResearch,
|
|
config.TenantUserIdentityForLaboratory: examineLaboratory,
|
|
config.TenantUserIdentityForAgent: examineAgent,
|
|
}
|
|
|
|
func checkManage(IModel model2.IModel, id uint64) error {
|
|
IModel.SetID(id)
|
|
|
|
if isExist, err := model2.First(IModel); err != nil {
|
|
return err
|
|
} else if !isExist {
|
|
return errors.New("操作错误，数据信息不存在")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func examineCompany(id, tenantID uint64) (*ExamineManageInfo, error) {
|
|
mManageCompany := model.NewManageCompany()
|
|
|
|
err := checkManage(mManageCompany.ManageCompany, id)
|
|
|
|
if err != nil {
|
|
return nil, err
|
|
} else if tenantID > 0 && mManageCompany.TenantID != tenantID {
|
|
return nil, errors.New("操作错误，无权限操作")
|
|
} else if mManageCompany.Examine.ExamineStatus != model2.ExamineStatusForOngoing {
|
|
return nil, errors.New("操作错误，当前入驻信息已审核")
|
|
}
|
|
mUserCompany := model.NewUserCompany()
|
|
uids := make([]uint64, 0)
|
|
|
|
if err = model2.Pluck(mUserCompany.UserCompany, "uid", &uids, model2.NewWhere("company_id", id),
|
|
model2.NewWhere("invalid_status", model2.InvalidStatusForNot)); err != nil {
|
|
return nil, err
|
|
}
|
|
return &ExamineManageInfo{IModel: mManageCompany.ManageCompany, IUserModel: mUserCompany.UserCompany,
|
|
UIDs: uids, Name: mManageCompany.Name, Industrys: mManageCompany.GetIndustryAttribute(),
|
|
Keywords: mManageCompany.GetKeywordAttribute()}, nil
|
|
}
|
|
|
|
func examineExpert(id, tenantID uint64) (*ExamineManageInfo, error) {
|
|
mManageExpert := model.NewManageExpert()
|
|
|
|
err := checkManage(mManageExpert.ManageExpert, id)
|
|
|
|
if err != nil {
|
|
return nil, err
|
|
} else if tenantID > 0 && mManageExpert.TenantID != tenantID {
|
|
return nil, errors.New("操作错误，无权限操作")
|
|
} else if mManageExpert.Examine.ExamineStatus != model2.ExamineStatusForOngoing {
|
|
return nil, errors.New("操作错误，当前入驻信息已审核")
|
|
}
|
|
mUserExpert := model.NewUserExpert()
|
|
uids := make([]uint64, 0)
|
|
|
|
if err = model2.Pluck(mUserExpert.UserExpert, "uid", &uids, model2.NewWhere("expert_id", id),
|
|
model2.NewWhere("invalid_status", model2.InvalidStatusForNot)); err != nil {
|
|
return nil, err
|
|
}
|
|
return &ExamineManageInfo{IModel: mManageExpert.ManageExpert, IUserModel: mUserExpert.UserExpert,
|
|
UIDs: uids, Name: mManageExpert.Name, Industrys: mManageExpert.GetIndustryAttribute(),
|
|
Keywords: mManageExpert.GetKeywordAttribute(), Researchs: mManageExpert.GetResearchAttribute()}, nil
|
|
}
|
|
|
|
func examineResearch(id, tenantID uint64) (*ExamineManageInfo, error) {
|
|
mManageResearch := model.NewManageResearch()
|
|
|
|
err := checkManage(mManageResearch.ManageResearch, id)
|
|
|
|
if err != nil {
|
|
return nil, err
|
|
} else if tenantID > 0 && mManageResearch.TenantID != tenantID {
|
|
return nil, errors.New("操作错误，无权限操作")
|
|
} else if mManageResearch.Examine.ExamineStatus != model2.ExamineStatusForOngoing {
|
|
return nil, errors.New("操作错误，当前入驻信息已审核")
|
|
}
|
|
|
|
mUserResearch := model.NewUserResearch()
|
|
uids := make([]uint64, 0)
|
|
|
|
if err = model2.Pluck(mUserResearch.UserResearch, "uid", &uids, model2.NewWhere("research_id", id),
|
|
model2.NewWhere("invalid_status", model2.InvalidStatusForNot)); err != nil {
|
|
return nil, err
|
|
}
|
|
return &ExamineManageInfo{IModel: mManageResearch.ManageResearch, IUserModel: mUserResearch.UserResearch, UIDs: uids,
|
|
Name: mManageResearch.Name, Industrys: mManageResearch.GetIndustryAttribute(),
|
|
Keywords: mManageResearch.GetKeywordAttribute(), Researchs: mManageResearch.GetResearchAttribute()}, nil
|
|
}
|
|
|
|
func examineLaboratory(id, tenantID uint64) (*ExamineManageInfo, error) {
|
|
mManageLaboratory := model.NewManageLaboratory()
|
|
|
|
err := checkManage(mManageLaboratory.ManageLaboratory, id)
|
|
|
|
if err != nil {
|
|
return nil, err
|
|
} else if tenantID > 0 && mManageLaboratory.TenantID != tenantID {
|
|
return nil, errors.New("操作错误，无权限操作")
|
|
} else if mManageLaboratory.Examine.ExamineStatus != model2.ExamineStatusForOngoing {
|
|
return nil, errors.New("操作错误，当前入驻信息已审核")
|
|
}
|
|
|
|
mUserLaboratory := model.NewUserLaboratory()
|
|
uids := make([]uint64, 0)
|
|
|
|
if err = model2.Pluck(mUserLaboratory.UserLaboratory, "uid", &uids, model2.NewWhere("laboratory_id", id),
|
|
model2.NewWhere("invalid_status", model2.InvalidStatusForNot)); err != nil {
|
|
return nil, err
|
|
}
|
|
return &ExamineManageInfo{IModel: mManageLaboratory.ManageLaboratory, IUserModel: mUserLaboratory.UserLaboratory, UIDs: uids,
|
|
Name: mManageLaboratory.Name, Industrys: mManageLaboratory.GetIndustryAttribute(),
|
|
Keywords: mManageLaboratory.GetKeywordAttribute(), Researchs: mManageLaboratory.GetResearchAttribute()}, nil
|
|
}
|
|
|
|
func examineAgent(id, tenantID uint64) (*ExamineManageInfo, error) {
|
|
mManageAgent := model.NewManageAgent()
|
|
|
|
err := checkManage(mManageAgent.ManageAgent, id)
|
|
|
|
if err != nil {
|
|
return nil, err
|
|
} else if tenantID > 0 && mManageAgent.TenantID != tenantID {
|
|
return nil, errors.New("操作错误，无权限操作")
|
|
} else if mManageAgent.Examine.ExamineStatus != model2.ExamineStatusForOngoing {
|
|
return nil, errors.New("操作错误，当前入驻信息已审核")
|
|
}
|
|
|
|
mUserAgent := model.NewUserAgent()
|
|
uids := make([]uint64, 0)
|
|
|
|
if err = model2.Pluck(mUserAgent.UserAgent, "uid", &uids, model2.NewWhere("laboratory_id", id),
|
|
model2.NewWhere("invalid_status", model2.InvalidStatusForNot)); err != nil {
|
|
return nil, err
|
|
}
|
|
return &ExamineManageInfo{IModel: mManageAgent.ManageAgent, IUserModel: mUserAgent.UserAgent, UIDs: uids,
|
|
Name: mManageAgent.Name, Industrys: mManageAgent.GetIndustryAttribute(),
|
|
Keywords: mManageAgent.GetKeywordAttribute()}, nil
|
|
}
|
|
|
|
// Launch 发起审核
|
|
func (c *Examine) Launch(id uint64, identity, status int, remark string, params map[string]interface{}) error {
|
|
_status := model2.ExamineStatusKind(status)
|
|
|
|
if _status != model2.ExamineStatusForRefuse && _status != model2.ExamineStatusForAgree {
|
|
return errors.New("操作错误，未知的审核模式")
|
|
}
|
|
handle, has := examineHandle[identity]
|
|
|
|
if !has {
|
|
return errors.New("操作错误，未知的身份信息")
|
|
}
|
|
data, err := handle(id, c.TenantID)
|
|
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return orm.GetDB().Transaction(func(tx *gorm.DB) error {
|
|
values := map[string]interface{}{
|
|
"examine_status": status, "examine_remark": remark, "updated_at": time.Now()}
|
|
|
|
if params != nil && len(params) > 0 {
|
|
if identity == config.TenantUserIdentityForCompany {
|
|
for k, v := range params {
|
|
values[k] = v
|
|
}
|
|
}
|
|
}
|
|
if err = model2.Updates(data.IModel, values, tx); err != nil {
|
|
return err
|
|
}
|
|
// 拒绝后，不执行以下数据
|
|
if _status == model2.ExamineStatusForRefuse {
|
|
// 清除所有的入驻信息变为失效
|
|
if len(data.UIDs) > 0 {
|
|
if err = model2.UpdatesWhere(data.IUserModel, map[string]interface{}{
|
|
"invalid_status": model2.InvalidStatusForYes, "updated_at": time.Now(),
|
|
}, []*model2.ModelWhere{model2.NewWhere("uid", data.UIDs),
|
|
model2.NewWhere("invalid_status", model2.InvalidStatusForNot)}, tx); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
mUserInstance := model.NewUserInstance()
|
|
// 客户端用户信息
|
|
users := make([]*model2.UserInstance, 0)
|
|
|
|
if err = model2.ScanFields(mUserInstance.UserInstance, &users, []string{"id", "uuid", "name", "identity"},
|
|
&model2.ModelWhereOrder{Where: model2.NewWhereIn("uuid", data.UIDs)}); err != nil {
|
|
return err
|
|
}
|
|
|
|
now := time.Now()
|
|
|
|
mUserIdentity := model.NewUserIdentity()
|
|
|
|
for _, v := range users {
|
|
var count int64
|
|
|
|
if err = model2.Count(mUserIdentity.UserIdentity, &count, model2.NewWhere("uid", v.UUID)); err != nil {
|
|
return err
|
|
}
|
|
userIdentity := &model2.UserIdentity{
|
|
Name: v.Name,
|
|
UID: v.UUID,
|
|
Identity: identity,
|
|
}
|
|
if count <= 0 {
|
|
userIdentity.IsSelected = model2.UserIdentitySelectedForYes
|
|
}
|
|
if err = model2.Create(userIdentity, tx); err != nil {
|
|
return err
|
|
}
|
|
if err = model2.UpdatesWhere(mUserInstance.UserInstance, map[string]interface{}{
|
|
"identity": v.Identity | identity, "updated_at": now,
|
|
}, []*model2.ModelWhere{
|
|
model2.NewWhere("id", v.ID),
|
|
}, tx); err != nil {
|
|
return err
|
|
}
|
|
|
|
// 需要同步redis库
|
|
cache, _ := cache2.Cache.HGet(config2.RedisKeyForAccountEnterprise, fmt.Sprintf("%v", v.UUID))
|
|
|
|
if cache != "" {
|
|
_session := new(session.Enterprise)
|
|
|
|
if err := json.Unmarshal([]byte(cache), _session); err != nil {
|
|
return err
|
|
}
|
|
_session.Identity = v.Identity | identity
|
|
|
|
if userIdentity.IsSelected == model2.UserIdentitySelectedForYes {
|
|
_session.SelectIdentity = identity
|
|
}
|
|
service.Publish(config2.EventForRedisHashProduce, config2.RedisKeyForAccountEnterprise, _session.GetStringUID(), _session)
|
|
}
|
|
}
|
|
// 存放es中
|
|
(&ESParams{
|
|
ID: data.IModel.GetID(),
|
|
Identity: identity, Name: data.Name, Keywords: data.Keywords,
|
|
Industrys: data.Industrys, Researchs: data.Researchs,
|
|
}).Set()
|
|
return nil
|
|
})
|
|
}
|
|
|
|
func NewExamine() ExamineHandle {
|
|
return func(session *session.Admin) *Examine {
|
|
return &Examine{Admin: session}
|
|
}
|
|
}
|