joybuywork/internal/service/w_fission.go

package service

import (
	"joybuywork/internal/consts"
	"joybuywork/internal/consts/ckey"
	"joybuywork/internal/repository/cache"
	"joybuywork/internal/repository/dbcheck"
	"joybuywork/internal/repository/model"
	"joybuywork/internal/repository/mtype"
	"joybuywork/internal/repository/withdefault"
	"joybuywork/internal/service/containers"
	"joybuywork/internal/utils"
	"joybuywork/internal/utils/arr"
	"joybuywork/internal/utils/logic"
	"joybuywork/internal/utils/verify"
	pb "joybuywork/proto/go_proto/w_fission"
	"joybuywork/proto/go_proto/workerr"

	"gorm.io/gen"
)

type WFission struct {
	Service
}

// List 玩法列表
func (s *WFission) List(req *pb.ListReq, res *pb.ListRes) (err error) {
	defer s.checkErr()

	list := consts.FissionList()

	var targets []int32
	if req.GetTarget() > 0 {
		targets = append(targets, req.GetTarget())
	}

	if len(req.GetTargets()) > 0 {
		for _, target := range req.GetTargets() {
			if target == req.GetTarget() {
				continue
			}
			targets = append(targets, target)
		}
	}

	// 找全部
	if len(targets) == 0 {
		*res = pb.ListRes{
			List: make([]*pb.ListRes_One, 0, len(list)),
		}

		for _, v := range list {
			res.List = append(res.List, &pb.ListRes_One{
				Id:     v.Id,
				Mark:   v.Mark,
				Logo:   v.Logo,
				Title:  v.GetTitle(req.GetLang(), req.GetTarget()),
				CanUse: v.CanUse,
				Desc:   v.GetDesc(req.GetLang(), req.GetTarget()),
				Color:  v.Color,
			})
		}

		return
	}

	// 找部分
	var fissionByTarget []int64
	for _, target := range targets {
		fissionByTarget = arr.NotExistAppend(fissionByTarget, consts.FissionByTarget[target])
	}

	*res = pb.ListRes{
		List: make([]*pb.ListRes_One, 0, len(fissionByTarget)),
	}

	for _, v := range list {
		if !verify.InArray(v.Id, fissionByTarget...) {
			continue
		}

		one := &pb.ListRes_One{
			Id:     v.Id,
			Mark:   v.Mark,
			Logo:   v.Logo,
			Title:  v.GetTitle(req.GetLang(), req.GetTarget()),
			CanUse: v.CanUse,
			Desc:   v.GetDesc(req.GetLang(), req.GetTarget()),
			Color:  v.Color,
		}

		if req.GetTarget() == consts.FissionTargetRetain {
			one.Logo = v.RetainLogo
		} else if req.GetTarget() == consts.FissionTargetConvert {
			one.Logo = v.ConvertLogo
		}

		res.List = append(res.List, one)
	}

	return
}

// TemplateList 玩法模版列表
func (s *WFission) TemplateList(req *pb.TemplateListReq, res *pb.TemplateListRes) (err error) {
	defer s.checkErr()

	fissionId, ok := consts.FissionMarkMap[req.Mark]

	if !ok {
		return workerr.NotFound("fission mark not found")
	}

	m := s.GetDao().FissionTempGroup
	var cond = []gen.Condition{
		m.IsDel.Eq(mtype.No),
		m.FissionID.Eq(fissionId),
	}

	list, err := m.WithContext(s.ctx).Where(cond...).Order(m.Sort, m.ID).Find()
	if err != nil {
		return s.BE().MysqlError(err)
	}

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

	var ids = make([]int64, 0, len(list))
	for _, v := range list {
		ids = append(ids, v.ID)
	}

	tempM := s.GetDao().FissionTemp
	tempList, err := tempM.WithContext(s.ctx).Where(tempM.GroupID.In(ids...), tempM.IsDel.Eq(mtype.No)).Order(tempM.LangType).Find()
	if err != nil {
		return s.BE().MysqlError(err)
	}
	var groupTemp = make(map[int64][]*model.FissionTemp)
	for _, v := range tempList {
		groupTemp[v.GroupID] = append(groupTemp[v.GroupID], v)
	}

	for _, v := range list {
		one := &pb.TemplateListRes_One{
			Id:        v.ID,
			Mark:      v.Mark,
			CoverUrl:  utils.Ternary(req.GetTarget() == mtype.FissionCampaignConfigTargetUp && v.ConvertCoverURL != "", v.ConvertCoverURL, v.CoverURL),
			Title:     "",
			Sort:      v.Sort,
			Temps:     nil,
			IsPrivate: int32(v.IsPrivate),
		}

		if temps, ok1 := groupTemp[v.ID]; ok1 {
			one.Temps = make([]*pb.TemplateListRes_Temp, 0, len(temps))
			for _, v1 := range temps {
				one.Temps = append(one.Temps, &pb.TemplateListRes_Temp{
					HashId:   v1.HashID,
					LangType: int32(v1.LangType),
				})
			}
		}

		res.List = append(res.List, one)
	}

	return
}

