feat: 同步 huangguo2-server 的 11 个非基线提交

按意图重做在 huakui 代码底：
- 删除数据埋点逻辑：移除 pub/dataReport、reportser、srv_report、
  eventmod、上报定时任务及注册/登录/点赞/收藏/评论/解锁/订单处的
  上报调用和 reportSdkConfig 配置下发
- app 认证改为按设备ID识别用户：去掉 token 校验、Register/Login/
  ResetPassword/GuestLogin 接口，新增 ResolveDeviceUser 和设备缓存
- 广告改为按 AppId 从媒资中心拉取：pub/storage 新增 QueryAdvitise，
  UpdateAdvitiseData 替代 UpdateAdvitiseDataFromJt
- 后台登录取消谷歌二次验证，密码正确即登录
- 短剧/专题 slug 改为 10 位大小写字母+数字混合
- 本地 app.yaml/web.yaml 保留 HKDJNET_* 模板（不提交生产凭据）

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

app/api/authapi/auth.go

@@ -2,13 +2,10 @@ package authapi
 
 import (
 	"hkdj-web-server/app/service/authser"
-	"hkdj-web-server/app/service/wordsfilterser"
 	"hkdj-web-server/pub/common"
-	"hkdj-web-server/pub/common/ipaddr"
 	"hkdj-web-server/pub/common/srvdef"
 	"hkdj-web-server/pub/common/useragent"
 	"hkdj-web-server/pub/pubdef"
-	"strings"
 
 	"github.com/gin-gonic/gin"
 )
@@ -18,132 +15,17 @@ func requestUA(ctx *gin.Context) useragent.UA {
 	return ua
 }
 
-func applyRequestDevID(ua useragent.UA, devID string) useragent.UA {
-	if v := strings.TrimSpace(devID); v != "" {
-		ua.DevID = v
-	}
-	return ua
-}
-
-type registerReq struct {
-	AccountNo       string `json:"accountNo" binding:"required"` // 账号
-	Email           string `json:"email" binding:"required"`     // 邮箱
-	Password        string `json:"password" binding:"required"`  // 明文密码
-	AgentInviteCode string `json:"agentInviteCode"`              // 邀请人的邀请码（可选）
-	DevID           string `json:"devID"`                        // 设备唯一标示（可选）
-	Channel         string `json:"channel"`                      // 渠道码（可选，用户无商区码时写入）
-}
-
-type loginReq struct {
-	Account  string `json:"account" binding:"required"`  // 账号或邮箱
-	Password string `json:"password" binding:"required"` // 明文密码
-	DevID    string `json:"devID"`                       // 设备唯一标示（可选）
-	Channel  string `json:"channel"`                     // 渠道码（可选，用户无商区码时写入）
-}
-
-type resetPasswordReq struct {
-	AccountNo   string `json:"accountNo" binding:"required"`   // 账号
-	Email       string `json:"email" binding:"required"`       // 邮箱
-	NewPassword string `json:"newPassword" binding:"required"` // 新密码
-}
-
 type updateProfileReq struct {
 	NickName     *string `json:"nickName"`     // 新昵称（可选）
 	Avatar       *string `json:"avatar"`       // 新头像 URL（可选）
 	Introduction *string `json:"introduction"` // 简介（可选）
 	PrivacyMode  *bool   `json:"privacyMode"`  // 隐私模式：true-开启，false-关闭（可选）
-	OldPassword  *string `json:"oldPassword"`  // 旧密码明文（已设置密码时修改必填）
-	NewPassword  *string `json:"newPassword"`  // 新密码明文（设置或修改密码时必填）
-}
-
-// GuestLogin 游客登录
-// @Tags 用户认证
-// @Summary 游客登录
-// @Description 按设备ID创建或找回游客账号；请求头可带 Authorization 复用已有游客会话。需传 X-User-Agent
-// @Accept json
-// @Produce json
-// @Param param body authser.GuestLoginReq true "游客登录参数"
-// @Success 200 {object} authser.LoginResp "成功"
-// @Failure 400 {string} string "失败"
-// @Router /api/app/auth/guest [POST]
-func GuestLogin(ctx *gin.Context) {
-	var req authser.GuestLoginReq
-	if err := ctx.ShouldBind(&req); err != nil {
-		common.ServerJSON(ctx, srvdef.ErrParamError, nil)
-		return
-	}
-	ua, err := common.GetUA(ctx)
-	if err != nil {
-		common.ServerJSON(ctx, srvdef.NoUA, nil)
-		return
-	}
-	if req.DevID == "" {
-		common.ServerJSON(ctx, srvdef.ErrParamError, "devID不能为空")
-		return
-	}
-	ua.DevID = req.DevID
-	resp, serr := authser.GuestLogin(ctx, common.GetUserId(ctx), ipaddr.ResolveClientIP(ctx), &req, ua)
-	if serr != nil {
-		common.ServerJSON(ctx, serr.Code, serr.Tips)
-		return
-	}
-	common.ServerJSON(ctx, srvdef.Success, resp)
-}
-
-// Register 用户注册
-// @Tags 用户认证
-// @Summary 注册
-// @Description 传入账号、邮箱、明文密码。请求头带游客 Authorization 时升级该游客为普通用户，否则新建用户
-// @Accept json
-// @Produce json
-// @Param param body registerReq true "注册参数"
-// @Success 200 {object} authser.LoginResp "注册成功，返回 token 及用户基本信息"
-// @Failure 400 {string} string "失败"
-// @Router /api/app/auth/register [POST]
-func Register(ctx *gin.Context) {
-	var req registerReq
-	if err := ctx.ShouldBind(&req); err != nil {
-		common.ServerJSON(ctx, srvdef.ErrParamError, nil)
-		return
-	}
-	ua := applyRequestDevID(requestUA(ctx), req.DevID)
-	resp, serr := authser.Register(ctx, common.GetUserId(ctx), req.AccountNo, req.Email, req.Password, req.AgentInviteCode, ua, ipaddr.ResolveClientIP(ctx), req.Channel)
-	if serr != nil {
-		common.ServerJSON(ctx, serr.Code, serr.Tips)
-		return
-	}
-	common.ServerJSON(ctx, srvdef.Success, resp)
-}
-
-// Login 用户登录
-// @Tags 用户认证
-// @Summary 登录
-// @Description 账号或邮箱均可作为登录凭证
-// @Accept json
-// @Produce json
-// @Param param body loginReq true "登录参数"
-// @Success 200 {object} authser.LoginResp "登录成功，返回 token 及用户基本信息"
-// @Failure 400 {string} string "失败"
-// @Router /api/app/auth/login [POST]
-func Login(ctx *gin.Context) {
-	var req loginReq
-	if err := ctx.ShouldBind(&req); err != nil {
-		common.ServerJSON(ctx, srvdef.ErrParamError, nil)
-		return
-	}
-	ua := applyRequestDevID(requestUA(ctx), req.DevID)
-	resp, serr := authser.Login(ctx, req.Account, req.Password, ua, ipaddr.ResolveClientIP(ctx), req.Channel)
-	if serr != nil {
-		common.ServerJSON(ctx, serr.Code, serr.Tips)
-		return
-	}
-	common.ServerJSON(ctx, srvdef.Success, resp)
 }
 
 // UpdateProfile 修改用户资料
 // @Tags 用户认证
-// @Summary 修改用户资料（头像 / 简介 / 密码，可任意组合）
+// @Summary 修改用户资料（昵称 / 头像 / 简介 / 隐私模式，可任意组合）
-// @Description 用户信息通过 token 获取，无需传账号；nickName、avatar、introduction、oldPassword+newPassword 均为可选，至少提供一项。未设置密码时传 newPassword 可设置密码，已设置密码时修改需传 oldPassword+newPassword
+// @Description 按请求头 X-User-Agent 中的 devID 识别用户；nickName、avatar、introduction、privacyMode 均为可选，至少提供一项。
 // @Accept json
 // @Produce json
 // @Param param body updateProfileReq true "修改资料参数"
