go_dreamfactory/modules/task/api_receive.go

package task

import (
	"go_dreamfactory/comm"
	"go_dreamfactory/lego/sys/log"
	"go_dreamfactory/pb"
	cfg "go_dreamfactory/sys/configure/structs"
)

//任务奖励领取

func (this *apiComp) ReceiveCheck(session comm.IUserSession, req *pb.TaskReceiveReq) (code pb.ErrorCode) {
	if req.Id == 0 {
		code = pb.ErrorCode_TaskIdEmpty
	} else if req.TaskTag == 0 {
		code = pb.ErrorCode_TaskTagEmpty
	}
	return
}

func (this *apiComp) Receive(session comm.IUserSession, req *pb.TaskReceiveReq) (code pb.ErrorCode, data *pb.ErrorData) {
	if code = this.ReceiveCheck(session, req); code != pb.ErrorCode_Success {
		return
	}
	uid := session.GetUserId()
	// 获取待领取的任务
	userTask := this.moduleTask.modelTask.getUserTask(uid, req.Id)

	if userTask == nil {
		code = pb.ErrorCode_TaskNotFound
		return
	}

	var taskDataList []*pb.TaskData

	switch req.TaskTag {
	case int32(comm.TASK_DAILY):
		taskDataList = userTask.DayList
	case int32(comm.TASK_WEEKLY):
		taskDataList = userTask.WeekList
	case int32(comm.TASK_ACHIEVE):
		taskDataList = userTask.AchieveList
	}

	resp := &pb.TaskReceiveResp{}
	var taskData *pb.TaskData
	for _, v := range taskDataList {
		if v.TaskId == req.Id {
			taskData = v
		}
	}

	//判断是否完成
	if taskData.Status == 0 {
		code = pb.ErrorCode_TaskNoFinished
		return
	}
	//判断任务是否领取
	if taskData.Received == 1 {
		code = pb.ErrorCode_TaskReceived
		return
	}

	// 待领取的任务配置
	conf := this.moduleTask.configure.getTaskById(taskData.TaskId)
	if conf == nil {
		code = pb.ErrorCode_ConfigNoFound
		return
	}

	// 更新活跃度
	if conf.Active > 0 {
		//更新活跃度
		ue, err := this.moduleTask.ModuleUser.GetUserExpand(session.GetUserId())
		if err != nil {
			code = pb.ErrorCode_DBError
			return
		}
		update := make(map[string]interface{})
		if ue != nil {
			if comm.TaskTag(req.TaskTag) == comm.TASK_DAILY {
				ue.Activeday = ue.Activeday + conf.Active
				update["activeday"] = ue.Activeday
			}
			if comm.TaskTag(req.TaskTag) == comm.TASK_WEEKLY {
				ue.Activeweek = ue.Activeweek + conf.Active
				update["activeweek"] = ue.Activeweek
			}
			// 周任务 自动领取奖励
			if comm.TaskTag(req.TaskTag) == comm.TASK_WEEKLY {
				TaskActive := make(map[string]interface{})
				activeList := this.moduleTask.modelTaskActive.getActiveList(uid)
				var rewards []*cfg.Gameatn
				var maxTaskId int32
				for _, v := range activeList {
					if v.Received != 1 {
						conf := this.moduleTask.configure.getTaskActiveById(v.TaskId)
						if conf == nil {
							code = pb.ErrorCode_ConfigNoFound
							return
						}
						if ue.Activeweek < conf.Active {
							continue
						}
						v.Received = 1
						rewards = append(rewards, conf.Reword...)
					}

					maxTaskId = v.TaskId

				}

				if len(rewards) > 0 {
					TaskActive["activityList"] = activeList

					if err := this.moduleTask.modelTaskActive.Change(session.GetUserId(), TaskActive); err != nil {
						this.moduleTask.Errorf("updateReceive err %v", err)
						code = pb.ErrorCode_DBError
						return
					}
					//派发奖励
					if code = this.moduleTask.DispenseRes(session, rewards, true); code != pb.ErrorCode_Success {
						this.moduleTask.Error("活跃度奖励",
							log.Field{Key: "uid", Value: uid},
							log.Field{Key: "rewards", Value: rewards},
							log.Field{Key: "code", Value: code},
						)
					}
					err := session.SendMsg(string(this.moduleTask.GetType()), "activereceive", &pb.TaskActiveReceivePush{
						TaskTag: int32(comm.TASK_WEEKLY),
						Id:      maxTaskId,
					})
					if err != nil {
						code = pb.ErrorCode_SystemError
						return
					}
				}
			}
		}

		if len(update) > 0 {
			if err = this.moduleTask.ModuleUser.ChangeUserExpand(session.GetUserId(), update); err != nil {
				code = pb.ErrorCode_DBError
				return
			}
		}
	}

	//奖励
	if code = this.moduleTask.DispenseRes(session, conf.Reword, true); code != pb.ErrorCode_Success {
		this.moduleTask.Error("发送奖励",
			log.Field{Key: "uid", Value: uid},
			log.Field{Key: "rewards", Value: conf.Reword},
			log.Field{Key: "code", Value: code},
		)
		return
	}

	//更新用户领取状态
	for _, v := range taskDataList {
		if v.TaskId == req.Id {
			v.Received = 1
			break
		}
	}
	update := map[string]interface{}{}
	switch req.TaskTag {
	case int32(comm.TASK_DAILY):
		update["dayList"] = taskDataList
	case int32(comm.TASK_WEEKLY):
		update["weekList"] = taskDataList
	case int32(comm.TASK_ACHIEVE):
		update["achieveList"] = taskDataList
	}

	if err := this.moduleTask.modelTask.Change(session.GetUserId(), update); err != nil {
		code = pb.ErrorCode_DBError
		return
	}
	resp.TaskId = taskData.TaskId

	err := session.SendMsg(string(this.moduleTask.GetType()), TaskSubTypeReceive, resp)
	if err != nil {
		code = pb.ErrorCode_SystemError
		return
	}

	return
}