lone-services/services/store/internal/svc/apply.go

package svc

import (
	"context"
	"lone-services/pkg/redis"
	"lone-services/pkg/utils"
	"strconv"
	"time"

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

type ApplySvc struct {
}

type ApplyData struct {
	Uid    int    `json:"uid"`
	Id     int    `json:"id"`
	Reason string `json:"reason"`
	Status uint8  `json:"status"` //9为审核中，1为审核通过，2为审核驳回,0为没有申请
	Time   string `json:"time"`
	Type   uint8  `json:"type"`
}

const (
	applyProductEditKey = "apply:edit:product:" //产品redis KEY
	applyStoreEditKey   = "apply:edit:store:"   //门店redis KEY
	applyEditTimeOut    = 60 * 24
	applyMd5Key         = "keys:"
)

func (l *ApplySvc) GetActionApply(uId, objId int) (ApplyData, utils.Status) {
	key := l.getKey(applyStoreEditKey, uId, objId)
	var data ApplyData
	_, err := l.run(key, &data)
	return data, err
}

func (l *ApplySvc) getKey(key string, uId, id int) string {
	return key + strconv.Itoa(uId) + "_" + strconv.Itoa(id)
}

func (l *ApplySvc) Run(uId, objId int, Type uint8, reason string) (string, utils.Status) {
	data := ApplyData{
		Uid:    uId,
		Id:     objId,
		Reason: reason,
		Status: utils.StatusWaitPass,
		Type:   Type,
	}
	return l.run(applyStoreEditKey, &data)
}

func (l *ApplySvc) run(key string, data *ApplyData) (string, utils.Status) {
	redisKey := l.getKey(key, data.Uid, data.Id)
	ctx := context.Background()
	if len(data.Reason) > utils.NumberZero {
		data.Time = utils.Now().String()
		md5 := utils.MD5Encrypt(strconv.Itoa(data.Uid) + strconv.Itoa(data.Id) + data.Time)
		jsonStr := utils.StructToJson(data)
		expire := l.getOutTime()
		_, err := redis.Client.Set(ctx, redisKey, jsonStr, time.Duration(expire)*time.Minute).Result()
		if err != nil {
			logx.Error(err)
			return md5, utils.SetError(utils.Fail, err.Error())
		}
		if data.Status == utils.StatusWaitPass {
			_, err = redis.Client.Set(ctx, l.getMd5key(key+applyMd5Key, md5), redisKey, time.Duration(expire)*time.Minute).Result()
			if err != nil {
				logx.Error(err)
				return md5, utils.SetError(utils.Fail, err.Error())
			}
		}
		return md5, utils.Ok
	}

	result, err := redis.Client.Get(ctx, key).Result()
	if err != nil && err.Error() != redis.RedisNil {
		logx.Error(err)
		return utils.StringEmpty, utils.SetError(utils.Fail, err.Error())
	}
	if len(result) < utils.NumberFive {
		return utils.StringEmpty, utils.Ok
	}
	if !utils.JsonStringToStruct(result, &data) {
		return utils.StringEmpty, utils.SetError(utils.Fail, "数据解析失败")
	}
	return utils.StringEmpty, utils.Ok
}

func (l *ApplySvc) getOutTime() int {
	outTime := utils.GetConfigInt("apply.time_out")
	if outTime <= utils.NumberZero {
		outTime = applyEditTimeOut
	}
	return outTime
}

func (l *ApplySvc) getMd5key(key, key2 string) string {
	return key + key2
}

func (l *ApplySvc) SetActionApply(uId, objId int, Type uint8, reason string) utils.Status {
	//data := ApplyData{
	//	Uid:    uId,
	//	Id:     objId,
	//	Reason: reason,
	//	Status: utils.StatusWaitPass,
	//	Type:   Type,
	//}
	//key, err := l.run(applyStoreEditKey, &data)
	//if err == utils.Ok {
	//TODO 写入日志
	//add := dao.ActionApplyLogCreate{
	//	AdminId: uId,
	//	ObjId:   objId,
	//	Type:    Type,
	//	Status:  utils.StatusWaitPass,
	//}
	//addErr := model.Create(&add)
	//if addErr != nil {
	//	logx.Error(addErr)
	//	s.DelActionApply(uId, objId)
	//	return utils.SetError(utils.Fail, addErr)
	//}

	// TODO 调取企业微信发消息 队列类型
	//qErr := QueueService{}.Create(utils.WecomStream, dao.WeComJob{
	//	ObjId:   data.Id,
	//	ObjType: Type,
	//	Type:    dao.StoreApplyReview,
	//	Ext: map[string]any{
	//		"reason": reason,
	//		"key":    key,
	//	},
	//})
	//
	//if qErr != nil {
	//	utils.Logger.Error(qErr)
	//	return qErr
	//}

	//return err
	//}
	//return err

	return utils.Ok
}

func (l *ApplySvc) DelActionApply(uId, objId int) utils.Status {
	key := l.getKey(applyStoreEditKey, uId, objId)
	_, err := redis.Client.Del(context.Background(), key).Result()
	if err != nil {
		logx.Error(err)
		return utils.SetError(utils.Fail, err.Error())
	}
	return utils.Ok
}