// TemplateInfo 玩法模版信息
func (s *WFission) TemplateInfo(req *pb.TemplateInfoReq, res *pb.TemplateInfoRes) (err error) {
	defer s.checkErr()
	container := new(containers.FissionTemplateInfo)
	{
		container.Init(s.ctx)
		container.Req = req
		container.Res = res
	}

	return container.Run()
}

// CreateTempGroup 创建模板组
func (s *WFission) CreateTempGroup(req *pb.CreateTempGroupReq, res *pb.CreateTempGroupRes) (err error) {
	defer s.checkErr()

	container := new(containers.FissionCreateTempGroup)
	{
		container.Init(s.ctx, logic.WithTran(), logic.WithOnce(ckey.FissionTempGroupStoreOnce(req.GetMark())))
		container.Req = req
		container.Res = res
	}

	return container.Run()
}

// CreateTemp 玩法模版列表
func (s *WFission) CreateTemp(req *pb.CreateTempReq, res *pb.CreateTempRes) (err error) {
	defer s.checkErr()

	group, err := cache.NewFissionTempGroup(s.ctx).FindById(req.GetGroupId())
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	if group == nil || group.IsDel == mtype.Yes {
		return workerr.NotFound("temp_group not found")
	}

	tx := s.GetDao().Begin()
	defer func() {
		if err != nil {
			_ = tx.Rollback()
			return
		}
		_ = tx.Commit()
	}()

	m := tx.FissionTemp
	temp := withdefault.FissionTemp(&model.FissionTemp{
		FissionID: group.FissionID,
		GroupID:   group.ID,
		LangType:  int8(req.GetLangType()),
		TextType:  int8(req.GetTextType()),
	})

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

	var conf = make([]*model.FissionTempImage, 0, len(req.GetImage()))
	for _, kv := range req.GetImage() {
		conf = append(conf, &model.FissionTempImage{
			TempID: temp.ID,
			Mark:   kv.Key,
			Val:    kv.Value,
			Desc:   kv.Desc,
		})
	}

	var lang = make([]*model.FissionTempLang, 0, len(req.GetLang()))
	for _, kv := range req.GetLang() {
		lang = append(lang, withdefault.FissionTempLang(&model.FissionTempLang{
			TempID: temp.ID,
			Mark:   kv.Key,
			Val:    kv.Value,
			Desc:   kv.Desc,
		}))
	}

	if err = tx.FissionTempImage.WithContext(s.ctx).Create(conf...); err != nil {
		return s.BE().MysqlError(err)
	}

	if err = tx.FissionTempLang.WithContext(s.ctx).Create(lang...); err != nil {
		return s.BE().MysqlError(err)
	}

	*res = pb.CreateTempRes{
		Id:     temp.ID,
		HashId: temp.HashID,
	}
	return
}

// CreateTempLang 玩法模版列表
func (s *WFission) CreateTempLang(req *pb.CreateTempLangReq, res *pb.CreateTempLangRes) (err error) {
	defer s.checkErr()
	tempM := s.GetDao().FissionTemp
	var temp *model.FissionTemp
	if req.GetId() > 0 {
		temp, err = tempM.WithContext(s.ctx).Where(tempM.ID.Eq(req.GetId())).Take()
	} else if req.GetHashId() != "" {
		temp, err = tempM.WithContext(s.ctx).Where(tempM.HashID.Eq(req.GetHashId())).Take()
	}

	if err = dbcheck.DbError(err); err != nil {
		return s.BE().MysqlError(err)
	}

	if temp == nil || temp.IsDel == mtype.Yes {
		return workerr.NotFound("temp not found")
	}

	conf := make([]*model.FissionTempLang, 0, len(req.GetLang()))
	for _, kv := range req.GetLang() {
		conf = append(conf, withdefault.FissionTempLang(&model.FissionTempLang{
			TempID: temp.ID,
			Mark:   kv.Key,
			Val:    kv.Value,
			Desc:   kv.Desc,
		}))
	}

	if err = s.GetDao().FissionTempLang.WithContext(s.ctx).Create(conf...); err != nil {
		return s.BE().MysqlError(err)
	}

	*res = pb.CreateTempLangRes{}
	return
}

