560 lines
18 KiB
Go
560 lines
18 KiB
Go
package reportser
|
|
|
|
import (
|
|
"context"
|
|
"crypto/md5"
|
|
"encoding/hex"
|
|
"encoding/json"
|
|
"fmt"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
"videoweb/app/service/playletcache"
|
|
"videoweb/pub/common"
|
|
"videoweb/pub/common/enum/consts"
|
|
"videoweb/pub/common/ipaddr"
|
|
"videoweb/pub/common/log"
|
|
"videoweb/pub/common/useragent"
|
|
"videoweb/pub/dataReport"
|
|
"videoweb/pub/models/eventmod"
|
|
"videoweb/pub/models/playletchaptermod"
|
|
"videoweb/pub/models/playletmod"
|
|
"videoweb/pub/models/usermod"
|
|
"videoweb/pub/models/videoinformationmod"
|
|
"videoweb/pub/pubdef"
|
|
|
|
"github.com/gin-gonic/gin"
|
|
"go.mongodb.org/mongo-driver/bson"
|
|
"go.mongodb.org/mongo-driver/mongo/options"
|
|
)
|
|
|
|
const (
|
|
videoContentTypeVideo = "video"
|
|
)
|
|
|
|
// ReportUserRegister 用户注册事件
|
|
func ReportUserRegister(user *usermod.User, ua useragent.UA, ip, registerType string) {
|
|
if user == nil {
|
|
return
|
|
}
|
|
if registerType == "" {
|
|
registerType = "deviceid"
|
|
}
|
|
ua = fillUserUA(user, ua)
|
|
createAt := user.CreatedAt
|
|
if !user.RegisterTime.IsZero() {
|
|
createAt = user.RegisterTime
|
|
}
|
|
eventId := newEventId(pubdef.TrackerAppId(), user.Id, "", createAt.Unix())
|
|
event := dataReport.NewCommonField(eventId, dataReport.EventTypeUserRegister, user.DistrictCode, ua, strconv.FormatInt(user.Id, 10), ip)
|
|
event.Payload = dataReport.JsonRawMessage(&dataReport.UserRegisterEvent{
|
|
Type: registerType,
|
|
CreateTime: dataReport.JsonNumber(createAt.Unix()),
|
|
})
|
|
insertEvent(event)
|
|
}
|
|
|
|
// ReportUserLogin 用户登录事件
|
|
func ReportUserLogin(user *usermod.User, ua useragent.UA, ip string, loginType pubdef.LoginType) {
|
|
if user == nil {
|
|
return
|
|
}
|
|
ua = fillUserUA(user, ua)
|
|
createTime := time.Now().Unix()
|
|
eventId := newEventId(pubdef.TrackerAppId(), user.Id, "", createTime)
|
|
event := dataReport.NewCommonField(eventId, dataReport.EventTypeUserLogin, user.DistrictCode, ua, strconv.FormatInt(user.Id, 10), ip)
|
|
event.Payload = dataReport.JsonRawMessage(&dataReport.UserLoginEvent{
|
|
Type: loginTypeEventValue(loginType),
|
|
})
|
|
insertEvent(event)
|
|
}
|
|
|
|
// ReportPlayletLike 短剧点赞
|
|
func ReportPlayletLike(ctx context.Context, userId, playletId, flag int64) {
|
|
reportDramaEvent(ctx, userId, playletId, 0, dataReport.EventTypeDramaLike, flag, "")
|
|
}
|
|
|
|
// ReportVideoLike 视频点赞
|
|
func ReportVideoLike(ctx context.Context, userId, videoId, flag int64) {
|
|
reportVideoEvent(ctx, userId, videoId, dataReport.EventTypeVideoLike, flag)
|
|
}
|
|
|
|
// ReportPlayletCollect 短剧收藏
|
|
func ReportPlayletCollect(ctx context.Context, userId, playletId, flag int64) {
|
|
reportDramaEvent(ctx, userId, playletId, 0, dataReport.EventTypeDramaCollect, flag, "")
|
|
}
|
|
|
|
// ReportVideoCollect 视频收藏
|
|
func ReportVideoCollect(ctx context.Context, userId, videoId, flag int64) {
|
|
reportVideoEvent(ctx, userId, videoId, dataReport.EventTypeVideoCollect, flag)
|
|
}
|
|
|
|
// ReportVideoComment 视频评论
|
|
func ReportVideoComment(ctx context.Context, user *usermod.User, videoId int64, content string) {
|
|
if user == nil || videoId <= 0 {
|
|
return
|
|
}
|
|
pub := buildVideoPub(ctx, videoId)
|
|
if pub.VideoID == "" {
|
|
return
|
|
}
|
|
ua, ip := uaAndIPFromCtx(ctx)
|
|
ua = fillUserUA(user, ua)
|
|
event := dataReport.NewCommonField(dataReport.GenerateGlobalEventID(), dataReport.EventTypeVideoComment, user.DistrictCode, ua, strconv.FormatInt(user.Id, 10), ip)
|
|
event.Payload = dataReport.JsonRawMessage(&dataReport.VideoCommentEvent{
|
|
VideoEventPub: pub,
|
|
CommentContent: content,
|
|
})
|
|
insertEvent(event)
|
|
}
|
|
|
|
// ReportPlayletChapterLike 短剧剧集点赞
|
|
func ReportPlayletChapterLike(ctx context.Context, userId, playletId, chapterId, flag int64) {
|
|
reportDramaEvent(ctx, userId, playletId, chapterId, dataReport.EventTypeDramaLike, flag, "")
|
|
}
|
|
|
|
// ReportPlayletChapterCollect 短剧剧集收藏
|
|
func ReportPlayletChapterCollect(ctx context.Context, userId, playletId, chapterId, flag int64) {
|
|
reportDramaEvent(ctx, userId, playletId, chapterId, dataReport.EventTypeDramaCollect, flag, "")
|
|
}
|
|
|
|
// ReportPlayletComment 短剧/剧集评论
|
|
func ReportPlayletComment(ctx context.Context, user *usermod.User, playletId, chapterId int64, content string) {
|
|
if user == nil || playletId <= 0 {
|
|
return
|
|
}
|
|
pub := buildDramaPub(ctx, playletId, chapterId)
|
|
if pub.DramaID == "" {
|
|
return
|
|
}
|
|
ua, ip := uaAndIPFromCtx(ctx)
|
|
ua = fillUserUA(user, ua)
|
|
event := dataReport.NewCommonField(dataReport.GenerateGlobalEventID(), dataReport.EventTypeDramaComment, user.DistrictCode, ua, strconv.FormatInt(user.Id, 10), ip)
|
|
event.Payload = dataReport.JsonRawMessage(&dataReport.DramaCommentEvent{
|
|
DramaEventPub: pub,
|
|
CommentContent: content,
|
|
})
|
|
insertEvent(event)
|
|
}
|
|
|
|
// ReportPlayletUnlock 短剧剧集金币解锁：同时上报金币消耗和购买
|
|
func ReportPlayletUnlock(ctx context.Context, user *usermod.User, playlet *playletmod.Playlet, chapter *playletchaptermod.PlayletChapter, amount, balanceBefore, balanceAfter int64, orderNo string) {
|
|
if user == nil || playlet == nil || chapter == nil || amount <= 0 {
|
|
return
|
|
}
|
|
if full, err := usermod.FindOneUser(ctx, bson.M{usermod.FN.User.Id: user.Id}); err == nil && full != nil {
|
|
user = full
|
|
}
|
|
ua, ip := uaAndIPFromCtx(ctx)
|
|
ua = fillUserUA(user, ua)
|
|
productId := strconv.FormatInt(chapter.Id, 10)
|
|
productName := playletUnlockProductName(playlet, chapter)
|
|
reportCoinConsume(user, ua, ip, productId, productName, amount, balanceBefore, balanceAfter, KeyPlayletUnlock, orderNo)
|
|
reportDramaPurchase(ctx, user, ua, ip, playlet, chapter, amount, orderNo)
|
|
}
|
|
|
|
// ReportPlayletStatusChange 短剧上下架，复用 video_status_change
|
|
func ReportPlayletStatusChange(playlet *playletmod.Playlet, flag int64) {
|
|
if playlet == nil || playlet.Id == 0 || flag == 0 {
|
|
return
|
|
}
|
|
typeID, typeName := resolvePlayletType(playlet)
|
|
event := dataReport.NewCommonField("", dataReport.EventTypeVideoStatusChange, "", useragent.UA{}, "", "")
|
|
event.Payload = dataReport.JsonRawMessage(&dataReport.VideoStatusChangeEvent{
|
|
MediaId: playletMediaId(playlet),
|
|
VideoID: strconv.FormatInt(playlet.Id, 10),
|
|
VideoTitle: playlet.Title,
|
|
VideoTypeID: typeID,
|
|
VideoTypeName: typeName,
|
|
Flag: dataReport.JsonNumber(flag),
|
|
})
|
|
insertEvent(event)
|
|
}
|
|
|
|
// PlayletStatusFlag 短剧上下架映射上报 flag：1上架 2下架
|
|
func PlayletStatusFlag(status playletmod.Status) int64 {
|
|
switch status {
|
|
case playletmod.StatusUp:
|
|
return 1
|
|
case playletmod.StatusDown:
|
|
return 2
|
|
default:
|
|
return 0
|
|
}
|
|
}
|
|
|
|
func reportDramaEvent(ctx context.Context, userId, playletId, chapterId int64, eventType string, flag int64, content string) {
|
|
if userId <= 0 || playletId <= 0 {
|
|
return
|
|
}
|
|
user, err := usermod.FindOneUser(ctx, bson.M{usermod.FN.User.Id: userId})
|
|
if err != nil || user == nil {
|
|
return
|
|
}
|
|
pub := buildDramaPub(ctx, playletId, chapterId)
|
|
if pub.DramaID == "" {
|
|
return
|
|
}
|
|
ua, ip := uaAndIPFromCtx(ctx)
|
|
ua = fillUserUA(user, ua)
|
|
event := dataReport.NewCommonField(dataReport.GenerateGlobalEventID(), eventType, user.DistrictCode, ua, strconv.FormatInt(user.Id, 10), ip)
|
|
switch eventType {
|
|
case dataReport.EventTypeDramaLike:
|
|
event.Payload = dataReport.JsonRawMessage(&dataReport.DramaLikeEvent{
|
|
DramaEventPub: pub,
|
|
Flag: dataReport.JsonNumber(flag),
|
|
})
|
|
case dataReport.EventTypeDramaCollect:
|
|
event.Payload = dataReport.JsonRawMessage(&dataReport.DramaCollectEvent{
|
|
DramaEventPub: pub,
|
|
Flag: dataReport.JsonNumber(flag),
|
|
})
|
|
case dataReport.EventTypeDramaComment:
|
|
event.Payload = dataReport.JsonRawMessage(&dataReport.DramaCommentEvent{
|
|
DramaEventPub: pub,
|
|
CommentContent: content,
|
|
})
|
|
default:
|
|
return
|
|
}
|
|
insertEvent(event)
|
|
}
|
|
|
|
func reportVideoEvent(ctx context.Context, userId, videoId int64, eventType string, flag int64) {
|
|
if userId <= 0 || videoId <= 0 {
|
|
return
|
|
}
|
|
user, err := usermod.FindOneUser(ctx, bson.M{usermod.FN.User.Id: userId})
|
|
if err != nil || user == nil {
|
|
return
|
|
}
|
|
pub := buildVideoPub(ctx, videoId)
|
|
if pub.VideoID == "" {
|
|
return
|
|
}
|
|
ua, ip := uaAndIPFromCtx(ctx)
|
|
ua = fillUserUA(user, ua)
|
|
event := dataReport.NewCommonField(dataReport.GenerateGlobalEventID(), eventType, user.DistrictCode, ua, strconv.FormatInt(user.Id, 10), ip)
|
|
switch eventType {
|
|
case dataReport.EventTypeVideoLike:
|
|
event.Payload = dataReport.JsonRawMessage(&dataReport.VideoLikeEvent{
|
|
VideoEventPub: pub,
|
|
Flag: dataReport.JsonNumber(flag),
|
|
})
|
|
case dataReport.EventTypeVideoCollect:
|
|
event.Payload = dataReport.JsonRawMessage(&dataReport.VideoCollectEvent{
|
|
VideoEventPub: pub,
|
|
Flag: dataReport.JsonNumber(flag),
|
|
})
|
|
default:
|
|
return
|
|
}
|
|
insertEvent(event)
|
|
}
|
|
|
|
func reportCoinConsume(user *usermod.User, ua useragent.UA, ip, productId, productName string, amount, balanceBefore, balanceAfter int64, reason Key, orderId string) {
|
|
if user == nil || amount == 0 {
|
|
return
|
|
}
|
|
if productId == "" {
|
|
if productName == "" {
|
|
productName = "金币消耗"
|
|
}
|
|
productId = md5String(productName)
|
|
}
|
|
createTime := time.Now().Unix()
|
|
eventId := newEventId(pubdef.TrackerAppId(), user.Id, orderId, createTime)
|
|
event := dataReport.NewCommonField(eventId, dataReport.EventTypeCoinConsume, user.DistrictCode, ua, strconv.FormatInt(user.Id, 10), ip)
|
|
event.Payload = dataReport.JsonRawMessage(&dataReport.CoinConsumeEvent{
|
|
ProductID: productId,
|
|
ProductName: productName,
|
|
CoinConsumeAmount: dataReport.JsonNumber(amount),
|
|
CoinBalanceBefore: dataReport.JsonNumber(balanceBefore),
|
|
CoinBalanceAfter: dataReport.JsonNumber(balanceAfter),
|
|
ConsumeReasonKey: reason.Key(),
|
|
ConsumeReasonName: reason.Name(),
|
|
CreateTime: dataReport.JsonNumber(createTime),
|
|
OrderId: orderId,
|
|
})
|
|
insertEvent(event)
|
|
}
|
|
|
|
func reportDramaPurchase(ctx context.Context, user *usermod.User, ua useragent.UA, ip string, playlet *playletmod.Playlet, chapter *playletchaptermod.PlayletChapter, amount int64, orderId string) {
|
|
pub := dataReport.DramaEventPub{}
|
|
if playlet != nil && chapter != nil && chapter.Id > 0 {
|
|
pub = buildDramaPub(ctx, playlet.Id, chapter.Id)
|
|
}
|
|
if pub.DramaID == "" {
|
|
pub = playletToDramaPub(playlet, chapter)
|
|
}
|
|
if pub.DramaID == "" {
|
|
return
|
|
}
|
|
event := dataReport.NewCommonField(dataReport.GenerateGlobalEventID(), dataReport.EventTypeDramaPurchase, user.DistrictCode, ua, strconv.FormatInt(user.Id, 10), ip)
|
|
event.Payload = dataReport.JsonRawMessage(&dataReport.DramaPurchaseEvent{
|
|
DramaEventPub: pub,
|
|
CoinQuantity: dataReport.JsonNumber(amount),
|
|
OrderID: orderId,
|
|
UnlockType: dataReport.DramaUnlockTypeCoin,
|
|
})
|
|
insertEvent(event)
|
|
}
|
|
|
|
func buildDramaPub(ctx context.Context, playletId, chapterId int64) dataReport.DramaEventPub {
|
|
playlet, err := playletmod.FindOnePlaylet(ctx, bson.M{playletmod.FN.Playlet.Id: playletId}, options.FindOne().SetProjection(bson.D{
|
|
{Key: playletmod.FN.Playlet.Id, Value: 1},
|
|
{Key: playletmod.FN.Playlet.Title, Value: 1},
|
|
{Key: playletmod.FN.Playlet.ThemeIds, Value: 1},
|
|
{Key: playletmod.FN.Playlet.TagIds, Value: 1},
|
|
{Key: playletmod.FN.Playlet.TotalEpisode, Value: 1},
|
|
}))
|
|
if err != nil || playlet == nil {
|
|
return dataReport.DramaEventPub{}
|
|
}
|
|
chapter := findDramaReportChapter(ctx, playletId, chapterId)
|
|
return playletToDramaPub(playlet, chapter)
|
|
}
|
|
|
|
// findDramaReportChapter 取上报用剧集。指定了剧集就用该集，短剧维度事件用第一集，保证 drama_id、video_id 都来自剧集。
|
|
func findDramaReportChapter(ctx context.Context, playletId, chapterId int64) *playletchaptermod.PlayletChapter {
|
|
projection := options.FindOne().SetProjection(bson.D{
|
|
{Key: playletchaptermod.FN.PlayletChapter.Id, Value: 1},
|
|
{Key: playletchaptermod.FN.PlayletChapter.PlayletId, Value: 1},
|
|
{Key: playletchaptermod.FN.PlayletChapter.MediaContentId, Value: 1},
|
|
{Key: playletchaptermod.FN.PlayletChapter.Title, Value: 1},
|
|
{Key: playletchaptermod.FN.PlayletChapter.CurrentEpisode, Value: 1},
|
|
{Key: playletchaptermod.FN.PlayletChapter.MediaTime, Value: 1},
|
|
})
|
|
if chapterId > 0 {
|
|
chapter, _ := playletchaptermod.FindOnePlayletChapter(ctx, bson.M{playletchaptermod.FN.PlayletChapter.Id: chapterId}, projection)
|
|
return chapter
|
|
}
|
|
chapter, _ := playletchaptermod.FindOnePlayletChapter(ctx, bson.M{playletchaptermod.FN.PlayletChapter.PlayletId: playletId}, projection.SetSort(bson.D{
|
|
{Key: playletchaptermod.FN.PlayletChapter.CurrentEpisode, Value: 1},
|
|
{Key: playletchaptermod.FN.PlayletChapter.Id, Value: 1},
|
|
}))
|
|
return chapter
|
|
}
|
|
|
|
func buildVideoPub(ctx context.Context, videoId int64) dataReport.VideoEventPub {
|
|
video, err := videoinformationmod.FindOneVideoInformationWithOptions(ctx, bson.M{videoinformationmod.FN.VideoInformation.Id: videoId}, options.FindOne().SetProjection(bson.D{
|
|
{Key: videoinformationmod.FN.VideoInformation.Id, Value: 1},
|
|
{Key: videoinformationmod.FN.VideoInformation.Title, Value: 1},
|
|
{Key: videoinformationmod.FN.VideoInformation.MediaType, Value: 1},
|
|
{Key: videoinformationmod.FN.VideoInformation.Video.FileId, Value: 1},
|
|
{Key: videoinformationmod.FN.VideoInformation.Video.TaskId, Value: 1},
|
|
{Key: videoinformationmod.FN.VideoInformation.SyncId, Value: 1},
|
|
}))
|
|
if err != nil || video == nil {
|
|
return dataReport.VideoEventPub{}
|
|
}
|
|
return videoToVideoPub(video)
|
|
}
|
|
|
|
func videoToVideoPub(video *videoinformationmod.VideoInformation) dataReport.VideoEventPub {
|
|
if video == nil {
|
|
return dataReport.VideoEventPub{}
|
|
}
|
|
mediaId := video.Video.FileId
|
|
if mediaId == "" {
|
|
mediaId = video.Video.TaskId
|
|
}
|
|
if mediaId == "" {
|
|
mediaId = video.SyncId
|
|
}
|
|
return dataReport.VideoEventPub{
|
|
MediaId: mediaId,
|
|
VideoID: strconv.FormatInt(video.Id, 10),
|
|
VideoTitle: video.Title,
|
|
VideoTypeID: strconv.FormatInt(int64(video.MediaType), 10),
|
|
VideoTypeName: videoMediaTypeName(video.MediaType),
|
|
VideoContentType: videoContentTypeVideo,
|
|
}
|
|
}
|
|
|
|
func playletToDramaPub(playlet *playletmod.Playlet, chapter *playletchaptermod.PlayletChapter) dataReport.DramaEventPub {
|
|
if playlet == nil {
|
|
return dataReport.DramaEventPub{}
|
|
}
|
|
typeID, typeName := resolvePlayletType(playlet)
|
|
tagKey, tagName := resolvePlayletTags(playlet.TagIds)
|
|
episode := int64(1)
|
|
duration := int64(0)
|
|
dramaID := ""
|
|
videoID := ""
|
|
if chapter != nil && chapter.Id > 0 {
|
|
if chapter.CurrentEpisode > 0 {
|
|
episode = chapter.CurrentEpisode
|
|
}
|
|
duration = chapter.MediaTime
|
|
dramaID = strconv.FormatInt(chapter.Id, 10)
|
|
if chapter.MediaContentId > 0 {
|
|
videoID = strconv.FormatUint(uint64(chapter.MediaContentId), 10)
|
|
}
|
|
}
|
|
return dataReport.DramaEventPub{
|
|
DramaID: dramaID,
|
|
DramaTitle: playlet.Title,
|
|
Episode: dataReport.JsonNumber(episode),
|
|
VideoID: videoID,
|
|
TotalEpisode: dataReport.JsonNumber(playlet.TotalEpisode),
|
|
DramaTypeID: typeID,
|
|
DramaTypeName: typeName,
|
|
DramaContentType: dataReport.DramaContentTypeShortDrama,
|
|
DramaTagKey: tagKey,
|
|
DramaTagName: tagName,
|
|
DramaDuration: dataReport.JsonNumber(duration),
|
|
}
|
|
}
|
|
|
|
func videoMediaTypeName(mediaType videoinformationmod.MediaType) string {
|
|
switch mediaType {
|
|
case videoinformationmod.MediaType_Video:
|
|
return "视频"
|
|
case videoinformationmod.MediaType_Collection:
|
|
return "合集"
|
|
case videoinformationmod.MediaType_Advitise:
|
|
return "广告"
|
|
case videoinformationmod.MediaType_VideoV2:
|
|
return "视频"
|
|
default:
|
|
return "视频"
|
|
}
|
|
}
|
|
|
|
func playletUnlockProductName(playlet *playletmod.Playlet, chapter *playletchaptermod.PlayletChapter) string {
|
|
title := ""
|
|
if playlet != nil {
|
|
title = playlet.Title
|
|
}
|
|
if chapter == nil {
|
|
return title
|
|
}
|
|
if chapter.Title != "" {
|
|
if title == "" {
|
|
return chapter.Title
|
|
}
|
|
return fmt.Sprintf("%s %s", title, chapter.Title)
|
|
}
|
|
if chapter.CurrentEpisode > 0 {
|
|
if title == "" {
|
|
return fmt.Sprintf("第%d集", chapter.CurrentEpisode)
|
|
}
|
|
return fmt.Sprintf("%s 第%d集", title, chapter.CurrentEpisode)
|
|
}
|
|
return title
|
|
}
|
|
|
|
func playletMediaId(playlet *playletmod.Playlet) string {
|
|
if playlet == nil || playlet.MediaCenterId == 0 {
|
|
return ""
|
|
}
|
|
return strconv.FormatUint(uint64(playlet.MediaCenterId), 10)
|
|
}
|
|
|
|
func resolvePlayletType(playlet *playletmod.Playlet) (string, string) {
|
|
if playlet == nil || len(playlet.ThemeIds) == 0 {
|
|
return "default", "默认分类"
|
|
}
|
|
id := playlet.ThemeIds[0]
|
|
if id <= 0 {
|
|
return "default", "默认分类"
|
|
}
|
|
name := strings.TrimSpace(playletcache.ThemeNameMap([]int64{id})[id])
|
|
if name == "" {
|
|
name = "默认分类"
|
|
}
|
|
return strconv.FormatInt(id, 10), name
|
|
}
|
|
|
|
func resolvePlayletTags(ids []int64) (string, string) {
|
|
keys := make([]string, 0, len(ids))
|
|
for _, id := range ids {
|
|
if id > 0 {
|
|
keys = append(keys, strconv.FormatInt(id, 10))
|
|
}
|
|
}
|
|
if len(keys) == 0 {
|
|
return "default", "默认标签"
|
|
}
|
|
nameMap := playletcache.TagNameMap(ids)
|
|
names := make([]string, 0, len(keys))
|
|
for _, id := range ids {
|
|
if id <= 0 {
|
|
continue
|
|
}
|
|
name := strings.TrimSpace(nameMap[id])
|
|
if name == "" {
|
|
name = strconv.FormatInt(id, 10)
|
|
}
|
|
names = append(names, name)
|
|
}
|
|
return strings.Join(keys, ","), strings.Join(names, ",")
|
|
}
|
|
|
|
func uaAndIPFromCtx(ctx context.Context) (useragent.UA, string) {
|
|
gc, ok := ctx.(*gin.Context)
|
|
if !ok {
|
|
if v := ctx.Value(consts.CtxUA); v != nil {
|
|
if ua, ok := v.(useragent.UA); ok {
|
|
return ua, ""
|
|
}
|
|
}
|
|
return useragent.UA{}, ""
|
|
}
|
|
ua, _ := common.GetUA(gc)
|
|
return ua, ipaddr.ResolveClientIP(gc)
|
|
}
|
|
|
|
func fillUserUA(user *usermod.User, ua useragent.UA) useragent.UA {
|
|
if user == nil {
|
|
return ua
|
|
}
|
|
if ua.DevID == "" {
|
|
ua.DevID = user.DevID
|
|
}
|
|
if ua.DevType == "" {
|
|
ua.DevType = user.Device
|
|
}
|
|
if ua.SysType == "" {
|
|
ua.SysType = user.SysType
|
|
}
|
|
return ua
|
|
}
|
|
|
|
func loginTypeEventValue(loginType pubdef.LoginType) string {
|
|
switch loginType {
|
|
case pubdef.LoginTypeAccount:
|
|
return "username"
|
|
case pubdef.LoginTypeEmail:
|
|
return "email"
|
|
default:
|
|
return "deviceid"
|
|
}
|
|
}
|
|
|
|
func newEventId(appId string, uid int64, orderId interface{}, createTime int64) string {
|
|
input := fmt.Sprintf("%v%v%v%v", appId, uid, orderId, createTime)
|
|
return md5String(input)
|
|
}
|
|
|
|
func md5String(input string) string {
|
|
h := md5.New()
|
|
h.Write([]byte(input))
|
|
return hex.EncodeToString(h.Sum(nil))
|
|
}
|
|
|
|
func insertEvent(event dataReport.CommonField) {
|
|
b, _ := json.Marshal(event)
|
|
if err := eventmod.InsertOneEvent(context.Background(), &eventmod.Event{
|
|
EventId: event.EventID,
|
|
EventType: event.Event,
|
|
Data: string(b),
|
|
Status: eventmod.Default,
|
|
CreatedAt: time.Now(),
|
|
UpdatedAt: time.Now(),
|
|
}); err != nil {
|
|
log.Error("reportser insertEvent failed", log.Any("eventType", event.Event), log.Any("eventId", event.EventID), log.E(err))
|
|
}
|
|
}
|