init: 初始化 web_hgdjb_server 项目

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

app/middleware/auth/http.go

@@ -0,0 +1,140 @@
+package auth
+
+import (
+	"net/http"
+	"strings"
+	"videoweb/app/appg"
+	"videoweb/pub/common/enum/consts"
+	"videoweb/pub/common/log"
+	"videoweb/pub/common/srvdef"
+	"videoweb/pub/common/utils"
+	"videoweb/pub/pubdef"
+
+	"github.com/gin-gonic/gin"
+)
+
+// gin 验证中间件
+
+var (
+	// 白名单，不需要验证token的api
+	whiteList = []string{
+		"/swagger",
+		"/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",
+		"/sitemap.xml",
+		"/sitemaps",
+	}
+)
+
+var (
+	tokener = utils.NewTokenRedis()
+)
+
+func Auth(ctx *gin.Context) {
+	dotoken := func() srvdef.CodeType {
+		token := ctx.Request.Header.Get("Authorization")
+		// 去掉Bearer，如果有
+		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)))
+			return srvdef.InvalidToken
+		}
+
+		userId, newToken, err := utils.ParseUserToken(token, appg.Conf.JwtKey)
+		if err != nil {
+			for _, w := range whiteList {
+				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,
+			"msg":  errType.Msg(),
+		})
+	}
+
+}

app/middleware/cors/cors.go

@@ -0,0 +1,135 @@
+package cors
+
+import (
+	"github.com/gin-gonic/gin"
+	"net/http"
+	"strconv"
+	"strings"
+)
+
+type Options struct {
+	Origin               *[]string //传入空指针，表示允许"*",  传入空数组表示禁止跨域
+	Methods              []string  //Methods
+	AllowedHeaders       []string  //AllowHeaders
+	ExposedHeaders       []string  //exposeHeader
+	Credentials          bool      //cookie
+	MaxAge               int64     //缓存MaxAge
+	PreflightContinue    bool      //在遇到Options的时候，继续，而不是返回请求
+	OptionsSuccessStatus int       //Options时，返回的状态码，默认204
+}
+
+func configureOrigin(o *Options, c *gin.Context) map[string]string {
+	reqOrigin := c.GetHeader("Origin")
+	headers := make(map[string]string)
+	if o.Origin == nil {
+		headers["Access-Control-Allow-Origin"] = "*"
+	} else {
+		isAllowed := false
+		for _, allowed := range *o.Origin {
+			if allowed == reqOrigin {
+				isAllowed = true
+				break
+			}
+		}
+		if isAllowed {
+			headers["Access-Control-Allow-Origin"] = reqOrigin
+		} else {
+			headers["Access-Control-Allow-Origin"] = strconv.FormatBool(false)
+		}
+		headers["Vary"] = "Origin"
+	}
+	return headers
+}
+
+func configureMethods(o *Options) map[string]string {
+	headers := make(map[string]string)
+	if len(o.Methods) > 0 {
+		headers["Access-Control-Allow-Methods"] = strings.ToUpper(strings.Join(o.Methods, ","))
+	}
+	return headers
+}
+
+func configureCredentials(o *Options) map[string]string {
+	headers := make(map[string]string)
+	if o.Credentials {
+		headers["Access-Control-Allow-Credentials"] = strconv.FormatBool(true)
+	}
+	return headers
+}
+
+func configureAllowedHeaders(o *Options, c *gin.Context) map[string]string {
+	headers := make(map[string]string)
+	if len(o.AllowedHeaders) > 0 {
+		headers["Access-Control-Allow-Headers"] = strings.Join(o.AllowedHeaders, ",")
+	}
+	return headers
+}
+
+func configureExposedHeaders(o *Options) map[string]string {
+	var headers = make(map[string]string)
+	if len(o.ExposedHeaders) > 0 {
+		headers["Access-Control-Expose-Headers"] = strings.Join(o.ExposedHeaders, ",")
+	}
+	return headers
+}
+
+func configureMaxAge(o *Options) map[string]string {
+	var headers = make(map[string]string)
+	if o.MaxAge >= 0 {
+		headers["Access-Control-Max-Age"] = strconv.FormatInt(o.MaxAge, 10)
+	}
+	return headers
+}
+
+func mergeMap(m ...map[string]string) map[string]string {
+	r := make(map[string]string)
+	for _, t := range m {
+		for k, v := range t {
+			r[k] = v
+		}
+	}
+	return r
+}
+
+func applyHeader(c *gin.Context, h map[string]string) {
+	for k, v := range h {
+		c.Header(k, v)
+	}
+}
+
+// Cors 跨域处理
+func Cors(o *Options) gin.HandlerFunc {
+	if o.OptionsSuccessStatus == 0 {
+		o.OptionsSuccessStatus = http.StatusNoContent
+	}
+	return func(c *gin.Context) {
+		method := c.Request.Method
+		//c.Header("Access-Control-Allow-Origin", "*")
+		//c.Header("Access-Control-Allow-Headers", "Content-Type,AccessToken,X-CSRF-Token,Authorization,Token,Content-Length,Etag,Content-Range,Accept-Ranges,User-Agent,Range,Bucket,Content-Disposition,Signature,X-Forwarded-For,X-Real-Ip")
+		if method == "OPTIONS" {
+			h := mergeMap(
+				configureOrigin(o, c),
+				configureCredentials(o),
+				configureMethods(o),
+				configureAllowedHeaders(o, c),
+				configureMaxAge(o),
+				configureExposedHeaders(o),
+			)
+			applyHeader(c, h)
+			if o.PreflightContinue {
+				c.Next()
+			} else {
+				c.Header("Content-Length", "0")
+				c.AbortWithStatus(o.OptionsSuccessStatus)
+			}
+		} else {
+			h := mergeMap(
+				configureOrigin(o, c),
+				configureCredentials(o),
+				configureExposedHeaders(o),
+			)
+			applyHeader(c, h)
+			c.Next()
+		}
+	}
+}

