ecs/servers/event/handler/inner_player.go

package handler

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

func (this *InnerHandler) PlayerCommon(msg *http.Message) {
	var req = new(old.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.TableCommonLog, &logic.CommonLog{
		PlayerLog: logic.PlayerLog{
			BaseLog: logic.BaseLog{
				LogType: req.LogType,
				LogTime: util.Unix(),
			},
			Platform:  req.Platform,
			Channel:   req.Channel,
			ServerId:  req.ServerId,
			Machine:   req.Machine,
			AccountId: req.UserId,
			PlayerId:  req.RoleId,
		},
		Param1:   req.Param1,
		Param2:   req.Param2,
		Param3:   req.Param3,
		ParamStr: req.ParamStr,
	})
	if err != nil {
		this.logger.Error("埋点执行失败, ", err)
	}
	_ = msg.Reply(err)
}

func (this *InnerHandler) PlayerCreate(msg *http.Message) {
	var req = new(old.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.TableCreateLog, &logic.CreateLog{
		PlayerLog: logic.PlayerLog{
			BaseLog: logic.BaseLog{
				LogType: req.LogType,
				LogTime: util.Unix(),
			},
			Platform:  req.Platform,
			Channel:   req.Channel,
			ServerId:  req.ServerId,
			Machine:   req.Machine,
			AccountId: req.UserId,
			PlayerId:  req.RoleId,
		},
	})
	if err != nil {
		this.logger.Error("埋点执行失败, ", err)
	}
	_ = msg.Reply(err)
}

func (this *InnerHandler) PlayerLogin(msg *http.Message) {
	var req = new(old.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.TableLoginLog, &logic.LoginLog{
		PlayerLog: logic.PlayerLog{
			BaseLog: logic.BaseLog{
				LogType: req.LogType,
				LogTime: util.Unix(),
			},
			Platform:  req.Platform,
			Channel:   req.Channel,
			ServerId:  req.ServerId,
			Machine:   req.Machine,
			AccountId: req.UserId,
			PlayerId:  req.RoleId,
		},
		OptionType: req.OptionType,
		LoginIp:    req.LoginIp,
	})
	if err != nil {
		this.logger.Error("埋点执行失败, ", err)
	}
	_ = msg.Reply(err)
}

func (this *InnerHandler) PlayerCharge(msg *http.Message) {
	var req = new(old.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.TableRechargeLog, &logic.RechargeLog{
		PlayerLog: logic.PlayerLog{
			BaseLog: logic.BaseLog{
				LogType: req.LogType,
				LogTime: util.Unix(),
			},
			Platform:  req.Platform,
			Channel:   req.Channel,
			ServerId:  req.ServerId,
			Machine:   req.Machine,
			AccountId: req.UserId,
			PlayerId:  req.RoleId,
		},
		ChargeId:   req.ChargeId,
		CurrType:   req.CurrType,
		Count:      req.Count,
		Added:      req.Added,
		LogSubtype: req.LogSubtype,
		Money:      req.Money,
		AddTime:    req.AddTime,
		Status:     req.Status,
	})
	if err != nil {
		this.logger.Error("埋点执行失败, ", err)
	}
	_ = msg.Reply(err)
}

