go_dreamfactory/modules/privilege/module.go

package privilege

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

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

func NewModule() core.IModule {
	m := new(Privilege)
	return m
}

type Privilege struct {
	modules.ModuleBase
	api_comp       *apiComp
	configure      *configureComp
	modelPrivilege *ModelPrivilege
	mail           comm.Imail
	service        core.IService
}

//模块名
func (this *Privilege) GetType() core.M_Modules {
	return comm.ModulePrivilege
}

//模块初始化接口 注册用户创建角色事件
func (this *Privilege) Init(service core.IService, module core.IModule, options core.IModuleOptions) (err error) {
	err = this.ModuleBase.Init(service, module, options)
	this.service = service
	return
}

//装备组件
func (this *Privilege) OnInstallComp() {
	this.ModuleBase.OnInstallComp()
	this.api_comp = this.RegisterComp(new(apiComp)).(*apiComp)
	this.modelPrivilege = this.RegisterComp(new(ModelPrivilege)).(*ModelPrivilege)
	this.configure = this.RegisterComp(new(configureComp)).(*configureComp)
}

func (this *Privilege) Start() (err error) {
	var module core.IModule
	if module, err = this.service.GetModule(comm.ModuleMail); err != nil {
		return
	}
	this.mail = module.(comm.Imail)
	err = this.ModuleBase.Start()
	event.RegisterGO(comm.EventUserOffline, this.EventUserOffline)
	return
}

//Event------------------------------------------------------------------------------------------------------------
func (this *Privilege) EventUserOffline(session comm.IUserSession) {
	this.modelPrivilege.DelByUId(session.GetUserId(), db.SetDBMgoLog(false))
}

// 购买了一个新的特权
func (this *Privilege) CreatePrivilegeCard(session comm.IUserSession, cId string) (res []*pb.UserAssets, code pb.ErrorCode) {
	var (
		data  *pb.DBPrivilege
		bFind bool
	)
	atn := &pb.UserAssets{
		A: "vip",
		T: "",
		N: 1,
	}

	conf, err := this.configure.GetPrivilegeCard(cId)
	if err != nil {
		code = pb.ErrorCode_ConfigNoFound
		return nil, code
	}
	// 是不是购买过
	list, err := this.modelPrivilege.getPrivilegeList(session.GetUserId())
	if err != nil {
		code = pb.ErrorCode_DBError
		return
	}
	for _, v := range list {
		if v.CId == cId {
			if v.ETime > configure.Now().Unix() { // 加时间
				v.ETime += int64(conf.AssertDay) * 24 * 3600
			} else {
				// 检测能否续费
				if configure.Now().Unix()-v.ETime <= int64(conf.RenewDay)*24*3600 {
					v.ETime = configure.Now().Unix() + int64(conf.AssertDay)*24*3600
				} else {
					code = pb.ErrorCode_PayRenewTimeErr
					return
				}

			}
			if err = this.modelPrivilege.Change(session.GetUserId(), map[string]interface{}{
				"eTime": v.ETime,
			}); err != nil {
				this.Errorf("err:%v", err)
				return
			}
			data = v
			bFind = true
			break
		}
	}
	if !bFind {

		data = &pb.DBPrivilege{
			Id:          primitive.NewObjectID().Hex(),
			Uid:         session.GetUserId(),
			CId:         cId,
			PrivilegeID: []int32{},
			CTime:       configure.Now().Unix(),
			ETime:       0,
			RewardTime:  configure.Now().Unix(),
		}
		data.ETime = configure.Now().Unix() + int64(conf.AssertDay*24*3600) // 设置过期时间
		for _, v := range conf.PrivilegeId {
			data.PrivilegeID = append(data.PrivilegeID, v)
		}
		this.modelPrivilege.addNewPrivilegeData(session.GetUserId(), data)
		this.SendDailyMail(session, cId, 1, conf.PType)
	}

	if code = this.DispenseRes(session, conf.DisposableReward, true); code != pb.ErrorCode_Success {
		return
	}
	atn.T = conf.Id
	res = append(res, atn) // 加资源
	for _, v := range conf.DisposableReward {
		res = append(res, &pb.UserAssets{
			A: v.A,
			T: v.T,
			N: v.N,
		})
	}

	// 推送
	session.SendMsg(string(this.GetType()), PrivilegeGetListResp, &pb.PrivilegeGetListResp{Data: []*pb.DBPrivilege{data}})
	return
}