app/middleware/ipblacklist/ipblacklist.go

@@ -0,0 +1,18 @@
+package ipblacklist
+
+import (
+	"errors"
+	"net/http"
+	"videoweb/app/service/configser"
+	"videoweb/pub/common/ipaddr"
+
+	"github.com/gin-gonic/gin"
+)
+
+func IpBlackListMiddleware(ctx *gin.Context) {
+	ip := ipaddr.ResolveClientIP(ctx)
+	if configser.CheckIpBlack(ip) {
+		ctx.AbortWithStatusJSON(http.StatusUnauthorized, errors.New("login limit"))
+		return
+	}
+}

app/middleware/ipstat/ipstat.go

@@ -0,0 +1,78 @@
+package ipstat
+
+import (
+	"net"
+	"time"
+	"videoweb/pub/common/enum/redisconst"
+	"videoweb/pub/common/ipaddr"
+	"videoweb/pub/common/log"
+	"videoweb/pub/common/utils"
+	"videoweb/pub/pubdef"
+	"videoweb/pub/redis"
+
+	"github.com/gin-gonic/gin"
+)
+
+func IpStatMiddleware(ctx *gin.Context) {
+	ctx.Next()
+
+	normalized := normalizeIP(ipaddr.ResolveClientIP(ctx))
+	if normalized == "" {
+		return
+	}
+
+	date := time.Now().In(utils.LocBJ).Format("20060102")
+	key := redisconst.IpStatKey(pubdef.AppId, date)
+
+	added, err := redis.SAddCount(key, normalized)
+	if err != nil {
+		log.Warn("IpStatMiddleware SAdd failed", log.Any("key", key), log.E(err))
+		return
+	}
+	if added > 0 {
+		if err := redis.Expire(key, redisconst.IpStatExpire); err != nil {
+			log.Warn("IpStatMiddleware Expire failed", log.Any("key", key), log.E(err))
+		}
+	}
+}
+
+func normalizeIP(raw string) string {
+	ip := net.ParseIP(raw)
+	if ip == nil {
+		return ""
+	}
+	if v4 := ip.To4(); v4 != nil {
+		ip = v4
+	}
+	if isPrivateIP(ip) {
+		return ""
+	}
+	return ip.String()
+}
+
+var privateRanges = []net.IPNet{
+	parseCIDR("10.0.0.0/8"),
+	parseCIDR("172.16.0.0/12"),
+	parseCIDR("192.168.0.0/16"),
+	parseCIDR("127.0.0.0/8"),
+	parseCIDR("::1/128"),
+	parseCIDR("fe80::/10"),
+	parseCIDR("fc00::/7"),
+}
+
+func parseCIDR(s string) net.IPNet {
+	_, network, err := net.ParseCIDR(s)
+	if err != nil {
+		panic(err)
+	}
+	return *network
+}
+
+func isPrivateIP(ip net.IP) bool {
+	for _, r := range privateRanges {
+		if r.Contains(ip) {
+			return true
+		}
+	}
+	return false
+}

