ecs/servers/event/handler/inner_player.go

package handler

import (
	"ecs/proto"
	"ecs/servers/event/logic"
	"github.com/oylshe1314/framework/http"
	"github.com/oylshe1314/framework/util"
)

func (this *InnerHandler) PlayerCommon(msg *http.Message) {
	var req = new(proto.MsgEventPlayerCommonReq)
	var err = msg.Read(req)
	if err != nil {
		this.logger.Error("读取消息失败, ", err)
		_ = msg.Reply(err)
		return
	}

	if this.logger.IsDebugEnabled() {
		this.logger.Debugf("通用事件埋点, req: %s", util.ToJsonString(req))
	}
	err = this.eventManager.LogPlayerEvent(&logic.PlayerCommonLog{
		EventLogger: logic.EventLogger{
			AppId:   req.AppId,
			LogType: req.LogType,
			LogTime: req.LogTime,
		},
		EventPlayer: logic.EventPlayer{
			Platform: req.Platform,
			Channel:  req.Channel,
			ServerId: req.ServerId,
			UserId:   req.UserId,
			RoleId:   req.RoleId,
			Device:   req.Device,
			Version:  req.Version,
		},
		Numbers: req.Numbers,
		Strings: req.Strings,
	})
	if err != nil {
		this.logger.Error("埋点执行失败, ", err)
	}
	_ = msg.Reply(err)
}

func (this *InnerHandler) PlayerCreate(msg *http.Message) {
	var req = new(proto.MsgEventPlayerCreateReq)
	var err = msg.Read(req)
	if err != nil {
		this.logger.Error("读取消息失败, ", err)
		_ = msg.Reply(err)
		return
	}

	if this.logger.IsDebugEnabled() {
		this.logger.Debugf("角色创建埋点, req: %s", util.ToJsonString(req))
	}
	err = this.eventManager.LogPlayerEvent(&logic.PlayerCreateLog{
		EventLogger: logic.EventLogger{
			AppId:   req.AppId,
			LogType: req.LogType,
			LogTime: req.LogTime,
		},
		EventPlayer: logic.EventPlayer{
			Platform: req.Platform,
			Channel:  req.Channel,
			ServerId: req.ServerId,
			UserId:   req.UserId,
			RoleId:   req.RoleId,
			Device:   req.Device,
			Version:  req.Version,
		},
		Name:   req.Name,
		Gender: req.Gender,
	})
	if err != nil {
		this.logger.Error("埋点执行失败, ", err)
	}
	_ = msg.Reply(err)
}

func (this *InnerHandler) PlayerLogin(msg *http.Message) {
	var req = new(proto.MsgEventPlayerLoginReq)
	var err = msg.Read(req)
	if err != nil {
		this.logger.Error("读取消息失败, ", err)
		_ = msg.Reply(err)
		return
	}

	if this.logger.IsDebugEnabled() {
		this.logger.Debugf("登录相关埋点, req: %s", util.ToJsonString(req))
	}
	err = this.eventManager.LogPlayerEvent(&logic.PlayerLoginLog{
		EventLogger: logic.EventLogger{
			AppId:   req.AppId,
			LogType: req.LogType,
			LogTime: req.LogTime,
		},
		EventPlayer: logic.EventPlayer{
			Platform: req.Platform,
			Channel:  req.Channel,
			ServerId: req.ServerId,
			UserId:   req.UserId,
			RoleId:   req.RoleId,
			Device:   req.Device,
			Version:  req.Version,
		},
		OptionType: req.OptionType,
		LoginIp:    req.LoginIp,
	})
	if err != nil {
		this.logger.Error("埋点执行失败, ", err)
	}
	_ = msg.Reply(err)
}

func (this *InnerHandler) PlayerRecharge(msg *http.Message) {
	var req = new(proto.MsgEventPlayerRechargeReq)
	var err = msg.Read(req)
	if err != nil {
		this.logger.Error("读取消息失败, ", err)
		_ = msg.Reply(err)
		return
	}

	if this.logger.IsDebugEnabled() {
		this.logger.Debugf("充值付费埋点, req: %s", util.ToJsonString(req))
	}
	err = this.eventManager.LogPlayerEvent(&logic.PlayerRechargeLog{
		EventLogger: logic.EventLogger{
			AppId:   req.AppId,
			LogType: req.LogType,
			LogTime: req.LogTime,
		},
		EventPlayer: logic.EventPlayer{
			Platform: req.Platform,
			Channel:  req.Channel,
			ServerId: req.ServerId,
			UserId:   req.UserId,
			RoleId:   req.RoleId,
			Device:   req.Device,
			Version:  req.Version,
		},
		RechargeId: req.RechargeId,
		Type:       req.Type,
		SubType:    req.SubType,
		Count:      req.Count,
		Money:      req.Money,
		Status:     req.Status,
	})
	if err != nil {
		this.logger.Error("埋点执行失败, ", err)
	}
	_ = msg.Reply(err)
}

