lone-services/services/analysis/internal/logic/analysisuser/deviceBindLogic.go

package analysisuserlogic

import (
	"context"

	"lone-services/pkg/utils"
	"lone-services/pkg/validate"
	analysis "lone-services/rpc/analysis/pb"
	equipmentpb "lone-services/rpc/equipment/pb"
	"lone-services/services/analysis/internal/logic/common"
	"lone-services/services/analysis/internal/svc"
	"lone-services/services/analysis/validator"

	"github.com/zeromicro/go-zero/core/logx"
)

const skinAnalyzerType int32 = 3

type DeviceBindLogic struct {
	ctx    context.Context
	svcCtx *svc.ServiceContext
	logx.Logger
}

func NewDeviceBindLogic(ctx context.Context, svcCtx *svc.ServiceContext) *DeviceBindLogic {
	return &DeviceBindLogic{
		ctx:    ctx,
		svcCtx: svcCtx,
		Logger: logx.WithContext(ctx),
	}
}

func (l *DeviceBindLogic) DeviceBind(in *analysis.DeviceBindReq) (*analysis.Response, error) {
	var req validator.DeviceBindValidator
	if msg := validate.ValidateFromProto(in, &req); msg != utils.StringEmpty {
		return common.OutResponse(utils.ErrorParams, msg), nil
	}

	loginUser := utils.GetUserFromCtx(l.ctx)
	if !loginUser.Valid || loginUser.ID < utils.NumberOne {
		return common.FailResponse(utils.ErrorNoLogin), nil
	}
	skinType, ok := common.SkinTypeOf(loginUser.ClientCode)
	if !ok {
		return common.FailResponse(utils.ErrorAuthority), nil
	}
	if l.svcCtx.EquipmentSvcName == utils.StringEmpty {
		return common.FailResponse(utils.Fail), nil
	}

	cli, err := svc.GetRpcClient(l.svcCtx.EquipmentSvcName)
	if err != nil {
		l.Errorf("device bind get equipment rpc: %v", err)
		return common.FailResponse(utils.Fail), nil
	}

	out, err := equipmentpb.NewEquipmentClient(cli.Conn()).InternalBindAdd(l.ctx, &equipmentpb.InternalBindAddRequest{
		UserId:       loginUser.ID,
		UserNickname: loginUser.Name,
		HostNickname: utils.StringEmpty,
		HostCode:     req.DeviceNo,
		Type:         skinAnalyzerType,
		SkinType:     skinType,
	})
	if err != nil {
		l.Errorf("device bind internal add: %v", err)
		return common.FailResponse(utils.Fail), nil
	}
	if out == nil {
		return common.FailResponse(utils.Fail), nil
	}
	return &analysis.Response{
		Code: out.Code,
		Msg:  out.Msg,
	}, nil
}