// CreateTempImg 玩法模版列表
func (s *WFission) CreateTempImg(req *pb.CreateTempImgReq, res *pb.CreateTempImgRes) (err error) {
	defer s.checkErr()
	tempM := s.GetDao().FissionTemp
	var temp *model.FissionTemp
	if req.GetId() > 0 {
		temp, err = tempM.WithContext(s.ctx).Where(tempM.ID.Eq(req.GetId())).Take()
	} else if req.GetHashId() != "" {
		temp, err = tempM.WithContext(s.ctx).Where(tempM.HashID.Eq(req.GetHashId())).Take()
	}

	if err = dbcheck.DbError(err); err != nil {
		return s.BE().MysqlError(err)
	}

	if temp == nil || temp.IsDel == mtype.Yes {
		return workerr.NotFound("temp not found")
	}

	conf := make([]*model.FissionTempImage, 0, len(req.GetImage()))
	for _, kv := range req.GetImage() {
		conf = append(conf, withdefault.FissionTempImage(&model.FissionTempImage{
			TempID: temp.ID,
			Mark:   kv.Key,
			Val:    kv.Value,
			Desc:   kv.Desc,
		}))
	}

	if err = s.GetDao().FissionTempImage.WithContext(s.ctx).Create(conf...); err != nil {
		return s.BE().MysqlError(err)
	}

	*res = pb.CreateTempImgRes{}
	return
}

// UpdateTempImg 更新玩法图片配置
func (s *WFission) UpdateTempImg(req *pb.UpdateTempImgReq, res *pb.UpdateTempImgRes) (err error) {
	defer s.checkErr()
	tempM := s.GetDao().FissionTemp
	var temp *model.FissionTemp
	if req.GetId() > 0 {
		temp, err = tempM.WithContext(s.ctx).Where(tempM.ID.Eq(req.GetId())).Take()
	} else if req.GetHashId() != "" {
		temp, err = tempM.WithContext(s.ctx).Where(tempM.HashID.Eq(req.GetHashId())).Take()
	}

	if err = dbcheck.DbError(err); err != nil {
		return s.BE().MysqlError(err)
	}

	if temp == nil || temp.IsDel == mtype.Yes {
		return workerr.NotFound("temp not found")
	}

	var marks []string
	var imgMap = make(map[string]*pb.UpdateTempImgReq_KV)

	for _, v := range req.GetImage() {
		marks = append(marks, v.GetKey())
		imgMap[v.Key] = v
	}

	m := s.GetDao().FissionTempImage

	list, err := m.WithContext(s.ctx).Where(m.TempID.Eq(temp.ID), m.Mark.In(marks...)).Find()
	if err != nil {
		return s.BE().MysqlError(err)
	}

	for _, v := range list {
		if img, ok := imgMap[v.Mark]; ok && (img.Value != v.Val || img.Desc != v.Desc) {
			_, err = m.WithContext(s.ctx).Where(m.ID.Eq(v.ID)).UpdateSimple(m.Val.Value(img.Value), m.Desc.Value(img.Desc))
			if err != nil {
				return s.BE().MysqlError(err)
			}

		}
	}
	*res = pb.UpdateTempImgRes{}
	return
}

// UpdateTempLang 更新玩法语言配置
func (s *WFission) UpdateTempLang(req *pb.UpdateTempLangReq, res *pb.UpdateTempLangRes) (err error) {
	defer s.checkErr()
	tempM := s.GetDao().FissionTemp
	var temp *model.FissionTemp
	if req.GetId() > 0 {
		temp, err = tempM.WithContext(s.ctx).Where(tempM.ID.Eq(req.GetId())).Take()
	} else if req.GetHashId() != "" {
		temp, err = tempM.WithContext(s.ctx).Where(tempM.HashID.Eq(req.GetHashId())).Take()
	}

	if err = dbcheck.DbError(err); err != nil {
		return s.BE().MysqlError(err)
	}

	if temp == nil || temp.IsDel == mtype.Yes {
		return workerr.NotFound("temp not found")
	}

	var marks []string
	var langMap = make(map[string]*pb.UpdateTempLangReq_KV)

	for _, v := range req.GetLang() {
		marks = append(marks, v.GetKey())
		langMap[v.Key] = v
	}

	m := s.GetDao().FissionTempLang

	list, err := m.WithContext(s.ctx).Where(m.TempID.Eq(temp.ID), m.Mark.In(marks...)).Find()
	if err != nil {
		return s.BE().MysqlError(err)
	}

	for _, v := range list {
		if lang, ok := langMap[v.Mark]; ok && (lang.Value != v.Val || lang.Desc != v.Desc) {
			_, err = m.WithContext(s.ctx).Where(m.ID.Eq(v.ID)).UpdateSimple(m.Val.Value(lang.Value), m.Desc.Value(lang.Desc))
			if err != nil {
				return s.BE().MysqlError(err)
			}
		}
	}

	*res = pb.UpdateTempLangRes{}
	return
}

// UpdateTempGroup 更新模板组
func (s *WFission) UpdateTempGroup(req *pb.UpdateTempGroupReq, res *pb.UpdateTempGroupRes) (err error) {
	defer s.checkErr()

	container := new(containers.FissionUpdateTempGroup)
	{
		container.Init(s.ctx, logic.WithTran())
		container.Req = req
		container.Res = res
	}

	return container.Run()
}