go_dreamfactory/modules/task/model_task.go

package task

import (
	"fmt"
	"go_dreamfactory/comm"
	"go_dreamfactory/lego/core"
	event_v2 "go_dreamfactory/lego/sys/event/v2"
	"go_dreamfactory/lego/sys/log"
	"go_dreamfactory/modules"
	"go_dreamfactory/pb"
	"sort"

	"github.com/pkg/errors"
	"go.mongodb.org/mongo-driver/bson/primitive"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/x/bsonx"
)

type ModelTask struct {
	modules.MCompModel
	moduleTask *ModuleTask
	EventApp   *event_v2.App
}

func (this *ModelTask) Init(service core.IService, module core.IModule, comp core.IModuleComp, options core.IModuleOptions) (err error) {
	this.TableName = comm.TableTask
	err = this.MCompModel.Init(service, module, comp, options)
	this.moduleTask = module.(*ModuleTask)
	this.EventApp = event_v2.NewApp()
	this.EventApp.Listen(comm.EventTaskChanged, this.doTaskHandle)
	this.DB.CreateIndex(core.SqlTable(this.TableName), mongo.IndexModel{
		Keys: bsonx.Doc{{Key: "uid", Value: bsonx.Int32(1)}},
	})
	return
}

// 查询完成的且未领取的任务 发现未领取返回true
func (this *ModelTask) noReceiveTask(uid string, taskTag comm.TaskTag) (bool, error) {
	list := []*pb.DBTask{}
	if err := this.GetList(uid, &list); err != nil {
		this.moduleTask.Errorf("getTaskList err %v", err)
		return false, err
	}
	for _, v := range list {
		if v.Tag == int32(taskTag) && v.Status == 1 && v.Received == 0 {
			return true, nil
		}
	}
	return false, nil
}

//获取玩家任务列表
func (this *ModelTask) getTaskListByTag(uid string, taskTag comm.TaskTag) (newlist []*pb.DBTask) {
	list := []*pb.DBTask{}
	if err := this.GetList(uid, &list); err != nil {
		this.moduleTask.Errorf("getTaskList err %v", err)
		return
	}

	// 排序
	sort.SliceStable(list, func(i, j int) bool {
		return list[i].Sort < list[j].Sort
	})

	dr := this.moduleTask.ModuleRtask.GetCondiData(uid)
	if dr == nil {
		return
	}

	// 筛选出指定tag的任务
	var taskList []*pb.DBTask
	for _, v := range list {
		if v.Tag == int32(taskTag) {
			if p, ok := dr.Vals[v.TypeId]; ok {
				if len(p.Data) > 0 {
					v.Progress = p.Data[0]
				}
			}
			taskList = append(taskList, v)
		}
	}

	// 当前玩家任务
	getCurTask := func(taskId int32) *pb.DBTask {
		for _, v := range list {
			if v.TaskId == taskId {
				return v
			}
		}
		return nil
	}

	// 判断上个成就任务领取了才显示最后一个任务
	isReceived := func(taskId int32) bool {
		if preCnf := this.moduleTask.configure.getPreTask(taskId); preCnf != nil {
			if preTask := getCurTask(preCnf.Key); preTask != nil {
				if preTask.Received == 1 {
					return true
				}
			}
		}
		return false
	}

	// 成就列表
	if taskTag == comm.TASK_ACHIEVE {
		for _, v := range taskList {
			if curTask := this.moduleTask.configure.getTaskById(v.TaskId); curTask != nil {
				if v.Received == 0 {
					isFirst := this.moduleTask.configure.isFirstTask(curTask.Key)
					if curTask.IdAfter == 0 && isFirst { //未领取和没有下个连续任务的
						newlist = append(newlist, v)
						continue
					}

					if isFirst && curTask.IdAfter != 0 { //连续任务的第一个任务
						next := this.moduleTask.configure.getTaskById(curTask.IdAfter)
						if next != nil && v.Received == 0 {
							newlist = append(newlist, v)
						}
					} else {
						if isReceived(curTask.Key) {
							newlist = append(newlist, v)
						}
						// else {
						// 	break
						// }
					}
				}
			}
		}
	} else {
		newlist = taskList
	}
	return
}

