joybuywork/internal/service/queue/consumer/campaignnotice/validevents/grow.go

package validevents

import (
	"joybuywork/internal/repository/dbcheck"
	"joybuywork/internal/repository/model"
	"joybuywork/internal/repository/mtype"
	"joybuywork/internal/repository/withdefault"
	"joybuywork/internal/service/cmm"
	"joybuywork/internal/utils/timez"
	"joybuywork/proto/go_proto/workerr"
	"fmt"
	"time"

	"gorm.io/gen/field"
)

type grow struct {
	base
}

func (s *grow) Event(user *model.FissionUser) (targetNum int32, setHelp bool, err error) {
	fc := cmm.NewFirstCreate(s.Ctx, s.GetDao())
	player, err := fc.FissionGrow(user)
	if err != nil {
		return
	}

	data, err := s._event(user)
	if err != nil {
		return
	}

	targetNum = data.targetNum

	playerM := s.GetDao().FissionGrow
	var upData []field.AssignExpr
	for mark, num := range data.props {
		switch mark {
		case mtype.FissionCampaignTaskPropMarkChance:
			upData = append(upData, playerM.GrowNum.Add(num), playerM.TaskNum.Add(num))
		}
	}

	if len(upData) > 0 {
		_, err = playerM.WithContext(s.Ctx).Where(playerM.ID.Eq(player.ID)).UpdateSimple(upData...)
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}
	}

	return
}

func (s *grow) Register(helper, beHelper *model.FissionUser) (setHelp bool, err error) {
	tasks, setHelp, err := s._getRegisterTasks(helper.CampaignID)
	if err != nil || len(tasks) == 0 {
		return
	}

	err = s._fixTaskDo(beHelper, helper, tasks)
	if err != nil {
		return
	}

	return
}

func (s *grow) Install(helper, beHelper *model.FissionUser) (setHelp bool, err error) {
	tasks, setHelp, err := s._getInstallTasks(helper.CampaignID)
	if err != nil || len(tasks) == 0 {
		return
	}

	err = s._fixTaskDo(beHelper, helper, tasks)
	if err != nil {
		return
	}

	return
}

// 用户固定事件任务
func (s *grow) _fixTaskDo(user, helper *model.FissionUser, tasks []*model.FissionCampaignTask) (err error) {
	fc := cmm.NewFirstCreate(s.Ctx, s.GetDao())
	player, err := fc.FissionGrow(user)
	if err != nil {
		return
	}

	for _, task := range tasks {
		switch task.PropMark {
		case mtype.FissionCampaignTaskPropMarkChance:
			err = s._taskEffectDo(user, task, s._addGrow(player.ID, task.Chance))
			if err != nil {
				return
			}
		case mtype.FissionCampaignTaskPropMarkRevive:
			//判断是否需要复活
			err = s._revive(user, helper, task)
			if err != nil {
				return
			}
		}
	}

	return
}

// 复活
func (s *grow) _revive(user, helper *model.FissionUser, task *model.FissionCampaignTask) (err error) {
	//判断是否死亡
	lifeM := s.GetDao().FissionGrowLife
	life, err := lifeM.WithContext(s.Ctx).Where(
		lifeM.IsGrow.Eq(mtype.Yes),
		lifeM.UserID.Eq(user.ID),
		lifeM.CampaignID.Eq(user.CampaignID),
	).Take()
	if err = dbcheck.DbError(err); err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	if life == nil {
		return
	}

	// 对应时区的时间
	now, dieTime := timez.GMTTime(s.tOffset), timez.GMTTime(s.tOffset, life.DieTime)
	if dieTime.After(now) { // 没有死
		return
	}

	// 不是死亡状态要修改成死亡状态
	if life.IsDie == mtype.No {
		err = cmm.NewCMM(s.Ctx, s.GetDao()).LifeStatus(life, true, 0)
		if err != nil {
			return
		}
	}

	//死亡，判断是否复活
	//死亡之后邀请的历史人数，当前
	m := s.GetDao().FissionUserTaskValid

	valid := withdefault.FissionUserTaskValid(&model.FissionUserTaskValid{
		CampaignID: user.CampaignID,
		UserID:     user.ID,
		TaskID:     task.ID,
	})
	valid.SetIdeq(mtype.FissionCampaignTaskPropMarkRevive, fmt.Sprint(helper.ID))

	has, err := m.WithContext(s.Ctx).Where(m.Ideq.Eq(valid.Ideq)).Count()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	if has == 0 {
		if err = m.WithContext(s.Ctx).Create(valid); err != nil {
			err = s.BE().MysqlError(err)
			return
		}
	}

	num, err := m.WithContext(s.Ctx).Where(
		m.CampaignID.Eq(user.CampaignID),
		m.UserID.Eq(user.ID),
		m.TaskID.Eq(task.ID),
		m.CreatedAt.Gt(life.DieTime),
	).Count()
	if err != nil {
		return
	}

	if num < int64(task.Num) { // 不能完成复活
		return
	}

	//邀请到足够的人复活
	indicatorData := &mtype.IndicatorData{
		InstallNum: num,
	}

	confM := s.GetDao().FissionCampaignGrow
	conf, err := confM.WithContext(s.Ctx).Where(confM.CampaignID.Eq(user.CampaignID)).Take()
	if err = dbcheck.DbError(err); err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	if conf == nil {
		return workerr.NotFound("conf not found")
	}

	err = cmm.NewCMM(s.Ctx, s.GetDao()).LifeStatus(life, true, 0)
	if err != nil {
		return
	}

	_, err = lifeM.WithContext(s.Ctx).Where(lifeM.ID.Eq(life.ID)).UpdateSimple(
		lifeM.IsDie.Value(mtype.No),
		lifeM.DieTime.Value(now.Add(time.Duration(conf.DieHour)*time.Hour).Unix()),
	)
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	err = s._taskRecord(user, task, indicatorData, mtype.No)
	if err != nil {
		return
	}
	return
}

// 增加养料
func (s *grow) _addGrow(playerId int64, chance int32) taskEffectDo {
	return func() (err error) {
		playerM := s.GetDao().FissionGrow
		_, err = playerM.WithContext(s.Ctx).Where(playerM.ID.Eq(playerId)).UpdateSimple(
			playerM.GrowNum.Add(chance),
			playerM.TaskNum.Add(chance),
		)
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}
		return
	}
}