func (this *InnerHandler) PlayerLevel(msg *http.Message) {
	var req = new(proto.MsgEventPlayerLevelReq)
	var err = msg.Read(req)
	if err != nil {
		this.logger.Error("读取消息失败, ", err)
		_ = msg.Reply(err)
		return
	}

	if this.logger.IsDebugEnabled() {
		this.logger.Debugf("等级升级埋点, req: %s", util.ToJsonString(req))
	}
	err = this.eventManager.LogPlayerEvent(&logic.PlayerLevelLog{
		EventLogger: logic.EventLogger{
			AppId:   req.AppId,
			LogType: req.LogType,
			LogTime: req.LogTime,
		},
		EventPlayer: logic.EventPlayer{
			Platform: req.Platform,
			Channel:  req.Channel,
			ServerId: req.ServerId,
			UserId:   req.UserId,
			RoleId:   req.RoleId,
			Device:   req.Device,
			Version:  req.Version,
		},
		PreLevel: req.PreLevel,
		CurLevel: req.CurLevel,
	})
	if err != nil {
		this.logger.Error("埋点执行失败, ", err)
	}
	_ = msg.Reply(err)
}

func (this *InnerHandler) PlayerItemObtain(msg *http.Message) {
	var req = new(proto.MsgEventPlayerItemObtainReq)
	var err = msg.Read(req)
	if err != nil {
		this.logger.Error("读取消息失败, ", err)
		_ = msg.Reply(err)
		return
	}

	if this.logger.IsDebugEnabled() {
		this.logger.Debugf("物品获得埋点, req: %s", util.ToJsonString(req))
	}
	err = this.eventManager.LogPlayerEvent(&logic.PlayerItemObtainLog{
		EventLogger: logic.EventLogger{
			AppId:   req.AppId,
			LogType: req.LogType,
			LogTime: req.LogTime,
		},
		EventPlayer: logic.EventPlayer{
			Platform: req.Platform,
			Channel:  req.Channel,
			ServerId: req.ServerId,
			UserId:   req.UserId,
			RoleId:   req.RoleId,
			Device:   req.Device,
			Version:  req.Version,
		},
		ItemId:  req.ItemId,
		ItemNum: req.ItemNum,
	})
	if err != nil {
		this.logger.Error("埋点执行失败, ", err)
	}
	_ = msg.Reply(err)
}

func (this *InnerHandler) PlayerItemConsume(msg *http.Message) {
	var req = new(proto.MsgEventPlayerItemConsumeReq)
	var err = msg.Read(req)
	if err != nil {
		this.logger.Error("读取消息失败, ", err)
		_ = msg.Reply(err)
		return
	}

	if this.logger.IsDebugEnabled() {
		this.logger.Debugf("物品消耗埋点, req: %s", util.ToJsonString(req))
	}
	err = this.eventManager.LogPlayerEvent(&logic.PlayerItemConsumeLog{
		EventLogger: logic.EventLogger{
			AppId:   req.AppId,
			LogType: req.LogType,
			LogTime: req.LogTime,
		},
		EventPlayer: logic.EventPlayer{
			Platform: req.Platform,
			Channel:  req.Channel,
			ServerId: req.ServerId,
			UserId:   req.UserId,
			RoleId:   req.RoleId,
			Device:   req.Device,
			Version:  req.Version,
		},
		ItemId:  req.ItemId,
		ItemNum: req.ItemNum,
	})
	if err != nil {
		this.logger.Error("埋点执行失败, ", err)
	}
	_ = msg.Reply(err)
}