// 获取用户任务
func (this *ModelTask) getTaskById(uid string, taskId int32) (newlist []*pb.DBTask) {
	list := []*pb.DBTask{}
	if err := this.GetList(uid, &list); err != nil {
		this.moduleTask.Errorf("getTaskById err %v", err)
		return
	}

	for _, v := range list {
		if v.TaskId == taskId {
			newlist = append(newlist, v)
		}
	}
	return
}

//初始化任务
func (this *ModelTask) initTask(uid string, taskTag comm.TaskTag) error {
	data := this.moduleTask.configure.getTaskByTag(int32(taskTag))
	for _, cnf := range data {
		objId := primitive.NewObjectID().Hex()
		task := &pb.DBTask{
			Id:     objId,
			Tag:    cnf.IdTag,
			Uid:    uid,
			TypeId: cnf.TypeId,
			TaskId: cnf.Key,
			Active: cnf.Active,
			Sort:   cnf.IdList,
		}
		if err := this.AddList(uid, task.Id, task); err != nil {
			this.moduleTask.Errorf("initTask addlists err %v", err)
			return err
		}
	}

	return nil
}

//查询用户任务
func (this *ModelTask) getUserTask(uid string, taskId string) *pb.DBTask {
	userTask := &pb.DBTask{}
	if err := this.moduleTask.modelTask.GetListObj(uid, taskId, userTask); err != nil {
		this.moduleTask.Errorf("getUserTask err:%v", err)
		return nil
	}
	return userTask
}

// 获取已完成的任务
func (this *ModelTask) getFinishTasks(uid string, taskTag comm.TaskTag) (list []*pb.DBTask) {
	taskList := this.getTaskListByTag(uid, taskTag)
	for _, v := range taskList {
		if v.Status == 1 {
			list = append(list, v)
		}
	}
	return
}

// 获取待处理的任务
func (this *ModelTask) getUnFinishTasks(uid string, taskId int32) (list []*pb.DBTask) {
	taskList := this.getTaskById(uid, taskId)
	for _, v := range taskList {
		if v.Status == 0 {
			list = append(list, v)
		}
	}
	return
}

//检查任务状态 返回等待处理的任务
func (this *ModelTask) checkTask(uid string, taskId int32) (*pb.DBTask, bool) {
	taskList := this.getUnFinishTasks(uid, taskId)
	for _, v := range taskList {
		if taskId == v.TaskId && v.Status == 0 {
			return v, true
		}
	}
	return nil, false
}

//更改用户任务
func (this *ModelTask) modifyUserTask(uid string, taskId string, data map[string]interface{}) error {
	if err := this.ChangeList(uid, taskId, data); err != nil {
		this.moduleTask.Errorf("err %v", err)
		return err
	}
	return nil
}

//清空任务
func (this *ModelTask) clearTask(uid string, taskTag ...comm.TaskTag) {
	if len(taskTag) == 0 {
		this.moduleTask.Error("TaskTag参数缺失", log.Fields{"uid": uid, "params": taskTag})
		return
	}
	taskList := this.getTaskListByTag(uid, taskTag[0])
	dr := this.moduleTask.ModuleRtask.GetCondiData(uid)
	for _, v := range taskList {
		if err := this.moduleTask.modelTask.DelListlds(uid, v.Id); err != nil {
			this.moduleTask.Error("清除任务", log.Fields{"uid": uid, "taskId": v.Id})
			return
		}
		//删除任务条件数据
		if dr != nil && dr.Vals != nil {
			delete(dr.Vals, v.TypeId)
		}
	}
	if err := this.moduleTask.ModuleRtask.ChangeCondi(uid, dr.Vals); err != nil {
		this.moduleTask.Error("更新任务条件数据", log.Fields{"uid": uid})
	}
}