app/middleware/monitor/define.go

@@ -0,0 +1,69 @@
+package monitor
+
+import "time"
+
+type APIStatis struct {
+	//路径
+	Path string `json:"path"`
+	//消耗最大时间rawdata
+	MaxTimeRawData string `json:"maxTimeRawData"`
+	//调用次数
+	CallNum int64 `json:"callNum"`
+	//最小耗时
+	MinTime int64 `json:"minTime"`
+	//最大耗时
+	MaxTime int64 `json:"maxTime"`
+	//总耗时
+	TotalTime int64 `json:"totalTime"`
+	//每次调用时间
+	TimePerCall int64 `json:"timePerCall"`
+	//每秒调用次数
+	CallPerSec int64 `json:"callPerSec"`
+	//开始时间
+	Start time.Time `json:"start"`
+	//是否发送过报警
+	Send int `json:"send"`
+}
+
+// APIStatis 接口统计
+// 每天统计数
+type LogicStatis struct {
+	//API总调用次数
+	ApiCallNum int64
+	//API调用总耗时
+	ApiTotalTime int64
+	//开始时间
+	Start time.Time
+	//接口访问次数
+	ApisStatis map[string]*APIStatis
+}
+
+type SPType string
+
+const (
+	SP_ApiCall   SPType = "apicall"
+	SP_GetStatis SPType = "getStatis"
+)
+
+// StatisReq 统计请求数据格式
+type AppStatisReq struct {
+	Time time.Time `json:"time"`
+	//获取的api数量
+	ApiNum int64 `json:"apiNum"`
+}
+
+type StatisParam struct {
+	//调用类型
+	Type   SPType
+	Param1 string
+	Param2 int64
+	Param3 string
+}
+
+var (
+	hourStatises   map[string]*LogicStatis
+	muniteStatises map[string]*LogicStatis
+	//api调用参数
+	apiCallChan chan *StatisParam
+	//退出
+)

app/middleware/monitor/monitor.go