func (this *InnerHandler) PlayerMail(msg *http.Message) {
	var req = new(proto.MsgEventPlayerMailReq)
	var err = msg.Read(req)
	if err != nil {
		this.logger.Error("读取消息失败, ", err)
		_ = msg.Reply(err)
		return
	}

	if this.logger.IsDebugEnabled() {
		this.logger.Debugf("邮件记录埋点, req: %s", util.ToJsonString(req))
	}
	err = this.eventManager.LogPlayerEvent(&logic.PlayerMailLog{
		EventLogger: logic.EventLogger{
			AppId:   req.AppId,
			LogType: req.LogType,
			LogTime: req.LogTime,
		},
		EventPlayer: logic.EventPlayer{
			Platform: req.Platform,
			Channel:  req.Channel,
			ServerId: req.ServerId,
			UserId:   req.UserId,
			RoleId:   req.RoleId,
			Device:   req.Device,
			Version:  req.Version,
		},
		MailId:       req.MailId,
		MailType:     req.MailType,
		SentUserId:   req.SentUserId,
		SentServerId: req.SentServerId,
		SentRoleId:   req.SentRoleId,
		Title:        req.Title,
		Content:      req.Content,
		ItemIds:      req.ItemIds,
		ItemNums:     req.ItemNums,
		CreateTime:   req.CreateTime,
		Expiration:   req.Expiration,
	})
	if err != nil {
		this.logger.Error("埋点执行失败, ", err)
	}
	_ = msg.Reply(err)
}

func (this *InnerHandler) PlayerTask(msg *http.Message) {
	var req = new(proto.MsgEventPlayerTaskReq)
	var err = msg.Read(req)
	if err != nil {
		this.logger.Error("读取消息失败, ", err)
		_ = msg.Reply(err)
		return
	}

	if this.logger.IsDebugEnabled() {
		this.logger.Debugf("任务记录埋点, req: %s", util.ToJsonString(req))
	}
	err = this.eventManager.LogPlayerEvent(&logic.PlayerTaskLog{
		EventLogger: logic.EventLogger{
			AppId:   req.AppId,
			LogType: req.LogType,
			LogTime: req.LogTime,
		},
		EventPlayer: logic.EventPlayer{
			Platform: req.Platform,
			Channel:  req.Channel,
			ServerId: req.ServerId,
			UserId:   req.UserId,
			RoleId:   req.RoleId,
			Device:   req.Device,
			Version:  req.Version,
		},
		TaskId: req.TaskId,
		Args1:  req.Args1,
		Args2:  req.Args2,
		Args3:  req.Args3,
	})
	if err != nil {
		this.logger.Error("埋点执行失败, ", err)
	}
	_ = msg.Reply(err)
}

func (this *InnerHandler) PlayerStore(msg *http.Message) {
	var req = new(proto.MsgEventPlayerStoreReq)
	var err = msg.Read(req)
	if err != nil {
		this.logger.Error("读取消息失败, ", err)
		_ = msg.Reply(err)
		return
	}

	if this.logger.IsDebugEnabled() {
		this.logger.Debugf("商店记录埋点, req: %s", util.ToJsonString(req))
	}
	err = this.eventManager.LogPlayerEvent(&logic.PlayerStoreLog{
		EventLogger: logic.EventLogger{
			AppId:   req.AppId,
			LogType: req.LogType,
			LogTime: req.LogTime,
		},
		EventPlayer: logic.EventPlayer{
			Platform: req.Platform,
			Channel:  req.Channel,
			ServerId: req.ServerId,
			UserId:   req.UserId,
			RoleId:   req.RoleId,
			Device:   req.Device,
			Version:  req.Version,
		},
		StoreType: req.StoreType,
		ItemId:    req.ItemId,
		ItemNum:   req.ItemNum,
		MoneyType: req.MoneyType,
		MoneyNum:  req.MoneyNum,
	})
	if err != nil {
		this.logger.Error("埋点执行失败, ", err)
	}
	_ = msg.Reply(err)
}

func (this *InnerHandler) PlayerActivity(msg *http.Message) {
	var req = new(proto.MsgEventPlayerActivityReq)
	var err = msg.Read(req)
	if err != nil {
		this.logger.Error("读取消息失败, ", err)
		_ = msg.Reply(err)
		return
	}

	if this.logger.IsDebugEnabled() {
		this.logger.Debugf("活动相关埋点, req: %s", util.ToJsonString(req))
	}
	err = this.eventManager.LogPlayerEvent(&logic.PlayerActivityLog{
		EventLogger: logic.EventLogger{
			AppId:   req.AppId,
			LogType: req.LogType,
			LogTime: req.LogTime,
		},
		EventPlayer: logic.EventPlayer{
			Platform: req.Platform,
			Channel:  req.Channel,
			ServerId: req.ServerId,
			UserId:   req.UserId,
			RoleId:   req.RoleId,
			Device:   req.Device,
			Version:  req.Version,
		},
		Type:   req.Type,
		Status: req.Status,
	})
	if err != nil {
		this.logger.Error("埋点执行失败, ", err)
	}
	_ = msg.Reply(err)
}