// 续费特权
func (this *Privilege) RenewPrivilegeCard(session comm.IUserSession, cId string) (res []*pb.UserAssets, code pb.ErrorCode) {

	atn := &pb.UserAssets{
		A: "vip",
		T: "",
		N: 1, // 暂时只支持一次续费一次
	}
	list, err := this.modelPrivilege.getPrivilegeList(session.GetUserId())
	if err != nil {
		return
	}
	for _, v := range list {
		if v.CId == cId {
			conf, err := this.configure.GetPrivilegeCard(cId)
			if err != nil {
				code = pb.ErrorCode_ConfigNoFound
				return nil, code
			}
			if conf.RenewDay >= int32(configure.Now().Unix()-v.ETime)/(24*3600) {
				v.ETime += int64(conf.AssertDay) * 24 * 3600
				mapData := make(map[string]interface{}, 0)
				mapData["eTime"] = v.ETime
				this.modelPrivilege.modifyPrivilegeData(session.GetUserId(), v.Id, mapData)
				// 发放奖励
				if code = this.DispenseRes(session, conf.DisposableReward, true); code != pb.ErrorCode_Success {
					break
				}

				session.SendMsg(string(this.GetType()), PrivilegeGetListResp, &pb.PrivilegeGetListResp{Data: []*pb.DBPrivilege{v}})
				atn.T = conf.Id
				res = append(res, atn) // 加资源
				for _, v := range conf.DisposableReward {
					res = append(res, &pb.UserAssets{
						A: v.A,
						T: v.T,
						N: v.N,
					})
				}

			} else {
				code = pb.ErrorCode_PrivilegeRenewTime
			}
			break
		}
	}
	code = pb.ErrorCode_PrivilegeNotFound

	return
}

// 查询特权特权
func (this *Privilege) CheckPrivilege(session comm.IUserSession, cId string) (privilege *pb.DBPrivilege) {
	list, err := this.modelPrivilege.getPrivilegeList(session.GetUserId())
	if err != nil {
		return
	}
	for _, v := range list {
		if v.CId == cId {
			if v.ETime < configure.Now().Unix() { // 判断当前特权是否过期
				if err := this.modelPrivilege.DelListlds(session.GetUserId(), v.Id); err != nil {
					this.Errorf("delete privilege failed:%v", err)
				}
				privilege = nil
				return
			}
			privilege = v
			return
		}
	}
	return
}

// 查询特权信息,把过期的特权清除掉
func (this *Privilege) QueryPrivilege(session comm.IUserSession) (privilegeID []int32) {
	list, err := this.modelPrivilege.getPrivilegeList(session.GetUserId())
	if err != nil {
		return
	}
	for _, v := range list {
		if v.ETime < configure.Now().Unix() { // 判断当前特权是否过期
			if err := this.modelPrivilege.DelListlds(session.GetUserId(), v.Id); err != nil {
				this.Errorf("delete privilege failed:%v", err)
			}
		} else {
			conf, err := this.configure.GetPrivilegeCard(v.CId)
			if err != nil {
				return nil
			}
			privilegeID = append(privilegeID, v.PrivilegeID...)
			// 检查 每日奖励是否发放
			if !utils.IsToday(v.RewardTime) {
				v.RewardTime = configure.Now().Unix()
				if err = this.modelPrivilege.Change(session.GetUserId(), map[string]interface{}{
					"rewardTime": v.RewardTime,
				}); err != nil {
					this.Errorf("err:%v", err)
					return
				}
				// 检查离上次领奖过去几天
				dt := configure.Now().Unix() - utils.GetZeroTime(v.RewardTime)
				count := dt / (24 * 3600)
				this.SendDailyMail(session, v.CId, int32(count+1), conf.PType)
			}
		}
	}
	return
}

func (this *Privilege) SendDailyMail(session comm.IUserSession, cId string, count int32, pType int32) {
	conf, err := this.configure.GetPrivilegeCard(cId)
	if err != nil {
		return
	}
	var (
		res []*pb.UserAssets
	)
	for _, v := range conf.DayReward {
		res = append(res, &pb.UserAssets{
			A: v.A,
			T: v.T,
			N: v.N,
		})
	}

	// 构建一个每日奖励邮件对象
	mail := &pb.DBMailData{
		ObjId:      "",
		Uid:        session.GetUserId(),
		CreateTime: uint64(configure.Now().Unix()),
		DueTime:    uint64(configure.Now().Unix() + 30*24*3600),
		Check:      false,
		Reward:     false,
		Items:      res,
		Param:      []string{},
	}
	if pType == 1 {
		mail.Cid = comm.Yueka_1
	} else if pType == 2 {
		mail.Cid = comm.Yueka_2
	}
	for i := 0; i < int(count); i++ {
		mail.ObjId = primitive.NewObjectID().Hex()
		this.mail.CreateNewMail(session, mail)
	}

}