@@ -0,0 +1,266 @@
+package monitor
+
+import (
+	"bytes"
+	"fmt"
+	"io/ioutil"
+	"math"
+	"net/http"
+	"runtime"
+	"sort"
+	"time"
+	"videoweb/pub/common/enum/consts"
+	"videoweb/pub/common/enum/redisconst"
+	"videoweb/pub/common/godef"
+	"videoweb/pub/common/ipaddr"
+	"videoweb/pub/common/log"
+	"videoweb/pub/common/srvdef"
+	"videoweb/pub/common/tgbot"
+	"videoweb/pub/redis"
+
+	"github.com/gin-gonic/gin"
+)
+
+// Check 运行监控检查
+func Check(ctx *gin.Context) {
+	//查看是否有限制登陆
+	ip := ipaddr.ResolveClientIP(ctx)
+	ifKey := redisconst.IpForbitKey(ip)
+	retValue, _ := redis.Get(ifKey)
+	if retValue != nil {
+		//log.Info("Test Check", log.Any("ip", ip), log.Any("retValue", *retValue))
+		ctx.AbortWithStatusJSON(http.StatusBadRequest, gin.H{
+			"code": srvdef.ErrIpForbid,
+			"msg":  srvdef.ErrIpForbid.Msg(),
+		})
+		return
+	}
+
+	// Start timer
+	start := time.Now()
+	path := ctx.Request.URL.Path
+	raw := ctx.Request.URL.RawQuery
+	rawData, err := ctx.GetRawData()
+	if err != nil {
+		log.Info("Test get raw data error", log.E(err))
+	}
+	// 将取出来的执行条件放回ctx中
+	ctx.Request.Body = ioutil.NopCloser(bytes.NewBuffer(rawData))
+	//recover
+	func() {
+		defer func() {
+			if r := recover(); r != nil {
+				buf := make([]byte, 2048)
+				length := runtime.Stack(buf, false)
+				info := string(buf[:length])
+				log.Error("catch a unkown excetion", log.Any("excetion :", info))
+				//发送tg消息
+				msg := "monitor check crash,the stack:\n" + info
+				tgbot.SendToProgram("API接口处理宕了", msg)
+			}
+		}()
+		// Process request
+		ctx.Next()
+	}()
+	// Stop timer
+	stopTime := time.Now()
+	latency := stopTime.Sub(start).Milliseconds()
+	if raw != "" {
+		path = path + "?" + raw
+	}
+	//添加记录
+	//log.Info("Test", log.Any("rawData", rawData))
+	rawString := string(rawData)
+	if path == "/api/app/feedback/add" {
+		rawString = ""
+	}
+	addApiCall(path, int64(latency), rawString)
+	//如果时间大于1秒发送tg消息
+	if latency > 4000 {
+		userId := ctx.GetInt64(consts.CtxUserID)
+		msg := ""
+		msg = msg + fmt.Sprintf("path:%s", path) + "\n"
+		msg = msg + fmt.Sprintf("userId:%d", userId) + "\n"
+		msg = msg + fmt.Sprintf("userIp:%s", ip) + "\n"
+		msg = msg + fmt.Sprintf("rawData:%s", string(rawData)) + "\n"
+		msg = msg + fmt.Sprintf("time:%d", latency) + "\n"
+		tgbot.SendToProgram("API接口调用超时", msg)
+	}
+	//log.Info("monitor:Check", log.Any("latency", latency), log.Any("path", path))
+}
+
+func init() {
+	hourStatises = make(map[string]*LogicStatis)
+	muniteStatises = make(map[string]*LogicStatis)
+	apiCallChan = make(chan *StatisParam, 1024)
+	godef.Go(loop)
+	log.Info("(monitor:init) init success.")
+}
+
+func loop() {
+	log.Info("(monitor:loop) start...")
+	defer log.Info("monitor:loop) end")
+	var param *StatisParam
+	for {
+		select {
+		case param = <-apiCallChan:
+			onStatis(param)
+		default:
+			time.Sleep(time.Millisecond * 10)
+		}
+	}
+}
+
+func onStatis(param *StatisParam) {
+	if param == nil {
+		return
+	}
+	now := time.Now()
+	hourStr := now.Format("2006-01-02 15")
+	hourStatis, hourOk := hourStatises[hourStr]
+	if !hourOk {
+		hourStatis = &LogicStatis{
+			ApisStatis: make(map[string]*APIStatis),
+		}
+		hourStatises[hourStr] = hourStatis
+	}
+	muniteStr := now.Format("2006-01-02 15:04")
+	minuteStatis, minuteOk := muniteStatises[muniteStr]
+	if !minuteOk {
+		minuteStatis = &LogicStatis{
+			ApisStatis: make(map[string]*APIStatis),
+		}
+		muniteStatises[muniteStr] = minuteStatis
+	}
+	onStatisApiCall(hourStr, param, hourStatis, 10000000)
+	onStatisApiCall(muniteStr, param, minuteStatis, 20000)
+	//如果新的一小时,发送上一小时数据
+	if !hourOk {
+		//清空分钟数据
+		muniteStatises = make(map[string]*LogicStatis)
+		lastHour := now.Add(-time.Hour).Format("2006-01-02 15")
+		hourStatis, hourOk = hourStatises[lastHour]
+		if hourOk {
+			msg := fmt.Sprintf("统计时间:%s\n", lastHour)
+			msg += formatStatis(hourStatis)
+			tgbot.SendToProgram("API接口调用统计", msg)
+		}
+	}
+}
+
+func formatStatis(hourStatis *LogicStatis) string {
+	apiStatises := make([]*APIStatis, 0)
+	for _, static := range hourStatis.ApisStatis {
+		apiStatises = append(apiStatises, static)
+	}
+	sort.Slice(apiStatises, func(i, j int) bool {
+		return apiStatises[i].CallNum > apiStatises[j].CallNum
+	})
+	//发送数据
+	msg := ""
+	maxlen := len(apiStatises)
+	if maxlen > 10 {
+		maxlen = 10
+	}
+	for i := 0; i < maxlen; i++ {
+		apiStatis := apiStatises[i]
+		msg += formatApiStatis(apiStatis)
+	}
+	timePerCall := int64(0)
+	callPerSec := int64(0)
+	if hourStatis.ApiCallNum > 0 {
+		timePerCall = hourStatis.ApiTotalTime / hourStatis.ApiCallNum
+		diffSecdonds := int64(time.Now().Sub(hourStatis.Start).Seconds())
+		if diffSecdonds > 0 {
+			callPerSec = hourStatis.ApiCallNum / diffSecdonds
+		}
+	}
+	msg += fmt.Sprintf("ApiCallNum:%d \n", hourStatis.ApiCallNum)
+	msg += fmt.Sprintf("ApiTotalTime:%d \n", hourStatis.ApiTotalTime)
+	msg += fmt.Sprintf("ApiTimePerCall:%d \n", timePerCall)
+	msg += fmt.Sprintf("ApiCallPerSec:%d \n", callPerSec)
+	return msg
+}
+
+func formatApiStatis(apiStatis *APIStatis) string {
+	msg := ""
+	if apiStatis.CallNum > 0 {
+		apiStatis.TimePerCall = apiStatis.TotalTime / apiStatis.CallNum
+		diffSeconds := int64(time.Now().Sub(apiStatis.Start).Seconds())
+		if diffSeconds > 0 {
+			apiStatis.CallPerSec = apiStatis.CallNum / diffSeconds
+		}
+	}
+
+	statisStr := fmt.Sprintf(`path %s:
+MaxRawData:%s
+CallNum:%d;MinTime:%d;MaxTime:%d;TotalTime:%d;TimePerCall:%d;CallPerSec:%d`,
+		apiStatis.Path,
+		apiStatis.MaxTimeRawData,
+		apiStatis.CallNum,
+		apiStatis.MinTime,
+		apiStatis.MaxTime,
+		apiStatis.TotalTime,
+		apiStatis.TimePerCall,
+		apiStatis.CallPerSec)
+	msg += statisStr
+	msg += "\n---------------------------------------------------\n"
+	return msg
+}
+
+// api统计
+func onStatisApiCall(dateStr string, param *StatisParam,
+	logicStatis *LogicStatis, maxCallNum int64) {
+	logicStatis.ApiCallNum++
+	logicStatis.ApiTotalTime += param.Param2
+	apiStatis, ok := logicStatis.ApisStatis[param.Param1]
+	if !ok {
+		apiStatis = &APIStatis{
+			Path:           param.Param1,
+			MaxTimeRawData: param.Param3,
+			CallNum:        0,
+			MinTime:        math.MaxInt64,
+			MaxTime:        0,
+			TotalTime:      0,
+			Start:          time.Now(),
+			Send:           0,
+		}
+		logicStatis.ApisStatis[param.Param1] = apiStatis
+	}
+	apiStatis.CallNum++
+	apiStatis.TotalTime += param.Param2
+	if param.Param2 > apiStatis.MaxTime {
+		apiStatis.MaxTime = param.Param2
+		apiStatis.MaxTimeRawData = param.Param3
+	}
+	if param.Param2 < apiStatis.MinTime {
+		apiStatis.MinTime = param.Param2
+	}
+	if apiStatis.CallNum > maxCallNum && apiStatis.Send < 4 {
+		apiStatis.Send++
+		msg := fmt.Sprintf("接口%s每分钟调用超过最大次数%d\n", apiStatis.Path, maxCallNum)
+		msg += formatApiStatis(apiStatis)
+		tgbot.SendToProgram("API调用警告", msg)
+	}
+}
+
+func addApiCall(path string, latency int64, rawData string) {
+	param := &StatisParam{
+		Type:   SP_ApiCall,
+		Param1: path,
+		Param2: latency,
+		Param3: rawData,
+	}
+	pushParam(param)
+}
+
+func pushParam(param *StatisParam) {
+	//no block
+	select {
+	case apiCallChan <- param:
+	default:
+		info := "(monitor:pushParam) failed,chan is full."
+		log.Info(info)
+		tgbot.SendToProgram("monitor pushParam failed", info)
+	}
+}

