xpggame/modules/web/handler/task.go

package handler

import (
	"github.com/gin-gonic/gin"
	"github.com/liangdas/mqant/log"
	"server/call"
	"server/common"
	"server/db"
	"server/modules/web/app"
	"server/modules/web/values"
	"time"
)

// Record 领奖进度,key为taskid,value为任务进度,小与0时表示已领取
type TaskInfoResp struct {
	TaskList []*values.OneTask
}

func GetTaskInfo(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.Response()
	}()
	a.GetUID()
	resp := &TaskInfoResp{TaskList: GetUserTaskStatus(a)}
	a.Data = resp
	num := 0
	for _, task := range resp.TaskList {
		if task.Status == 1 {
			//log.Debug("uid:%d task:%+v", a.UID, *task)
			num++
		}
	}
	//if num > 0 {
	//	call.PushRed(a.UID, pb.RedPointModule_RedPointTaskDraw, uint32(num))
	//}
}

type DrawTaskReq struct {
	TaskID int
}

type DrawTaskResp struct {
	TaskID int
	Award  int64
}

func TaskComplete(a *app.Gin, req *DrawTaskReq) (reward int64) {
	if !db.Redis().Lock(common.GetRedisKeyTask(a.UID)) {
		a.Code = values.CodeRetry
		return
	}
	defer func() {
		db.Redis().UnLock(common.GetRedisKeyTask(a.UID))
	}()
	con := call.GetConfigTaskByTaskID(req.TaskID)
	if con == nil {
		a.Code = values.CodeRetry
		return
	}
	task, err := call.GetUserTaskDataByTaskID(a.UID, req.TaskID)
	if err != nil {
		log.Error("get task data err, %s ", err.Error())
		a.Code = values.CodeRetry
		return
	}
	if task.ID == 0 {
		a.Code = values.CodeRetry
		return
	}
	if task.TaskValue < int(con.Target) {
		a.Code = values.CodeParam
		a.Msg = "Task not complete."
		return
	}
	err = db.Mysql().Update(&common.TaskData{ID: task.ID}, map[string]interface{}{
		"task_status": 2,
		"updated_at":  time.Now(),
	})
	if err != nil {
		log.Error("update task status err, %s", err.Error())
		a.Code = values.CodeRetry
		return
	}
	reward = con.Reward
	if reward == 0 {
		return
	}
	_, err = call.UpdateCurrencyPro(&common.UpdateCurrency{
		CurrencyBalance: &common.CurrencyBalance{
			UID:     a.UID,
			Value:   reward,
			Event:   common.CurrencyEventTask,
			Type:    common.CurrencyINR,
			Exi1:    req.TaskID,
			NeedBet: call.GetConfigCurrencyResourceNeedBet(common.CurrencyResourceBonus, con.Reward),
		},
	})
	if err != nil {
		a.Code = values.CodeRetry
		return
	}
	return
}

func DrawTask(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.Response()
	}()
	req := &DrawTaskReq{}
	if !a.S(req) {
		return
	}
	resp := &DrawTaskResp{
		TaskID: req.TaskID,
		Award:  TaskComplete(a, req),
	}
	a.Data = resp
}

type JoinChannelReq struct {
}

func JoinChannel(c *gin.Context) {
	a := app.NewApp(c)
	defer func() {
		a.Response()
	}()
	req := &JoinChannelReq{}
	if !a.S(req) {
		return
	}
	uid := a.UID
	call.CheckTask(call.Task{
		Uid:   uid,
		Value: 1,
		Types: []common.TaskType{common.TaskTypeJoinChannel},
	})
}