joybuywork/internal/service/w_reward.go

package service

import (
	"joybuywork/internal/plugins/jsonm"
	"joybuywork/internal/repository/cache"
	"joybuywork/internal/repository/dbcheck"
	"joybuywork/internal/repository/finder"
	"joybuywork/internal/repository/model"
	"joybuywork/internal/repository/mtype"
	"joybuywork/internal/repository/withdefault"
	"joybuywork/internal/service/containers"
	"joybuywork/internal/service/provider"
	"joybuywork/internal/service/provider/s2s"
	"joybuywork/internal/utils"
	"joybuywork/internal/utils/verify"
	pb "joybuywork/proto/go_proto/w_reward"
	"joybuywork/proto/go_proto/workerr"
	"fmt"
	"time"

	"gorm.io/gen"
)

type WReward struct {
	Service
}

// List 奖品列表
func (s *WReward) List(req *pb.ListReq, res *pb.ListRes) (err error) {
	defer s.checkErr()

	*res = pb.ListRes{}

	container := new(containers.RewardList)
	{
		container.Init(s.ctx)
		container.Req = req
		container.Res = res
	}

	return container.Run()
}

// Select 奖品选择
func (s *WReward) Select(req *pb.SelectReq, res *pb.SelectRes) (err error) {
	defer s.checkErr()

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

	rewards, err := provider.NewRewards(s.ctx, project.ID)
	if err != nil {
		return
	}

	list, err := rewards.InfoList()
	if err != nil {
		return
	}

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

	for _, v := range list {

		if req.GetReceiveType() > 0 && v.ReceiveType != req.GetReceiveType() {
			continue
		}

		one := &pb.SelectRes_One{
			Id:          v.Id,
			RewardTitle: v.RewardTitle,
			Title:       "",
			ImgUrl:      "",
			LangMark:    "",
			ReceiveType: v.ReceiveType,
			KvData:      make([]*pb.SelectRes_KV, 0, len(v.KvData)),
			Contact:     v.Contact,
			Url:         v.Url,
			FormTitle:   v.FormTitle,
		}

		for _, kv := range v.KvData {
			one.KvData = append(one.KvData, &pb.SelectRes_KV{
				Key:    kv.Key,
				Value:  kv.Value,
				IsShow: kv.IsShow,
			})
		}

		lang := rewards.AutoLang(v.Id, req.GetLangMark())
		one.Title, one.ImgUrl, one.LangMark = lang.Title, lang.ImgUrl, lang.Mark

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

	return
}

// Show 奖品详情
func (s *WReward) Show(req *pb.ShowReq, res *pb.ShowRes) (err error) {
	defer s.checkErr()
	project, err := s.ProjectErrNil(req.GetProjectHashId())
	if err != nil {
		return
	}

	reward, err := cache.NewReward(s.ctx).FindById(req.GetId())
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	if reward == nil || reward.IsDel == mtype.Yes || reward.ProjectID != project.ID {
		err = workerr.NotFound("not found reward")
		return
	}

	rlm := s.GetDao().RewardLang
	rls, err := rlm.WithContext(s.ctx).Where(rlm.RewardID.Eq(reward.ID), rlm.IsDel.Eq(mtype.No)).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	relateM := s.GetDao().RewardRelated
	relateNum, err := relateM.WithContext(s.ctx).Where(relateM.RewardID.Eq(reward.ID), relateM.CancelTime.Eq(0)).Count()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	*res = pb.ShowRes{
		Id:           reward.ID,
		RewardTitle:  reward.RewardTitle,
		ReceiveType:  int32(reward.ReceiveType),
		UrlId:        reward.URLID,
		Contact:      reward.Contact,
		KvData:       nil,
		Langs:        make([]*pb.ShowRes_Lang, 0, len(rls)),
		FormId:       reward.FormID,
		RelateNum:    relateNum,
		DyRewardType: int32(reward.DyRewardType),
	}

	_ = jsonm.StrUnmarshal(reward.KvData, &res.KvData)

	for _, v := range rls {
		res.Langs = append(res.Langs, &pb.ShowRes_Lang{
			Mark:      v.Mark,
			Title:     v.Title,
			ImgUrl:    v.ImgURL,
			IsDefault: int32(v.IsDefault),
			LangType:  int32(mtype.MarkToLangType[v.Mark]),
			OpenToUse: int32(v.OpenToUse),
			WebUrl:    v.WebURL,
			AppParam:  v.AppParam,
			PcParam:   v.PcParam,
		})
	}

	return
}

// Store 创建奖品
func (s *WReward) Store(req *pb.StoreReq, res *pb.StoreRes) (err error) {
	defer s.checkErr()
	project, err := s.ProjectErrNil(req.GetProjectHashId())
	if err != nil {
		return
	}

	// 验证kv是否存在
	var kvData []*mtype.RewardKV
	var kvStr, kvMark string
	if verify.InArray[int32](req.GetReceiveType(), mtype.RewardReceiveTypeNotify, mtype.RewardReceiveTypeClient) {
		kvData = make([]*mtype.RewardKV, 0, len(req.GetKvData()))
		markStruct := make([]*mtype.KV, 0, len(req.GetKvData()))
		for _, v := range req.GetKvData() {
			markStruct = append(markStruct, &mtype.KV{
				Key:   v.GetKey(),
				Value: v.GetValue(),
			})

			kvData = append(kvData, &mtype.RewardKV{
				Key:    v.GetKey(),
				Value:  v.GetValue(),
				IsShow: utils.Ternary(req.GetDyRewardType() == mtype.RewardDyRewardTypeNone, v.GetIsShow(), mtype.No),
			})
		}

		kvStr, _ = jsonm.MarshalToString(markStruct)
		kvMark = utils.Md5String(kvStr)

		m := s.GetDao().Reward
		var exist *model.Reward
		exist, err = m.WithContext(s.ctx).Where(
			m.ProjectID.Eq(project.ID),
			m.KvMark.Eq(kvMark),
			m.ReceiveType.Eq(int8(req.GetReceiveType())),
			m.IsDel.Eq(mtype.No)).Take()
		if err = dbcheck.DbError(err); err != nil {
			return s.BE().MysqlError(err)
		}

		if exist != nil {
			return workerr.RewardKvExistError
		}
	}

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

	m := tran.Reward
	reward := withdefault.Reward(&model.Reward{
		ProjectID:    project.ID,
		ReceiveType:  int8(req.GetReceiveType()),
		KvData:       "",
		KvMark:       kvMark,
		URLID:        req.GetUrlId(),
		Contact:      req.GetContact(),
		RewardTitle:  req.GetRewardTitle(),
		TitleDefault: 0,
		FormID:       req.GetFormId(),
		DyRewardType: int8(req.GetDyRewardType()),
		Source:       int8(req.GetSource()),
	})

	reward.SetKvData(kvData)

	if req.GetRewardTitle() == "" {
		for _, v := range req.GetLangs() {
			if v.GetIsDefault() == mtype.Yes {
				reward.RewardTitle = v.GetTitle()
				reward.TitleDefault = mtype.Yes
				break
			}
		}
	}

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

	var imgIds []int64
	for _, v := range req.GetLangs() {
		if v.GetImageId() > 0 {
			imgIds = append(imgIds, v.GetImageId())
		}
	}

	var imgMap = make(map[int64]string, len(imgIds))
	if len(imgIds) > 0 {
		mm := s.GetDao().Material
		var materials []*model.Material
		materials, err = mm.WithContext(s.ctx).Where(mm.ID.In(imgIds...)).Find()
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}

		if len(materials) != len(imgIds) {
			err = workerr.RewardImageInvalidError
			return
		}

		for _, v := range materials {
			imgMap[v.ID] = v.MaterialData
		}
	}

	var langs = make([]*model.RewardLang, 0, len(req.GetLangs()))
	for _, v := range req.GetLangs() {
		one := withdefault.RewardLang(&model.RewardLang{
			ProjectID: project.ID,
			RewardID:  reward.ID,
			Mark:      v.GetMark(),
			Title:     v.GetTitle(),
			ImgURL:    v.GetImgUrl(),
			IsDefault: int8(v.GetIsDefault()),
			OpenToUse: int8(v.GetOpenToUse()),
			WebURL:    v.GetWebUrl(),
			AppParam:  v.GetAppParam(),
			ImageID:   v.GetImageId(),
			PcParam:   v.GetPcParam(),
		})
		if _, ok := imgMap[v.GetImageId()]; ok {
			one.ImgURL = imgMap[v.GetImageId()]
		}

		langs = append(langs, one)
	}

	rlm := s.GetDao().RewardLang
	err = rlm.WithContext(s.ctx).Create(langs...)
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	*res = pb.StoreRes{
		Id: reward.ID,
	}
	return
}