app/middleware/reptilerecord/reptilerecord.go

@@ -0,0 +1,50 @@
+package reptilerecord
+
+import (
+	"strings"
+	"videoweb/pub/common/ipaddr"
+	"videoweb/pub/common/log"
+
+	"github.com/gin-gonic/gin"
+)
+
+const ctxKeyIsBot = "isBot"
+
+var (
+	botPatterns = map[string]string{
+		"Googlebot":           "Googlebot",
+		"Bingbot":             "Bingbot",
+		"Slurp":               "Slurp",
+		"DuckDuckBot":         "DuckDuckBot",
+		"Baiduspider":         "Baiduspider",
+		"YandexBot":           "YandexBot",
+		"Sogou":               "Sogou",
+		"Exabot":              "Exabot",
+		"facebot":             "facebot",
+		"facebookexternalhit": "facebookexternalhit",
+	}
+)
+
+func ReptileRecord(c *gin.Context) {
+	ua := c.Request.UserAgent()
+	botName := identifyBot(ua)
+	if botName != "" {
+		c.Set(ctxKeyIsBot, true)
+		log.Info("爬虫访问:", log.Any("botName", botName), log.Any("ua", ua), log.Any("path", c.Request.URL.Path), log.Any("ip", ipaddr.ResolveClientIP(c)))
+	}
+}
+
+// IsBot 返回当前请求是否来自已知搜索引擎爬虫
+func IsBot(c *gin.Context) bool {
+	v, exists := c.Get(ctxKeyIsBot)
+	return exists && v.(bool)
+}
+
+func identifyBot(userAgent string) string {
+	for name, pattern := range botPatterns {
+		if strings.Contains(userAgent, pattern) {
+			return name
+		}
+	}
+	return ""
+}

