cas_tt_cloud_backend/app/api/manage/controller/manage/examine.go

package manage

import (
	"SciencesServer/app/api/manage/model"
	"SciencesServer/app/basic/config"
	model2 "SciencesServer/app/common/model"
	"SciencesServer/app/service"
	"SciencesServer/serve/orm"
	"errors"
	"gorm.io/gorm"
	"time"
)

type Examine struct {
	*service.Session
	local string
}

type ExamineHandle func(session *service.Session, local string) *Examine

type ExamineManageInfo struct {
	IModel   model2.IModel
	TenantID uint64 // 租户ID
	UID      uint64 // 用户表UUID
}

// examineHandle 审核处理
var examineHandle = map[int]func(uint64) (*ExamineManageInfo, error){
	config.TenantUserIdentityForCompany:    examineCompany,
	config.TenantUserIdentityForExpert:     examineExpert,
	config.TenantUserIdentityForResearch:   examineResearch,
	config.TenantUserIdentityForLaboratory: examineLaboratory,
}

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 uint64) (*ExamineManageInfo, error) {
	mManageCompany := model.NewManageCompany()

	err := checkManage(mManageCompany.ManageCompany, id)

	if err != nil {
		return nil, err
	} else if mManageCompany.Status != model2.ExamineStatusForOngoing {
		return nil, errors.New("当前入住信息已审核")
	}
	return &ExamineManageInfo{
		IModel: mManageCompany.ManageCompany, UID: mManageCompany.UID,
	}, nil
}

func examineExpert(id uint64) (*ExamineManageInfo, error) {
	mManageExpert := model.NewManageExpert()

	err := checkManage(mManageExpert.ManageExpert, id)

	if err != nil {
		return nil, err
	} else if mManageExpert.Status != model2.ExamineStatusForOngoing {
		return nil, errors.New("当前入住信息已审核")
	}
	return &ExamineManageInfo{
		IModel: mManageExpert.ManageExpert, UID: mManageExpert.UID,
	}, nil
}

func examineResearch(id uint64) (*ExamineManageInfo, error) {
	mManageResearch := model.NewManageResearch()

	err := checkManage(mManageResearch.ManageResearch, id)

	if err != nil {
		return nil, err
	} else if mManageResearch.Status != model2.ExamineStatusForOngoing {
		return nil, errors.New("当前入住信息已审核")
	}
	return &ExamineManageInfo{
		IModel: mManageResearch.ManageResearch, UID: mManageResearch.UID,
	}, nil
}

func examineLaboratory(id uint64) (*ExamineManageInfo, error) {
	mManageLaboratory := model.NewManageLaboratory()

	err := checkManage(mManageLaboratory.ManageLaboratory, id)

	if err != nil {
		return nil, err
	} else if mManageLaboratory.Status != model2.ExamineStatusForOngoing {
		return nil, errors.New("当前入住信息已审核")
	}
	return &ExamineManageInfo{
		IModel: mManageLaboratory.ManageLaboratory, UID: mManageLaboratory.UID,
	}, nil
}

// Launch 发起审核
func (c *Examine) Launch(id uint64, identity, status int) 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)

	if err != nil {
		return err
	}
	return orm.GetDB().Transaction(func(tx *gorm.DB) error {
		if err = model2.Updates(data.IModel, map[string]interface{}{
			"status": status, "updated_at": time.Now(),
		}, tx); err != nil {
			return err
		}
		// 拒绝后，不执行以下数据
		if _status == model2.ExamineStatusForRefuse {
			return nil
		}
		mUserIdentity := model.NewUserIdentity()

		isExist := true

		if isExist, err = model2.FirstField(mUserIdentity.UserIdentity, []string{"id", "uid"}, model2.NewWhere("uid", data.UID),
			model2.NewWhere("identity", identity)); err != nil {
			return err
		}
		if !isExist {
			mUserIdentity.UID = data.UID
			mUserIdentity.Identity = identity
		}
		// 更新账户身份信息
		mUserInstance := model.NewUserInstance()

		if _, err = model2.FirstField(mUserInstance.UserInstance, []string{"id", "uuid", "identity"},
			model2.NewWhere("uuid", data.UID)); err != nil {
			return err
		}
		if err = model2.Updates(mUserInstance.UserInstance, map[string]interface{}{
			"identity": mUserInstance.Identity | identity, "updated_at": time.Now(),
		}, tx); err != nil {
			return err
		}
		return nil
	})
}

func NewExamine() ExamineHandle {
	return func(session *service.Session, local string) *Examine {
		return &Examine{
			Session: session,
			local:   local,
		}
	}
}