go_dreamfactory/modules/task/model_task.go

package task

import (
	"fmt"
	"go_dreamfactory/comm"
	"go_dreamfactory/lego/core"
	"go_dreamfactory/lego/sys/log"
	"go_dreamfactory/modules"
	"go_dreamfactory/pb"
	cfg "go_dreamfactory/sys/configure/structs"

	"go.mongodb.org/mongo-driver/bson/primitive"
)

const ( //Redis
	TableTask core.SqlTable = "task" //每日任务表
)

type ModelTask struct {
	modules.MCompModel
	moduleTask *ModuleTask
}

func (this *ModelTask) Init(service core.IService, module core.IModule, comp core.IModuleComp, options core.IModuleOptions) (err error) {
	err = this.MCompModel.Init(service, module, comp, options)
	this.moduleTask = module.(*ModuleTask)
	this.TableName = string(TableTask)
	return
}

func swapKey(uid string, tag comm.TaskTag) string {
	return fmt.Sprintf("%s_%v", uid, tag)
}

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

//初始化任务
func (this *ModelTask) initTaskByTag(uid string, taskTag comm.TaskTag) error {
	taskList := this.getTaskList(uid, taskTag)
	if len(taskList) > 0 {
		return fmt.Errorf("clear data before init task")
	}
	if data, err := this.moduleTask.configure.getTaskByTag(int32(taskTag)); err == nil {
		for _, cnf := range data {
			objId := primitive.NewObjectID().Hex()
			task := &pb.DBTask{
				Id:       objId,
				Uid:      uid,
				TaskId:   cnf.Key,
				Active:   cnf.Active,
				Progress: cnf.ConditionSecond,
			}
			if err := this.AddList(swapKey(uid, taskTag), task.Id, task); err != nil {
				log.Errorf("initTaskByTag addlists err %v", err)
				return err
			}
		}
	}
	return nil
}

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

//获取未完成的任务列表
func (this *ModelTask) getUnFinishTaskList(uid string, taskTag comm.TaskTag) (list []*pb.DBTask) {
	taskList := this.getTaskList(uid, taskTag)
	for _, v := range taskList {
		if v.Status == 0 {
			list = append(list, v)
		}
	}
	return
}

//活跃度统计
func (this *ModelTask) countActive(uid string, taskTag comm.TaskTag) (total int32) {
	taskList := this.getTaskList(uid, taskTag)
	for _, v := range taskList {
		if v.Status == 1 {
			total += v.Active
		}
	}
	return
}

//检查任务进度  返回未完成的
func (this *ModelTask) checkTaskProgress(uid string, config *cfg.Game_taskRoundData) (*pb.DBTask, bool) {
	taskList := this.getUnFinishTaskList(uid, comm.TaskTag(config.IdTag))
	for _, v := range taskList {
		if config.Key == v.TaskId && v.Status == 0 {
			return v, true
		}
	}

	return nil, false
}

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

//任务处理
func (this *ModelTask) taskHandle(uid string, taskType comm.TaskType, taskParam *pb.TaskParam) error {
	//查询当前用户未完成的任务列表
	data, err := this.moduleTask.configure.getTasks(int32(taskType))
	if err != nil {
		log.Errorf("taskHandle err %v", err)
		return err
	}

	for _, conf := range data {
		//不满足限定条件
		if taskParam.First != conf.ConditionCondition {
			continue
		}
		//检查进度，完成了执行处理器
		if v, ok := this.checkTaskProgress(uid, conf); ok {
			if err := this.finishHandle(v, comm.TaskTag(conf.IdTag), conf); err != nil {
				return err
			}

		}
	}
	return nil
}

//任务完成处理
func (this *ModelTask) finishHandle(userTask *pb.DBTask, taskTag comm.TaskTag, config *cfg.Game_taskRoundData) error {
	if userTask.Progress-1 < 0 {
		return fmt.Errorf("uid %s task[%s] was finished", userTask.Uid, userTask.Id)
	}
	//修改玩家任务状态和进度
	update := map[string]interface{}{
		"progress": userTask.Progress - 1,
	}
	if userTask.Progress-1 == 0 {
		update["status"] = 1
	}

	if err := this.modifyUserTask(userTask.Uid, taskTag, userTask.Id, update); err != nil {
		log.Errorf("err %v", err)
		return err
	}

	return nil
}

//清空任务
func (this *ModelTask) clearTask(uid string, taskTag comm.TaskTag) error {
	taskList := this.getTaskList(uid, taskTag)
	for _, v := range taskList {
		if err := this.moduleTask.modelTask.DelListlds(swapKey(uid, taskTag), v.Id); err != nil {
			log.Errorf("uid: %v taskTag:%v err:%v", uid, taskTag, err)
			return err
		}
	}
	return nil
}