app/middleware/templatecache/cache.go

@@ -0,0 +1,72 @@
+package templatecache
+
+import (
+	"bytes"
+	"github.com/gin-gonic/gin"
+	"github.com/patrickmn/go-cache"
+	"net/http"
+	"time"
+)
+
+var (
+	Cache *cache.Cache
+)
+
+func init() {
+	Cache = cache.New(5*time.Minute, 5*time.Minute)
+}
+
+// 自定义 ResponseWriter 用于捕获 HTML 输出
+type templateResponseWriter struct {
+	gin.ResponseWriter
+	body *bytes.Buffer
+}
+
+func (w *templateResponseWriter) Write(b []byte) (int, error) {
+	w.body.Write(b)
+	return w.ResponseWriter.Write(b)
+}
+
+func WithCache(duration time.Duration) gin.HandlerFunc {
+	return func(ctx *gin.Context) {
+		// 只缓存 GET 请求（HEAD 由 _web 层处理，_server 不会收到 HEAD）
+		if ctx.Request.Method != "GET" {
+			ctx.Next()
+			return
+		}
+
+		// 生成缓存键（包含路径和查询参数）
+		cacheKey := ctx.Request.URL.String()
+		var cacheJson []byte
+		if cacheData, exists := Cache.Get(cacheKey); exists {
+			if item, ok := cacheData.([]byte); ok {
+				cacheJson = item
+			}
+		}
+		// 检查缓存
+		if cacheJson != nil {
+			ctx.Data(http.StatusOK, "application/json; charset=utf-8", cacheJson)
+			ctx.Abort()
+			return
+		}
+
+		writer := &templateResponseWriter{
+			body:           bytes.NewBuffer(nil),
+			ResponseWriter: ctx.Writer,
+		}
+		ctx.Writer = writer
+
+		ctx.Next()
+
+		// 只有成功的响应才缓存
+		status := ctx.Writer.Status()
+		if status == 200 {
+			cacheJsonData := writer.body.Bytes()
+			cacheDuration := duration
+			if cacheDuration == 0 {
+				cacheDuration = 1 * time.Minute
+			}
+			Cache.Set(cacheKey, cacheJsonData, cacheDuration)
+		}
+	}
+}