// Update 更新奖品
func (s *WReward) Update(req *pb.UpdateReq, res *pb.UpdateRes) (err error) {
	defer s.checkErr()
	project, err := s.ProjectErrNil(req.GetProjectHashId())
	if err != nil {
		return
	}

	c := cache.NewReward(s.ctx)
	reward, err := c.FindById(req.GetId())
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	if reward == nil || reward.IsDel == mtype.Yes || reward.ProjectID != project.ID {
		err = workerr.NotFound("not found reward")
		return
	}

	if req.GetReceiveType() != int32(reward.ReceiveType) {
		relateM := s.GetDao().RewardRelated
		var count int64
		count, err = relateM.WithContext(s.ctx).Where(relateM.RewardID.Eq(reward.ID), relateM.CancelTime.Eq(0)).Count()
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}

		if count > 0 {
			err = s.BE().VerifyError("奖品已经被绑定，无法修改奖品的发放类型")
			return
		}

	}

	// 验证kv是否存在
	var kvData []*mtype.RewardKV
	var kvStr, kvMark string
	if verify.InArray[int32](req.GetReceiveType(), mtype.RewardReceiveTypeNotify, mtype.RewardReceiveTypeClient) {
		kvData = make([]*mtype.RewardKV, 0, len(req.GetKvData()))
		markStruct := make([]*mtype.KV, 0, len(req.GetKvData()))
		for _, v := range req.GetKvData() {
			markStruct = append(markStruct, &mtype.KV{
				Key:   v.GetKey(),
				Value: v.GetValue(),
			})

			kvData = append(kvData, &mtype.RewardKV{
				Key:    v.GetKey(),
				Value:  v.GetValue(),
				IsShow: utils.Ternary(req.GetDyRewardType() == mtype.RewardDyRewardTypeNone, v.GetIsShow(), mtype.No),
			})
		}

		kvStr, _ = jsonm.MarshalToString(markStruct)
		kvMark = utils.Md5String(kvStr)

		m := s.GetDao().Reward
		var exist *model.Reward
		exist, err = m.WithContext(s.ctx).Where(
			m.ProjectID.Eq(project.ID),
			m.KvMark.Eq(kvMark),
			m.ReceiveType.Eq(int8(req.GetReceiveType())),
			m.IsDel.Eq(mtype.No), m.ID.Neq(reward.ID)).Take()
		if err = dbcheck.DbError(err); err != nil {
			return s.BE().MysqlError(err)
		}

		if exist != nil {
			return workerr.RewardKvExistError
		}
	}

	// 语言数据
	rlm := s.GetDao().RewardLang
	oldLang, err := rlm.WithContext(s.ctx).Where(rlm.RewardID.Eq(reward.ID)).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	var oldLangMap = make(map[string]*model.RewardLang)
	for _, v := range oldLang {
		oldLangMap[v.Mark] = v
	}

	var imgIds []int64
	for _, v := range req.GetLangs() {
		if v.GetImageId() > 0 {
			imgIds = append(imgIds, v.GetImageId())
		}
	}

	var imgMap = make(map[int64]string, len(imgIds))
	if len(imgIds) > 0 {
		mm := s.GetDao().Material
		var materials []*model.Material
		materials, err = mm.WithContext(s.ctx).Where(mm.ID.In(imgIds...)).Find()
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}

		if len(materials) != len(imgIds) {
			err = workerr.RewardImageInvalidError
			return
		}

		for _, v := range materials {
			imgMap[v.ID] = v.MaterialData
		}
	}

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

	m := tran.Reward

	var rewardTitle = req.GetRewardTitle()
	var titleDefault int8
	if (reward.RewardTitle == rewardTitle && reward.TitleDefault == mtype.Yes) || rewardTitle == "" {
		for _, v := range req.GetLangs() {
			if v.GetIsDefault() == mtype.Yes {
				rewardTitle = v.GetTitle()
				titleDefault = mtype.Yes
				break
			}
		}
	}

	kvDataStr, _ := jsonm.MarshalToString(kvData)

	_, err = m.WithContext(s.ctx).Where(m.ID.Eq(reward.ID)).UpdateSimple(
		m.Contact.Value(req.GetContact()),
		m.KvData.Value(kvDataStr),
		m.KvMark.Value(kvMark),
		m.URLID.Value(req.GetUrlId()),
		m.ReceiveType.Value(int8(req.GetReceiveType())),
		m.RewardTitle.Value(rewardTitle),
		m.TitleDefault.Value(titleDefault),
		m.OldData.Value(mtype.No),
		m.FormID.Value(req.GetFormId()),
		m.DyRewardType.Value(int8(req.GetDyRewardType())),
	)
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	var newLangMap = make(map[string]struct{})
	var addLangs []*model.RewardLang
	rlm = tran.RewardLang
	for _, v := range req.GetLangs() {
		newLangMap[v.GetMark()] = struct{}{}
		image := utils.Ternary(v.GetImageId() > 0, imgMap[v.GetImageId()], v.GetImgUrl())
		old, ok := oldLangMap[v.GetMark()]
		if ok {
			_, err = rlm.WithContext(s.ctx).Where(rlm.ID.Eq(old.ID)).UpdateSimple(
				rlm.Title.Value(v.GetTitle()),
				rlm.ImgURL.Value(image),
				rlm.IsDefault.Value(int8(v.GetIsDefault())),
				rlm.IsDel.Value(mtype.No),
				rlm.OpenToUse.Value(int8(v.GetOpenToUse())),
				rlm.WebURL.Value(v.GetWebUrl()),
				rlm.AppParam.Value(v.GetAppParam()),
				rlm.ImageID.Value(v.GetImageId()),
				rlm.PcParam.Value(v.GetPcParam()),
			)
			if err != nil {
				err = s.BE().MysqlError(err)
				return
			}

			continue
		}

		addLangs = append(addLangs, withdefault.RewardLang(&model.RewardLang{
			ProjectID: project.ID,
			RewardID:  reward.ID,
			Mark:      v.GetMark(),
			Title:     v.GetTitle(),
			ImgURL:    image,
			IsDefault: int8(v.GetIsDefault()),
			OpenToUse: int8(v.GetOpenToUse()),
			WebURL:    v.GetWebUrl(),
			AppParam:  v.GetAppParam(),
			ImageID:   v.GetImageId(),
			PcParam:   v.GetPcParam(),
		}))
	}

	for _, v := range oldLang {
		if _, ok := newLangMap[v.Mark]; !ok {
			_, err = rlm.WithContext(s.ctx).Where(rlm.ID.Eq(v.ID)).UpdateSimple(rlm.IsDel.Value(mtype.Yes))
			if err != nil {
				err = s.BE().MysqlError(err)
				return
			}
		}
	}

	if len(addLangs) > 0 {
		err = rlm.WithContext(s.ctx).Create(addLangs...)
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}
	}

	*res = pb.UpdateRes{
		Id: reward.ID,
	}
	return
}

