go_dreamfactory/modules/dailytask/module.go

package dailytask

import (
	"go_dreamfactory/comm"
	"go_dreamfactory/lego/core"
	"go_dreamfactory/lego/sys/event"
	"go_dreamfactory/lego/sys/log"
	"go_dreamfactory/modules"
	"go_dreamfactory/pb"
	"go_dreamfactory/sys/configure"
	"go_dreamfactory/sys/db"
	"go_dreamfactory/utils"
)

type Dailytask struct {
	modules.ModuleBase
	service        core.IService
	wtask          comm.IWtask
	api            *apiComp
	configure      *configureComp
	modelDailytask *ModelDailytask
}

func NewModule() core.IModule {
	return &Dailytask{}
}

func (this *Dailytask) GetType() core.M_Modules {
	return comm.ModuleDailytask
}

func (this *Dailytask) Init(service core.IService, module core.IModule, options core.IModuleOptions) (err error) {
	if err = this.ModuleBase.Init(service, module, options); err != nil {
		return
	}
	this.service = service
	return
}

func (this *Dailytask) Start() (err error) {
	if err = this.ModuleBase.Start(); err != nil {
		return
	}
	var module core.IModule
	if module, err = this.service.GetModule(comm.ModuleWtask); err != nil {
		return
	}
	this.wtask = module.(comm.IWtask)
	event.Register(comm.EventUserLogin, this.EventUserLogin)
	return
}

func (this *Dailytask) OnInstallComp() {
	this.ModuleBase.OnInstallComp()
	this.api = this.RegisterComp(new(apiComp)).(*apiComp)
	this.modelDailytask = this.RegisterComp(new(ModelDailytask)).(*ModelDailytask)
	this.configure = this.RegisterComp(new(configureComp)).(*configureComp)

}

// 用户登录
func (this *Dailytask) EventUserLogin(session comm.IUserSession) {
	var (
		isopen bool
	)

	if db.IsCross() { //跨服不支持
		return
	}

	if isopen, _ = this.ModuleSys.CheckOpenCondCfgById(session.GetUserId(), "annulartask"); !isopen {
		return
	}
	this.refreshtask(session)
}

// 任务组完成
func (this *Dailytask) TaskGroupComplete(session comm.IUserSession, group int32) {
	var (
		dtask *pb.DBDailytask
		err   error
	)
	if dtask, err = this.modelDailytask.getUserDTasks(session.GetUserId()); err != nil {
		this.Errorln(err)
		return
	}
	for _, v := range dtask.Groups {
		if v.Group == group {
			v.Complete = true
			if err = this.modelDailytask.Change(session.GetUserId(), map[string]interface{}{
				"groups": dtask.Groups,
			}); err != nil {
				this.Errorln(err)
				return
			}
			break
		}
	}
}

// 功能是否开启
func (this *Dailytask) OpenCmdNotice(session comm.IUserSession, keys ...string) {
	for _, v := range keys {
		if v == "annulartask" { //日常功能开启
			this.refreshtask(session)
		}
	}
}

// 查询每日红点信息
func (this *Dailytask) Reddot(session comm.IUserSession, rid ...comm.ReddotType) (reddot map[comm.ReddotType]*pb.ReddotItem) {
	var (
		dtask    *pb.DBDailytask
		progress int32
		err      error
	)
	reddot = make(map[comm.ReddotType]*pb.ReddotItem)
	if dtask, err = this.modelDailytask.getUserDTasks(session.GetUserId()); err != nil {
		this.Errorln(err)
		return
	}
	for _, v := range rid {
		switch v {
		case comm.Reddot25101:
			for _, v := range dtask.Groups {
				if v.Complete {
					progress++
				}
			}
			reddot[comm.Reddot25101] = &pb.ReddotItem{
				Rid:       int32(comm.Reddot25101),
				Activated: true,
				Progress:  progress,
				Total:     int32(len(dtask.Groups)),
			}
			break
		}
	}
	return
}

func (this *Dailytask) refreshtask(session comm.IUserSession) {
	var (
		dtask   *pb.DBDailytask
		user    *pb.DBUser
		errdata *pb.ErrorData
		key     int32
		group   []int32
		tasks   map[int32][]int32
		err     error
	)
	if dtask, err = this.modelDailytask.getUserDTasks(session.GetUserId()); err != nil {
		this.Errorln(err)
		return
	}

	if !utils.IsToday(dtask.Rtime) { //不是同一天 重置
		if user, err = this.ModuleUser.GetUser(session.GetUserId()); err != nil {
			this.Error("no found user", log.Field{Key: "uid", Value: session.GetUserId()})
			return
		}
		if key, group, err = this.modelDailytask.resetUserDTasks(user.Lv); err != nil {
			this.Errorln(err)
			return
		}
		if tasks, errdata = this.wtask.ResetDailytaskTask(session, key, group...); errdata != nil {
			this.Errorln(errdata)
			return
		}
		dtask.Key = key
		dtask.Groups = make([]*pb.DBDailytaskGroup, 0)
		for k, v := range tasks {
			dtask.Groups = append(dtask.Groups, &pb.DBDailytaskGroup{
				Group: k,
				Tasks: v,
			})
		}
		dtask.Rtime = configure.Now().Unix()
		if err = this.modelDailytask.Change(session.GetUserId(), map[string]interface{}{
			"key":    dtask.Key,
			"groups": dtask.Groups,
			"rtime":  dtask.Rtime,
		}); err != nil {
			this.Errorln(err)
			return
		}
	}
}