app/middleware/validator/default-validator.go

@@ -0,0 +1,81 @@
+package validator
+
+import (
+	"reflect"
+	"strings"
+	"sync"
+
+	"github.com/gin-gonic/gin/binding"
+	"github.com/go-playground/locales/en"
+	ut "github.com/go-playground/universal-translator"
+	"gopkg.in/go-playground/validator.v9"
+	en_translations "gopkg.in/go-playground/validator.v9/translations/en"
+)
+
+var (
+	ValidatorUni *ut.UniversalTranslator
+)
+
+type defaultValidator struct {
+	once     sync.Once
+	validate *validator.Validate
+}
+
+var v binding.StructValidator = &defaultValidator{}
+
+func init() {
+	v.Engine()
+}
+
+func (v *defaultValidator) ValidateStruct(obj interface{}) error {
+
+	if kindOfData(obj) == reflect.Struct {
+
+		v.lazyinit()
+
+		if err := v.validate.Struct(obj); err != nil {
+			return error(err)
+		}
+	}
+
+	return nil
+}
+
+func (v *defaultValidator) Engine() interface{} {
+	v.lazyinit()
+	return v.validate
+}
+
+func (v *defaultValidator) lazyinit() {
+	v.once.Do(func() {
+		v.validate = validator.New()
+
+		// 依旧使用bingding tag兼容v8
+		v.validate.SetTagName("binding")
+
+		// 错误信息转换
+		en := en.New()
+		ValidatorUni = ut.New(en, en)
+		trans, _ := ValidatorUni.GetTranslator("en")
+		en_translations.RegisterDefaultTranslations(v.validate, trans)
+
+		v.validate.RegisterTagNameFunc(func(fld reflect.StructField) string {
+			name := strings.SplitN(fld.Tag.Get("comment"), ",", 2)[0]
+			if name == "-" {
+				return ""
+			}
+			return name
+		})
+	})
+}
+
+func kindOfData(data interface{}) reflect.Kind {
+
+	value := reflect.ValueOf(data)
+	valueType := value.Kind()
+
+	if valueType == reflect.Ptr {
+		valueType = value.Elem().Kind()
+	}
+	return valueType
+}

app/middleware/validator/v9.go

@@ -0,0 +1,11 @@
+package validator
+
+import (
+	"github.com/gin-gonic/gin/binding"
+)
+
+// 替换gin 默认v8验证器
+// 改为v9
+func init() {
+	binding.Validator = new(defaultValidator)
+}

app/middleware/verfyparam/verfyparam.go

@@ -0,0 +1,23 @@
+package verfyparam
+
+import (
+	"strings"
+
+	"github.com/gin-gonic/gin"
+)
+
+var (
+	// 白名单，不需要验证token的api
+	whitelist = map[string]bool{}
+)
+
+func VerifyReplayAttackRequest() gin.HandlerFunc {
+	return func(ctx *gin.Context) {
+		for url, ok := range whitelist {
+			if ok && strings.HasPrefix(ctx.Request.URL.Path, url) {
+				return
+			}
+		}
+		ctx.Next()
+	}
+}

app/middleware/visit/visit.go