//进入卡牌攻略
// Deprecated
func (this *ModelTask) inStrategy(uid string, heroCfgId int32) (taskIds []int32, err error) {
	//检查此英雄攻略是否完成
	taskList := this.getTaskListByTag(uid, comm.TASK_STRATEGY)
	allFinished := true
	for _, v := range taskList {
		conf := this.moduleTask.configure.getTaskById(v.TaskId)
		if conf != nil {
			// if conf.RestrictiveCondition == heroCfgId && v.Status != 1 {
			// 	allFinished = false
			// 	break
			// }
		}
	}

	if !allFinished {
		//重置状态
		for _, v := range taskList {
			if v.Status != 0 {
				update := map[string]interface{}{
					"status": 0,
				}
				if err = this.modifyUserTask(uid, v.Id, update); err != nil {
					this.moduleTask.Errorf("doStrategy err %v", err)
					break
				}
			}
			taskIds = append(taskIds, v.TaskId)
		}
	}

	return
}

// 任务处理
func (this *ModelTask) doTaskHandle(event interface{}, next func(event interface{})) {
	tl := event.(*TaskListen)

	data, err := this.moduleTask.configure.getTasks(int32(tl.TaskType))
	if err != nil {
		this.moduleTask.Errorf("taskHandle err %v", err)
		return
	}

	// 获取玩家的任务条件数据
	dr := this.moduleTask.ModuleRtask.GetCondiData(tl.Uid)
	if dr == nil {
		return
	}

	// 遍历事件列表
	for _, conf := range data {
		// 从任务条件中查找
		ret, ok := dr.Vals[conf.TypeId]
		if !ok {
			continue
		}

		task, ok := this.checkTask(tl.Uid, conf.Key)
		if !ok {
			this.moduleTask.Debug("任务已完成", log.Fields{"uid": tl.Uid, "任务ID": conf.Key})
			continue
		}

		var (
			progress int32
			update   map[string]interface{}
		)
		if code := this.moduleTask.ModuleRtask.CheckCondi(tl.Uid, conf.TypeId); code == pb.ErrorCode_Success {
			// update data
			if ret != nil && len(ret.Data) > 0 {
				progress = ret.Data[0]
			}
			update = map[string]interface{}{
				"progress": progress,
				"status":   1,
			}
			// err = this.updateActive(tl.Uid, conf.Key)
		} else {
			if ret != nil && len(ret.Data) > 0 {
				progress = ret.Data[0]
			}
			update = map[string]interface{}{
				"progress": progress,
			}
		}
		if err = this.modifyUserTask(tl.Uid, task.Id, update); err != nil {
			return
		}
		this.moduleTask.Debug("更新任务",
			log.Fields{"uid": tl.Uid, "任务ID": conf.Key, "事件ID": conf.TypeId, "progress": update["progress"], "status": update["status"]},
		)
	}
	return
}

// 更新活跃度
func (this *ModelTask) updateActive(uid string, cfgId int32) error {
	// 更新活跃度
	de, err := this.moduleTask.ModuleUser.GetUserExpand(uid)
	if err != nil {
		return err
	}

	conf := this.moduleTask.configure.getTaskById(cfgId)
	if conf == nil {
		return errors.New(fmt.Sprintf("%v config nil", cfgId))
	}

	switch conf.IdTag {
	case int32(comm.TASK_DAILY):
		de.Activeday += conf.Active
	case int32(comm.TASK_WEEKLY):
		de.Activeweek += conf.Active
	}

	update := map[string]interface{}{
		"activeday":  de.Activeday,
		"activeweek": de.Activeweek,
	}

	return this.moduleTask.ModuleUser.ChangeUserExpand(uid, update)
}

type TaskListen struct {
	event_v2.Event
	Uid      string
	TaskType comm.TaskType
}