joybuywork/internal/service/w_common.go

package service

import (
	"joybuywork/internal/config"
	"joybuywork/internal/plugins/jsonm"
	"joybuywork/internal/repository/dbcheck"
	"joybuywork/internal/repository/model"
	"joybuywork/internal/repository/mtype"
	"joybuywork/internal/repository/withdefault"
	"joybuywork/internal/service/queue/producer"
	"joybuywork/internal/service/queue/types"
	"joybuywork/internal/utils"
	"joybuywork/internal/utils/upload"
	pb "joybuywork/proto/go_proto/w_common"
	"joybuywork/proto/go_proto/workerr"

	"gorm.io/gen"
)

type WCommon struct {
	Service
}

// PolicyToken 获取阿里云token
func (s *WCommon) PolicyToken(req *pb.PolicyTokenReq, res *pb.PolicyTokenRes) (err error) {
	defer s.checkErr()
	policy := upload.GetPolicy(req.FileSuffix)

	*res = pb.PolicyTokenRes{
		AccessKeyId: config.Config.Upload.AccessKey,
		Host:        config.Config.Upload.Host,
		UploadUrl:   config.Config.Upload.UploadUrl,
		Expire:      policy.Expire,
		Signature:   policy.Signature,
		Dir:         policy.Directory,
		Policy:      policy.Policy,
		Key:         policy.Key,
	}
	return
}

// Whitelist 服务器白名单
func (s *WCommon) Whitelist(req *pb.WhitelistReq, res *pb.WhitelistRes) (err error) {
	defer s.checkErr()

	m := s.GetDao().ServerWhitelist

	*res = pb.WhitelistRes{}

	err = m.WithContext(s.ctx).Pluck(m.IP, &res.Ips)
	if err != nil {
		return s.BE().MysqlError(err)
	}

	return
}

// Download 下载
func (s *WCommon) Download(req *pb.DownloadReq, res *pb.DownloadRes) (err error) {
	defer s.checkErr()

	m := s.GetDao().ExportTask

	task := withdefault.ExportTask(&model.ExportTask{
		UserID:    req.GetUserId(),
		Mark:      req.GetMark(),
		Cond:      "",
		EptStatus: mtype.ExportTaskEptStatusDoing,
		ExpiredAt: 0,
		Filename:  "",
		FailMsg:   "",
	})

	var data jsonm.JsonM

	switch req.Mark {
	case mtype.ExportTaskMarkCampaignReport:
		data, _ = jsonm.Marshal(req.CampaignReport)
	case mtype.ExportTaskMarkFissionUser:
		data, _ = jsonm.Marshal(req.FissionUser)
	case mtype.ExportTaskMarkFissionRewardRecord:
		data, _ = jsonm.Marshal(req.FissionRewardRecord)
	case mtype.ExportTaskMarkFissionUserStat:
		data, _ = jsonm.Marshal(req.FissionUserStat)
	case mtype.ExportTaskMarkAdsTable:
		data, _ = jsonm.Marshal(req.AdsTable)
	case mtype.ExportTaskMarkNewUserList:
		data, _ = jsonm.Marshal(req.NewUserList)
	case mtype.ExportTaskMarkCoinRecord:
		data, _ = jsonm.Marshal(req.CoinRecord)
	case mtype.ExportTaskMarkChildList:
		data, _ = jsonm.Marshal(req.ChildList)
	default:
		err = workerr.VerifyError("not found download type")
		return
	}

	task.Cond = data.ToString()

	err = m.WithContext(s.ctx).Create(task)
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	producer.NewCampaignNotice(s.ctx).Download(types.Download{
		TaskId: task.HashID,
		Mark:   task.Mark,
		Cond:   data,
	})

	*res = pb.DownloadRes{
		HashId: task.HashID,
	}
	return
}

// DownloadStatus 下载状态
func (s *WCommon) DownloadStatus(req *pb.DownloadStatusReq, res *pb.DownloadStatusRes) (err error) {
	defer s.checkErr()
	m := s.GetDao().ExportTask

	task, err := m.WithContext(s.ctx).Where(m.HashID.Eq(req.GetHashId())).Take()
	if err = dbcheck.DbError(err); err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	if task == nil {
		err = workerr.NotFound("not found ept task")
		return
	}

	*res = pb.DownloadStatusRes{
		Status:   int32(task.EptStatus),
		Url:      task.Filename,
		FailMsg:  task.FailMsg,
		Progress: "",
	}

	return
}

// OperateLog dashboard操作日志
func (s *WCommon) OperateLog(req *pb.OperateLogReq, res *pb.OperateLogRes) (err error) {
	defer s.checkErr()

	_ = s.GetDao().OperateLog.WithContext(s.ctx).Create(withdefault.OperateLog(&model.OperateLog{
		UserID: req.GetUserId(),
		Mark:   req.GetMark(),
		MarkID: req.GetMarkId(),
		Data:   req.GetData(),
		IP:     req.GetIp(),
	}))

	*res = pb.OperateLogRes{}
	return
}

// SaveMaterial 保存素材
func (s *WCommon) SaveMaterial(req *pb.SaveMaterialReq, res *pb.SaveMaterialRes) (err error) {
	defer s.checkErr()

	project, err := s.ProjectErrNil(req.GetProjectHashId())
	if err != nil {
		return
	}

	m := s.GetDao().Material

	material := withdefault.Material(&model.Material{
		ProjectID:    project.ID,
		MaterialType: int8(req.GetMaterialType()),
		MaterialData: req.GetMaterialData(),
	})
	err = m.WithContext(s.ctx).Create(material)
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	*res = pb.SaveMaterialRes{
		Id: material.ID,
	}
	return
}

// MaterialList 素材列表
func (s *WCommon) MaterialList(req *pb.MaterialListReq, res *pb.MaterialListRes) (err error) {
	defer s.checkErr()
	project, err := s.ProjectErrNil(req.GetProjectHashId())
	if err != nil {
		return
	}

	m := s.GetDao().Material
	var cond = []gen.Condition{
		m.IsDel.Eq(mtype.No),
		m.ProjectID.Eq(project.ID),
	}

	if req.GetMaterialType() > 0 {
		cond = append(cond, m.MaterialType.Value(int8(req.GetMaterialType())))
	}

	offset, limit := utils.PpDbLo(req.GetPage(), req.GetPerPage())
	list, total, err := m.WithContext(s.ctx).Where(cond...).FindByPage(offset, limit)
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	if total == 0 {
		return
	}

	*res = pb.MaterialListRes{
		List:  make([]*pb.MaterialListRes_One, 0, len(list)),
		Total: total,
	}

	for _, v := range list {
		res.List = append(res.List, &pb.MaterialListRes_One{
			Id:           v.ID,
			MaterialType: int32(v.MaterialType),
			MaterialData: v.MaterialData,
		})
	}

	return
}

// CompanyMade 企业定制组件列表
func (s *WCommon) CompanyMade(req *pb.CompanyMadeReq, res *pb.CompanyMadeRes) (err error) {
	defer s.checkErr()
	m := s.GetDao().CompanyMade
	list, err := m.WithContext(s.ctx).Where(m.CompanyID.Eq(req.GetCompanyId())).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	*res = pb.CompanyMadeRes{
		List: make([]*pb.CompanyMadeRes_One, 0, len(list)),
	}

	for _, v := range list {
		res.List = append(res.List, &pb.CompanyMadeRes_One{
			Id:          v.ID,
			Mark:        v.Mark,
			FissionTemp: v.GetFissionTemp(),
		})
	}

	return
}