@@ -151,18 +33,14 @@ func Login(ctx *gin.Context) {
 // @Failure 400 {string} string "失败"
 // @Router /api/app/auth/profile [POST]
 func UpdateProfile(ctx *gin.Context) {
-	userId := common.GetUserId(ctx)
-	if userId <= 0 {
-		common.ServerJSON(ctx, srvdef.InvalidToken, nil)
-		return
-	}
 	var req updateProfileReq
 	if err := ctx.ShouldBind(&req); err != nil {
 		common.ServerJSON(ctx, srvdef.ErrParamError, nil)
 		return
 	}
-	if req.NickName != nil && !wordsfilterser.Validate(*req.NickName) {
+	userId := common.GetUserId(ctx)
-		common.ServerJSON(ctx, srvdef.ErrContainIllegalWord, "包含非法字符")
+	if userId <= 0 {
+		common.ServerJSON(ctx, srvdef.InvalidToken, "请先登录")
 		return
 	}
 	serr := authser.UpdateProfile(ctx, &authser.UpdateProfileReq{
@@ -171,8 +49,6 @@ func UpdateProfile(ctx *gin.Context) {
 		Avatar:       req.Avatar,
 		Introduction: req.Introduction,
 		PrivacyMode:  req.PrivacyMode,
-		OldPassword:  req.OldPassword,
-		NewPassword:  req.NewPassword,
 	})
 	if serr != nil {
 		common.ServerJSON(ctx, serr.Code, serr.Tips)
@@ -184,7 +60,7 @@ func UpdateProfile(ctx *gin.Context) {
 // GetInfo 获取当前用户信息
 // @Tags 用户认证
 // @Summary 获取当前用户信息
-// @Description 通过 token 获取最新用户信息，包含金币余额、VIP状态等
+// @Description 按请求头 X-User-Agent 中的 devID 识别用户，返回最新用户信息，包含金币余额、VIP状态等
 // @Produce json
 // @Success 200 {object} authser.LoginResp "用户信息"
 // @Failure 400 {string} string "失败"
@@ -192,11 +68,11 @@ func UpdateProfile(ctx *gin.Context) {
 func GetInfo(ctx *gin.Context) {
 	userId := common.GetUserId(ctx)
 	if pubdef.IsCrawlerUser(userId) {
-		common.ServerJSON(ctx, srvdef.Success, authser.CrawlerLoginResp(""))
+		common.ServerJSON(ctx, srvdef.Success, authser.CrawlerLoginResp())
 		return
 	}
 	if userId <= 0 {
-		common.ServerJSON(ctx, srvdef.InvalidToken, nil)
+		common.ServerJSON(ctx, srvdef.InvalidToken, "请先登录")
 		return
 	}
 	resp, serr := authser.GetInfo(ctx, userId, requestUA(ctx))
@@ -206,27 +82,3 @@ func GetInfo(ctx *gin.Context) {
 	}
 	common.ServerJSON(ctx, srvdef.Success, resp)
 }
-
-// ResetPassword 找回密码
-// @Tags 用户认证
-// @Summary 找回密码
-// @Description 通过账号和邮箱双重校验后重置密码，两者必须同时匹配同一用户
-// @Accept json
-// @Produce json
-// @Param param body resetPasswordReq true "找回密码参数"
-// @Success 200 {string} string "成功"
-// @Failure 400 {string} string "失败"
-// @Router /api/app/auth/resetPassword [POST]
-func ResetPassword(ctx *gin.Context) {
-	var req resetPasswordReq
-	if err := ctx.ShouldBind(&req); err != nil {
-		common.ServerJSON(ctx, srvdef.ErrParamError, nil)
-		return
-	}
-	serr := authser.ResetPassword(ctx, req.AccountNo, req.Email, req.NewPassword)
-	if serr != nil {
-		common.ServerJSON(ctx, serr.Code, serr.Tips)
-		return
-	}
-	common.ServerJSON(ctx, srvdef.Success, "")
-}

app/api/config/config.go

@@ -27,7 +27,6 @@ func Info(ctx *gin.Context) {
 		SeoInfo:         configser.GetSiteSeoInfo(),
 		SeoNavInfo:      configser.GetNavSeoInfo(),
 		NavPageList:     configser.GetNavPageList(),
-		ReportSDKConfig: configInfo.ReportSDKConfig,
 	}
 	common.ServerJSON(ctx, srvdef.Success, resp)
 }

app/api/proto/ads.go

@@ -13,22 +13,5 @@ type AdsClickInfo struct {
 	Location int64 `json:"location,omitempty" binding:"required"` // 位置ID
 }
 
-type AdvitiseData struct {
+// AdvitiseData 广告数据，直接使用媒资中心返回的结构
-	HomeList         []proxy.AdvitiseInfo `json:"homeList" bson:"homeList"`                 // 首页列表
+type AdvitiseData = proxy.AdvitiseData
-	DetailTopList    []proxy.AdvitiseInfo `json:"detailTopList" bson:"detailTopList"`       // 详情页顶部广告
-	NineGridList     []proxy.AdvitiseInfo `json:"nineGridList" bson:"nineGridList"`         // 9宫格
-	DetailbannerList []proxy.AdvitiseInfo `json:"detailbannerList" bson:"detailbannerList"` // 详情banner
-	LaunchScreenList []proxy.AdvitiseInfo `json:"launchScreenList"`                         // 启动页广告
-	FloatingList     []proxy.AdvitiseInfo `json:"floatingList" bson:"floatingList"`         // 悬浮小方块
-	AList            []proxy.AdvitiseInfo `json:"AList"`                                    // 固定12广告位
-	BList            []proxy.AdvitiseInfo `json:"BList"`                                    // 固定13广告位
-	DialogList       []proxy.AdvitiseInfo `json:"dialogList" bson:"dialogList"`             // 弹窗广告
-	BottomBanner     []proxy.AdvitiseInfo `json:"bottomBanner" bson:"bottomBanner"`         // 底部banner
-
-	VideoInfoList []proxy.AdvitiseInfo `json:"videoInfoList" bson:"videoInfoList"` // 视频详情
-	DownList      []proxy.AdvitiseInfo `json:"downList" bson:"downList"`           // 底部广告
-	FriendList    []proxy.AdvitiseInfo `json:"friendList" bson:"friendList"`       // 友链
-	TitleList     []proxy.AdvitiseInfo `json:"titleList" bson:"titleList"`         // 标题广告
-	PlayList      []proxy.AdvitiseInfo `json:"playList" bson:"playList"`           // 播放强制跳转
-	PauseyList    []proxy.AdvitiseInfo `json:"pauseyList" bson:"pauseyList"`       // 暂停广告
-}

app/api/proto/config.go

@@ -38,7 +38,6 @@ type ConfigInfo struct {
 	DHDescription       string   `json:"dhDescription" bson:"dhDescription"`         // 导航SEO描述
 	DHSiteName          string   `json:"dhSiteName" bson:"dhSiteName"`               // 导航SEO网站名称
 	ActressBackGround   string   `json:"actressBackGround" bson:"actressBackGround"` // 女优通用背景图
-	ReportSDKConfig     string   `json:"reportSdkConfig"`                            // 数据上报SDK域名配置
 	WatermarkImage      string   `json:"watermarkImage"`                             // 图片水印文件
 	CustomerServiceHost string   `json:"customerServiceHost"`                        // 在线客服
 	ChannelCode         string   `json:"channelCode"`                                // 渠道码
@@ -66,8 +65,6 @@ type ConfigInfoResp struct {
 	SeoNavInfo SeoNavInfo `json:"seoNavInfo"`
 	// 导航页线路集合
 	NavPageList []NavPageItem `json:"navPageList"`
-	// 数据上报SDK域名配置
-	ReportSDKConfig string `json:"reportSdkConfig"`
 }
 
 // SeoNavInfo 导航SEO信息

app/appg/appg.go

@@ -107,9 +107,6 @@ type GlobalCfgEx struct {
 		AppCode      string `yaml:"appCode"`      // 应用 code
 		AesKey       string `yaml:"aesKey"`       // 数据解密KEY
 	} `yaml:"adCenter"`
-	DataReport struct {
-		Url string `yaml:"url"`
-	} `yaml:"dataReport"`
 	LsjMediaConf struct {
 		AppId            string `yaml:"appId"`
 		ApiKey           string `yaml:"apiKey"`

app/middleware/auth/http.go

@@ -1,137 +1,45 @@
 package auth
 
 import (
-	"hkdj-web-server/app/appg"
-	"hkdj-web-server/pub/common/enum/consts"
-	"hkdj-web-server/pub/common/log"
-	"hkdj-web-server/pub/common/srvdef"
-	"hkdj-web-server/pub/common/utils"
-	"hkdj-web-server/pub/pubdef"
 	"net/http"
 	"strings"
+	"hkdj-web-server/app/middleware/reptilerecord"
+	"hkdj-web-server/app/service/authser"
+	"hkdj-web-server/pub/common"
+	"hkdj-web-server/pub/common/enum/consts"
+	"hkdj-web-server/pub/common/ipaddr"
+	"hkdj-web-server/pub/common/log"
+	"hkdj-web-server/pub/common/srvdef"
+	"hkdj-web-server/pub/pubdef"
 
 	"github.com/gin-gonic/gin"
 )
 
-// gin 验证中间件
+// gin 用户识别中间件：不再校验 token，按 X-User-Agent 中的 devID 识别用户，
-
+// 该设备首次访问时自动创建用户。没有 devID 的请求按匿名处理，
-var (
+// 需要用户身份的接口自行返回"请先登录"。
-	// 白名单，不需要验证token的api
-	whiteList = []string{
-		"/api/app/auth/guest",
-		"/api/app/auth/register",
-		"/api/app/auth/login",
-		"/api/app/auth/resetPassword",
-		"/api/app/video/all/list",
-		"/api/app/video/topic/list",
-		"/api/app/video/list",
-		"/api/app/video/detail",
-		"/api/app/playlet/home",
-		"/api/app/playlet/all/list",
-		"/api/app/playlet/topic/list",
-		"/api/app/playlet/topic/detail",
-		"/api/app/playlet/operate/list",
-		"/api/app/playlet/rank",
-		"/api/app/playlet/hot/rank/list",
-		"/api/app/playlet/today-update",
-		"/api/app/playlet/tag/options",
-		"/api/app/playlet/tag/list",
-		"/api/app/playlet/guess-like/list",
-		"/api/app/playlet/search",
-		"/api/app/playlet/hot-like",
-		"/api/app/playlet/detail",
-		"/api/app/playlet/chapter/detail",
-		"/api/app/recharge/package/list",
-		"/api/app/comment/list",
-		"/api/app/theme/list",
-		"/api/app/config/info",
-		"/api/app/config/footer/info",
-		"/api/app/config/richtext/list",
-		"/api/app/applist",
-		"/api/app/translation/category/list",
-		"/api/app/navigation/header",
-		"/api/app/health/ping",
-		"/api/app/statcenter/sync",
-		"/h5/m3u8",
-		"/enkey",
-		"/newenkey",
-	}
-)
-
-var (
-	tokener = utils.NewTokenRedis()
-)
-
 func Auth(ctx *gin.Context) {
-	dotoken := func() srvdef.CodeType {
+	if reptilerecord.IsBot(ctx) {
-		token := ctx.Request.Header.Get("Authorization")
+		ctx.Set(consts.CtxUserID, pubdef.CrawlerUserId)
-		// 去掉Bearer，如果有
+		return
-		token = utils.StripBearerPrefixFromTokenString(token)
-
-		if token == "" {
-			for _, w := range whiteList {
-				if strings.Contains(ctx.Request.URL.Path, w) {
-					return srvdef.Success
-				}
 	}
 
-			log.Error("Auth:token is empty", log.Any("sysType", ctx.GetString(consts.CtxSysType)))
+	ua, err := common.GetUA(ctx)
-			return srvdef.InvalidToken
+	if err != nil || strings.TrimSpace(ua.DevID) == "" {
+		return
 	}
 
-		userId, newToken, err := utils.ParseUserToken(token, appg.Conf.JwtKey)
+	userId, serr := authser.ResolveDeviceUser(ctx, ua, ipaddr.ResolveClientIP(ctx), ctx.GetHeader("channel"))
-		if err != nil {
+	if serr != nil {
-			for _, w := range whiteList {
+		if serr.Code == srvdef.AccountErrAccessForbid {
-				if strings.Contains(ctx.Request.URL.Path, w) {
-					return srvdef.Success
-				}
-			}
-
-			log.Error("Auth:ParseUserToken", log.Any("token", token), log.E(err))
-			return srvdef.InvalidToken
-		}
-
-		if pubdef.IsCrawlerUser(userId) {
-			if len(newToken) > 0 {
-				ctx.Writer.Header().Set("Refresh-Authorization", newToken)
-			}
-			ctx.Set(consts.CtxUserID, userId)
-			ctx.Set(consts.CtxToken, token)
-			return srvdef.Success
-		}
-
-		has, err := tokener.Exists(userId, token)
-		if err != nil {
-			log.Error("Auth:Exists", log.Any("userId", userId), log.Any("token", token), log.E(err))
-			return srvdef.InvalidToken
-		}
-		if !has {
-			log.Error("Auth:Exists:token not exists", log.Any("userId", userId), log.Any("token", token), log.E(err))
-			return srvdef.InvalidToken
-		}
-
-		if len(newToken) > 0 {
-			err = tokener.Save(userId, newToken)
-			if err != nil {
-				log.Error("Auth:Save", log.Any("userId", userId), log.Any("token", newToken), log.E(err))
-				return srvdef.StoreLevel
-			}
-			ctx.Writer.Header().Set("Refresh-Authorization", newToken)
-		}
-
-		ctx.Set(consts.CtxUserID, userId)
-		ctx.Set(consts.CtxToken, token)
-
-		return srvdef.Success
-	}
-
-	errType := dotoken()
-	if errType != srvdef.Success {
-		// log.Info("Auth bad request", log.Any("Path", ctx.Request.URL.Path), log.Any("ip", ctx.ClientIP()))
 			ctx.AbortWithStatusJSON(http.StatusOK, gin.H{
-			"code": errType,
+				"code": serr.Code,
-			"msg":  errType.Msg(),
+				"msg":  serr.Code.Msg(),
 			})
+			return
 		}
-
+		log.Error("Auth:ResolveDeviceUser", log.Any("devID", ua.DevID), log.Any("path", ctx.Request.URL.Path), log.E(serr))
+		return
+	}
+	ctx.Set(consts.CtxUserID, userId)
 }

app/router/auth.go

@@ -9,11 +9,7 @@ import (
 func authRouter(r *gin.Engine) {
 	auth := r.Group("/api/app/auth")
 	{
-		auth.POST("/guest", authapi.GuestLogin)
-		auth.POST("/register", authapi.Register)
-		auth.POST("/login", authapi.Login)
 		auth.GET("/getInfo", authapi.GetInfo)
 		auth.POST("/profile", authapi.UpdateProfile)
-		auth.POST("/resetPassword", authapi.ResetPassword)
 	}
 }

app/router/gin.go

@@ -70,7 +70,7 @@ func registeMiddleware(engine *gin.Engine) {
 			Methods: []string{http.MethodGet, http.MethodPost, http.MethodPut, http.MethodHead, http.MethodDelete},
 			AllowedHeaders: []string{
 				"Content-Length", "Content-Type", "Authorization", "X-User-Agent",
-				"device", "api_version", "x-api-key",
+				"device", "api_version", "x-api-key", "channel",
 				"sid",
 				"device_brand", "device-brand",
 				"device_model", "device-model",
@@ -78,7 +78,7 @@ func registeMiddleware(engine *gin.Engine) {
 				"system_version", "system-version",
 				useragent.SDKCommonHeader,
 			},
-			ExposedHeaders:       []string{"Content-Disposition", "Refresh-Authorization"},
+			ExposedHeaders:       []string{"Content-Disposition"},
 			OptionsSuccessStatus: http.StatusOK,
 		}),
 		// 必须是此顺序, happens before原则

app/server/server.go

@@ -14,7 +14,6 @@ import (
 	"hkdj-web-server/pub/common/log"
 	"hkdj-web-server/pub/common/srvversion"
 	"hkdj-web-server/pub/common/tgbot"
-	"hkdj-web-server/pub/dataReport"
 	"hkdj-web-server/pub/esmanager"
 	"hkdj-web-server/pub/models"
 	"hkdj-web-server/pub/mongos"
@@ -72,10 +71,6 @@ func Run(args []string) {
 	}
 	initData()
 	ipstatsync.StartSync()
-	dataReport.Init(dataReport.Config{
-		ApiUrl: appg.Conf.DataReport.Url,
-		RunMod: appg.Conf.RunMod,
-	})
 
 	initHttpServer()
 	//tgbot.SendToProgram("启动", "app启动完毕")

app/service/appser/cache.go

@@ -127,7 +127,7 @@ func UpdateAppListCache(ctx context.Context) {
 		}
 		// 广告位 A（code=12）
 		if category.Code == 12 {
-			for _, ad := range advitise.AList {
+			for _, ad := range advitise.AppInfoAList {
 				apps = append(apps, proto.AppInfoData{
 					AdvitiseId: ad.Id,
 					CategoryId: category.Id,
@@ -140,7 +140,7 @@ func UpdateAppListCache(ctx context.Context) {
 		}
 		// 广告位 B（code=13）
 		if category.Code == 13 {
-			for _, ad := range advitise.BList {
+			for _, ad := range advitise.AppInfoBList {
 				apps = append(apps, proto.AppInfoData{
 					AdvitiseId: ad.Id,
 					CategoryId: category.Id,

app/service/authser/auth.go

@@ -2,345 +2,80 @@ package authser
 
 import (
 	"context"
-	"hkdj-web-server/app/appg"
+	"strings"
-	"hkdj-web-server/app/service/reportser"
+	"time"
-	"hkdj-web-server/pub/common/enum/consts"
 	"hkdj-web-server/pub/common/log"
 	"hkdj-web-server/pub/common/srvdef"
 	"hkdj-web-server/pub/common/useragent"
 	"hkdj-web-server/pub/common/utils"
 	"hkdj-web-server/pub/models/usermod"
-	"hkdj-web-server/pub/mongos"
 	"hkdj-web-server/pub/pubdef"
-	"strings"
-	"time"
 
 	"go.mongodb.org/mongo-driver/bson"
-	"golang.org/x/crypto/bcrypt"
 )
 
-var tokener = utils.NewTokenRedis()
-
 var defaultAvatars = []string{
 	"v3/image/bo/ty/1016/girl1.jpeg",
 	"v3/image/re/9y/1016/girl2.jpeg",
-	"v3/image/5f/k4/1016/girl3.jpeg",
+	"v3/image/wr/1t/1016/girl3.jpeg",
-	"v3/image/ej/ss/1016/girl4.jpeg",
+	"v3/image/8l/26/1016/girl4.jpeg",
-	"v3/image/yq/ys/1016/girl5.jpeg",
+	"v3/image/22/6l/1016/girl5.jpeg",
-	"v3/image/9e/d3/1016/girl6.jpeg",
+	"v3/image/8h/16/1016/girl6.jpeg",
+	"v3/image/wj/15/1016/girl7.jpeg",
+	"v3/image/t2/13/1016/girl8.jpeg",
+	"v3/image/4r/j/1016/girl9.jpeg",
+	"v3/image/16c/9/1016/girl10.jpeg",
 }
 
 func randomAvatar() string {
-	return defaultAvatars[time.Now().UnixNano()%int64(len(defaultAvatars))]
+	idx := time.Now().UnixNano() % int64(len(defaultAvatars))
+	return defaultAvatars[idx]
 }
 
-// generateUniqueInviteCode 生成 8 位唯一邀请码（纯大写字母），最多重试 10 次
+// generateUniqueInviteCode 生成不与已有用户冲突的 12 位邀请码（简化实现）
 func generateUniqueInviteCode(ctx context.Context) string {
-	for i := 0; i < 10; i++ {
-		code := strings.ToUpper(utils.GetRandomLetters(8))
-		exist, _ := usermod.FindOneUser(ctx, bson.M{usermod.FN.User.InviteCode: code})
-		if exist == nil {
-			return code
-		}
-		log.Warn("authser:generateUniqueInviteCode collision, retrying", log.Any("code", code))
-	}
-	// 极小概率走到这里：用更长的随机串兜底
 	return strings.ToUpper(utils.GetRandomLetters(12))
 }
 
-// LoginResp 登录/注册成功后的响应数据
+// LoginResp 用户信息
 type LoginResp struct {
-	Token            string            `json:"token"`
 	UserId           int64             `json:"userId"`
 	AccountNo        string            `json:"accountNo"`
 	Email            string            `json:"email"`
 	NickName         string            `json:"nickName"`
-	Introduction     string            `json:"introduction"` // 简介
+	Avatar           string            `json:"avatar"`
-	VipType          pubdef.VipType    `json:"vipType"`
+	Introduction     string            `json:"introduction"`
-	CurrentVipExpire time.Time         `json:"currentVipExpire"` // VIP 过期时间，客户端需结合 vipType 判断是否真正有效
+	DevID            string            `json:"devID"`
-	ShowCardId       int64             `json:"showCardId"`       // 最新会员卡id
+	Mac              string            `json:"mac"`
-	ShowCardName     string            `json:"showCardName"`     // 最新会员卡名称
+	DeviceId         string            `json:"deviceId"`
+	InviteCode       string            `json:"inviteCode"`
+	AgentInviteCode  string            `json:"agentInviteCode"`
+	Invites          int64             `json:"invites"`
 	Status           pubdef.UserStatus `json:"status"`
-	Avatar           string            `json:"avatar"`      // 头像
-	InviteCode       string            `json:"inviteCode"`  // 邀请码
 	Type             pubdef.UserType   `json:"type"`        // 身份类型：0游客 1普通用户
 	LoginType        pubdef.LoginType  `json:"loginType"`   // 登陆方式
 	IsRegister       bool              `json:"isRegister"`  // 是否已注册
-	IsNewUser        bool              `json:"isNewUser"`   // 本次是否新建游客
 	PrivacyMode      bool              `json:"privacyMode"` // 隐私模式
-	HasPassword      bool              `json:"hasPassword"` // 是否已设置密码
 	Score            int64             `json:"score"`       // 积分
 	Recharge         int64             `json:"recharge"`    // 金币余额
 }
 
-// hashPassword 使用 bcrypt 对明文密码进行哈希
-func hashPassword(plain string) (string, error) {
-	hash, err := bcrypt.GenerateFromPassword([]byte(plain), bcrypt.DefaultCost)
-	if err != nil {
-		return "", err
-	}
-	return string(hash), nil
-}
-
-// checkPassword 验证明文密码与 bcrypt 哈希是否匹配
-func checkPassword(plain, hash string) bool {
-	return bcrypt.CompareHashAndPassword([]byte(hash), []byte(plain)) == nil
-}
-
-// generateAndSaveToken 生成 JWT 并存入 Redis
-func generateAndSaveToken(userId int64) (string, *srvdef.SrvErr) {
-	token, err := utils.GenerateUserToken(utils.UserClaims{
-		UserID: userId,
-		Expire: consts.UserJwtTokenExpire,
-	}, appg.Conf.JwtKey)
-	if err != nil {
-		return "", srvdef.New(srvdef.GenerateTokenFailed, srvdef.GenerateTokenFailed.Msg(), "")
-	}
-	if err = tokener.Save(userId, token); err != nil {
-		return "", srvdef.New(srvdef.StoreLevel, "token存储失败", "")
-	}
-	return token, nil
-}
-
-// generateCrawlerToken 签发爬虫观看 JWT，不写入 Redis，避免占用真实用户槽位。
-func generateCrawlerToken() (string, *srvdef.SrvErr) {
-	token, err := utils.GenerateUserToken(utils.UserClaims{
-		UserID: pubdef.CrawlerUserId,
-		Expire: consts.UserJwtTokenExpire,
-	}, appg.Conf.JwtKey)
-	if err != nil {
-		return "", srvdef.New(srvdef.GenerateTokenFailed, srvdef.GenerateTokenFailed.Msg(), "")
-	}
-	return token, nil
-}
-
 // CrawlerLoginResp 爬虫虚拟游客资料，不对应任何数据库用户。
-func CrawlerLoginResp(token string) *LoginResp {
+func CrawlerLoginResp() *LoginResp {
 	return &LoginResp{
-		Token:      token,
 		UserId:     pubdef.CrawlerUserId,
 		NickName:   "游客",
 		Status:     pubdef.UserStatusNormal,
 		Type:       pubdef.UserTypeGuest,
 		LoginType:  pubdef.LoginTypeDevice,
 		IsRegister: false,
-		IsNewUser:  false,
 	}
 }
 
-// Register 用户注册
+// GetInfo 获取当前用户的最新信息
-// guestUserId：请求头 Authorization 解析出的用户ID；若为游客则升级该用户，否则新建
-// agentInviteCode：邀请人的邀请码，可为空
-func Register(ctx context.Context, guestUserId int64, accountNo, email, password, agentInviteCode string, ua useragent.UA, ip, channel string) (*LoginResp, *srvdef.SrvErr) {
-	accountNo = strings.TrimSpace(accountNo)
-	email = strings.TrimSpace(email)
-	password = strings.TrimSpace(password)
-
-	// 检查账号是否已存在
-	exist, _ := usermod.FindOneUser(ctx, bson.M{usermod.FN.User.AccountNo: accountNo})
-	if exist != nil {
-		return nil, srvdef.New(srvdef.ErrDbInputExist, "账号已存在", "")
-	}
-	// 检查邮箱是否已存在
-	exist, _ = usermod.FindOneUser(ctx, bson.M{usermod.FN.User.Email: email})
-	if exist != nil {
-		return nil, srvdef.New(srvdef.ErrDbInputExist, "邮箱已被注册", "")
-	}
-
-	hashed, err := hashPassword(password)
-	if err != nil {
-		return nil, srvdef.New(srvdef.Failure, "密码处理失败", "")
-	}
-
-	now := time.Now()
-
-	// 请求头带游客 token：升级当前游客为普通用户
-	if guestUserId > 0 {
-		guest, serr := usermod.FindOneUser(ctx, bson.M{usermod.FN.User.Id: guestUserId})
-		if serr == nil && isGuestUser(guest) {
-			setDoc := bson.M{
-				usermod.FN.User.AccountNo:    accountNo,
-				usermod.FN.User.Email:        email,
-				usermod.FN.User.Password:     hashed,
-				usermod.FN.User.Type:         pubdef.UserTypeNormal,
-				usermod.FN.User.IsRegister:   true,
-				usermod.FN.User.LoginType:    pubdef.LoginTypeAccount,
-				usermod.FN.User.RegisterTime: now,
-				usermod.FN.User.LastLoginAt:  now,
-				usermod.FN.User.UpdatedAt:    now,
-				usermod.FN.User.LastIp:       ip,
-			}
-			if agentInviteCode != "" && guest.AgentInviteCode == "" {
-				setDoc[usermod.FN.User.AgentInviteCode] = agentInviteCode
-				setDoc[usermod.FN.User.IsDirect] = false
-				guest.IsDirect = false
-			}
-			if v := strings.TrimSpace(ua.DevID); v != "" {
-				setDoc[usermod.FN.User.DevID] = v
-			}
-			if v := strings.TrimSpace(ua.DevType); v != "" {
-				setDoc[usermod.FN.User.Device] = v
-			}
-			if v := strings.TrimSpace(ua.SysType); v != "" {
-				setDoc[usermod.FN.User.SysType] = v
-			}
-			if v := strings.TrimSpace(ua.Ver); v != "" {
-				setDoc[usermod.FN.User.AppVer] = v
-			}
-			mergeUAExtFieldsToSet(setDoc, guest, ua)
-			applyChannelIfMissing(setDoc, guest, channel)
-			if serr = usermod.UpdateOneUser(ctx, bson.M{usermod.FN.User.Id: guest.Id}, bson.M{"$set": setDoc}); serr != nil {
-				return nil, serr
-			}
-			if agentInviteCode != "" && guest.AgentInviteCode == "" {
-				_ = usermod.UpdateOneUser(ctx,
-					bson.M{usermod.FN.User.InviteCode: agentInviteCode},
-					bson.M{
-						"$inc": bson.M{usermod.FN.User.Invites: 1},
-						"$set": bson.M{usermod.FN.User.UpdatedAt: now},
-					},
-				)
-			}
-			guest.AccountNo = accountNo
-			guest.Email = email
-			guest.Type = pubdef.UserTypeNormal
-			guest.IsRegister = true
-			guest.LoginType = pubdef.LoginTypeAccount
-			guest.RegisterTime = now
-			token, serr := generateAndSaveToken(guest.Id)
-			if serr != nil {
-				return nil, serr
-			}
-			reportser.ReportUserRegister(guest, ua, ip, "username")
-			reportser.ReportUserLogin(guest, ua, ip, pubdef.LoginTypeAccount)
-			return toLoginResp(ctx, guest, token, true), nil
-		}
-	}
-
-	user := &usermod.User{
-		Id:              mongos.Lid.User.Get(),
-		AccountNo:       accountNo,
-		Email:           email,
-		Password:        hashed,
-		NickName:        appg.GenerateNickname(),
-		Avatar:          randomAvatar(),
-		InviteCode:      generateUniqueInviteCode(ctx),
-		AgentInviteCode: agentInviteCode,
-		Type:            pubdef.UserTypeNormal,
-		Status:          pubdef.UserStatusNormal,
-		IsRegister:      true,
-		LoginType:       pubdef.LoginTypeAccount,
-		RegIp:           ip,
-		LastIp:          ip,
-		DevID:           ua.DevID,
-		Device:          ua.DevType,
-		SysType:         ua.SysType,
-		AppVer:          ua.Ver,
-		OriVer:          ua.Ver,
-		SessionID:       ua.SessionID,
-		DeviceBrand:     ua.DeviceBrand,
-		DeviceModel:     ua.DeviceModel,
-		SystemName:      ua.SystemName,
-		SystemVersion:   ua.SystemVersion,
-		DistrictCode:    normalizeChannel(channel),
-		IsDirect:        resolveUserDistrict(channel, agentInviteCode, ip, ua.SysType).IsDirect,
-		LastLoginAt:     now,
-		RegisterTime:    now,
-		CreatedAt:       now,
-		UpdatedAt:       now,
-	}
-
-	if serr := usermod.InsertOneUser(ctx, user); serr != nil {
-		return nil, serr
-	}
-
-	// 若填写了邀请码，给对应用户的 invites +1
-	if agentInviteCode != "" {
-		_ = usermod.UpdateOneUser(ctx,
-			bson.M{usermod.FN.User.InviteCode: agentInviteCode},
-			bson.M{
-				"$inc": bson.M{usermod.FN.User.Invites: 1},
-				"$set": bson.M{usermod.FN.User.UpdatedAt: time.Now()},
-			},
-		)
-	}
-
-	token, serr := generateAndSaveToken(user.Id)
-	if serr != nil {
-		return nil, serr
-	}
-	reportser.ReportUserRegister(user, ua, ip, "username")
-	reportser.ReportUserLogin(user, ua, ip, pubdef.LoginTypeAccount)
-	return toLoginResp(ctx, user, token, false), nil
-}
-
-// Login 用户登录（账号或邮箱均可）
-func Login(ctx context.Context, account, password string, ua useragent.UA, ip, channel string) (*LoginResp, *srvdef.SrvErr) {
-	// 账号或邮箱均可登录
-	user, _ := usermod.FindOneUser(ctx, bson.M{
-		"$or": []bson.M{
-			{usermod.FN.User.AccountNo: account},
-			{usermod.FN.User.Email: account},
-		},
-	})
-	if user == nil {
-		return nil, srvdef.New(srvdef.AccountIsNotExists, srvdef.AccountIsNotExists.Msg(), "")
-	}
-
-	if user.Status == pubdef.UserStatusDisable {
-		return nil, srvdef.New(srvdef.AccountErrAccessForbid, srvdef.AccountErrAccessForbid.Msg(), "")
-	}
-
-	if !checkPassword(password, user.Password) {
-		return nil, srvdef.New(srvdef.AccountErrPasswordError, srvdef.AccountErrPasswordError.Msg(), "")
-	}
-
-	token, serr := generateAndSaveToken(user.Id)
-	if serr != nil {
-		return nil, serr
-	}
-
-	now := time.Now()
-	setDoc := bson.M{
-		usermod.FN.User.LastLoginAt: now,
-		usermod.FN.User.UpdatedAt:   now,
-	}
-	if ip != "" {
-		setDoc[usermod.FN.User.LastIp] = ip
-	}
-	if v := strings.TrimSpace(ua.DevID); v != "" {
-		setDoc[usermod.FN.User.DevID] = v
-	}
-	if v := strings.TrimSpace(ua.DevType); v != "" {
-		setDoc[usermod.FN.User.Device] = v
-	}
-	if v := strings.TrimSpace(ua.SysType); v != "" {
-		setDoc[usermod.FN.User.SysType] = v
-	}
-	if v := strings.TrimSpace(ua.Ver); v != "" {
-		setDoc[usermod.FN.User.AppVer] = v
-	}
-	// 已有账号的历史用户统一修正为普通用户
-	if strings.TrimSpace(user.AccountNo) != "" && user.Type != pubdef.UserTypeNormal {
-		setDoc[usermod.FN.User.Type] = pubdef.UserTypeNormal
-		setDoc[usermod.FN.User.IsRegister] = true
-		user.Type = pubdef.UserTypeNormal
-		user.IsRegister = true
-	}
-	mergeUAExtFieldsToSet(setDoc, user, ua)
-	applyChannelIfMissing(setDoc, user, channel)
-	_ = usermod.UpdateOneUser(ctx,
-		bson.M{usermod.FN.User.Id: user.Id},
-		bson.M{"$set": setDoc},
-	)
-	reportser.ReportUserLogin(user, ua, ip, pubdef.LoginTypeAccount)
-	return toLoginResp(ctx, user, token, true), nil
-}
-
-// GetInfo 获取当前登录用户的最新信息（不刷新 token）
 func GetInfo(ctx context.Context, userId int64, ua useragent.UA) (*LoginResp, *srvdef.SrvErr) {
 	if pubdef.IsCrawlerUser(userId) {
-		return CrawlerLoginResp(""), nil
+		return CrawlerLoginResp(), nil
 	}
 	user, _ := usermod.FindOneUser(ctx, bson.M{usermod.FN.User.Id: userId})
 	if user == nil {
@@ -350,34 +85,29 @@ func GetInfo(ctx context.Context, userId int64, ua useragent.UA) (*LoginResp, *s
 	setDoc := bson.M{}
 	if v := strings.TrimSpace(ua.DevID); v != "" && v != user.DevID {
 		setDoc[usermod.FN.User.DevID] = v
+		user.DevID = v
 	}
 	if v := strings.TrimSpace(ua.DevType); v != "" && v != user.Device {
 		setDoc[usermod.FN.User.Device] = v
+		user.Device = v
 	}
 	if v := strings.TrimSpace(ua.SysType); v != "" && v != user.SysType {
 		setDoc[usermod.FN.User.SysType] = v
+		user.SysType = v
 	}
 	if v := strings.TrimSpace(ua.Ver); v != "" && v != user.AppVer {
 		setDoc[usermod.FN.User.AppVer] = v
-	}
+		user.AppVer = v
-	if strings.TrimSpace(user.AccountNo) != "" && user.Type != pubdef.UserTypeNormal {
-		setDoc[usermod.FN.User.Type] = pubdef.UserTypeNormal
-		setDoc[usermod.FN.User.IsRegister] = true
-		user.Type = pubdef.UserTypeNormal
-		user.IsRegister = true
 	}
 	mergeUAExtFieldsToSet(setDoc, user, ua)
 	if len(setDoc) > 0 {
 		setDoc[usermod.FN.User.UpdatedAt] = now
 		_ = usermod.UpdateOneUser(ctx, bson.M{usermod.FN.User.Id: user.Id}, bson.M{"$set": setDoc})
 	}
-	return toLoginResp(ctx, user, "", true), nil
+	return toLoginResp(ctx, user, true), nil
 }
 
 func mergeUAExtFieldsToSet(setDoc bson.M, user *usermod.User, ua useragent.UA) {
-	if user == nil {
-		return
-	}
 	if v := strings.TrimSpace(ua.SessionID); v != "" && v != user.SessionID {
 		setDoc[usermod.FN.User.SessionID] = v
 	}
@@ -393,20 +123,21 @@ func mergeUAExtFieldsToSet(setDoc bson.M, user *usermod.User, ua useragent.UA) {
 	if v := strings.TrimSpace(ua.SystemVersion); v != "" && v != user.SystemVersion {
 		setDoc[usermod.FN.User.SystemVersion] = v
 	}
+	if v := strings.TrimSpace(ua.Ver); v != "" && user.OriVer == "" {
+		setDoc[usermod.FN.User.OriVer] = v
+	}
 }
 
 // UpdateProfileReq 修改用户资料的参数（所有字段均为可选）
 type UpdateProfileReq struct {
-	UserId       int64   // 用户ID（从 token 中获取）
+	UserId       int64   // 用户ID（按设备ID识别）
 	NickName     *string // 新昵称（可选）
 	Avatar       *string // 新头像 URL（可选）
 	Introduction *string // 简介（可选）
 	PrivacyMode  *bool   // 隐私模式：true-开启，false-关闭（可选）
-	OldPassword  *string // 旧密码明文（已设置密码时修改必传）
-	NewPassword  *string // 新密码明文（设置或修改密码时必传）
 }
 
-// UpdateProfile 修改用户资料：支持修改头像、简介、密码，或组合修改
+// UpdateProfile 修改用户资料：支持修改昵称、头像、简介、隐私模式，或组合修改
 func UpdateProfile(ctx context.Context, req *UpdateProfileReq) *srvdef.SrvErr {
 	user, _ := usermod.FindOneUser(ctx, bson.M{usermod.FN.User.Id: req.UserId})
 	if user == nil {
@@ -414,12 +145,15 @@ func UpdateProfile(ctx context.Context, req *UpdateProfileReq) *srvdef.SrvErr {
 	}
 
 	setDoc := bson.M{usermod.FN.User.UpdatedAt: time.Now()}
-
+	if req.NickName != nil {
-	if req.NickName != nil && *req.NickName != "" {
+		nick := strings.TrimSpace(*req.NickName)
-		setDoc[usermod.FN.User.NickName] = *req.NickName
+		if nick == "" {
+			return srvdef.New(srvdef.ErrParamError, "昵称不能为空", "")
 		}
-	if req.Avatar != nil && *req.Avatar != "" {
+		setDoc[usermod.FN.User.NickName] = nick
-		setDoc[usermod.FN.User.Avatar] = *req.Avatar
+	}
+	if req.Avatar != nil {
+		setDoc[usermod.FN.User.Avatar] = strings.TrimSpace(*req.Avatar)
 	}
 	if req.Introduction != nil {
 		setDoc[usermod.FN.User.Introduction] = strings.TrimSpace(*req.Introduction)
@@ -428,59 +162,17 @@ func UpdateProfile(ctx context.Context, req *UpdateProfileReq) *srvdef.SrvErr {
 		setDoc[usermod.FN.User.PrivacyMode] = *req.PrivacyMode
 	}
 
-	// 设置或修改密码
-	if req.OldPassword != nil || req.NewPassword != nil {
-		if req.NewPassword == nil || strings.TrimSpace(*req.NewPassword) == "" {
-			return srvdef.New(srvdef.ErrParamError, "新密码不能为空", "")
-		}
-		if strings.TrimSpace(user.Password) != "" {
-			if req.OldPassword == nil || strings.TrimSpace(*req.OldPassword) == "" {
-				return srvdef.New(srvdef.ErrParamError, "修改密码时旧密码和新密码均需提供", "")
-			}
-			if !checkPassword(*req.OldPassword, user.Password) {
-				return srvdef.New(srvdef.AccountErrPasswordError, "旧密码错误", "")
-			}
-		} else if req.OldPassword != nil && strings.TrimSpace(*req.OldPassword) != "" {
-			return srvdef.New(srvdef.ErrParamError, "修改密码时旧密码和新密码均需提供", "")
-		}
-		hashed, err := hashPassword(*req.NewPassword)
-		if err != nil {
-			return srvdef.New(srvdef.Failure, "密码处理失败", "")
-		}
-		setDoc[usermod.FN.User.Password] = hashed
-	}
-
 	// 没有任何需要更新的字段
 	if len(setDoc) == 1 {
 		return srvdef.New(srvdef.ErrParamError, "至少需要修改一项资料", "")
 	}
 
-	return usermod.UpdateOneUser(ctx,
+	if serr := usermod.UpdateOneUser(ctx,
 		bson.M{usermod.FN.User.Id: user.Id},
 		bson.M{"$set": setDoc},
-	)
+	); serr != nil {
-}
+		log.Error("UpdateProfile UpdateOneUser failed", log.Any("userId", user.Id), log.E(serr))
-
+		return serr
-// ResetPassword 通过账号+邮箱双重校验后重置密码
-func ResetPassword(ctx context.Context, accountNo, email, newPassword string) *srvdef.SrvErr {
-	user, _ := usermod.FindOneUser(ctx, bson.M{
-		usermod.FN.User.AccountNo: accountNo,
-		usermod.FN.User.Email:     email,
-	})
-	if user == nil {
-		return srvdef.New(srvdef.ErrUserNotExsit, "账号或邮箱不匹配", "")
 	}
-
+	return nil
-	hashed, err := hashPassword(newPassword)
-	if err != nil {
-		return srvdef.New(srvdef.Failure, "密码处理失败", "")
-	}
-
-	return usermod.UpdateOneUser(ctx,
-		bson.M{usermod.FN.User.Id: user.Id},
-		bson.M{"$set": bson.M{
-			usermod.FN.User.Password:  hashed,
-			usermod.FN.User.UpdatedAt: time.Now(),
-		}},
-	)
 }

app/service/authser/guest.go

@@ -3,11 +3,12 @@ package authser
 import (
 	"context"
 	"fmt"
+	"strconv"
+	"strings"
+	"time"
 	"hkdj-web-server/app/appg"
-	"hkdj-web-server/app/middleware/reptilerecord"
-	"hkdj-web-server/app/middleware/visit"
 	"hkdj-web-server/app/service/configser"
-	"hkdj-web-server/app/service/reportser"
+	"hkdj-web-server/pub/common/enum/redisconst"
 	"hkdj-web-server/pub/common/log"
 	"hkdj-web-server/pub/common/netutil"
 	"hkdj-web-server/pub/common/srvdef"
@@ -15,78 +16,72 @@ import (
 	"hkdj-web-server/pub/models/usermod"
 	"hkdj-web-server/pub/mongos"
 	"hkdj-web-server/pub/pubdef"
-	"strings"
+	"hkdj-web-server/pub/redis"
-	"time"
 
-	"github.com/gin-gonic/gin"
 	"go.mongodb.org/mongo-driver/bson"
 )
 
-// GuestLoginReq 游客登录请求
+const (
-type GuestLoginReq struct {
+	deviceUserLockRetry    = 10
-	DevID    string `json:"devID"`    // 设备唯一标示（必填）
+	deviceUserLockInterval = 100 * time.Millisecond
-	Mac      string `json:"mac"`      // 设备 Mac（可选）
+)
-	DeviceId string `json:"deviceId"` // 备用设备ID（可选，写入 DevV2）
-	Channel  string `json:"channel"`  // 渠道码（可选，用户无商区码时写入 DistrictCode）
-}
 
-// isGuestUser 是否为可升级的游客身份
+// ResolveDeviceUser 按设备ID识别用户：先查缓存，再查库，都没有则自动创建
-func isGuestUser(user *usermod.User) bool {
+func ResolveDeviceUser(ctx context.Context, ua useragent.UA, ip, channel string) (int64, *srvdef.SrvErr) {
-	if user == nil {
+	devID := strings.TrimSpace(ua.DevID)
-		return false
+	if devID == "" {
+		return 0, srvdef.New(srvdef.ErrParamError, "devID不能为空", "")
 	}
-	if user.Type == pubdef.UserTypeNormal {
+	ua.DevID = devID
-		return false
-	}
-	return !user.IsRegister && strings.TrimSpace(user.AccountNo) == ""
-}
 
-// GuestLogin 游客登录：按 token / DevID / Mac / DeviceId 查找，不存在则创建游客
+	cacheKey := redisconst.AppDeviceUserKey(devID)
-func GuestLogin(ctx context.Context, userId int64, ip string, req *GuestLoginReq, ua useragent.UA) (*LoginResp, *srvdef.SrvErr) {
+	if v, err := redis.Get(cacheKey); err == nil && v != nil {
-	if isBotRequest(ctx) {
+		if userId, perr := strconv.ParseInt(*v, 10, 64); perr == nil && userId > 0 {
-		return crawlerGuestLogin()
+			return userId, nil
 		}
-	if req == nil || strings.TrimSpace(req.DevID) == "" {
-		return nil, srvdef.New(srvdef.ErrParamError, "devID不能为空", "")
 	}
-	ua.DevID = strings.TrimSpace(req.DevID)
 
-	var user *usermod.User
+	user, serr := findOrCreateDeviceUser(ctx, ua, ip, channel)
-	var serr *srvdef.SrvErr
-	reuseToken := false
-
-	if userId > 0 {
-		user, serr = usermod.FindOneUser(ctx, bson.M{usermod.FN.User.Id: userId})
 	if serr != nil {
-			if serr.Code != srvdef.ErrUserNotExsit {
+		return 0, serr
-				return nil, serr
 	}
-			userId = 0
-			user = nil
-		} else {
-			reuseToken = true
-		}
-	}
-
-	isNewUser := false
-	if userId == 0 {
-		user, serr = findGuestUser(ctx, req)
-		if serr != nil {
-			if serr.Code != srvdef.ErrUserNotExsit {
-				return nil, serr
-			}
-			user, serr = createGuestUser(ctx, ua, req, ip)
-			if serr != nil {
-				return nil, serr
-			}
-			isNewUser = true
-		}
-	}
-
 	if user.Status == pubdef.UserStatusDisable {
-		return nil, srvdef.New(srvdef.AccountErrAccessForbid, srvdef.AccountErrAccessForbid.Msg(), "")
+		return 0, srvdef.New(srvdef.AccountErrAccessForbid, srvdef.AccountErrAccessForbid.Msg(), "")
+	}
+	if err := redis.Set(cacheKey, user.Id, redisconst.AppDeviceUserExpire); err != nil {
+		log.Warn("authser:ResolveDeviceUser cache set failed", log.Any("devID", devID), log.E(err))
+	}
+	return user.Id, nil
+}
+
+// findOrCreateDeviceUser 按设备ID查找用户，不存在时加锁创建，避免同一设备并发请求建出多个用户
+func findOrCreateDeviceUser(ctx context.Context, ua useragent.UA, ip, channel string) (*usermod.User, *srvdef.SrvErr) {
+	lockKey := redisconst.AppDeviceUserLockKey(ua.DevID)
+	for i := 0; i < deviceUserLockRetry; i++ {
+		user, serr := usermod.FindOneUser(ctx, bson.M{usermod.FN.User.DevID: ua.DevID})
+		if serr == nil {
+			touchDeviceUser(ctx, user, ua, ip, channel)
+			return user, nil
+		}
+		if serr.Code != srvdef.ErrUserNotExsit {
+			return nil, serr
 		}
 
+		ok, err := redis.Setnx_NewOK(lockKey, 1, redisconst.AppDeviceUserLockExpire)
+		if err != nil {
+			return nil, srvdef.New(srvdef.StoreLevel, "用户创建失败", "")
+		}
+		if ok {
+			defer func() { _ = redis.Del(lockKey) }()
+			return createGuestUser(ctx, ua, ip, channel)
+		}
+		time.Sleep(deviceUserLockInterval)
+	}
+	return nil, srvdef.New(srvdef.StoreLevel, "用户创建失败", "")
+}
+
+// touchDeviceUser 更新最近访问信息（缓存未命中时执行，频率受缓存时长限制）
+func touchDeviceUser(ctx context.Context, user *usermod.User, ua useragent.UA, ip, channel string) {
 	now := time.Now()
 	setDoc := bson.M{
 		usermod.FN.User.LastLoginAt: now,
@@ -94,9 +89,6 @@ func GuestLogin(ctx context.Context, userId int64, ip string, req *GuestLoginReq
 		usermod.FN.User.LastIp:      ip,
 		usermod.FN.User.LoginType:   pubdef.LoginTypeDevice,
 	}
-	if v := strings.TrimSpace(ua.DevID); v != "" {
-		setDoc[usermod.FN.User.DevID] = v
-	}
 	if v := strings.TrimSpace(ua.DevType); v != "" {
 		setDoc[usermod.FN.User.Device] = v
 	}
@@ -106,91 +98,29 @@ func GuestLogin(ctx context.Context, userId int64, ip string, req *GuestLoginReq
 	if v := strings.TrimSpace(ua.Ver); v != "" {
 		setDoc[usermod.FN.User.AppVer] = v
 	}
-	if v := strings.TrimSpace(req.Mac); v != "" {
-		setDoc[usermod.FN.User.Mac] = v
-	}
-	if v := strings.TrimSpace(req.DeviceId); v != "" {
-		setDoc[usermod.FN.User.DevV2] = v
-	}
-	// 历史用户 Type 为空/旧值时，未注册则归为游客
-	if isGuestUser(user) && user.Type != pubdef.UserTypeGuest {
-		setDoc[usermod.FN.User.Type] = pubdef.UserTypeGuest
-		user.Type = pubdef.UserTypeGuest
-	}
 	mergeUAExtFieldsToSet(setDoc, user, ua)
-	applyChannelIfMissing(setDoc, user, req.Channel)
+	applyChannelIfMissing(setDoc, user, channel)
 	_ = usermod.UpdateOneUser(ctx, bson.M{usermod.FN.User.Id: user.Id}, bson.M{"$set": setDoc})
-
-	var token string
-	if reuseToken {
-		if old, err := tokener.Get(user.Id); err == nil && len(old) > 0 {
-			token = string(old)
-		}
-	}
-	if token == "" {
-		token, serr = generateAndSaveToken(user.Id)
-		if serr != nil {
-			return nil, serr
-		}
-	}
-
-	resp := toLoginResp(ctx, user, token, true)
-	resp.IsNewUser = isNewUser
-	if isNewUser {
-		visit.RecordDailyVisit(ctx, user.Id, ua, ip)
-		reportser.ReportUserRegister(user, ua, ip, "deviceid")
-	}
-	reportser.ReportUserLogin(user, ua, ip, pubdef.LoginTypeDevice)
-	return resp, nil
 }
 
-func findGuestUser(ctx context.Context, req *GuestLoginReq) (*usermod.User, *srvdef.SrvErr) {
+func createGuestUser(ctx context.Context, ua useragent.UA, ip, channel string) (*usermod.User, *srvdef.SrvErr) {
-	user, serr := usermod.FindOneUser(ctx, bson.M{usermod.FN.User.DevID: req.DevID})
-	if serr == nil {
-		return user, nil
-	}
-	if serr.Code != srvdef.ErrUserNotExsit {
-		return nil, serr
-	}
-
-	mac := strings.TrimSpace(req.Mac)
-	if mac != "" && !strings.Contains(mac, "00:00:00:00") {
-		user, serr = usermod.FindOneUser(ctx, bson.M{usermod.FN.User.Mac: mac})
-		if serr == nil {
-			return user, nil
-		}
-		if serr.Code != srvdef.ErrUserNotExsit {
-			return nil, serr
-		}
-	}
-
-	deviceId := strings.TrimSpace(req.DeviceId)
-	if deviceId != "" && !strings.Contains(deviceId, "00:00:00:00") {
-		return usermod.FindOneUser(ctx, bson.M{usermod.FN.User.DevV2: deviceId})
-	}
-	return nil, srvdef.New(srvdef.ErrUserNotExsit, "", "")
-}
-
-func createGuestUser(ctx context.Context, ua useragent.UA, req *GuestLoginReq, ip string) (*usermod.User, *srvdef.SrvErr) {
 	now := time.Now()
 	uid := mongos.Lid.User.Get()
-	districtInfo := resolveUserDistrict(req.Channel, "", ip, ua.SysType)
+	districtInfo := resolveUserDistrict(channel, "", ip, ua.SysType)
 	user := &usermod.User{
 		Id:            uid,
 		Type:          pubdef.UserTypeGuest,
 		Status:        pubdef.UserStatusNormal,
-		LoginType:     pubdef.LoginTypeDevice,
 		IsRegister:    false,
+		LoginType:     pubdef.LoginTypeDevice,
 		NickName:      fmt.Sprintf("游客%d", uid),
 		Avatar:        randomAvatar(),
 		InviteCode:    generateUniqueInviteCode(ctx),
-		DistrictCode:  normalizeChannel(req.Channel),
+		DistrictCode:  normalizeChannel(channel),
 		IsDirect:      districtInfo.IsDirect,
 		RegIp:         ip,
 		LastIp:        ip,
 		DevID:         ua.DevID,
-		Mac:           strings.TrimSpace(req.Mac),
-		DevV2:         strings.TrimSpace(req.DeviceId),
 		Device:        ua.DevType,
 		SysType:       ua.SysType,
 		AppVer:        ua.Ver,
@@ -204,41 +134,39 @@ func createGuestUser(ctx context.Context, ua useragent.UA, req *GuestLoginReq, i
 		CreatedAt:     now,
 		UpdatedAt:     now,
 	}
-	if nick := appg.GenerateNickname(); nick != "" {
+	if user.NickName == "" {
-		user.NickName = nick
+		user.NickName = appg.GenerateNickname()
 	}
 	if serr := usermod.InsertOneUser(ctx, user); serr != nil {
-		log.Error("authser:createGuestUser InsertOneUser failed", log.E(serr), log.Any("devID", ua.DevID))
 		return nil, serr
 	}
 	return user, nil
 }
 
-func toLoginResp(ctx context.Context, user *usermod.User, token string, withCDN bool) *LoginResp {
+func toLoginResp(ctx context.Context, user *usermod.User, withCDN bool) *LoginResp {
 	avatar := user.Avatar
 	if withCDN {
 		cdn := configser.GetAppImageCdn(configser.ClientIPFromCtx(ctx))
 		avatar = netutil.MergeURL(cdn, user.Avatar)
 	}
 	return &LoginResp{
-		Token:            token,
 		UserId:          user.Id,
 		AccountNo:       user.AccountNo,
 		Email:           user.Email,
 		NickName:        user.NickName,
-		Introduction:     user.Introduction,
-		VipType:          user.VipType,
-		CurrentVipExpire: user.CurrentVipExpire,
-		ShowCardId:       user.ShowCardId,
-		ShowCardName:     user.ShowCardName,
-		Status:           user.Status,
 		Avatar:          avatar,
+		Introduction:    user.Introduction,
+		DevID:           user.DevID,
+		Mac:             user.Mac,
+		DeviceId:        user.DevV2,
 		InviteCode:      user.InviteCode,
+		AgentInviteCode: user.AgentInviteCode,
+		Invites:         user.Invites,
+		Status:          user.Status,
 		Type:            user.Type,
 		LoginType:       user.LoginType,
 		IsRegister:      user.IsRegister,
 		PrivacyMode:     user.PrivacyMode,
-		HasPassword:      strings.TrimSpace(user.Password) != "",
 		Score:           user.Score,
 		Recharge:        user.Recharge,
 	}
@@ -252,26 +180,15 @@ func hasDistrictCode(code string) bool {
 	return strings.TrimSpace(code) != ""
 }
 
-func isBotRequest(ctx context.Context) bool {
-	gc, ok := ctx.(*gin.Context)
-	return ok && reptilerecord.IsBot(gc)
-}
-
-// crawlerGuestLogin 给爬虫签发可观看的虚拟游客 token，不建用户、不写日活、不上报。
-func crawlerGuestLogin() (*LoginResp, *srvdef.SrvErr) {
-	token, serr := generateCrawlerToken()
-	if serr != nil {
-		return nil, serr
-	}
-	return CrawlerLoginResp(token), nil
-}
-
 func applyChannelIfMissing(setDoc bson.M, user *usermod.User, channel string) {
 	if user == nil || hasDistrictCode(user.DistrictCode) {
 		return
 	}
-	if ch := normalizeChannel(channel); ch != "" {
+	code := normalizeChannel(channel)
-		setDoc[usermod.FN.User.DistrictCode] = ch
+	if code == "" {
-		user.DistrictCode = ch
+		return
 	}
+	setDoc[usermod.FN.User.DistrictCode] = code
+	districtInfo := resolveUserDistrict(channel, user.AgentInviteCode, user.LastIp, user.SysType)
+	setDoc[usermod.FN.User.IsDirect] = districtInfo.IsDirect
 }

app/service/coinser/coin_buy.go

@@ -2,22 +2,14 @@ package coinser
 
 import (
 	"context"
-	"crypto/md5"
-	"encoding/hex"
-	"encoding/json"
-	"fmt"
 	"hkdj-web-server/app/service/rechargeser/jiahua"
 	"hkdj-web-server/pub/common/log"
 	"hkdj-web-server/pub/common/srvdef"
-	"hkdj-web-server/pub/common/useragent"
-	"hkdj-web-server/pub/dataReport"
-	"hkdj-web-server/pub/models/eventmod"
 	"hkdj-web-server/pub/models/rechargepackagemod"
 	"hkdj-web-server/pub/models/usermod"
 	"hkdj-web-server/pub/models/vipordermod"
 	"hkdj-web-server/pub/mongos"
 	"hkdj-web-server/pub/pubdef"
-	"strconv"
 	"strings"
 	"time"
 
@@ -115,8 +107,6 @@ func CreateCoinOrder(ctx context.Context,
 		return nil, serr
 	}
 
-	go reportCoinOrderCreated(order, pkg, ip)
-
 	return &BuyCoinResp{
 		TradeNo:          tradeNo,
 		PayUrl:           payInfo.PayUrl,
@@ -125,49 +115,6 @@ func CreateCoinOrder(ctx context.Context,
 	}, nil
 }
 
-func reportCoinOrderCreated(order *vipordermod.VipOrder, pkg *rechargepackagemod.RechargePackage, ip string) {
-	ctx := context.Background()
-	user, _ := usermod.FindOneUser(ctx, bson.M{usermod.FN.User.Id: order.UserId})
-	districtCode := order.DistrictCode
-	if user != nil && strings.TrimSpace(user.DistrictCode) != "" {
-		districtCode = user.DistrictCode
-	}
-
-	ua := useragent.UA{SysType: order.SysType}
-	eventId := newEventId(pubdef.TrackerAppId(), order.UserId, order.TradeNo, order.CreatedAt.Unix())
-	commonField := dataReport.NewCommonField(eventId, dataReport.EventTypeOrderCreated, districtCode, ua, strconv.FormatInt(order.UserId, 10), ip)
-	commonField.Payload = dataReport.JsonRawMessage(&dataReport.OrderCreatedEvent{
-		OrderID:      order.TradeNo,
-		OrderType:    "coin_purchase",
-		ProductID:    strconv.FormatInt(pkg.Id, 10),
-		ProductName:  pkg.Name,
-		Amount:       dataReport.JsonNumber(order.Amount),
-		Currency:     "CNY",
-		CoinQuantity: dataReport.JsonNumber(order.Coin),
-		CreateTime:   dataReport.JsonNumber(order.CreatedAt.Unix()),
-	})
-
-	eventData, _ := json.Marshal(commonField)
-	if err := eventmod.InsertOneEvent(ctx, &eventmod.Event{
-		EventId:   commonField.EventID,
-		EventType: commonField.Event,
-		Data:      string(eventData),
-		Status:    eventmod.Default,
-		CreatedAt: time.Now(),
-		UpdatedAt: time.Now(),
-	}); err != nil {
-		log.Error("reportCoinOrderCreated InsertOneEvent failed",
-			log.Any("tradeNo", order.TradeNo), log.E(err))
-	}
-}
-
-func newEventId(appId string, uid int64, orderId interface{}, createTime int64) string {
-	input := fmt.Sprintf("%v%v%v%v", appId, uid, orderId, createTime)
-	h := md5.New()
-	h.Write([]byte(input))
-	return hex.EncodeToString(h.Sum(nil))
-}
-
 // GetCoinOrderHistory 查询用户金币购买记录
 func GetCoinOrderHistory(ctx context.Context, userId int64, page, pageSize int64) (vipordermod.VipOrderList, int64, *srvdef.SrvErr) {
 	filter := bson.M{

app/service/commentser/comment.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"hkdj-web-server/app/api/proto"
 	"hkdj-web-server/app/service/configser"
-	"hkdj-web-server/app/service/reportser"
 	"hkdj-web-server/pub/common/enum/redisconst"
 	"hkdj-web-server/pub/common/log"
 	"hkdj-web-server/pub/common/netutil"
@@ -126,13 +125,6 @@ func SendComment(ctx context.Context, userId int64, ip string, req *proto.Commen
 			log.Error("评论发布后更新短剧热度失败", log.Any("短剧ID", playletId), log.Any("评论信息", info), log.E(err))
 			return err
 		}
-		chapterId := int64(0)
-		if req.ObjectType == ObjectTypePlayletChapter {
-			chapterId = req.ObjectId
-		}
-		reportser.ReportPlayletComment(ctx, user, playletId, chapterId, text)
-	} else if req.ObjectType == ObjectTypeVideo {
-		reportser.ReportVideoComment(ctx, user, req.ObjectId, text)
 	}
 	// app端发布评论先进入待审核状态，不立即增加业务对象评论数；后台审核通过时再统一同步 countComment
 	return nil

app/service/configser/announcement.go

@@ -1,97 +1,61 @@
 package configser
 
 import (
-	"hkdj-web-server/app/api/proto"
+	"context"
-	"hkdj-web-server/app/appg"
-	"hkdj-web-server/pub/adcenter"
 	"hkdj-web-server/pub/common/log"
 	"hkdj-web-server/pub/common/netutil"
+	"hkdj-web-server/pub/pubdef"
+	"hkdj-web-server/pub/storage"
 	"hkdj-web-server/pub/storage/proxy"
-	"strconv"
+	"net/http"
 )
 
-// UpdateAdvitiseDataFromJt 从广告中心拉取福利页广告
+// UpdateAdvitiseData 从媒资中心按 AppId 拉取广告，图片拼接 CDN 后写入缓存
-func UpdateAdvitiseDataFromJt() {
+func UpdateAdvitiseData(ctx context.Context) {
 	config := GetConfigInfo()
-	var resp proto.AdvitiseData
+	queryAdvitiseReq := &proxy.AppAdvitiseInfoReq{
-	jtAds, err := adcenter.JtAdvertiseThreeServer(appg.Conf.AdCenter.ApiDomain, appg.Conf.AdCenter.MerchantCode, appg.Conf.AdCenter.AppCode, appg.Conf.AdCenter.AesKey)
+		Id: pubdef.AppId,
-	if err != nil {
+	}
-		log.Error("JtAdvertiseThreeServer error occur", log.E(err))
+	advitiseResult, err := storage.QueryAdvitiseList(ctx, queryAdvitiseReq, "")
+	if err != nil || advitiseResult.Code != http.StatusOK {
+		if advitiseResult != nil {
+			log.Warn("UpdateAdvitiseData.QueryAdvitiseList failed", log.Any("filter", queryAdvitiseReq), log.E(err), log.Any("respCode", advitiseResult.Code))
+		} else {
+			log.Warn("UpdateAdvitiseData.QueryAdvitiseList failed", log.Any("filter", queryAdvitiseReq), log.E(err))
+		}
 		return
 	}
-	adMap := make(map[string]adcenter.AdCacheInfo)
-	for _, loc := range jtAds {
-		pos, err := strconv.Atoi(loc.AdvertiseLocationCode)
-		if err != nil {
-			log.Error("广告位置代码错误，必须为数字", log.Any("code", loc.AdvertiseLocationCode))
-			continue
-		}
-		//if pos < 100001 {
-		//	continue
-		//}
-		ads := make([]proxy.AdvitiseInfo, 0)
-		for _, ad := range loc.AdDetailInfoList {
-			//extra := ad.GetExtraData()
-			ads = append(ads, proxy.AdvitiseInfo{
-				Id:       ad.AdvertiseCode,
-				Location: int64(pos),
-				Title:    ad.AdvertiseName,
-				Images:   netutil.MergeURL(config.ImgCdn, ad.GetCoverLsj()),
-				Link:     ad.GetRealLink(),
-			})
-			adMap[ad.AdvertiseCode] = adcenter.AdCacheInfo{
-				AdvertiseCode:         ad.AdvertiseCode,
-				CustomerCode:          ad.CustomerCode,
-				AdvertiseName:         ad.AdvertiseName,
-				AdvertiseUrl:          ad.AdvertiseUrl,
-				AdvertiseIcon:         ad.AdvertiseIcon,
-				AdvertiseType:         ad.AdvertiseType,
-				AdMode:                ad.AdMode,
-				AppCode:               ad.AppCode,
-				LocationType:          ad.LocationType,
-				AdvertiseDesc:         ad.AdvertiseDesc,
-				PageType:              ad.PageType,
-				StartTimeStamp:        ad.StartTimeStamp,
-				EndTimeStamp:          ad.EndTimeStamp,
-				Sort:                  ad.Sort,
-				AdExtData:             ad.AdExtData,
-				DeptCode:              loc.DeptCode,
-				MerchantCode:          loc.MerchantCode,
-				AdvertiseLocationCode: loc.AdvertiseLocationCode,
-				AdvertiseLocationName: loc.AdvertiseLocationName,
-				DisplayMode:           loc.DisplayMode,
-				AdvertiseHeight:       loc.AdvertiseHeight,
-				AdvertiseWidth:        loc.AdvertiseWidth,
-				MaterialType:          loc.MaterialType,
-				AdLimit:               loc.AdLimit,
-			}
-		}
-		switch pos {
-		case 1: //弹窗
-			resp.DialogList = ads
-		case 2: // 应用
 
-			resp.NineGridList = ads
+	data := advitiseResult.Data
-		case 3: // 横幅
+	for _, list := range []*[]proxy.AdvitiseInfo{
-			resp.DetailbannerList = ads
+		&data.DialogList,
+		&data.HomeList,
+		&data.VideoTopList,
+		&data.VideoDownList,
+		&data.HotAppList,
+		&data.NewAppList,
+		&data.MustAppList,
+		&data.TitleAppList,
+		&data.FriendList,
+		&data.NineGridList,
+		&data.VideoList,
+		&data.StopList,
+		&data.ForcedJumpList,
+		&data.AppInfoAList,
+		&data.AppInfoBList,
+	} {
+		mergeAdvitiseImages(*list, config.ImgCdn)
+	}
 
-		case 12:
-			resp.AList = ads
-		case 13:
-			resp.BList = ads
-		}
-	}
 	CacheMgr.Lock.Lock()
 	defer CacheMgr.Lock.Unlock()
-	CacheMgr.Advitise = resp
+	CacheMgr.Advitise = data
-	CacheMgr.AdvitiseMap = adMap
 }
 
-func GetAdvertiseLocation(adverId string) (res adcenter.AdCacheInfo) {
+func mergeAdvitiseImages(list []proxy.AdvitiseInfo, cdn string) {
-	CacheMgr.Lock.RLock()
+	for i := range list {
-	defer CacheMgr.Lock.RUnlock()
+		if len(list[i].Images) > 0 {
-	if ad, ok := CacheMgr.AdvitiseMap[adverId]; ok {
+			list[i].Images = netutil.MergeURL(cdn, list[i].Images)
-		res = ad
+		}
 	}
-	return
 }

app/service/configser/catch.go

@@ -4,11 +4,9 @@ import (
 	"context"
 	"hkdj-web-server/app/api/proto"
 	"hkdj-web-server/app/service/translationser"
-	"hkdj-web-server/pub/adcenter"
 	"hkdj-web-server/pub/common/log"
 	"hkdj-web-server/pub/common/netutil"
 	"hkdj-web-server/pub/common/srvdef"
-	"hkdj-web-server/pub/dataReport"
 	"hkdj-web-server/pub/models/announcementmod"
 	"hkdj-web-server/pub/models/cfg"
 	"hkdj-web-server/pub/models/ipblackmod"
@@ -36,7 +34,6 @@ type CacheInfo struct {
 	Lock            sync.RWMutex     // 读写锁
 	Config          proto.ConfigInfo // 系统配置缓存
 	Advitise        proto.AdvitiseData
-	AdvitiseMap     map[string]adcenter.AdCacheInfo
 	TagCategoryList []proto.VideoTagCategoryData
 	TotalHistory    int64
 	IpBlackMaps     map[string]struct{}
@@ -61,16 +58,15 @@ func init() {
 
 func Start() {
 	ctx := context.Background()
-	dataReport.StartSDKConfigCron()
 	UpdateConfigInfo(ctx)
-	UpdateAdvitiseDataFromJt()
+	UpdateAdvitiseData(ctx)
 	updateIpBlack()
 	updateTagsCache()
 	updateAppRichTexts()
 	updateAnnouncements()
 	_, _ = skdCron.AddFunc("0 */5 * * * ?", func() {
 		UpdateConfigInfo(ctx)
-		UpdateAdvitiseDataFromJt()
+		UpdateAdvitiseData(ctx)
 		updateIpBlack()
 		updateTagsCache()
 		updateAppRichTexts()
@@ -155,7 +151,6 @@ func UpdateConfigInfo(ctx context.Context) {
 	config.DHSiteName = sysCfg.DHSiteName
 	config.DHTitle = sysCfg.DHTitle
 	config.ActressBackGround = netutil.MergeURL(sysCfg.ImgAppCdn, sysCfg.ActressBackGround)
-	config.ReportSDKConfig = dataReport.GetSDKDomainConfig()
 	config.WatermarkImage = sysCfg.WatermarkImage
 	config.CustomerServiceHost = sysCfg.CustomerServiceHost
 	config.ChannelCode = sysCfg.ChannelCode
@@ -562,7 +557,6 @@ func GetVideoTagCategoryDataList() []proto.VideoTagCategoryData {
 	return rsl
 }
 func Stop() {
-	dataReport.StopSDKConfigCron()
 	skdCron.Stop()
 }
 

app/service/playletser/playlet.go

@@ -8,7 +8,6 @@ import (
 	"hkdj-web-server/app/api/proto"
 	"hkdj-web-server/app/service/configser"
 	"hkdj-web-server/app/service/playletcache"
-	"hkdj-web-server/app/service/reportser"
 	"hkdj-web-server/app/service/videoser"
 	"hkdj-web-server/pub/common/enum/redisconst"
 	"hkdj-web-server/pub/common/log"
@@ -914,9 +913,6 @@ func SetLike(ctx context.Context, userId int64, req *proto.PlayletLikeSetReq) (*
 		IsLike:    operateStatusByFlag(*req.IsLike),
 		CountLike: countLike,
 	}
-	if changed {
-		reportser.ReportPlayletLike(ctx, userId, req.Id, resp.IsLike)
-	}
 	return resp, nil
 }
 
@@ -936,9 +932,6 @@ func SetCollect(ctx context.Context, userId int64, req *proto.PlayletCollectSetR
 		IsCollect:    operateStatusByFlag(*req.IsCollect),
 		CountCollect: countCollect,
 	}
-	if changed {
-		reportser.ReportPlayletCollect(ctx, userId, req.Id, resp.IsCollect)
-	}
 	return resp, nil
 }
 
@@ -988,9 +981,6 @@ func SetChapterLike(ctx context.Context, userId int64, req *proto.PlayletChapter
 		IsLike:    operateStatusByFlag(*req.IsLike),
 		CountLike: countLike,
 	}
-	if changed {
-		reportser.ReportPlayletChapterLike(ctx, userId, chapter.PlayletId, req.ChapterId, resp.IsLike)
-	}
 	return resp, nil
 }
 
@@ -1010,9 +1000,6 @@ func SetChapterCollect(ctx context.Context, userId int64, req *proto.PlayletChap
 		IsCollect:    operateStatusByFlag(*req.IsCollect),
 		CountCollect: countCollect,
 	}
-	if changed {
-		reportser.ReportPlayletChapterCollect(ctx, userId, chapter.PlayletId, req.ChapterId, resp.IsCollect)
-	}
 	return resp, nil
 }
 
@@ -1276,7 +1263,6 @@ func UnlockChapter(ctx context.Context, userId int64, req *proto.PlayletChapterU
 		return nil, srvdef.New(srvdef.DBTransaction, "解锁失败，请稍后重试", "解锁失败，请稍后重试")
 	}
 	updatePlayletChapterUnlockStatsAsync(chapter.PlayletId, chapter.Id)
-	reportser.ReportPlayletUnlock(ctx, user, playlet, chapter, chapter.SingleCoins, user.Recharge, balanceAfter, orderNo)
 	return playletChapterUnlockResp(chapter, balanceAfter, -chapter.SingleCoins), nil
 }
 

app/service/rechargeser/recharge.go

@@ -2,22 +2,14 @@ package rechargeser
 
 import (
 	"context"
-	"crypto/md5"
-	"encoding/hex"
-	"encoding/json"
-	"fmt"
 	"hkdj-web-server/app/service/rechargeser/jiahua"
 	"hkdj-web-server/pub/common/log"
 	"hkdj-web-server/pub/common/srvdef"
-	"hkdj-web-server/pub/common/useragent"
-	"hkdj-web-server/pub/dataReport"
-	"hkdj-web-server/pub/models/eventmod"
 	"hkdj-web-server/pub/models/rechargepackagemod"
 	"hkdj-web-server/pub/models/usermod"
 	"hkdj-web-server/pub/models/vipordermod"
 	"hkdj-web-server/pub/mongos"
 	"hkdj-web-server/pub/pubdef"
-	"strconv"
 	"strings"
 	"time"
 
@@ -104,8 +96,6 @@ func CreateOrder(ctx context.Context,
 		return nil, serr
 	}
 
-	go reportOrderCreated(ctx, order, pkg, userId, ip)
-
 	return &SubmitOrderResp{
 		TradeNo:          tradeNo,
 		PayUrl:           payInfo.PayUrl,
@@ -138,45 +128,3 @@ func GetOrderHistory(ctx context.Context, userId int64, page, pageSize int64) (v
 func GetUserInfo(ctx context.Context, userId int64) (*usermod.User, *srvdef.SrvErr) {
 	return usermod.FindOneUser(ctx, bson.M{usermod.FN.User.Id: userId})
 }
-
-func reportOrderCreated(ctx context.Context, order *vipordermod.VipOrder, pkg *rechargepackagemod.RechargePackage, userId int64, ip string) {
-	user, _ := usermod.FindOneUser(ctx, bson.M{usermod.FN.User.Id: userId})
-	districtCode := ""
-	if user != nil {
-		districtCode = user.DistrictCode
-	}
-
-	ua := useragent.UA{SysType: order.SysType}
-	eventId := newEventId(pubdef.TrackerAppId(), user.Id, order.TradeNo, order.CreatedAt.Unix())
-	commonField := dataReport.NewCommonField(eventId, dataReport.EventTypeOrderCreated, districtCode, ua, strconv.FormatInt(user.Id, 10), ip)
-
-	commonField.Payload = dataReport.JsonRawMessage(&dataReport.OrderCreatedEvent{
-		OrderID:     order.TradeNo,
-		OrderType:   "vip_subscription",
-		ProductID:   strconv.FormatInt(pkg.Id, 10),
-		ProductName: pkg.Name,
-		Amount:      dataReport.JsonNumber(order.Amount),
-		Currency:    "CNY",
-		CreateTime:  dataReport.JsonNumber(order.CreatedAt.Unix()),
-	})
-
-	eventData, _ := json.Marshal(commonField)
-	if err := eventmod.InsertOneEvent(ctx, &eventmod.Event{
-		EventId:   commonField.EventID,
-		EventType: commonField.Event,
-		Data:      string(eventData),
-		Status:    eventmod.Default,
-		CreatedAt: time.Now(),
-		UpdatedAt: time.Now(),
-	}); err != nil {
-		log.Error("reportOrderCreated InsertOneEvent failed",
-			log.Any("tradeNo", order.TradeNo), log.E(err))
-	}
-}
-
-func newEventId(appId string, uid int64, orderId interface{}, createTime int64) string {
-	input := fmt.Sprintf("%v%v%v%v", appId, uid, orderId, createTime)
-	h := md5.New()
-	h.Write([]byte(input))
-	return hex.EncodeToString(h.Sum(nil))
-}

app/service/reportser/report.go

@@ -1,530 +0,0 @@
-package reportser
-
-import (
-	"context"
-	"crypto/md5"
-	"encoding/hex"
-	"encoding/json"
-	"fmt"
-	"hkdj-web-server/app/service/playletcache"
-	"hkdj-web-server/pub/common"
-	"hkdj-web-server/pub/common/enum/consts"
-	"hkdj-web-server/pub/common/ipaddr"
-	"hkdj-web-server/pub/common/log"
-	"hkdj-web-server/pub/common/useragent"
-	"hkdj-web-server/pub/dataReport"
-	"hkdj-web-server/pub/models/eventmod"
-	"hkdj-web-server/pub/models/playletchaptermod"
-	"hkdj-web-server/pub/models/playletmod"
-	"hkdj-web-server/pub/models/usermod"
-	"hkdj-web-server/pub/models/videoinformationmod"
-	"hkdj-web-server/pub/pubdef"
-	"strconv"
-	"strings"
-	"time"
-
-	"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(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(user *usermod.User, ua useragent.UA, ip string, playlet *playletmod.Playlet, chapter *playletchaptermod.PlayletChapter, amount int64, orderId string) {
-	pub := playletToDramaPub(playlet, chapter)
-	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{}
-	}
-	var chapter *playletchaptermod.PlayletChapter
-	if chapterId > 0 {
-		chapter, _ = playletchaptermod.FindOnePlayletChapter(ctx, bson.M{playletchaptermod.FN.PlayletChapter.Id: chapterId}, options.FindOne().SetProjection(bson.D{
-			{Key: playletchaptermod.FN.PlayletChapter.Id, Value: 1},
-			{Key: playletchaptermod.FN.PlayletChapter.PlayletId, Value: 1},
-			{Key: playletchaptermod.FN.PlayletChapter.CurrentEpisode, Value: 1},
-			{Key: playletchaptermod.FN.PlayletChapter.MediaTime, Value: 1},
-		}))
-	}
-	return playletToDramaPub(playlet, 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)
-	if chapter != nil && chapter.Id > 0 {
-		if chapter.CurrentEpisode > 0 {
-			episode = chapter.CurrentEpisode
-		}
-		duration = chapter.MediaTime
-	}
-	return dataReport.DramaEventPub{
-		DramaID:          strconv.FormatInt(playlet.Id, 10),
-		DramaTitle:       playlet.Title,
-		Episode:          dataReport.JsonNumber(episode),
-		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))
-	}
-}

app/service/reportser/type.go

@@ -1,21 +0,0 @@
-package reportser
-
-type Key string
-
-const (
-	KeyPlayletUnlock Key = "playlet_unlock" // 短剧剧集解锁
-	KeyCoinConsume   Key = "coin_consume"   // 金币消耗
-)
-
-var keyMap = map[Key]string{
-	KeyPlayletUnlock: "短剧解锁",
-	KeyCoinConsume:   "金币消耗",
-}
-
-func (p Key) Name() string {
-	return keyMap[p]
-}
-
-func (p Key) Key() string {
-	return string(p)
-}

app/service/videoser/video.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"hkdj-web-server/app/api/proto"
 	"hkdj-web-server/app/service/configser"
-	"hkdj-web-server/app/service/reportser"
 	"hkdj-web-server/pub/common/log"
 	"hkdj-web-server/pub/common/netutil"
 	"hkdj-web-server/pub/common/srvdef"
@@ -255,9 +254,6 @@ func SetLike(ctx context.Context, userId int64, req *proto.VideoLikeSetReq) (*pr
 		IsLike:    videoOperateStatusByFlag(*req.IsLike),
 		CountLike: countLike,
 	}
-	if changed {
-		reportser.ReportVideoLike(ctx, userId, req.Id, resp.IsLike)
-	}
 	return resp, nil
 }
 
@@ -277,9 +273,6 @@ func SetCollect(ctx context.Context, userId int64, req *proto.VideoCollectSetReq
 		IsCollect:    videoOperateStatusByFlag(*req.IsCollect),
 		CountCollect: countCollect,
 	}
-	if changed {
-		reportser.ReportVideoCollect(ctx, userId, req.Id, resp.IsCollect)
-	}
 	return resp, nil
 }
 

pub/common/enum/redisconst/const.go

@@ -12,6 +12,10 @@ const (
 	FiveMVisit                    = "bd_visitFmt:%s"
 	BloomUser                     = "bd_bloom_user:%d"
 	AppUserToken                  = "bd_app_user_token:%d"
+	appDeviceUserFmt              = "app:device:user:%s"
+	appDeviceUserLockFmt          = "app:device:user:lock:%s"
+	AppDeviceUserExpire           = 10 * time.Minute
+	AppDeviceUserLockExpire       = 5 * time.Second
 	captchaKey                    = "bd_captcha_mobile_%s"
 	CaptchaExpire                 = 5 * time.Minute
 	replayNonceKey                = "bd_replay:nonce:_%s"
@@ -86,6 +90,16 @@ func AppUserTokenKey(userId int64) string {
 	return fmt.Sprintf(AppUserToken, userId)
 }
 
+// AppDeviceUserKey 设备ID到用户ID的缓存
+func AppDeviceUserKey(devID string) string {
+	return fmt.Sprintf(appDeviceUserFmt, devID)
+}
+
+// AppDeviceUserLockKey 按设备ID创建用户时的并发锁
+func AppDeviceUserLockKey(devID string) string {
+	return fmt.Sprintf(appDeviceUserLockFmt, devID)
+}
+
 func MediaM3U8Key(name string) string {
 	return fmt.Sprintf(mediaM3U8Fmt, name)
 }

pub/common/utils/strings.go

@@ -113,6 +113,29 @@ func IsSlugAllDigits(s string) bool {
 	return true
 }
 
+// RandomSlugLength 随机 slug 长度
+const RandomSlugLength = 10
+
+// GetRandomAlphanumeric 生成 n 位大小写字母 + 数字随机串
+func GetRandomAlphanumeric(n int) string {
+	const chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
+	b := make([]byte, n)
+	for i := range b {
+		b[i] = chars[rand.IntN(len(chars))]
+	}
+	return string(b)
+}
+
+// MakeRandomSlug 生成唯一的随机 slug（10 位大小写字母+数字混合）；exists 返回 true 表示已被占用。
+func MakeRandomSlug(exists func(string) bool) string {
+	for {
+		s := GetRandomAlphanumeric(RandomSlugLength)
+		if !exists(s) {
+			return s
+		}
+	}
+}
+
 // MakeUniqueSlug 生成唯一 slug；exists 返回 true 表示已被占用。生成结果不能全是数字。
 func MakeUniqueSlug(source string, exists func(string) bool) string {
 	pinyin := GetSlugInfo(source)

pub/dataReport/handle.go

@@ -1,250 +0,0 @@
-package dataReport
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"fmt"
-	"hkdj-web-server/pub/common/godef"
-	"hkdj-web-server/pub/common/log"
-	"hkdj-web-server/pub/common/useragent"
-	"hkdj-web-server/pub/pubdef"
-	"io/ioutil"
-	"math"
-	"math/rand"
-	"net/http"
-	"net/url"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/google/uuid"
-	"github.com/moul/http2curl"
-)
-
-var config = Config{}
-
-func Init(c Config) {
-	config = c
-	// 根据运行模式设置SDK配置API地址
-	switch c.RunMod {
-	case "prod", "release":
-		sdkConfigAPIURL = sdkConfigAPIProd
-	default:
-		sdkConfigAPIURL = sdkConfigAPIDev
-	}
-}
-
-// GenerateGlobalEventID 生成全局唯一的 event_id
-func GenerateGlobalEventID() string {
-	// 生成一个新的 UUID
-	return strings.ReplaceAll(uuid.New().String(), "-", "")
-}
-
-func AsyncReport(eventData interface{}, retryCount int) {
-	if strings.TrimSpace(config.ApiUrl) == "" {
-		return
-	}
-	// TODO 后续可改成kafka异步处理
-	godef.Go(func() {
-		// 自动重试
-		baseDelay := 1 * time.Second
-		for i := 0; i < retryCount; i++ {
-			err := report(eventData)
-			if err != nil {
-				log.Error("Event.report failed", log.Any("retryCount", retryCount), log.Any("eventData", eventData), log.E(err))
-				// 指数退避 + 随机抖动
-				sleepTime := time.Duration(math.Pow(2, float64(i)))*baseDelay + time.Duration(rand.Intn(1000))*time.Millisecond
-				time.Sleep(sleepTime)
-				continue
-			}
-			break
-		}
-	})
-
-}
-
-// 上报事件
-func report(eventData interface{}) error {
-	// 将结构体转换为表单数据
-	formData, err := structToFormData(eventData)
-	if err != nil {
-		return err
-	}
-	apiUrl := config.ApiUrl + "/api/eventTracking/report.json"
-	req, err := http.NewRequest("POST", apiUrl, bytes.NewBufferString(formData))
-	if err != nil {
-		log.Error("Event report NewRequest fail", log.E(err))
-		return fmt.Errorf("failed to create request: %v", err)
-	}
-	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
-
-	client := &http.Client{
-		Timeout: 5 * time.Second, // 设置超时时间为 5 秒
-	}
-	command, _ := http2curl.GetCurlCommand(req)
-	fmt.Println(command)
-	resp, err := client.Do(req)
-	if err != nil {
-		log.Error("Event report fail", log.E(err))
-		return fmt.Errorf("failed to send request: %v", err)
-	}
-	defer resp.Body.Close()
-
-	if resp.StatusCode != http.StatusOK {
-		log.Error("Event report fail", log.Any("http.code", resp.StatusCode))
-		return fmt.Errorf("failed to report event, http.code: %d", resp.StatusCode)
-	}
-	// 读取返回的 body
-	body, err := ioutil.ReadAll(resp.Body)
-	if err != nil {
-		log.Error("Event report fail", log.E(err))
-		return fmt.Errorf("failed to read response body: %v", err)
-	}
-	res := &Response{}
-	err = json.Unmarshal(body, res)
-	if err != nil {
-		log.Error("Event report json.Unmarshal(body, res) fail", log.Any("body", string(body)), log.E(err))
-		return err
-	}
-	if res.Code != 0 {
-		log.Error("Event report fail", log.Any("code", res.Code), log.Any("msg", res.Msg), log.Any("data", res.Data))
-		return fmt.Errorf("failed to report event, res.code: %d", res.Code)
-	}
-	// 输出响应状态和返回的 body
-	log.Info("Event report Response", log.Any("eventData", eventData), log.Any("body", string(body)))
-	return nil
-}
-
-func structToFormData(data interface{}) (string, error) {
-	// 序列化结构体为 JSON 字符串
-	jsonData, err := json.Marshal(data)
-	if err != nil {
-		return "", err
-	}
-
-	// 反序列化为 map
-	var dataMap map[string]interface{}
-	err = json.Unmarshal(jsonData, &dataMap)
-	if err != nil {
-		return "", err
-	}
-
-	var formData []string
-
-	// 遍历 map，将其转换为 form 数据
-	for key, value := range dataMap {
-		if value == nil {
-			continue // 如果值为 nil，跳过
-		}
-
-		// 将值转换为字符串
-		valueStr := fmt.Sprintf("%v", value)
-
-		// 使用 URL 编码
-		formData = append(formData, fmt.Sprintf(
-			"%s=%s",
-			url.QueryEscape(key),
-			url.QueryEscape(valueStr),
-		))
-	}
-
-	return strings.Join(formData, "&"), nil
-}
-
-func NewCommonField(eventId, event string, districtCode string, ua useragent.UA, uid, ip string) CommonField {
-	return NewCommonFieldAt(eventId, event, districtCode, ua, uid, ip, time.Now().Unix())
-}
-
-func NewCommonFieldAt(eventId, event string, districtCode string, ua useragent.UA, uid, ip string, clientTS int64) CommonField {
-	channel := strings.TrimSpace(districtCode)
-	if channel == "" {
-		channel = "system"
-	}
-	if eventId == "" {
-		eventId = GenerateGlobalEventID()
-	}
-	// 五项公共字段和 app_version 使用当前请求中的 SDK 原值，旧客户端缺失时留空。
-	// 不能用业务 DevID、用户表会话或推算的平台补齐，否则仍会与客户端埋点不一致。
-	sdk := ua.SDKCommon
-	if missing := sdk.MissingFields(); len(missing) > 0 {
-		log.Warn("【SDK公共参数缺失】NewCommonFieldAt",
-			log.Any("接口", ua.RequestPath), log.Any("事件", event),
-			log.Any("eventId", eventId), log.Any("userId", uid), log.Any("客户端版本", ua.Ver),
-			log.Any("已获取SDK参数", sdk != nil), log.Any("缺失字段", missing))
-	}
-	if sdk == nil {
-		sdk = &useragent.SDKCommonFields{}
-	}
-	return CommonField{
-		UID:               uid,
-		EventID:           eventId,
-		Event:             event,
-		Channel:           channel,
-		AppID:             pubdef.TrackerAppId(),
-		AppVersion:        sdk.AppVersion,
-		ClientTS:          fmt.Sprintf("%v", clientTS),
-		Device:            sdk.Device,
-		DeviceID:          sdk.DeviceID,
-		DeviceFingerprint: sdk.DeviceFingerprint,
-		FPVersion:         sdk.FPVersion,
-		UserAgent:         strings.TrimSpace(ua.UserAgent),
-		DeviceBrand:       strings.TrimSpace(ua.DeviceBrand),
-		DeviceModel:       strings.TrimSpace(ua.DeviceModel),
-		SystemName:        strings.TrimSpace(ua.SystemName),
-		SystemVersion:     strings.TrimSpace(ua.SystemVersion),
-		SID:               sdk.SID,
-		IP:                ip,
-	}
-}
-
-func JsonNumber(v int64) json.Number {
-	return json.Number(strconv.FormatInt(v, 10))
-}
-func JsonRawMessage(v interface{}) json.RawMessage {
-	b, _ := json.Marshal(v)
-	return b
-}
-
-// 批量上报事件
-func BatchReport(ctx context.Context, data interface{}) error {
-	if strings.TrimSpace(config.ApiUrl) == "" {
-		return nil
-	}
-	apiUrl := config.ApiUrl + "/api/eventTracking/batchReport.json"
-	reqBody, err := json.Marshal(data)
-	if err != nil {
-		log.Error("Event report json.Marshal fail", log.E(err))
-		return err
-	}
-	req, err := http.NewRequest("POST", apiUrl, bytes.NewReader(reqBody))
-	if err != nil {
-		log.Error("Event report NewRequest fail", log.E(err))
-		return fmt.Errorf("failed to create request: %v", err)
-	}
-	req.Header.Set("Content-Type", "application/json")
-	curl, _ := http2curl.GetCurlCommand(req)
-	client := &http.Client{
-		Timeout: 5 * time.Second, // 设置超时时间为 5 秒
-	}
-	resp, err := client.Do(req)
-	if err != nil {
-		log.Error("Event report fail", log.Any("curl", curl), log.E(err))
-		return fmt.Errorf("failed to send request: %v", err)
-	}
-	defer resp.Body.Close()
-
-	if resp.StatusCode != http.StatusOK {
-		log.Error("Event report fail", log.Any("curl", curl), log.Any("http.code", resp.StatusCode))
-		return fmt.Errorf("failed to report event, status code: %d", resp.StatusCode)
-	}
-	// 读取返回的 body
-	body, err := ioutil.ReadAll(resp.Body)
-	if err != nil {
-		log.Error("Event report fail", log.Any("curl", curl), log.E(err))
-		return fmt.Errorf("failed to read response body: %v", err)
-	}
-	// 输出响应状态和返回的 body
-	log.Info("Event report Response", log.Any("body", string(body)))
-	return nil
-}

pub/dataReport/sdk_config.go

@@ -1,131 +0,0 @@
-package dataReport
-
-import (
-	"encoding/json"
-	"fmt"
-	"hkdj-web-server/pub/common/log"
-	"hkdj-web-server/pub/redis"
-	"net/http"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/robfig/cron/v3"
-)
-
-const (
-	sdkConfigAPIProd       = "https://api.dc-server.cc/sdk/getAvailableDomainList"
-	sdkConfigAPIDev        = "https://dcapi.dc-dev.cc/sdk/getAvailableDomainList"
-	sdkConfigCacheKey      = "report:sdk:domain_config"
-	sdkConfigCacheTTL      = 30 * time.Minute
-	sdkConfigFetchInterval = "0 */10 * * * *"
-)
-
-var (
-	sdkConfigAPIURL = sdkConfigAPIProd // 默认正式环境，Init时会根据RunMod覆盖
-	sdkConfigCron   *cron.Cron
-	sdkConfigOnce   sync.Once
-
-	sdkConfigMu        sync.RWMutex
-	sdkDomainConfig    string
-	sdkConfigUpdatedAt time.Time
-)
-
-type sdkConfigResponse struct {
-	Code int    `json:"code"`
-	Msg  string `json:"msg"`
-	Data string `json:"data"`
-}
-
-// StartSDKConfigCron 定时拉取 SDK 域名配置串，服务端只缓存并原样透传。
-func StartSDKConfigCron() {
-	sdkConfigOnce.Do(func() {
-		if err := RefreshSDKDomainConfig(); err != nil {
-			log.Error("RefreshSDKDomainConfig first run fail", log.E(err))
-		}
-
-		sdkConfigCron = cron.New(cron.WithSeconds())
-		if _, err := sdkConfigCron.AddFunc(sdkConfigFetchInterval, func() {
-			if err := RefreshSDKDomainConfig(); err != nil {
-				log.Error("RefreshSDKDomainConfig cron fail", log.E(err))
-			}
-		}); err != nil {
-			log.Error("StartSDKConfigCron AddFunc fail", log.E(err))
-			return
-		}
-		sdkConfigCron.Start()
-	})
-}
-
-func StopSDKConfigCron() {
-	if sdkConfigCron == nil {
-		return
-	}
-	ctx := sdkConfigCron.Stop()
-	<-ctx.Done()
-}
-
-func RefreshSDKDomainConfig() error {
-	data, err := fetchSDKDomainConfig(sdkConfigAPIURL, &http.Client{Timeout: 5 * time.Second})
-	if err != nil {
-		return err
-	}
-	setSDKDomainConfig(data)
-	if redis.Client() == nil {
-		return nil
-	}
-	return redis.Set(sdkConfigCacheKey, data, sdkConfigCacheTTL)
-}
-
-func GetSDKDomainConfig() string {
-	if redis.Client() != nil {
-		data, err := redis.Get(sdkConfigCacheKey)
-		if err != nil {
-			log.Error("GetSDKDomainConfig redis get fail", log.E(err))
-		} else if data != nil && *data != "" {
-			setSDKDomainConfig(*data)
-			return *data
-		}
-	}
-
-	sdkConfigMu.RLock()
-	defer sdkConfigMu.RUnlock()
-	return sdkDomainConfig
-}
-
-func setSDKDomainConfig(data string) {
-	sdkConfigMu.Lock()
-	defer sdkConfigMu.Unlock()
-	sdkDomainConfig = data
-	sdkConfigUpdatedAt = time.Now()
-}
-
-func fetchSDKDomainConfig(apiURL string, client *http.Client) (string, error) {
-	req, err := http.NewRequest(http.MethodGet, apiURL, nil)
-	if err != nil {
-		return "", err
-	}
-	req.Header.Set("Accept", "application/json")
-
-	resp, err := client.Do(req)
-	if err != nil {
-		return "", err
-	}
-	defer resp.Body.Close()
-
-	if resp.StatusCode != http.StatusOK {
-		return "", fmt.Errorf("sdk config http status: %d", resp.StatusCode)
-	}
-
-	var result sdkConfigResponse
-	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
-		return "", err
-	}
-	if result.Code != 0 {
-		return "", fmt.Errorf("sdk config code: %d, msg: %s", result.Code, result.Msg)
-	}
-	if strings.TrimSpace(result.Data) == "" {
-		return "", fmt.Errorf("sdk config data is empty")
-	}
-	return result.Data, nil
-}

pub/dataReport/type.go

@@ -1,222 +0,0 @@
-package dataReport
-
-import (
-	"context"
-	"encoding/json"
-)
-
-type Response struct {
-	Code int         `json:"code"`
-	Msg  string      `json:"msg"`
-	Data interface{} `json:"data"`
-}
-
-type Config struct {
-	ApiUrl string `json:"apiUrl"`
-	RunMod string `json:"runMod"` // 运行模式: dev/test/prod/release
-}
-
-const (
-	EventTypeAdClick           = "ad_click"
-	EventTypeUserLogin         = "user_login"
-	EventTypeUserRegister      = "user_register"
-	EventTypeOrderCreated      = "order_created"
-	EventTypeOrderPaid         = "order_paid"
-	EventTypeCoinConsume       = "coin_consume"
-	EventTypeVideoPurchase     = "video_purchase"
-	EventTypeVideoLike         = "video_like"
-	EventTypeVideoCollect      = "video_collect"
-	EventTypeVideoComment      = "video_comment"
-	EventTypeVideoStatusChange = "video_status_change" // 视频状态变更
-	EventTypeDramaLike         = "drama_like"
-	EventTypeDramaCollect      = "drama_collect"
-	EventTypeDramaComment      = "drama_comment"
-	EventTypeDramaPurchase     = "drama_purchase"
-
-	DramaContentTypeShortDrama = "short_drama"
-	DramaUnlockTypeCoin        = "coin"
-	DramaUnlockTypeVIP         = "vip_subscription"
-	DramaUnlockTypeAd          = "ad"
-	DramaUnlockTypeOther       = "other"
-)
-
-// Event 定义事件的接口
-type Event interface {
-	Generate(ctx context.Context, retryCount int)
-	AsyncReport(ctx context.Context, retryCount int) error // 执行事件上报
-}
-
-// 定义公共字段和事件数据结构
-type CommonField struct {
-	Event             string          `json:"event"`              // 事件类型
-	Channel           string          `json:"channel"`            // 渠道码
-	EventID           string          `json:"event_id"`           // 事件唯一标识符
-	AppID             string          `json:"app_id"`             // 应用ID
-	AppVersion        string          `json:"app_version"`        // 客户端通过 X-SDK-Common 传入的版本，缺失时留空
-	UID               string          `json:"uid"`                // 用户ID
-	SID               string          `json:"sid"`                // 会话ID
-	ClientTS          string          `json:"client_ts"`          // 客户端时间戳
-	Device            string          `json:"device"`             // 设备类型（如：Android, iOS, PC）
-	DeviceID          string          `json:"device_id"`          // 设备ID
-	DeviceFingerprint string          `json:"device_fingerprint"` // SDK 设备指纹，SDK 原值为空时也保留字段。
-	FPVersion         string          `json:"fp_version"`         // SDK 指纹算法版本
-	UserAgent         string          `json:"user_agent"`         // 用户代理信息
-	DeviceBrand       string          `json:"device_brand"`       // 设备品牌（如：HUAWEI）
-	DeviceModel       string          `json:"device_model"`       // 设备型号
-	SystemName        string          `json:"system_name"`        // 系统名称
-	SystemVersion     string          `json:"system_version"`     // 系统版本
-	IP                string          `json:"ip"`                 // 用户IP地址
-	Payload           json.RawMessage `json:"payload"`            // 事件数据
-}
-
-// UserRegisterEvent 注册事件
-type UserRegisterEvent struct {
-	Type       string      `json:"type"`        // 注册方式：phone, deviceid, email, username
-	TraceID    string      `json:"trace_id"`    // 唯一标识，落地页点击生成
-	CreateTime json.Number `json:"create_time"` // 注册时间，10位时间戳
-}
-
-type UserLoginEvent struct {
-	Type string `json:"type"` // 登录方式
-}
-
-// OrderCreatedEvent 订单创建
-type OrderCreatedEvent struct {
-	OrderID         string      `json:"order_id"`     // 订单号（唯一标识）
-	OrderType       string      `json:"order_type"`   // 订单类型
-	ProductID       string      `json:"product_id"`   // 商品ID
-	ProductName     string      `json:"product_name"` // 商品名称
-	VIPDurationID   string      `json:"vip_duration_type"`
-	VIPDurationName string      `json:"vip_duration_name"`
-	Amount          json.Number `json:"amount"`           // 订单金额（分）
-	Currency        string      `json:"currency"`         // 货币类型
-	CoinQuantity    json.Number `json:"coin_quantity"`    // 金币数量
-	SourcePageKey   string      `json:"source_page_key"`  // 来源页面标识
-	SourcePageName  string      `json:"source_page_name"` // 来源页面名称
-	CreateTime      json.Number `json:"create_time"`      // 订单创建时间
-}
-
-// OrderPaidEvent 订单支付成功
-type OrderPaidEvent struct {
-	OrderID           string      `json:"order_id"`            // 订单号（关联创建事件）
-	OrderType         string      `json:"order_type"`          // 订单类型：coin_purchase, vip_subscription
-	ProductID         string      `json:"product_id"`          // 商品ID
-	Amount            json.Number `json:"amount"`              // 实际支付金额（分）
-	Currency          string      `json:"currency"`            // 货币类型：CNY, USD
-	CoinQuantity      json.Number `json:"coin_quantity"`       // 金币数量（仅金币订单）
-	VIPExpirationTime json.Number `json:"vip_expiration_time"` // VIP过期时间（10位时间戳）
-	PayType           string      `json:"pay_type"`            // 支付方式：wechat, alipay, bank_card
-	PayChannel        string      `json:"pay_channel"`         // 支付渠道：银行名称
-	TransactionID     string      `json:"transaction_id"`      // 第三方支付交易号
-	CreateTime        json.Number `json:"create_time"`
-}
-
-// CoinConsumeEvent 金币消耗
-type CoinConsumeEvent struct {
-	ProductID         string      `json:"product_id"`          // 商品ID
-	ProductName       string      `json:"product_name"`        // 商品名称
-	CoinConsumeAmount json.Number `json:"coin_consume_amount"` // 金币消耗数量
-	CoinBalanceBefore json.Number `json:"coin_balance_before"` // 消耗前金币余额
-	CoinBalanceAfter  json.Number `json:"coin_balance_after"`  // 消耗后金币余额
-	ConsumeReasonKey  string      `json:"consume_reason_key"`  // 消耗原因
-	ConsumeReasonName string      `json:"consume_reason_name"` // 消耗原因名称
-	CreateTime        json.Number `json:"create_time"`         // 订单创建时间
-	OrderId           string      `json:"order_id"`            // 订单id
-}
-
-// VideoPurchaseEvent 视频购买事件
-type VideoPurchaseEvent struct {
-	MediaId          string      `json:"media_id"`           // 老司机媒体资源ID（老司机接口返回的id字段）
-	VideoID          string      `json:"video_id"`           // 视频ID
-	VideoTitle       string      `json:"video_title"`        // 视频标题
-	VideoTypeID      string      `json:"video_type_id"`      // 视频分类ID
-	VideoTypeName    string      `json:"video_type_name"`    // 视频分类名称
-	VideoContentType string      `json:"video_content_type"` // 视频类型: video(长视频)、short_video(短视频)
-	RecommendTraceId string      `json:"recommend_trace_id"` // 推荐引擎的trace_id。没有对接搜索推荐引擎的上报空字符串。
-	CoinQuantity     json.Number `json:"coin_quantity"`      // 金币数量
-	OrderID          string      `json:"order_id"`           // 订单号
-}
-
-type (
-	VideoEventPub struct {
-		MediaId          string `json:"media_id"`           // 老司机媒体资源ID（老司机接口返回的id字段）
-		VideoID          string `json:"video_id"`           // 视频ID
-		VideoTitle       string `json:"video_title"`        // 视频标题
-		VideoTypeID      string `json:"video_type_id"`      // 视频分类ID
-		VideoTypeName    string `json:"video_type_name"`    // 视频分类名称
-		VideoContentType string `json:"video_content_type"` // 视频类型: video(长视频)、short_video(短视频)
-		RecommendTraceId string `json:"recommend_trace_id"` // 推荐引擎的trace_id。没有对接搜索推荐引擎的上报空字符串。
-	}
-
-	VideoLikeEvent struct {
-		VideoEventPub
-		Flag json.Number `json:"flag"` // 点赞状态：1(点赞), 2(取消点赞)
-	}
-
-	VideoCollectEvent struct {
-		VideoEventPub
-		Flag json.Number `json:"flag"` // 收藏状态：1(收藏), 2(取消收藏)
-	}
-
-	VideoCommentEvent struct {
-		VideoEventPub
-		CommentContent string `json:"comment_content"` // 评论内容
-	}
-
-	// VideoStatusChangeEvent 视频状态变更事件
-	VideoStatusChangeEvent struct {
-		MediaId       string      `json:"media_id"`        // 老司机媒体资源ID
-		VideoID       string      `json:"video_id"`        // 视频ID
-		VideoTitle    string      `json:"video_title"`     // 视频标题
-		VideoTypeID   string      `json:"video_type_id"`   // 视频分类ID
-		VideoTypeName string      `json:"video_type_name"` // 视频分类名称
-		Flag          json.Number `json:"flag"`            // 状态标识
-	}
-
-	DramaEventPub struct {
-		DramaID          string      `json:"drama_id"`           // 剧集ID（短剧ID）
-		DramaTitle       string      `json:"drama_title"`        // 剧集名称
-		Episode          json.Number `json:"episode"`            // 第几集，默认1
-		TotalEpisode     json.Number `json:"total_episode"`      // 已上线总集数
-		DramaTypeID      string      `json:"drama_type_id"`      // 剧集分类ID
-		DramaTypeName    string      `json:"drama_type_name"`    // 剧集分类名称
-		DramaContentType string      `json:"drama_content_type"` // short_drama
-		DramaTagKey      string      `json:"drama_tag_key"`      // 标签KEY，逗号分隔
-		DramaTagName     string      `json:"drama_tag_name"`     // 标签名称，逗号分隔
-		DramaDuration    json.Number `json:"drama_duration"`     // 剧集时长（秒）
-	}
-
-	DramaLikeEvent struct {
-		DramaEventPub
-		Flag json.Number `json:"flag"` // 点赞状态：1(点赞), 2(取消点赞)
-	}
-
-	DramaCollectEvent struct {
-		DramaEventPub
-		Flag json.Number `json:"flag"` // 收藏状态：1(收藏), 2(取消收藏)
-	}
-
-	DramaCommentEvent struct {
-		DramaEventPub
-		CommentContent string `json:"comment_content"` // 评论内容
-	}
-
-	DramaPurchaseEvent struct {
-		DramaEventPub
-		CoinQuantity json.Number `json:"coin_quantity"` // 金币数量
-		OrderID      string      `json:"order_id"`      // 订单号，与 coin_consume 保持一致
-		UnlockType   string      `json:"unlock_type"`   // coin / vip_subscription / ad / other
-		AdID         string      `json:"ad_id"`         // 广告解锁时的广告ID
-	}
-)
-
-type AdClickEvent struct {
-	CommonField
-	PageKey    string `json:"page_key"`     // 页面标识
-	PageName   string `json:"page_name"`    // 页面名称
-	AdSlotKey  string `json:"ad_slot_key"`  // 广告位标识
-	AdSlotName string `json:"ad_slot_name"` // 广告位名称
-	AdID       string `json:"ad_id"`        // 广告ID
-	CreativeID string `json:"creative_id"`  // 素材ID（可选）
-	AdType     string `json:"ad_type"`      // 广告类型
-}

pub/models/eventmod/index.go

@@ -1,47 +0,0 @@
-package eventmod
-
-import (
-	"context"
-	"fmt"
-	"hkdj-web-server/pub/mongos"
-
-	"go.mongodb.org/mongo-driver/bson"
-	"go.mongodb.org/mongo-driver/mongo"
-)
-
-var db *mongos.Collection
-
-func Init(ctx context.Context) {
-	db = mongos.Shop.Coll(TN.Event)
-	indexes := []mongo.IndexModel{
-		{
-			Keys: bson.D{
-				{Key: FN.Event.Status, Value: 1},
-			},
-		},
-		{
-			Keys: bson.D{
-				{Key: FN.Event.EventType, Value: 1},
-			},
-		},
-		{
-			Keys: bson.D{
-				{Key: FN.Event.EventId, Value: 1},
-			},
-		},
-		{
-			Keys: bson.D{
-				{Key: FN.Event.Status, Value: 1},
-				{Key: FN.Event.RetryCount, Value: 1},
-			},
-		},
-		{
-			Keys: bson.D{
-				{Key: FN.Event.CreatedAt, Value: -1},
-			},
-		},
-	}
-	if _, err := db.CreateIndex(ctx, indexes); err != nil {
-		panic(fmt.Sprintf("(eventmod:Init) Create Event Index failed! err:%+v:", err))
-	}
-}

pub/models/eventmod/model.go

@@ -1,130 +0,0 @@
-package eventmod
-
-import (
-	"context"
-	"hkdj-web-server/pub/common/log"
-	"hkdj-web-server/pub/common/srvdef"
-
-	"go.mongodb.org/mongo-driver/bson"
-	"go.mongodb.org/mongo-driver/mongo"
-	"go.mongodb.org/mongo-driver/mongo/options"
-)
-
-// InsertOneEvent 插入一个事件
-func InsertOneEvent(ctx context.Context, event *Event) *srvdef.SrvErr {
-	if _, err := db.InsertOne(ctx, event); err != nil {
-		log.Warn("eventmod:InsertOneEvent db.InsertOne failed", log.E(err))
-		return srvdef.New(srvdef.ErrDbInsertError, "", "")
-	}
-	return nil
-}
-
-// InsertManyEvent 批量插入事件
-func InsertManyEvent(ctx context.Context, events *EventList) *srvdef.SrvErr {
-	if _, err := db.InsertMany(ctx, events); err != nil {
-		log.Warn("eventmod:InsertManyEvent db.InsertMany failed", log.E(err))
-		return srvdef.New(srvdef.ErrDbInsertError, "", "")
-	}
-	return nil
-}
-
-// DelOneEvent 删除一个事件
-func DelOneEvent(ctx context.Context, filter bson.M) (int64, *srvdef.SrvErr) {
-	count, err := db.DeleteOne(ctx, filter)
-	if err != nil {
-		log.Warn("eventmod:DelOneEvent db.DeleteOne failed",
-			log.E(err), log.Any("filter", filter))
-		return 0, srvdef.New(srvdef.ErrDbDeleteError, "", "")
-	}
-	return count, nil
-}
-
-// DelManyEvent 批量删除事件
-func DelManyEvent(ctx context.Context, filter bson.M) (int64, *srvdef.SrvErr) {
-	count, err := db.DeleteMany(ctx, filter)
-	if err != nil {
-		log.Warn("eventmod:DelManyEvent db.DeleteMany failed",
-			log.E(err), log.Any("filter", filter))
-		return 0, srvdef.New(srvdef.ErrDbDeleteError, "", "")
-	}
-	return count, nil
-}
-
-// FindOneEvent 查找一个事件
-func FindOneEvent(ctx context.Context, filter bson.M, opts ...*options.FindOneOptions) (*Event, *srvdef.SrvErr) {
-	var event Event
-	if err := db.FindOneEx(ctx, &event, filter, opts...); err != nil {
-		if err != mongo.ErrNoDocuments {
-			log.Warn("eventmod:FindOneEvent db.FindOne failed",
-				log.E(err), log.Any("filter", filter))
-			return nil, srvdef.New(srvdef.ErrDbQueryError, "", "")
-		}
-		return nil, srvdef.New(srvdef.ErrNoData, "", "")
-	}
-	return &event, nil
-}
-
-// FindManyEvent 查找多个事件
-func FindManyEvent(ctx context.Context, filter bson.M, opts ...*options.FindOptions) (EventList, *srvdef.SrvErr) {
-	data := make(EventList, 0)
-	if err := db.Find(ctx, &data, filter, opts...); err != nil {
-		log.Warn("eventmod:FindManyEvent db.Find failed",
-			log.E(err), log.Any("filter", filter))
-		return nil, srvdef.New(srvdef.ErrDbQueryError, "", "")
-	}
-	return data, nil
-}
-
-// CountEvent 统计事件数量
-func CountEvent(ctx context.Context, filter bson.M) (int64, *srvdef.SrvErr) {
-	count, err := db.Count(ctx, filter)
-	if err != nil {
-		log.Warn("eventmod:CountEvent db.Count failed",
-			log.E(err), log.Any("filter", filter))
-		return 0, srvdef.New(srvdef.ErrDbQueryError, "", "")
-	}
-	return count, nil
-}
-
-// UpdateOneEvent 更新一个事件
-func UpdateOneEvent(ctx context.Context, filter bson.M, update bson.M) *srvdef.SrvErr {
-	result, err := db.UpdateOne(ctx, filter, update)
-	if err != nil {
-		log.Warn("eventmod:UpdateOneEvent db.UpdateOne failed",
-			log.E(err), log.Any("filter", filter))
-		return srvdef.New(srvdef.ErrDbUpdateError, "", "")
-	}
-	if result.MatchedCount != 1 {
-		log.Warn("eventmod:UpdateOneEvent db.UpdateOne not matched",
-			log.Any("filter", filter))
-		return srvdef.New(srvdef.ErrNoData, "", "")
-	}
-	return nil
-}
-
-// UpdateManyEvent 批量更新事件
-func UpdateManyEvent(ctx context.Context, filter bson.M, update bson.M) *srvdef.SrvErr {
-	result, err := db.UpdateMany(ctx, filter, update)
-	if err != nil {
-		log.Warn("eventmod:UpdateManyEvent db.UpdateMany failed",
-			log.E(err), log.Any("filter", filter))
-		return srvdef.New(srvdef.ErrDbUpdateError, "", "")
-	}
-	if result.MatchedCount < 1 {
-		log.Warn("eventmod:UpdateManyEvent db.UpdateMany not matched",
-			log.Any("filter", filter))
-		return srvdef.New(srvdef.ErrNoData, "", "")
-	}
-	return nil
-}
-
-// UpsertOneEvent 插入或更新一个事件
-func UpsertOneEvent(ctx context.Context, filter bson.M, update bson.M) *srvdef.SrvErr {
-	opts := options.Update().SetUpsert(true)
-	if _, err := db.UpdateOne(ctx, filter, update, opts); err != nil {
-		log.Warn("eventmod:UpsertOneEvent db.UpdateOne failed",
-			log.E(err), log.Any("filter", filter))
-		return srvdef.New(srvdef.ErrDbUpdateError, "", "")
-	}
-	return nil
-}

pub/models/eventmod/tag.go

@@ -1,31 +0,0 @@
-package eventmod
-
-type TagEvent struct {
-	ID         string //
-	CreatedAt  string // 创建事件
-	RetryCount string // 重试次数
-	Status     string //
-	Data       string //
-	EventType  string //
-	EventId    string //
-	UpdatedAt  string // 修改时间
-}
-
-var FN struct {
-	Event TagEvent
-}
-var TN struct {
-	Event string
-}
-
-func init() {
-	FN.Event.ID = "_id"
-	FN.Event.CreatedAt = "createdAt"
-	FN.Event.RetryCount = "retryCount"
-	FN.Event.Status = "status"
-	FN.Event.Data = "data"
-	FN.Event.EventType = "eventType"
-	FN.Event.EventId = "eventId"
-	FN.Event.UpdatedAt = "updatedAt"
-	TN.Event = "event"
-}

pub/models/eventmod/type.go

@@ -1,32 +0,0 @@
-package eventmod
-
-import (
-	"time"
-
-	"go.mongodb.org/mongo-driver/bson/primitive"
-)
-
-type EventStatus int
-
-const (
-	Default EventStatus = 0 // 默认状态，等待上报
-	Success EventStatus = 1 // 成功
-	Failure EventStatus = 2 // 失败
-)
-
-//go:generate fox mongo --model
-//go:generate fox mongo --tag
-//go:generate fox mongo --update
-
-// @table:event
-// @title:事件表
-type Event struct {
-	ID         primitive.ObjectID `bson:"_id,omitempty"`
-	EventId    string             `json:"eventId" bson:"eventId"`
-	EventType  string             `json:"eventType" bson:"eventType"`
-	Data       string             `json:"data" bson:"data"`
-	Status     EventStatus        `json:"status" bson:"status"`         //
-	RetryCount int                `json:"retryCount" bson:"retryCount"` // 重试次数
-	CreatedAt  time.Time          `json:"createdAt" bson:"createdAt"`   // 创建事件
-	UpdatedAt  time.Time          `bson:"updatedAt"`                    // 修改时间
-}

pub/models/eventmod/update.go

@@ -1,53 +0,0 @@
-package eventmod
-
-import (
-	"time"
-
-	"go.mongodb.org/mongo-driver/bson"
-	"go.mongodb.org/mongo-driver/bson/primitive"
-)
-
-type EventList []*Event
-type EventUpdate struct {
-	RetryCount *int         `json:"retryCount" bson:"retryCount,omitempty"` // 重试次数
-	Status     *EventStatus `json:"status" bson:"status,omitempty"`         //
-	Data       *string      `json:"data" bson:"data,omitempty"`             //
-	EventType  *string      `json:"eventType" bson:"eventType,omitempty"`   //
-	EventId    *string      `json:"eventId" bson:"eventId,omitempty"`       //
-	UpdatedAt  *time.Time   `json:"" bson:"updatedAt,omitempty"`            // 修改时间
-}
-type EventQuery struct {
-	ID         *primitive.ObjectID `json:"" bson:"_id,omitempty"`                  //
-	RetryCount *int                `json:"retryCount" bson:"retryCount,omitempty"` // 重试次数
-	Status     *EventStatus        `json:"status" bson:"status,omitempty"`         //
-	Data       *string             `json:"data" bson:"data,omitempty"`             //
-	EventType  *string             `json:"eventType" bson:"eventType,omitempty"`   //
-	EventId    *string             `json:"eventId" bson:"eventId,omitempty"`       //
-	UpdatedAt  *time.Time          `json:"" bson:"updatedAt,omitempty"`            // 修改时间
-}
-
-func (query *EventQuery) GetQueryFilter() bson.M {
-	filter := bson.M{}
-	if query.ID != nil {
-		filter[FN.Event.ID] = *query.ID
-	}
-	if query.RetryCount != nil {
-		filter[FN.Event.RetryCount] = *query.RetryCount
-	}
-	if query.Status != nil {
-		filter[FN.Event.Status] = *query.Status
-	}
-	if query.Data != nil {
-		filter[FN.Event.Data] = bson.M{"$regex": primitive.Regex{Pattern: *query.Data, Options: "i"}}
-	}
-	if query.EventType != nil {
-		filter[FN.Event.EventType] = bson.M{"$regex": primitive.Regex{Pattern: *query.EventType, Options: "i"}}
-	}
-	if query.EventId != nil {
-		filter[FN.Event.EventId] = bson.M{"$regex": primitive.Regex{Pattern: *query.EventId, Options: "i"}}
-	}
-	if query.UpdatedAt != nil {
-		filter[FN.Event.UpdatedAt] = *query.UpdatedAt
-	}
-	return filter
-}

pub/models/models.go

@@ -11,7 +11,6 @@ import (
 	"hkdj-web-server/pub/models/contactusmod"
 	"hkdj-web-server/pub/models/detailnavmod"
 	"hkdj-web-server/pub/models/esmod"
-	"hkdj-web-server/pub/models/eventmod"
 	"hkdj-web-server/pub/models/feedbackmod"
 	"hkdj-web-server/pub/models/homebannermod"
 	"hkdj-web-server/pub/models/homeconfigmod"
@@ -74,7 +73,6 @@ func Init() {
 	ipdailystatmod.Init(ctx)
 	esmod.Init(ctx)
 	detailnavmod.Init(ctx)
-	eventmod.Init(ctx)
 	translationcategorymod.Init(ctx)
 	translationmod.Init(ctx)
 	playletthememod.Init(ctx)

pub/pubdef/pubdef.go

@@ -1,7 +1,5 @@
 package pubdef
 
-import "fmt"
-
 type Page struct {
 	PageNum  int64 `form:"pageNum" json:"pageNum,omitempty"`
 	PageSize int64 `form:"pageSize" json:"pageSize,omitempty"`
@@ -25,11 +23,6 @@ const (
 	seoPushEnabled = false
 )
 
-// TrackerAppId 数据上报 SDK / 服务端埋点共用的应用 ID
-func TrackerAppId() string {
-	return fmt.Sprintf("JHA-%d", AppId)
-}
-
 // Enabled 业务开关是否打开（不含环境判断）。
 func Enabled() bool {
 	return seoPushEnabled

pub/storage/proxy/object.go

@@ -156,6 +156,30 @@ func QueryMedia(baseInfo *MediaQueryeReq, domain string) (result *VideoQueryResu
 	return
 }
 
+func QueryAdvitise(baseInfo *AppAdvitiseInfoReq, domain string) (result *AdvitiseQuerysResult, err error) {
+	result = &AdvitiseQuerysResult{}
+	paramJson, err := json.Marshal(baseInfo)
+	if err != nil {
+		return
+	}
+	if len(domain) == 0 {
+		domain = DomainAddressRepair(domain, BucketVideoAddressV2)
+	}
+	url := domain
+	if !strings.Contains(domain, "/media/web/app/advitise") {
+		url = domain + "/media/web/app/advitise"
+	}
+	fr, err := http.Post(url, header, bytes.NewReader(paramJson))
+	if err != nil {
+		return
+	}
+	if err = json.Unmarshal(fr.Data, result); err != nil {
+		fmt.Println(err)
+		return nil, err
+	}
+	return
+}
+
 func QueryMedias(baseInfo *MediaQueryesReq, domain string) (result *VideoQuerysResult, err error) {
 	result = &VideoQuerysResult{
 		Data: make([]MediaResp, 0),

pub/storage/proxy/types.go

@@ -1,6 +1,7 @@
 package proxy
 
 import (
+	"encoding/json"
 	"hkdj-web-server/pub/models/videoinformationmod"
 	"hkdj-web-server/pub/mongos"
 	"strings"
@@ -425,6 +426,32 @@ type AdvitiseInfo struct {
 	Images   string `json:"images" bson:"images"`     // 视频banner
 	Link     string `json:"link" bson:"link"`         // 链接
 }
+
+// UnmarshalJSON 兼容远端 id 返回数字或字符串两种格式，统一解析为字符串，避免大整数(雪花ID)在 JS 端丢精度
+func (a *AdvitiseInfo) UnmarshalJSON(data []byte) error {
+	type alias AdvitiseInfo
+	aux := &struct {
+		Id json.RawMessage `json:"id"`
+		*alias
+	}{alias: (*alias)(a)}
+	if err := json.Unmarshal(data, aux); err != nil {
+		return err
+	}
+	raw := strings.TrimSpace(string(aux.Id))
+	switch {
+	case raw == "" || raw == "null":
+		a.Id = ""
+	case strings.HasPrefix(raw, `"`):
+		var s string
+		if err := json.Unmarshal([]byte(raw), &s); err != nil {
+			return err
+		}
+		a.Id = s
+	default:
+		a.Id = raw
+	}
+	return nil
+}
 type AdvitiseData struct {
 	DialogList     []AdvitiseInfo `json:"dialogList" bson:"dialogList"`         // 弹窗广告
 	HomeList       []AdvitiseInfo `json:"homeList" bson:"homeList"`             // 首页列表

pub/storage/upload.go

@@ -29,6 +29,10 @@ func UploadImage(ctx context.Context, f *multipart.FileHeader, domain string) (p
 	return proxy.UploadImg(f.Filename, buffer.Bytes(), domain)
 }
 
+func QueryAdvitiseList(ctx context.Context, in *proxy.AppAdvitiseInfoReq, domain string) (*proxy.AdvitiseQuerysResult, error) {
+	return proxy.QueryAdvitise(in, domain)
+}
+
 func QueryMedias(ctx context.Context, in *proxy.MediaQueryesReq, domain string) (*proxy.VideoQuerysResult, error) {
 	return proxy.QueryMedias(in, domain)
 }

web/api/web_acc/login.go

@@ -26,26 +26,22 @@ func AccLogin(c *gin.Context) {
 		return
 	}
 
-	accInfo, err := srv_mwacc.AccLogin(c, req.Acc, req.Pwd, req.Code)
+	accInfo, err := srv_mwacc.AccLogin(c, req.Acc, req.Pwd)
 	if err != nil || accInfo == nil {
 		common.ServerJSON(c, err.Code, err.Msg)
 		return
 	}
 
-	resp := MainWebLoginResp{}
-
-	if len(accInfo.Qurl) != 0 {
-		resp.Qurl = accInfo.Qurl
-	} else {
 	// 成功保存token
 	if ok, _ := mwacc.SaveToken(c, accInfo.Id, accInfo.Token); ok != true {
 		common.ServerJSON(c, srvdef.GenerateTokenFailed, srvdef.GenerateTokenFailed.Msg())
 	}
 
-		resp.AccId = accInfo.Id
+	resp := MainWebLoginResp{
-		resp.Acc = accInfo.Acc
+		AccId:  accInfo.Id,
-		resp.RoleId = accInfo.RoleId
+		Acc:    accInfo.Acc,
-		resp.Token = accInfo.Token
+		RoleId: accInfo.RoleId,
+		Token:  accInfo.Token,
 	}
 	common.ServerJSON(c, srvdef.Success, resp)
 	return

web/server/server.go

@@ -6,7 +6,6 @@ import (
 	"hkdj-web-server/pub/common/laosiji"
 	"hkdj-web-server/pub/common/log"
 	"hkdj-web-server/pub/common/srvversion"
-	"hkdj-web-server/pub/dataReport"
 	"hkdj-web-server/pub/esmanager"
 	"hkdj-web-server/pub/models"
 	"hkdj-web-server/pub/mongos"
@@ -77,10 +76,6 @@ func Run(args []string) {
 	mongos.StartLid()
 	initData()
 	initSeoPush()
-	dataReport.Init(dataReport.Config{
-		ApiUrl: webg.Conf.DataReport.Url,
-		RunMod: webg.Conf.RunMod,
-	})
 
 	initHttpServer()
 

web/service/srv_mediaresource/resource.go

@@ -1336,8 +1336,7 @@ func ensureImportedPlayletSlug(ctx context.Context, playlet *playletmod.Playlet)
 	if playlet == nil {
 		return srvdef.New(srvdef.ErrParamError, "短剧数据为空", "")
 	}
-	source := utils.SlugSourceFromKeywordsOrTitle(playlet.SeoInfo.Keyworld, playlet.Title)
+	playlet.Slug = utils.MakeRandomSlug(func(slug string) bool {
-	playlet.Slug = utils.MakeUniqueSlug(source, func(slug string) bool {
 		exist, _ := playletmod.FindOnePlaylet(ctx, bson.M{
 			playletmod.FN.Playlet.Slug: slug,
 		})

web/service/srv_mwacc/login.go

@@ -7,13 +7,11 @@ import (
 	"hkdj-web-server/pub/common/log"
 	"hkdj-web-server/pub/common/srvdef"
 	"hkdj-web-server/pub/common/utils"
-	"hkdj-web-server/pub/google"
 	"hkdj-web-server/pub/models/mwacc"
 	"hkdj-web-server/web/webg"
 	"strings"
 	"time"
 
-	"github.com/skip2/go-qrcode"
 	"go.mongodb.org/mongo-driver/bson"
 )
 
@@ -78,8 +76,8 @@ func isCustomerServiceRole(ctx context.Context, acc *mwacc.MwAcc) bool {
 	return strings.Contains(roleName, "客服")
 }
 
-// 账号登录
+// AccLogin 账号登录（已取消谷歌验证，密码正确即登录）
-func AccLogin(ctx context.Context, acc string, pwd string, code string) (*mwacc.MwAcc, *srvdef.SrvErr) {
+func AccLogin(ctx context.Context, acc string, pwd string) (*mwacc.MwAcc, *srvdef.SrvErr) {
 	var data *mwacc.MwAcc
 	res, dataErr := mwacc.FindOneAccByFilter(ctx, bson.M{
 		mwacc.FN.MwAcc.Acc: acc,
@@ -93,36 +91,11 @@ func AccLogin(ctx context.Context, acc string, pwd string, code string) (*mwacc.
 		return data, srvdef.New(srvdef.AccountErrAccessForbid, srvdef.AccountErrAccessForbid.Msg(), "")
 	}
 
-	// 通过验证，再次验证密码是否正确
 	md5pwd := crypt.StrToMd5(pwd)
 	if res.Pwd != md5pwd {
 		return data, srvdef.New(srvdef.AccountErrPasswordError, srvdef.AccountErrPasswordError.Msg(), "")
 	}
 
-	if !res.IsBase32 {
-		// 谷歌绑定二维码
-		googleUrl := google.NewGoogleAuth().GetQrcode(acc, res.Base32)
-		qrCodePNG, _ := qrcode.Encode(googleUrl, qrcode.Medium, 256)
-
-		bq := &mwacc.MwAcc{}
-		bq.Qurl = qrCodePNG
-		data = bq
-	} else {
-		// hf屏蔽
-		if webg.Conf.RunMod == "prod" && (res.RoleId != 46761 && res.RoleId != 29601) {
-			if code == "" {
-				return data, srvdef.New(srvdef.ErrCaptcha, srvdef.ErrCaptcha.Msg(), "")
-			}
-			result, Verr := google.NewGoogleAuth().VerifyCode(res.Base32, code)
-			if Verr != nil || !result {
-				return data, srvdef.New(srvdef.ErrCaptchaInvalid, srvdef.ErrCaptchaInvalid.Msg(), "")
-			}
-		}
-		// 通过验证，再次验证密码是否正确
-		pwd := crypt.StrToMd5(pwd)
-		if res.Pwd != pwd {
-			return data, srvdef.New(srvdef.AccountErrPasswordError, srvdef.AccountErrPasswordError.Msg(), "")
-		}
 	getToken, err := generateToken(res.Id)
 	if err != nil {
 		return data, srvdef.New(srvdef.GenerateTokenFailed, srvdef.GenerateTokenFailed.Msg(), "")
@@ -132,10 +105,8 @@ func AccLogin(ctx context.Context, acc string, pwd string, code string) (*mwacc.
 	}, bson.M{
 		mwacc.FN.MwAcc.LastTime: time.Now(),
 	})
-		// 更新最近登录时间
 	data = res
 	data.Token = getToken
-	}
 
 	return data, nil
 }

web/service/srv_playlet/playlet.go

@@ -2,7 +2,6 @@ package srv_playlet
 
 import (
 	"context"
-	"hkdj-web-server/app/service/reportser"
 	"hkdj-web-server/pub/common/log"
 	"hkdj-web-server/pub/common/response"
 	"hkdj-web-server/pub/common/srvdef"
@@ -502,30 +501,9 @@ func SetPlayletStatus(ctx context.Context, req *proto.PlayletStatusSetReq) *srvd
 			log.Error("短剧状态同步ES失败", log.Any("短剧ID", syncIds), log.Any("状态", syncStatus), log.E(err))
 		}
 	}()
-	if flag := reportser.PlayletStatusFlag(req.Status); flag != 0 {
-		reportPlayletStatusEvents(ctx, ids, flag)
-	}
 	return nil
 }
 
-func reportPlayletStatusEvents(ctx context.Context, ids []int64, flag int64) {
-	if len(ids) == 0 {
-		return
-	}
-	list, err := playletmod.FindManyPlaylet(ctx, bson.M{playletmod.FN.Playlet.Id: bson.M{"$in": ids}}, options.Find().SetProjection(bson.D{
-		{Key: playletmod.FN.Playlet.Id, Value: 1},
-		{Key: playletmod.FN.Playlet.Title, Value: 1},
-		{Key: playletmod.FN.Playlet.MediaCenterId, Value: 1},
-	}))
-	if err != nil {
-		log.Error("短剧状态变更上报查询失败", log.Any("短剧ID", ids), log.E(err))
-		return
-	}
-	for _, item := range list {
-		reportser.ReportPlayletStatusChange(item, flag)
-	}
-}
-
 // SetPlayletRecommend 单/批量设置短剧是否推荐
 func SetPlayletRecommend(ctx context.Context, req *proto.PlayletRecommendSetReq) *srvdef.SrvErr {
 	if req == nil {

web/service/srv_playlet/slug.go

@@ -47,8 +47,7 @@ func ensureThemeSlug(ctx context.Context, ac *playletthememod.PlayletTheme, excl
 		}
 		return nil
 	}
-	source := utils.SlugSourceFromKeywordsOrTitle(ac.SeoInfo.Keyworld, ac.Name)
+	ac.Slug = utils.MakeRandomSlug(func(slug string) bool {
-	ac.Slug = utils.MakeUniqueSlug(source, func(slug string) bool {
 		filter := bson.M{playletthememod.FN.PlayletTheme.Slug: slug}
 		if excludeId > 0 {
 			filter[playletthememod.FN.PlayletTheme.Id] = bson.M{"$ne": excludeId}
@@ -80,16 +79,7 @@ func prepareThemeSlugOnUpdate(ctx context.Context, id int64, info *playletthemem
 		}
 		return nil
 	}
-	name := info.Name
+	newSlug := utils.MakeRandomSlug(func(s string) bool {
-	if req.Name != nil {
-		name = strings.TrimSpace(*req.Name)
-	}
-	keywords := info.SeoInfo.Keyworld
-	if req.SeoInfo != nil {
-		keywords = normalizeSeoValue(*req.SeoInfo).Keyworld
-	}
-	source := utils.SlugSourceFromKeywordsOrTitle(keywords, name)
-	newSlug := utils.MakeUniqueSlug(source, func(s string) bool {
 		exist, _ := playletthememod.FindOnePlayletTheme(ctx, bson.M{
 			playletthememod.FN.PlayletTheme.Slug: s,
 			playletthememod.FN.PlayletTheme.Id:   bson.M{"$ne": id},
@@ -185,8 +175,7 @@ func ensurePlayletSlug(ctx context.Context, ac *playletmod.Playlet, excludeId in
 		}
 		return nil
 	}
-	source := utils.SlugSourceFromKeywordsOrTitle(ac.SeoInfo.Keyworld, ac.Title)
+	ac.Slug = utils.MakeRandomSlug(func(slug string) bool {
-	ac.Slug = utils.MakeUniqueSlug(source, func(slug string) bool {
 		filter := bson.M{playletmod.FN.Playlet.Slug: slug}
 		if excludeId > 0 {
 			filter[playletmod.FN.Playlet.Id] = bson.M{"$ne": excludeId}
@@ -218,16 +207,7 @@ func preparePlayletSlugOnUpdate(ctx context.Context, id int64, info *playletmod.
 		}
 		return nil
 	}
-	title := info.Title
+	newSlug := utils.MakeRandomSlug(func(s string) bool {
-	if req.Title != nil {
-		title = strings.TrimSpace(*req.Title)
-	}
-	keywords := info.SeoInfo.Keyworld
-	if req.SeoInfo != nil {
-		keywords = normalizeSeoValue(*req.SeoInfo).Keyworld
-	}
-	source := utils.SlugSourceFromKeywordsOrTitle(keywords, title)
-	newSlug := utils.MakeUniqueSlug(source, func(s string) bool {
 		exist, _ := playletmod.FindOnePlaylet(ctx, bson.M{
 			playletmod.FN.Playlet.Slug: s,
 			playletmod.FN.Playlet.Id:   bson.M{"$ne": id},

web/service/srv_recharge/callback.go

@@ -2,22 +2,15 @@ package srv_recharge
 
 import (
 	"context"
-	"crypto/md5"
-	"encoding/hex"
-	"encoding/json"
 	"fmt"
 	"hkdj-web-server/pub/common/log"
 	"hkdj-web-server/pub/common/srvdef"
-	"hkdj-web-server/pub/common/useragent"
-	"hkdj-web-server/pub/dataReport"
 	"hkdj-web-server/pub/models/cointransmod"
-	"hkdj-web-server/pub/models/eventmod"
 	"hkdj-web-server/pub/models/rechargepackagemod"
 	"hkdj-web-server/pub/models/usermod"
 	"hkdj-web-server/pub/models/vipordermod"
 	"hkdj-web-server/pub/payment"
 	"hkdj-web-server/pub/pubdef"
-	"strconv"
 	"time"
 
 	"github.com/gin-gonic/gin"
@@ -88,6 +81,7 @@ func OnPayCenterCallback(ctx *gin.Context, param *BillCallbackParam) *srvdef.Srv
 
 func handleVipOrderSuccess(order vipordermod.VipOrder, oid string, realAmount int64) {
 	ctx := context.Background()
+	_, _ = oid, realAmount
 
 	pkg, err := findVipPackage(ctx, order.CardId)
 	if err != nil {
@@ -119,12 +113,11 @@ func handleVipOrderSuccess(order vipordermod.VipOrder, oid string, realAmount in
 			Remark:   payment.CoinTransRemark(cointransmod.TranTypeVipGiftCoin, pkg.Name),
 		})
 	}
-
-	reportVipOrderPaid(ctx, &order, oid, realAmount, expire)
 }
 
 func handleCoinOrderSuccess(order vipordermod.VipOrder, oid string, realAmount int64) {
 	ctx := context.Background()
+	_, _ = oid, realAmount
 
 	if err := addUserCoins(ctx, order.UserId, order.Coin); err != nil {
 		log.Error("handleCoinOrderSuccess addUserCoins failed, retrying",
@@ -138,8 +131,6 @@ func handleCoinOrderSuccess(order vipordermod.VipOrder, oid string, realAmount i
 	log.Info("handleCoinOrderSuccess done", log.Any("userId", order.UserId), log.Any("coin", order.Coin))
 
 	writeCoinOrderTrans(ctx, order)
-
-	reportCoinOrderPaid(ctx, &order, oid, realAmount)
 }
 
 func writeCoinOrderTrans(ctx context.Context, order vipordermod.VipOrder) {
@@ -229,80 +220,3 @@ func addUserCoins(ctx context.Context, userId int64, coin int64) *srvdef.SrvErr
 		},
 	)
 }
-
-func reportVipOrderPaid(ctx context.Context, order *vipordermod.VipOrder, oid string, realAmount int64, vipExpire time.Time) {
-	user, _ := usermod.FindOneUser(ctx, bson.M{usermod.FN.User.Id: order.UserId})
-	districtCode, ip := "", order.IPAddr
-	if user != nil {
-		districtCode = user.DistrictCode
-	}
-
-	ua := useragent.UA{SysType: order.SysType}
-	eventId := newEventId(pubdef.TrackerAppId(), order.UserId, order.TradeNo, order.CreatedAt.Unix())
-	cf := dataReport.NewCommonField(eventId, dataReport.EventTypeOrderPaid, districtCode, ua, strconv.FormatInt(user.Id, 10), ip)
-
-	var expireTS int64
-	if !vipExpire.IsZero() {
-		expireTS = vipExpire.Unix()
-	}
-	cf.Payload = dataReport.JsonRawMessage(&dataReport.OrderPaidEvent{
-		OrderID:           order.TradeNo,
-		OrderType:         "vip_subscription",
-		ProductID:         strconv.FormatInt(order.CardId, 10),
-		Amount:            dataReport.JsonNumber(realAmount),
-		Currency:          "CNY",
-		VIPExpirationTime: dataReport.JsonNumber(expireTS),
-		PayType:           order.PayMode,
-		PayChannel:        order.PayChannel,
-		TransactionID:     oid,
-		CreateTime:        dataReport.JsonNumber(order.CreatedAt.Unix()),
-	})
-	insertEvent(ctx, cf, order.TradeNo)
-}
-
-func reportCoinOrderPaid(ctx context.Context, order *vipordermod.VipOrder, oid string, realAmount int64) {
-	user, _ := usermod.FindOneUser(ctx, bson.M{usermod.FN.User.Id: order.UserId})
-	districtCode, ip := "", order.IPAddr
-	if user != nil {
-		districtCode = user.DistrictCode
-	}
-
-	ua := useragent.UA{SysType: order.SysType}
-	eventId := newEventId(pubdef.TrackerAppId(), order.UserId, order.TradeNo, order.CreatedAt.Unix())
-	cf := dataReport.NewCommonField(eventId, dataReport.EventTypeOrderPaid, districtCode, ua, strconv.FormatInt(user.Id, 10), ip)
-
-	cf.Payload = dataReport.JsonRawMessage(&dataReport.OrderPaidEvent{
-		OrderID:       order.TradeNo,
-		OrderType:     "coin_purchase",
-		ProductID:     strconv.FormatInt(order.CoinCfgId, 10),
-		Amount:        dataReport.JsonNumber(realAmount),
-		Currency:      "CNY",
-		CoinQuantity:  dataReport.JsonNumber(order.Coin),
-		PayType:       order.PayMode,
-		PayChannel:    order.PayChannel,
-		TransactionID: oid,
-		CreateTime:    dataReport.JsonNumber(order.CreatedAt.Unix()),
-	})
-	insertEvent(ctx, cf, order.TradeNo)
-}
-
-func insertEvent(ctx context.Context, cf dataReport.CommonField, tradeNo string) {
-	data, _ := json.Marshal(cf)
-	if err := eventmod.InsertOneEvent(ctx, &eventmod.Event{
-		EventId:   cf.EventID,
-		EventType: cf.Event,
-		Data:      string(data),
-		Status:    eventmod.Default,
-		CreatedAt: time.Now(),
-		UpdatedAt: time.Now(),
-	}); err != nil {
-		log.Error("insertEvent failed", log.Any("tradeNo", tradeNo), log.E(err))
-	}
-}
-
-func newEventId(appId string, uid int64, orderId interface{}, createTime int64) string {
-	input := fmt.Sprintf("%v%v%v%v", appId, uid, orderId, createTime)
-	h := md5.New()
-	h.Write([]byte(input))
-	return hex.EncodeToString(h.Sum(nil))
-}

web/service/srv_report/report.go

@@ -1,73 +0,0 @@
-package srv_report
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"hkdj-web-server/pub/common/log"
-	"hkdj-web-server/pub/common/useragent"
-	"hkdj-web-server/pub/dataReport"
-	"hkdj-web-server/pub/models/eventmod"
-	"hkdj-web-server/pub/models/videocategorymod"
-	"hkdj-web-server/pub/models/videoinformationmod"
-	"strconv"
-	"time"
-
-	"go.mongodb.org/mongo-driver/bson"
-)
-
-// ReportVideoStatusChangeEvent 视频状态变更事件上报
-func ReportVideoStatusChangeEvent(media *videoinformationmod.VideoInformation, flag, userId int64, ua useragent.UA) {
-	if media == nil || media.Id == 0 || flag == 0 {
-		return
-	}
-
-	var lsjId string
-
-	var videoTypeID = "default"
-	var videoTypeName = "默认分类"
-	if len(media.CategoryIds) > 0 {
-		ctx, cancel := context.WithTimeout(context.Background(), time.Second*3)
-		defer cancel()
-		category, _ := videocategorymod.FindOneVideoCategory(ctx, bson.M{
-			videocategorymod.FN.VideoCategory.Id: media.CategoryIds[0],
-		})
-		if category != nil {
-			videoTypeID = fmt.Sprintf("%v", category.Id)
-			videoTypeName = category.Name
-		}
-	}
-	event := dataReport.NewCommonField("", dataReport.EventTypeVideoStatusChange, "", ua, strconv.FormatInt(userId, 10), "")
-
-	event.Payload = dataReport.JsonRawMessage(&dataReport.VideoStatusChangeEvent{
-		MediaId:       lsjId,
-		VideoID:       fmt.Sprintf("%v", media.Id),
-		VideoTitle:    media.Title,
-		VideoTypeID:   videoTypeID,
-		VideoTypeName: videoTypeName,
-		Flag:          dataReport.JsonNumber(flag),
-	})
-	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("ReportVideoStatusChangeEvent fail", log.Any("mediaId", media.Id), log.E(err))
-	}
-}
-
-// VideoStatusFlag 将媒体状态映射为上报flag
-func VideoStatusFlag(status videoinformationmod.InformationSatus) int64 {
-	switch status {
-	case videoinformationmod.InformationSatusVerifyOK:
-		return 1 // 上架
-	case videoinformationmod.InformationSatusVerifyCancel:
-		return 2 // 未通过
-	default:
-		return 0
-	}
-}

web/service/srv_videoinfo/videoinfo.go

@@ -2,7 +2,6 @@ package srv_videoinfo
 
 import (
 	"context"
-	"hkdj-web-server/pub/common/godef"
 	"hkdj-web-server/pub/common/log"
 	"hkdj-web-server/pub/common/playletcache"
 	"hkdj-web-server/pub/common/srvdef"
@@ -14,7 +13,6 @@ import (
 	"hkdj-web-server/pub/seo/sitemapdirty"
 	"hkdj-web-server/pub/storage"
 	"hkdj-web-server/pub/storage/proxy"
-	"hkdj-web-server/web/service/srv_report"
 	"hkdj-web-server/web/service/srv_search"
 	"hkdj-web-server/web/service/srv_seopush"
 	"hkdj-web-server/web/service/srv_videoslug"
@@ -353,15 +351,6 @@ func UpdateVideoInfo(ctx context.Context, id, userId int64, param VideoInfoUpdat
 			}
 		}()
 	}
-	if param.Status != nil && info.Status != *param.Status {
-		if flag := srv_report.VideoStatusFlag(*param.Status); flag != 0 {
-			mediaCopy := *info
-			mediaCopy.Status = *param.Status
-			godef.Go(func() {
-				srv_report.ReportVideoStatusChangeEvent(&mediaCopy, flag, userId, ua)
-			})
-		}
-	}
 	sitemapdirty.Mark(ctx)
 	if param.Status != nil {
 		if *param.Status == videoinformationmod.InformationSatusVerifyOK &&

web/skd/job/reportdata/event.go

@@ -1,124 +0,0 @@
-package job
-
-import (
-	"context"
-	"encoding/json"
-	"hkdj-web-server/pub/common/log"
-	"hkdj-web-server/pub/dataReport"
-	"hkdj-web-server/pub/models/eventmod"
-
-	"go.mongodb.org/mongo-driver/bson"
-	"go.mongodb.org/mongo-driver/mongo/options"
-)
-
-var isRuining = false
-
-const (
-	maxRetryCount = 10  // 最大重试次数
-	maxReportNum  = 100 // 最大上报数
-)
-
-func Report() {
-	//防止重入
-	if isRuining {
-		return
-	}
-	isRuining = true
-	defer func() {
-		isRuining = false
-	}()
-	ctx := context.Background()
-	opts := options.Find()
-	opts = opts.SetSort(bson.D{{Key: "_id", Value: 1}}).SetLimit(1000)
-	// 查询出一千条记录批量上传
-	list, stdErr := eventmod.FindManyEvent(ctx, bson.M{
-		"$or": []bson.M{
-			bson.M{
-				"status": eventmod.Default,
-			},
-			bson.M{
-				"status":     eventmod.Failure,
-				"retryCount": bson.M{"$lte": maxRetryCount},
-			},
-		},
-	}, opts)
-	if stdErr != nil {
-		log.Error("Get event list error", log.E(stdErr))
-		return
-	}
-	if len(list) == 0 {
-		return
-	}
-	var eventList []*dataReport.CommonField
-	for _, v := range list {
-		event := &dataReport.CommonField{}
-		err := json.Unmarshal([]byte(v.Data), &event)
-		if err != nil {
-			log.Error("event report json.Unmarshal fail", log.Any("eventData", v.Data), log.E(err))
-			continue
-		}
-		eventList = append(eventList, event)
-		if len(eventList) < maxReportNum {
-			continue
-		}
-		// 批量上报
-		err = dataReport.BatchReport(ctx, eventList)
-		if err != nil {
-			log.Error("Batch report error", log.E(err))
-			// 将这些设置为失败
-			onReportEventFail(ctx, eventList)
-		} else {
-			onReportEventSuccess(ctx, eventList)
-		}
-		eventList = []*dataReport.CommonField{} // 重新变成0个
-	}
-
-	// 将剩余的批量上报
-	err := dataReport.BatchReport(ctx, eventList)
-	if err != nil {
-		log.Error("Batch report error", log.E(err))
-		// 将这些设置为失败
-		onReportEventFail(ctx, eventList)
-	} else {
-		onReportEventSuccess(ctx, eventList)
-	}
-}
-
-func onReportEventSuccess(ctx context.Context, eventList []*dataReport.CommonField) {
-	eventIds := []string{}
-	for _, v := range eventList {
-		eventIds = append(eventIds, v.EventID)
-	}
-	if len(eventIds) == 0 {
-		return
-	}
-	err := eventmod.UpdateManyEvent(ctx, bson.M{
-		"eventId": bson.M{"$in": eventIds},
-	}, bson.M{
-		"$set": bson.M{"status": eventmod.Success},
-	})
-	if err != nil {
-		log.Error("Update event fail", log.E(err))
-		return
-	}
-}
-
-func onReportEventFail(ctx context.Context, eventList []*dataReport.CommonField) {
-	eventIds := []string{}
-	for _, v := range eventList {
-		eventIds = append(eventIds, v.EventID)
-	}
-	if len(eventIds) == 0 {
-		return
-	}
-	err := eventmod.UpdateManyEvent(ctx, bson.M{
-		"eventId": bson.M{"$in": eventIds},
-	}, bson.M{
-		"$set": bson.M{"status": eventmod.Failure},
-		"$inc": bson.M{"retryCount": 1},
-	})
-	if err != nil {
-		log.Error("Update event fail", log.E(err))
-		return
-	}
-}

web/skd/skd.go

@@ -3,7 +3,6 @@ package skd
 import (
 	"hkdj-web-server/pub/common/log"
 	"hkdj-web-server/web/service/srv_mediaresource"
-	job "hkdj-web-server/web/skd/job/reportdata"
 	seopushjob "hkdj-web-server/web/skd/job/seopush"
 	"hkdj-web-server/web/skd/job/vipexpiry"
 	"hkdj-web-server/web/skd/playletwatermark"
@@ -60,10 +59,6 @@ func Start() {
 
 	}
 
-	if webg.Conf.DataReport.Url != "" {
-		_, _ = skdCron.AddFunc("0/1 * * * * ?", func() { job.Report() })
-	}
-
 	// 每天凌晨 02:00 重置 VIP 已过期用户的 VipType
 	_, _ = skdCron.AddFunc("0 0 2 * * ?", func() {
 		vipexpiry.ResetExpiredVip()

web/webg/webg.go

@@ -56,9 +56,6 @@ type GlobalCfgEx struct {
 		Secret  string `yaml:"secret"`  // 商户密钥
 	} `yaml:"playletMediaResourceDBCfg"`
 	NewInnerStatUrl string `yaml:"newInnerStatUrl"`
-	DataReport      struct {
-		Url string `yaml:"url"`
-	} `yaml:"dataReport"`
 	IndexNow struct {
 		Key string `yaml:"key"` // 与 SEO 站点的 {key}.txt 验证文件对应
 	} `yaml:"indexNow"`