lone-services/services/equipment/internal/logic/apiMaskStoreUseLogic.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 ApiMaskStoreUseLogic struct {
	ctx    context.Context
	svcCtx *svc.ServiceContext
	logx.Logger
	BaseLogic
}

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

func (l *ApiMaskStoreUseLogic) ApiMaskStoreUse(in *equipment.ApiMaskUseRequest) (*equipment.Response, error) {
	var v validator.MaskUseValidator

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

	maskInfo, storeInfo, cErr := l.checkStoreUse(in, adminInfo)
	if cErr != utils.Ok {
		return l.fail(cErr)
	}

	two := true
	if len(maskInfo.UseTime) < utils.NumberEight {
		maskInfo.IsUse = utils.StatusDone
		maskInfo.UseTime = in.UseTime
		maskInfo.HostCode = in.HostCode
		maskInfo.UserId = in.UserId
		maskInfo.StoreId = storeInfo.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 !two {
		record := dao.MaskUsageRecordCreate{
			StoreId:      int(storeInfo.Id),
			FacialMaskId: maskInfo.FacialMaskId,
		}
		err := model.MaskUsageRecordModel{}.Init().Create(&record)
		if err != 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 *ApiMaskStoreUseLogic) checkStoreUse(v *equipment.ApiMaskUseRequest, u utils.UserInfo) (dao.MaskUseInfo, dao.StoreInfo, utils.Status) {
	var maskInfo dao.MaskUseInfo
	var storeInfo dao.StoreInfo

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

	//校验门店信息（门店登录 token 中 ObjId 为门店ID）
	storeInfo = svc.GetStore(v.StoreId, l.svcCtx.StoreSvcName)
	if storeInfo.Id < utils.NumberOne {
		return maskInfo, storeInfo, utils.SetError(utils.ErrorNotFund, "没有找到门店信息")
	}

	return maskInfo, storeInfo, utils.Ok
}

func (l *ApiMaskStoreUseLogic) 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() {
			utils.Logger.Error(err)
			return maskInfo, utils.SetError(utils.Fail, "超过30分不能继续使用")
		}
	}

	return maskInfo, utils.Ok
}