// Destroy 删除奖品
func (s *WReward) Destroy(req *pb.DestroyReq, res *pb.DestroyRes) (err error) {
	defer s.checkErr()

	*res = pb.DestroyRes{}

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

	sids := utils.SplitToInt64(req.GetIds(), ",")

	m := s.GetDao().Reward
	list, err := m.WithContext(s.ctx).Where(m.ProjectID.Eq(project.ID), m.ID.In(sids...), m.IsDel.Value(mtype.No)).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

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

	relateM := s.GetDao().RewardRelated

	var num []struct {
		RewardId int64
		Num      int64
	}

	err = relateM.WithContext(s.ctx).
		Select(relateM.RewardID, relateM.ID.Count().As("num")).
		Where(relateM.RewardID.In(ids...), relateM.CancelTime.Eq(0)).
		Group(relateM.RewardID).
		Scan(&num)

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

	var bindMap = make(map[int64]int64)
	for _, v := range num {
		bindMap[v.RewardId] = v.Num
	}

	var clearCache []*model.Reward
	var delIds []int64
	for _, v := range list {
		if _, ok := bindMap[v.ID]; !ok {
			delIds = append(delIds, v.ID)
			clearCache = append(clearCache, v)
		} else {
			res.Ids = append(res.Ids, fmt.Sprintf("%d", v.ID))
		}
	}

	if len(delIds) > 0 {
		_, err = m.WithContext(s.ctx).Where(m.ID.In(delIds...)).UpdateSimple(m.IsDel.Value(mtype.Yes))
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}

		_ = cache.NewReward(s.ctx).Clear(clearCache...)
	}

	return
}

