lone-services/services/equipment/internal/logic/apiMaskUseLogic.go

package logic

import (
	"context"
	"lone-services/pkg/modelbase"
	"lone-services/pkg/utils"
	"lone-services/services/equipment/internal/dao"
	"lone-services/services/equipment/internal/model"
	"lone-services/services/equipment/validator"
	"strconv"

	"lone-services/rpc/equipment/pb"
	"lone-services/services/equipment/internal/svc"

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

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

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

func (l *ApiMaskUseLogic) ApiMaskUse(in *equipment.ApiMaskUseRequest) (*equipment.Response, error) {
	var v validator.MaskUseValidator
	if fail := l.checkParams(in, &v); fail != nil {
		return fail, nil
	}

	adminInfo := utils.GetUserFromCtx(l.ctx)
	if adminInfo.ID < utils.NumberOne {
		return l.fail(utils.ErrorNoLoginInfo)
	}

	maskInfo, userInfo, err := l.checkUse(in, adminInfo)
	if err != utils.Ok {
		return l.fail(err)
	}

	two := true
	if len(maskInfo.UseTime) < utils.NumberEight {
		maskInfo.IsUse = utils.StatusDone
		maskInfo.UseTime = in.UseTime
		maskInfo.HostCode = in.HostCode
		maskInfo.UserId = userInfo.Id
		maskInfo.GearPosition = in.GearPosition
		maskInfo.Voltage = in.Voltage
		maskInfo.ElectricCurrent = in.ElectricCurrent
		maskInfo.Efficiency = in.Efficiency
		maskInfo.Resistance = in.Resistance
		maskInfo.Score = in.Score
		two = false
	} else {
		maskInfo.SecondUseTime = v.UseTime
	}

	modelObj := model.MaskModel{}.Init()
	modelObj.Begin()
	if v.StoreId > utils.NumberZero && !two {
		maskInfo.StoreId = in.StoreId
		record := dao.MaskUsageRecordCreate{
			Userid:       int(userInfo.Id),
			StoreId:      v.StoreId,
			FacialMaskId: maskInfo.FacialMaskId,
		}
		aErr := model.MaskUsageRecordModel{}.Init().Create(&record)
		if aErr != nil {
			l.Logger.Error(err)
			modelObj.Rollback()
			return l.fail(utils.SetError(utils.Fail, "添加使用记录失败"))
		}
	}

	w := modelbase.Params{Eq: map[string]string{"id": strconv.FormatInt(maskInfo.Id, 10)}}
	_, err2 := modelObj.Edit(w, &maskInfo)
	if err2 != nil {
		l.Logger.Error(err2)
		modelObj.Rollback()
		return l.fail(utils.SetError(utils.Fail, "更新数据失败"))
	}

	modelObj.Commit()

	return l.ok(utils.NumberOne)
}

func (l *ApiMaskUseLogic) checkUse(v *equipment.ApiMaskUseRequest, u utils.UserInfo) (dao.MaskUseInfo, dao.UserInfo, utils.Status) {
	var maskInfo dao.MaskUseInfo
	var userInfo dao.UserInfo

	maskInfo, err := l.checkMaskUse(v)
	if err != utils.Ok {
		return maskInfo, userInfo, err
	}

	//校验用户信息
	userInfo = svc.GetUser(u.ID, l.svcCtx.UserSvcName)
	if userInfo.Id < utils.NumberOne {
		return maskInfo, userInfo, utils.SetError(utils.ErrorNotFund, "没有找到用户信息")
	}

	//如果有门店信息校验信息
	if v.StoreId > utils.NumberZero {
		var storeInfo dao.StoreInfo
		storeInfo = svc.GetStore(v.StoreId, l.svcCtx.StoreSvcName)
		if storeInfo.Id < utils.NumberOne {
			return maskInfo, userInfo, utils.SetError(utils.ErrorNotFund, "没有找到门店信息")
		}
	}

	return maskInfo, userInfo, utils.Ok
}

func (l *ApiMaskUseLogic) checkMaskUse(v *equipment.ApiMaskUseRequest) (dao.MaskUseInfo, utils.Status) {
	var maskInfo dao.MaskUseInfo

	//面膜信息校验信息
	maskW := modelbase.Params{Eq: map[string]string{"facial_mask_id": v.FacialMaskId}}
	err := model.MaskModel{}.Init().GetOne(maskW, &maskInfo)
	if err != nil || maskInfo.Id < utils.NumberOne {
		l.Logger.Error(err)
		return maskInfo, utils.SetError(utils.ErrorNotFund, "没有找到面膜信息")
	}

	//如果使用过
	if maskInfo.IsUse == utils.StatusDone {
		//试用与一次性直接返回
		if maskInfo.IsOnTrial == dao.FacialTypeTry ||
			maskInfo.IsOnTrial == dao.FacialTypeOnce {
			return maskInfo, utils.SetError(utils.Fail, "产品已使用过")
		}
		//普通与通过做过两次返回
		if len(maskInfo.SecondUseTime) > utils.NumberEight {
			return maskInfo, utils.SetError(utils.Fail, "产品已使用过二次")
		}
		//两次间隔不能超过30分
		userTime, err := utils.TimeToUnix(maskInfo.UseTime, "2006-1-2 15:4")
		if err != nil && userTime+30*60 < utils.Now().Unix() {
			l.Logger.Error(err)
			return maskInfo, utils.SetError(utils.Fail, "超过30分不能继续使用")
		}
	}

	return maskInfo, utils.Ok
}