@@ -0,0 +1,114 @@
+package visit
+
+import (
+	"context"
+	"strings"
+	"time"
+	"videoweb/app/middleware/reptilerecord"
+	"videoweb/pub/common/enum/consts"
+	"videoweb/pub/common/enum/redisconst"
+	"videoweb/pub/common/ipaddr"
+	"videoweb/pub/common/srvdef"
+	"videoweb/pub/common/useragent"
+	"videoweb/pub/common/utils"
+	"videoweb/pub/models/usermod"
+	"videoweb/pub/models/uservisitlog"
+	"videoweb/pub/redis"
+
+	"github.com/gin-gonic/gin"
+	"go.mongodb.org/mongo-driver/bson/primitive"
+)
+
+// Visit 用户日活访问中间件：每天首次访问写入 user_visit_log
+func Visit(ctx *gin.Context) {
+	if reptilerecord.IsBot(ctx) {
+		return
+	}
+	val, ok := ctx.Get(consts.CtxUA)
+	if !ok {
+		return
+	}
+	ua, ok := val.(useragent.UA)
+	if !ok {
+		return
+	}
+	RecordDailyVisit(ctx, ctx.GetInt64(consts.CtxUserID), ua, ipaddr.ResolveClientIP(ctx))
+}
+
+// RecordDailyVisit 当天首次访问写入 user_visit_log，游客新建成功后也会立刻记一笔。
+func RecordDailyVisit(ctx context.Context, userId int64, ua useragent.UA, ip string) {
+	if userId <= 0 {
+		return
+	}
+	now := time.Now()
+	userVisitLogKey := redisconst.UserVisitLogKey(userId, now)
+	exist, err := redis.Exists(userVisitLogKey)
+	if err != nil || exist {
+		return
+	}
+	visitInfo := &uservisitlog.UserVisitLog{
+		Id:      primitive.NewObjectID(),
+		UserId:  userId,
+		SysType: ua.SysType,
+		DevType: ua.DevType,
+		DevID:   ua.DevID,
+		Version: ua.Ver,
+		IP:      ip,
+		VisitAt: now,
+	}
+	if serr := uservisitlog.InsertOneVisitLog(ctx, visitInfo); serr != nil {
+		return
+	}
+	if serr := userVisitStatus(ctx, userId, ua, visitInfo.IP, visitInfo.VisitAt); serr != nil {
+		return
+	}
+	_ = redis.Set(userVisitLogKey, "1", utils.BeginOfToday().Add(24*time.Hour).Sub(now)+5*time.Minute)
+}
+
+func userVisitStatus(ctx context.Context, uId int64, ua useragent.UA, ip string, visitTime time.Time) *srvdef.SrvErr {
+	uFilter := primitive.M{usermod.FN.User.Id: uId}
+	user, serr := usermod.FindOneUser(ctx, uFilter)
+	if serr != nil {
+		return serr
+	}
+
+	todayZero := utils.BeginOfToday()
+	yesterdayZero := todayZero.AddDate(0, 0, -1)
+	setDoc := primitive.M{
+		usermod.FN.User.AppVer:      ua.Ver,
+		usermod.FN.User.SysType:     ua.SysType,
+		usermod.FN.User.Device:      ua.DevType,
+		usermod.FN.User.LastIp:      ip,
+		usermod.FN.User.LastLoginAt: visitTime,
+	}
+	mergeUAExtFields(setDoc, user, ua)
+	var updateDoc primitive.M
+	if user.LastLoginAt.Before(todayZero) && user.LastLoginAt.After(yesterdayZero) {
+		updateDoc = primitive.M{
+			"$inc": primitive.M{usermod.FN.User.ConsecutiveLogin: 1},
+			"$set": setDoc,
+		}
+	} else {
+		setDoc[usermod.FN.User.ConsecutiveLogin] = int64(1)
+		updateDoc = primitive.M{"$set": setDoc}
+	}
+	return usermod.UpdateOneUser(ctx, uFilter, updateDoc)
+}
+
+func mergeUAExtFields(setDoc primitive.M, user *usermod.User, ua useragent.UA) {
+	if v := strings.TrimSpace(ua.SessionID); v != "" && v != user.SessionID {
+		setDoc[usermod.FN.User.SessionID] = v
+	}
+	if v := strings.TrimSpace(ua.DeviceBrand); v != "" && v != user.DeviceBrand {
+		setDoc[usermod.FN.User.DeviceBrand] = v
+	}
+	if v := strings.TrimSpace(ua.DeviceModel); v != "" && v != user.DeviceModel {
+		setDoc[usermod.FN.User.DeviceModel] = v
+	}
+	if v := strings.TrimSpace(ua.SystemName); v != "" && v != user.SystemName {
+		setDoc[usermod.FN.User.SystemName] = v
+	}
+	if v := strings.TrimSpace(ua.SystemVersion); v != "" && v != user.SystemVersion {
+		setDoc[usermod.FN.User.SystemVersion] = v
+	}
+}