// UrlList 回调地址列表
func (s *WReward) UrlList(req *pb.UrlListReq, res *pb.UrlListRes) (err error) {
	defer s.checkErr()

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

	m := s.GetDao().NotifyURL

	query := m.WithContext(s.ctx).Where(m.ProjectID.Eq(project.ID), m.IsDel.Eq(mtype.No))
	switch req.GetOrderType() {
	case 1:
		query = query.Order(m.CreatedAt)
	default:
		query = query.Order(m.OldData, m.ID.Desc())
	}

	list, err := query.Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	if len(list) == 0 {
		return
	}

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

	var urlIds []int64
	for _, v := range list {
		urlIds = append(urlIds, v.ID)
	}

	type Num struct {
		UrlId int64
		Num   int64
	}

	var num []*Num
	rewardM := s.GetDao().Reward
	err = rewardM.WithContext(s.ctx).
		Select(rewardM.URLID, rewardM.ID.Count().As("num")).
		Where(rewardM.URLID.In(urlIds...), rewardM.IsDel.Eq(mtype.No)).
		Group(rewardM.URLID).
		Scan(&num)
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	var numMap = map[int64]int64{}
	for _, v := range num {
		numMap[v.UrlId] = v.Num
	}

	for _, v := range list {
		headers := v.GetHeaders()

		one := &pb.UrlListRes_One{
			Id:        v.ID,
			Title:     v.Title,
			Url:       v.URL,
			Num:       numMap[v.ID],
			CreatedAt: v.CreatedAt,
			Headers:   make([]*pb.UrlListRes_Header, 0, len(headers)),
		}

		for _, header := range headers {
			one.Headers = append(one.Headers, &pb.UrlListRes_Header{
				Key:  header.Key,
				Mark: header.Mark,
				Val:  header.Val,
			})
		}

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

	return
}

// UrlStore 创建回调地址
func (s *WReward) UrlStore(req *pb.UrlStoreReq, res *pb.UrlStoreRes) (err error) {
	defer s.checkErr()
	project, err := s.ProjectErrNil(req.GetProjectHashId())
	if err != nil {
		return
	}

	m := s.GetDao().NotifyURL

	url := withdefault.NotifyURL(&model.NotifyURL{
		ProjectID: project.ID,
		Title:     req.GetTitle(),
		URL:       req.GetUrl(),
		Source:    int8(req.GetSource()),
	})

	url.Headers, _ = jsonm.ToSliceString(req.GetHeaders())

	err = m.WithContext(s.ctx).Create(url)

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

	*res = pb.UrlStoreRes{
		Id: url.ID,
	}

	return
}

// UrlUpdate 更新回调地址
func (s *WReward) UrlUpdate(req *pb.UrlUpdateReq, res *pb.UrlUpdateRes) (err error) {
	defer s.checkErr()
	project, err := s.ProjectErrNil(req.GetProjectHashId())
	if err != nil {
		return
	}

	c := cache.NewNotifyURL(s.ctx)
	url, err := c.FindById(req.GetId())
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	if url == nil || url.IsDel == mtype.Yes || url.ProjectID != project.ID {
		err = workerr.NotFound("not found url")
		return
	}

	headers, _ := jsonm.ToSliceString(req.GetHeaders())

	m := s.GetDao().NotifyURL
	_, err = m.WithContext(s.ctx).Where(m.ID.Eq(url.ID)).UpdateSimple(
		m.URL.Value(req.GetUrl()),
		m.Title.Value(req.GetTitle()),
		m.Headers.Value(headers),
	)
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	_ = c.Clear(url)

	*res = pb.UrlUpdateRes{
		Id: url.ID,
	}
	return
}

// UrlDestroy 删除回调地址
func (s *WReward) UrlDestroy(req *pb.UrlDestroyReq, res *pb.UrlDestroyRes) (err error) {
	defer s.checkErr()
	project, err := s.ProjectErrNil(req.GetProjectHashId())
	if err != nil {
		return
	}

	c := cache.NewNotifyURL(s.ctx)
	url, err := c.FindById(req.GetId())
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	if url == nil || url.IsDel == mtype.Yes || url.ProjectID != project.ID {
		err = workerr.NotFound("not found url")
		return
	}

	rewardM := s.GetDao().Reward
	bindNum, err := rewardM.WithContext(s.ctx).Where(rewardM.ProjectID.Eq(project.ID), rewardM.URLID.Eq(url.ID), rewardM.IsDel.Eq(mtype.No)).Count()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	if bindNum > 0 {
		err = s.BE().VerifyError("can not delete")
		return
	}

	m := s.GetDao().NotifyURL
	_, err = m.WithContext(s.ctx).Where(m.ID.Eq(url.ID)).UpdateSimple(m.IsDel.Value(mtype.Yes))
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	_ = c.Clear(url)
	*res = pb.UrlDestroyRes{}
	return
}

// FormList 表单列表
func (s *WReward) FormList(req *pb.FormListReq, res *pb.FormListRes) (err error) {
	defer s.checkErr()
	project, err := finder.Project(s.ctx, req.GetProjectHashId())
	if err != nil {
		return
	}

	if project == nil {
		return
	}

	m := s.GetDao().Form

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

	if req.GetTitle() != "" {
		cond = append(cond, m.Title.Like(utils.DbAllLike(req.GetTitle())))
	}

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

	if total == 0 {
		return
	}

	var formIds []int64
	for _, v := range list {
		formIds = append(formIds, v.ID)
	}

	type Num struct {
		FormId int64
		Num    int64
	}

	var num []*Num
	rewardM := s.GetDao().Reward
	err = rewardM.WithContext(s.ctx).
		Select(rewardM.FormID, rewardM.ID.Count().As("num")).
		Where(rewardM.FormID.In(formIds...), rewardM.IsDel.Eq(mtype.No)).
		Group(rewardM.FormID).
		Scan(&num)
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	var numMap = map[int64]int64{}
	for _, v := range num {
		numMap[v.FormId] = v.Num
	}

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

	for _, v := range list {
		items := v.GetItems()
		one := &pb.FormListRes_One{
			Id:        v.ID,
			Title:     v.Title,
			CreatedAt: v.CreatedAt,
			Items:     make([]*pb.FormListRes_Item, 0, len(items)),
			Num:       numMap[v.ID],
		}

		for _, item := range items {
			one.Items = append(one.Items, &pb.FormListRes_Item{
				Name: item.Name,
			})
		}

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

	return
}

// FormSelect 表单选择
func (s *WReward) FormSelect(req *pb.FormSelectReq, res *pb.FormSelectRes) (err error) {
	defer s.checkErr()
	project, err := finder.Project(s.ctx, req.GetProjectHashId())
	if err != nil {
		return
	}

	if project == nil {
		return
	}

	m := s.GetDao().Form

	list, err := m.WithContext(s.ctx).Where(m.ProjectID.Eq(project.ID), m.IsDel.Eq(mtype.No)).Order(m.ID.Desc()).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	if len(list) == 0 {
		return
	}

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

	for _, v := range list {
		res.List = append(res.List, &pb.FormSelectRes_One{
			Id:    v.ID,
			Title: v.Title,
		})
	}

	return
}

// FormStore 创建表单
func (s *WReward) FormStore(req *pb.FormStoreReq, res *pb.FormStoreRes) (err error) {
	defer s.checkErr()
	project, err := s.ProjectErrNil(req.GetProjectHashId())
	if err != nil {
		return
	}

	var items = make([]*mtype.FormItem, 0, len(req.GetItems()))
	for _, item := range req.GetItems() {
		trans := make([]*mtype.FormItemTran, 0, len(item.GetTrans()))
		for _, tran := range item.GetTrans() {
			trans = append(trans, &mtype.FormItemTran{
				Mark:      tran.GetMark(),
				Name:      tran.GetName(),
				IsDefault: tran.GetIsDefault(),
			})
		}

		items = append(items, &mtype.FormItem{
			Name:  item.GetName(),
			Trans: trans,
		})
	}

	form := withdefault.Form(&model.Form{
		ProjectID: project.ID,
		Title:     req.GetTitle(),
		Items:     "",
	})
	form.SetItems(items)

	m := s.GetDao().Form
	if err = m.WithContext(s.ctx).Create(form); err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	*res = pb.FormStoreRes{
		Id: form.ID,
	}
	return
}

// FormUpdate 更新表单
func (s *WReward) FormUpdate(req *pb.FormUpdateReq, res *pb.FormUpdateRes) (err error) {
	defer s.checkErr()

	cc := cache.NewForm(s.ctx)
	form, err := cc.FindById(req.GetId())
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

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

	var items = make([]*mtype.FormItem, 0, len(req.GetItems()))
	for _, item := range req.GetItems() {
		trans := make([]*mtype.FormItemTran, 0, len(item.GetTrans()))
		for _, tran := range item.GetTrans() {
			trans = append(trans, &mtype.FormItemTran{
				Mark:      tran.GetMark(),
				Name:      tran.GetName(),
				IsDefault: tran.GetIsDefault(),
			})
		}

		items = append(items, &mtype.FormItem{
			Name:  item.GetName(),
			Trans: trans,
		})
	}

	upItems, _ := jsonm.MarshalToString(items)

	m := s.GetDao().Form
	_, err = m.WithContext(s.ctx).Where(m.ID.Eq(form.ID)).UpdateSimple(m.Title.Value(req.GetTitle()), m.Items.Value(upItems))
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	_ = cc.Clear(form)

	*res = pb.FormUpdateRes{
		Id: form.ID,
	}
	return
}

// FormDestroy 删除表单
func (s *WReward) FormDestroy(req *pb.FormDestroyReq, res *pb.FormDestroyRes) (err error) {
	defer s.checkErr()
	project, err := s.ProjectErrNil(req.GetProjectHashId())
	if err != nil {
		return
	}

	cc := cache.NewForm(s.ctx)
	form, err := cc.FindById(req.GetId())
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	if form == nil || form.IsDel == mtype.Yes {
		return
	}

	rewardM := s.GetDao().Reward
	total, err := rewardM.WithContext(s.ctx).Where(rewardM.ProjectID.Eq(project.ID), rewardM.IsDel.Eq(mtype.No), rewardM.FormID.Eq(form.ID)).Count()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	if total > 0 {
		err = s.BE().VerifyError("can not delete")
		return
	}

	m := s.GetDao().Form
	_, err = m.WithContext(s.ctx).Where(m.ID.Eq(form.ID)).UpdateSimple(m.IsDel.Value(mtype.Yes))
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	_ = cc.Clear(form)

	*res = pb.FormDestroyRes{
		Id: form.ID,
	}
	return
}

// Urls 回调地址列表
func (s *WReward) Urls(req *pb.UrlsReq, res *pb.UrlsRes) (err error) {
	defer s.checkErr()

	m := s.GetDao().NotifyURL
	list, err := m.WithContext(s.ctx).Where(m.ProjectID.Eq(req.GetProjectId()), m.ID.In(req.GetIds()...)).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	if len(list) == 0 {
		return
	}

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

	for _, v := range list {
		headers := v.GetHeaders()

		one := &pb.UrlsRes_One{
			Id:        v.ID,
			Title:     v.Title,
			Url:       v.URL,
			CreatedAt: v.CreatedAt,
			Headers:   make([]*pb.UrlsRes_Header, 0, len(headers)),
		}

		for _, header := range headers {
			one.Headers = append(one.Headers, &pb.UrlsRes_Header{
				Key:  header.Key,
				Mark: header.Mark,
				Val:  header.Val,
			})
		}

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

	return
}

// Rewards 奖品详情
func (s *WReward) Rewards(req *pb.RewardsReq, res *pb.RewardsRes) (err error) {
	defer s.checkErr()

	prewards, err := provider.NewRewards(s.ctx, req.GetProjectId(), req.GetIds()...)
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	*res = pb.RewardsRes{
		List: make([]*pb.RewardsRes_One, 0, len(req.GetIds())),
	}

	for _, id := range req.GetIds() {
		info, _ := prewards.InfoAutoLang(id, req.GetLangMark())

		one := &pb.RewardsRes_One{
			Id:          info.Id,
			RewardTitle: info.RewardTitle,
			ReceiveType: info.ReceiveType,
			UrlId:       info.UrlId,
			Contact:     info.Contact,
			KvData:      make([]*pb.RewardsRes_KV, 0, len(info.KvData)),
			Lang: &pb.RewardsRes_Lang{
				Mark:      info.Mark,
				Title:     info.Title,
				ImgUrl:    info.ImgUrl,
				IsDefault: info.IsDefault,
				OpenToUse: info.OpenToUse,
				WebUrl:    info.WebUrl,
				AppParam:  info.AppParam,
				PcParam:   info.PcParam,
			},
			FormId:       info.FormId,
			DyRewardType: info.DyRewardType,
		}

		for _, v := range info.KvData {
			one.KvData = append(one.KvData, &pb.RewardsRes_KV{
				Key:    v.Key,
				Value:  v.Value,
				IsShow: v.IsShow,
			})
		}

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

	return
}

// Forms 表单列表
func (s *WReward) Forms(req *pb.FormsReq, res *pb.FormsRes) (err error) {
	defer s.checkErr()

	m := s.GetDao().Form
	list, err := m.WithContext(s.ctx).Where(m.ProjectID.Eq(req.GetProjectId()), m.ID.In(req.GetIds()...)).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	if len(list) == 0 {
		return
	}

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

	for _, v := range list {
		items := v.GetItems()
		one := &pb.FormsRes_One{
			Id:        v.ID,
			Title:     v.Title,
			CreatedAt: v.CreatedAt,
			Items:     make([]*pb.FormsRes_Item, 0, len(items)),
		}

		for _, item := range items {
			one.Items = append(one.Items, &pb.FormsRes_Item{
				Name: item.Name,
			})
		}

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

	return
}

// RelateReward 关联奖品
func (s *WReward) RelateReward(req *pb.RelateRewardReq, res *pb.RelateRewardRes) (err error) {
	defer s.checkErr()

	m := s.GetDao().RewardRelated
	list, err := m.WithContext(s.ctx).Where(m.RelateID.Eq(req.GetRelateId()), m.RelateTable.Eq(req.GetRelateTable())).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	var oldMap = make(map[int64]*model.RewardRelated)
	for _, v := range list {
		oldMap[v.RewardID] = v
	}

	var reRelate []int64
	var relates []*model.RewardRelated
	for _, id := range req.GetRewardIds() {
		old, ok := oldMap[id]
		if !ok {
			relates = append(relates, withdefault.RewardRelated(&model.RewardRelated{
				RewardID:    id,
				RelateID:    req.GetRelateId(),
				RelateTable: req.GetRelateTable(),
			}))

			continue
		}

		delete(oldMap, old.RewardID)

		if old.CancelTime == 0 {
			continue
		}

		reRelate = append(reRelate, old.ID)
	}

	if len(relates) > 0 {
		if err = m.WithContext(s.ctx).Create(relates...); err != nil {
			err = s.BE().MysqlError(err)
			return
		}
	}

	if len(reRelate) > 0 {
		idGroup := utils.Groups[int64](reRelate, 200)
		for _, ids := range idGroup {
			_, err = m.WithContext(s.ctx).Where(m.ID.In(ids...)).UpdateSimple(m.CancelTime.Value(0))
			if err != nil {
				err = s.BE().MysqlError(err)
				return
			}
		}
	}

	var cancelIds []int64
	for _, related := range oldMap {
		cancelIds = append(cancelIds, related.ID)
	}

	if len(cancelIds) > 0 {
		idGroup := utils.Groups[int64](cancelIds, 200)
		for _, ids := range idGroup {
			_, err = m.WithContext(s.ctx).Where(m.ID.In(ids...)).UpdateSimple(m.CancelTime.Value(time.Now().Unix()))
			if err != nil {
				err = s.BE().MysqlError(err)
				return
			}
		}
	}

	*res = pb.RelateRewardRes{}
	return
}

// PushReward 奖品推送
func (s *WReward) PushReward(req *pb.PushRewardReq, res *pb.PushRewardRes) (err error) {
	defer s.checkErr()
	reward, err := cache.NewReward(s.ctx).FindById(req.GetRewardId())
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	if reward == nil || reward.ReceiveType != mtype.RewardReceiveTypeNotify {
		return
	}

	rp, err := s2s.NewReward(s.ctx, reward)
	if err != nil {
		return
	}

	push, err := rp.CreatePush(
		req.GetSource(),
		req.GetSourceId(),
		req.GetSourceSecondId(),
		req.GetRelateId(),
		int8(req.GetSync()),
		mtype.RewardPushParam{
			SourceHashId:       req.GetSourceHashId(),
			RelateHashId:       req.GetRelateHashId(),
			UserId:             req.GetUserId(),
			UserPlatform:       req.GetUserPlatform(),
			ParentUserId:       req.GetParentUserId(),
			ParentUserPlatform: req.GetParentPlatform(),
			Num:                req.GetNum(),
			Lang:               req.GetLang(),
			Title:              req.GetTitle(),
			RewardType:         req.GetRewardType(),
			RewardId:           fmt.Sprintf("%d", req.GetRelateId()),
			CampaignId:         req.GetCampaignId(),
		},
	)

	if err != nil || push == nil {
		return
	}

	if req.GetSync() == mtype.Yes {
		push, err = rp.Send(push, false)
		if err != nil || push == nil {
			return
		}
	} else {
		rp.Async(push, 0)
	}

	*res = pb.PushRewardRes{
		TaskId:    push.ID,
		RewardVal: push.RespData,
		Status:    int32(push.Status),
		FailType:  push.FailType,
		FailMsg:   push.FailMsg,
	}
	return
}

// RewardIds 查询奖品id
func (s *WReward) RewardIds(req *pb.RewardIdsReq, res *pb.RewardIdsRes) (err error) {
	defer s.checkErr()
	m := s.GetDao().Reward
	var cond = []gen.Condition{
		m.ProjectID.Eq(req.GetProjectId()),
	}

	if req.GetRewardTitle() != "" {
		cond = append(cond, m.RewardTitle.Like(utils.DbAllLike(req.GetRewardTitle())))
	}

	var ids []int64
	err = m.WithContext(s.ctx).Where(cond...).Pluck(m.ID, &ids)
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}
	*res = pb.RewardIdsRes{
		Ids: ids,
	}
	return
}