func (this *InnerHandler) PlayerLevelUpgrade(msg *http.Message) {
	var req = new(old.MsgEventPlayerLevelUpgradeReq)
	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.TableLevelUpgradeLog, &logic.LevelUpgradeLog{
		PlayerLog: logic.PlayerLog{
			BaseLog: logic.BaseLog{
				LogType: req.LogType,
				LogTime: util.Unix(),
			},
			Platform:  req.Platform,
			Channel:   req.Channel,
			ServerId:  req.ServerId,
			Machine:   req.Machine,
			AccountId: req.UserId,
			PlayerId:  req.RoleId,
		},
		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(old.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.TableItemObtainLog, &logic.ItemObtainLog{
		PlayerLog: logic.PlayerLog{
			BaseLog: logic.BaseLog{
				LogType: req.LogType,
				LogTime: util.Unix(),
			},
			Platform:  req.Platform,
			Channel:   req.Channel,
			ServerId:  req.ServerId,
			Machine:   req.Machine,
			AccountId: req.UserId,
			PlayerId:  req.RoleId,
		},
		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(old.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.TableItemConsumeLog, &logic.ItemConsumeLog{
		PlayerLog: logic.PlayerLog{
			BaseLog: logic.BaseLog{
				LogType: req.LogType,
				LogTime: util.Unix(),
			},
			Platform:  req.Platform,
			Channel:   req.Channel,
			ServerId:  req.ServerId,
			Machine:   req.Machine,
			AccountId: req.UserId,
			PlayerId:  req.RoleId,
		},
		ItemId:  req.ItemId,
		ItemNum: req.ItemNum,
	})
	if err != nil {
		this.logger.Error("埋点执行失败, ", err)
	}
	_ = msg.Reply(err)
}

func (this *InnerHandler) PlayerMoneyObtain(msg *http.Message) {
	var req = new(old.MsgEventPlayerMoneyConsumeReq)
	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.TableMoneyObtainLog, &logic.MoneyObtainLog{
		PlayerLog: logic.PlayerLog{
			BaseLog: logic.BaseLog{
				LogType: req.LogType,
				LogTime: util.Unix(),
			},
			Platform:  req.Platform,
			Channel:   req.Channel,
			ServerId:  req.ServerId,
			Machine:   req.Machine,
			AccountId: req.UserId,
			PlayerId:  req.RoleId,
		},
		MoneyType: req.MoneyType,
		Amount:    req.Amount,
		CurAmount: req.CurAmount,
	})
	if err != nil {
		this.logger.Error("埋点执行失败, ", err)
	}
	_ = msg.Reply(err)
}

func (this *InnerHandler) PlayerMoneyConsume(msg *http.Message) {
	var req = new(old.MsgEventPlayerMoneyConsumeReq)
	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.TableMoneyConsumeLog, &logic.MoneyConsumeLog{
		PlayerLog: logic.PlayerLog{
			BaseLog: logic.BaseLog{
				LogType: req.LogType,
				LogTime: util.Unix(),
			},
			Platform:  req.Platform,
			Channel:   req.Channel,
			ServerId:  req.ServerId,
			Machine:   req.Machine,
			AccountId: req.UserId,
			PlayerId:  req.RoleId,
		},
		MoneyType: req.MoneyType,
		Amount:    req.Amount,
		CurAmount: req.CurAmount,
	})
	if err != nil {
		this.logger.Error("埋点执行失败, ", err)
	}
	_ = msg.Reply(err)
}

func (this *InnerHandler) PlayerMailLog(msg *http.Message) {
	var req = new(old.MsgEventPlayerMailLogReq)
	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.TableMailLog, &logic.MailLog{
		PlayerLog: logic.PlayerLog{
			BaseLog: logic.BaseLog{
				LogType: req.LogType,
				LogTime: util.Unix(),
			},
			Platform:  req.Platform,
			Channel:   req.Channel,
			ServerId:  req.ServerId,
			Machine:   req.Machine,
			AccountId: req.UserId,
			PlayerId:  req.RoleId,
		},
		MailId:     req.MailId,
		MailType:   req.MailType,
		RewardType: req.RewardType,
		Title:      req.Title,
		Content:    req.Content,
		Attachment: req.Attachment,
		SenderId:   req.SenderId,
		SenderTime: req.SenderTime,
	})
	if err != nil {
		this.logger.Error("埋点执行失败, ", err)
	}
	_ = msg.Reply(err)
}

func (this *InnerHandler) PlayerTaskLog(msg *http.Message) {
	var req = new(old.MsgEventPlayerTaskLogReq)
	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.TableTaskLog, &logic.TaskLog{
		PlayerLog: logic.PlayerLog{
			BaseLog: logic.BaseLog{
				LogType: req.LogType,
				LogTime: util.Unix(),
			},
			Platform:  req.Platform,
			Channel:   req.Channel,
			ServerId:  req.ServerId,
			Machine:   req.Machine,
			AccountId: req.UserId,
			PlayerId:  req.RoleId,
		},
		TaskId: req.TaskId,
		Param1: util.IntegersJoinToString(req.Param1, ","),
		Param2: util.IntegersJoinToString(req.Param2, ","),
		Param3: util.IntegersJoinToString(req.Param3, ","),
	})
	if err != nil {
		this.logger.Error("埋点执行失败, ", err)
	}
	_ = msg.Reply(err)
}

func (this *InnerHandler) PlayerShopLog(msg *http.Message) {
	var req = new(old.MsgEventPlayerShopLogReq)
	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.TableShopLog, &logic.ShopLog{
		PlayerLog: logic.PlayerLog{
			BaseLog: logic.BaseLog{
				LogType: req.LogType,
				LogTime: util.Unix(),
			},
			Platform:  req.Platform,
			Channel:   req.Channel,
			ServerId:  req.ServerId,
			Machine:   req.Machine,
			AccountId: req.UserId,
			PlayerId:  req.RoleId,
		},
		ShopType:     req.ShopType,
		ItemId:       req.ItemId,
		ItemNum:      req.ItemNum,
		CurrencyType: req.PriceType,
		ConsumeNum:   req.Price,
	})
	if err != nil {
		this.logger.Error("埋点执行失败, ", err)
	}
	_ = msg.Reply(err)
}

func (this *InnerHandler) PlayerActivity(msg *http.Message) {
	var req = new(old.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.TableActivityLog, &logic.ActivityLog{
		PlayerLog: logic.PlayerLog{
			BaseLog: logic.BaseLog{
				LogType: req.LogType,
				LogTime: util.Unix(),
			},
			Platform:  req.Platform,
			Channel:   req.Channel,
			ServerId:  req.ServerId,
			Machine:   req.Machine,
			AccountId: req.UserId,
			PlayerId:  req.RoleId,
		},
		ActivityType: req.ActivityType,
		Status:       req.Status,
	})
	if err != nil {
		this.logger.Error("埋点执行失败, ", err)
	}
	_ = msg.Reply(err)
}