feat: add module resp

database/cache/cache.go

@@ -52,6 +52,9 @@ type Cache interface {
 	GetDel(ctx context.Context, key string) ([]byte, error)
 	GetDelScan(ctx context.Context, key string) Scanner
 	Close()
+	// Client return raw client
+	// !!! dangerous api
+	Client() any
 }
 
 var (

database/cache/new_test.go

@@ -37,3 +37,37 @@ func TestNew(t *testing.T) {
 			t.Fatal(err)
 		}*/
 }
+
+func TestNoAuth(t *testing.T) {
+	//if err := Init(WithRedis("10.125.1.28", 6379, "", "")); err != nil {
+	//	t.Fatal(err)
+	//}
+	//
+	//type User struct {
+	//	Name string `json:"name"`
+	//	Age  int    `json:"age"`
+	//}
+	//
+	//if err := Default.Set(t.Context(), "zyp:haha", &User{
+	//	Name: "cache",
+	//	Age:  18,
+	//}); err != nil {
+	//	t.Fatal(err)
+	//}
+	//
+	//s := Default.GetDelScan(t.Context(), "zyp:haha")
+	//u := new(User)
+	//
+	//if err := s.Scan(u); err != nil {
+	//	t.Fatal(err)
+	//}
+	//
+	//t.Logf("%#v", *u)
+	//
+	//if err := Default.SetEx(t.Context(), "zyp:haha", &User{
+	//	Name: "redis",
+	//	Age:  2,
+	//}, time.Hour); err != nil {
+	//	t.Fatal(err)
+	//}
+}

database/cache/option.go

@@ -22,7 +22,7 @@ func WithCtx(ctx context.Context) OptionFn {
 
 func WithRedis(host string, port int, username, password string) OptionFn {
 	return func(c *config) {
-		uri := fmt.Sprintf("%s:%d", host, port)
+		uri := fmt.Sprintf("redis://%s:%d", host, port)
 		if username != "" || password != "" {
 			uri = fmt.Sprintf("redis://%s:%s@%s:%d", username, password, host, port)
 		}

database/cache/redis.go

@@ -18,6 +18,10 @@ type _redis struct {
 	client *redis.Client
 }
 
+func (r *_redis) Client() any {
+	return r.client
+}
+
 func newRedis(ctx context.Context, client *redis.Client) *_redis {
 	r := &_redis{ctx: ctx, client: client}
 

middlewares/dump/req.go

@@ -0,0 +1,147 @@
+package dump
+
+import (
+	"bytes"
+	"context"
+	"gitea.loveuer.com/yizhisec/packages/logger"
+	"gitea.loveuer.com/yizhisec/packages/tool"
+	"github.com/gin-gonic/gin"
+	"io"
+	"net/http"
+	"os"
+	"strconv"
+	"strings"
+	"time"
+)
+
+type RequestHandler func(r *http.Request, body []byte) string
+
+func Request(ctx context.Context, handler RequestHandler, writers ...io.Writer) gin.HandlerFunc {
+
+	var (
+		out     io.Writer = os.Stdout
+		ch                = make(chan string, 128)
+		builder           = strings.Builder{}
+		buf               = make([]string, 0, 16)
+	)
+
+	if len(writers) > 0 && writers[0] != nil {
+		out = writers[0]
+	}
+
+	do := func() {
+		for _, item := range buf {
+			builder.WriteString(item)
+			builder.WriteRune('\n')
+		}
+
+		_, _ = out.Write(tool.StringToBytes(builder.String()))
+
+		builder.Reset()
+		buf = buf[:0]
+	}
+
+	go func() {
+
+		ticker := time.NewTicker(time.Second)
+		defer ticker.Stop()
+
+		for {
+			select {
+			case <-ctx.Done():
+				if len(buf) > 0 {
+					do()
+				}
+				return
+			case <-ticker.C:
+				if len(buf) > 0 {
+					do()
+				}
+			case msg, _ := <-ch:
+				buf = append(buf, msg)
+				if len(buf) >= 10 {
+					do()
+				}
+			}
+		}
+	}()
+
+	return func(c *gin.Context) {
+		var (
+			err           error
+			contentType   = c.GetHeader("Content-Type")
+			contentLength = c.GetHeader("Content-Length")
+			cl            int
+		)
+
+		if contentLength == "" && (c.Request.Method == "GET" || c.Request.Method == "HEAD") {
+			goto DUMP
+		}
+
+		if cl, err = strconv.Atoi(contentLength); err != nil {
+			logger.WarnCtx(c.Request.Context(), "Request: convert Content-Length failed, err = %s", err.Error())
+			c.Next()
+			return
+		}
+
+		if cl > 0 && !strings.Contains(contentType, "application/json") {
+			c.Next()
+			return
+		}
+
+	DUMP:
+
+		bodyBytes, err := io.ReadAll(c.Request.Body)
+		if err != nil {
+			logger.WarnCtx(c.Request.Context(), "读取请求体错误: %v", err)
+			c.Next()
+			return
+		}
+
+		c.Request.Body = io.NopCloser(bytes.NewBuffer(bodyBytes))
+
+		dumped := handler(c.Request, bodyBytes)
+
+		ch <- dumped
+
+		c.Next()
+	}
+}
+
+func RequestHandlerCurl(r *http.Request, body []byte) string {
+	var builder strings.Builder
+
+	// 添加 curl 基础命令和方法
+	builder.WriteString("curl -X " + r.Method)
+
+	// 添加请求 URL
+	url := getFullURL(r)
+	builder.WriteString(" '" + url + "'")
+
+	// 添加请求头
+	for key, values := range r.Header {
+		if strings.EqualFold(key, "Host") {
+			continue // 跳过 Host 头
+		}
+		for _, value := range values {
+			builder.WriteString(" -H '" + key + ": " + value + "'")
+		}
+	}
+
+	// 添加 JSON 数据
+	if len(body) > 0 {
+		// 转义单引号防止命令中断
+		escapedBody := strings.ReplaceAll(string(body), "'", `'\''`)
+		builder.WriteString(" -d '" + escapedBody + "'")
+	}
+
+	return builder.String()
+}
+
+func getFullURL(r *http.Request) string {
+	scheme := "http"
+	if r.TLS != nil {
+		scheme = "https"
+	}
+	return scheme + "://" + r.Host + r.URL.RequestURI()
+}

middlewares/dump/req_test.go

@@ -0,0 +1,74 @@
+package dump
+
+import (
+	"bytes"
+	"encoding/json"
+	"gitea.loveuer.com/yizhisec/packages/logger"
+	"gitea.loveuer.com/yizhisec/packages/tool"
+	"github.com/gin-gonic/gin"
+	"net/http"
+	"testing"
+	"time"
+)
+
+func TestRequest(t *testing.T) {
+	ready := make(chan struct{})
+
+	go func() {
+		app := gin.Default()
+		app.Use(Request(t.Context(), RequestHandlerCurl))
+
+		app.GET("/hello", func(c *gin.Context) {
+			c.JSON(200, gin.H{"name": c.Query("name")})
+		})
+
+		app.POST("/hello", func(c *gin.Context) {
+			type Req struct {
+				Id   int    `json:"id"`
+				Name string `json:"name"`
+			}
+
+			var (
+				err error
+				req = new(Req)
+			)
+
+			if err = c.BindJSON(req); err != nil {
+				c.JSON(200, gin.H{"err": err})
+			}
+
+			c.JSON(200, gin.H{"id": req.Id, "name": req.Name})
+		})
+
+		logger.Fatal(app.Run(":18080").Error())
+	}()
+
+	go func() {
+		time.Sleep(1 * time.Second)
+		for _ = range 10 {
+			_, err := http.Get("http://localhost:18080/hello?name=" + tool.RandomName())
+			if err != nil {
+				t.Error(err.Error())
+			}
+		}
+
+		for _ = range 5 {
+			bs, _ := json.Marshal(map[string]interface{}{"id": tool.RandomInt(30), "name": tool.RandomName()})
+			req, err := http.NewRequest(http.MethodPost, "http://localhost:18080/hello", bytes.NewReader(bs))
+			req.Header.Set("Content-Type", "application/json")
+			if err != nil {
+				t.Fatal(err.Error())
+			}
+
+			_, err = http.DefaultClient.Do(req)
+			if err != nil {
+				t.Fatal(err.Error())
+			}
+		}
+
+		ready <- struct{}{}
+	}()
+
+	<-ready
+	time.Sleep(1 * time.Second)
+}

resp/error.go

@@ -0,0 +1,56 @@
+package resp
+
+import "net/http"
+
+type Error struct {
+	Status int    `json:"status"`
+	Msg    string `json:"msg"`
+	Err    error  `json:"err"`
+	Data   any    `json:"data"`
+}
+
+func (e *Error) Error() string {
+	return e.Err.Error()
+}
+
+func (e *Error) _r() *res {
+	data := &res{
+		Status: e.Status,
+		Msg:    e.Msg,
+		Data:   e.Data,
+		Err:    e.Err,
+	}
+
+	if data.Status < 0 || data.Status > 999 {
+		data.Status = 500
+	}
+
+	return data
+}
+
+func NewError(err error, args ...any) *Error {
+	e := &Error{
+		Status: http.StatusInternalServerError,
+		Err:    err,
+	}
+
+	if len(args) > 0 {
+		if status, ok := args[0].(int); ok {
+			e.Status = status
+		}
+	}
+
+	e.Msg = Msg(e.Status)
+
+	if len(args) > 1 {
+		if msg, ok := args[1].(string); ok {
+			e.Msg = msg
+		}
+	}
+
+	if len(args) > 2 {
+		e.Data = args[2]
+	}
+
+	return e
+}

resp/msg.go

@@ -0,0 +1,34 @@
+package resp
+
+const (
+	Msg200        = "操作成功"
+	Msg400        = "参数错误"
+	Msg401        = "登录信息不存在或已过期, 请重新登录"
+	Msg401NoMulti = "用户已在其他地方登录"
+	Msg403        = "权限不足"
+	Msg404        = "资源不存在"
+	Msg500        = "服务器开小差了"
+	Msg501        = "服务不可用"
+	Msg503        = "服务不可用或正在升级, 请联系管理员"
+)
+
+func Msg(status int) string {
+	switch status {
+	case 400:
+		return Msg400
+	case 401:
+		return Msg401
+	case 403:
+		return Msg403
+	case 404:
+		return Msg404
+	case 500:
+		return Msg500
+	case 501:
+		return Msg501
+	case 503:
+		return Msg503
+	}
+
+	return "未知错误"
+}

resp/resp.go

@@ -0,0 +1,100 @@
+package resp
+
+import (
+	"errors"
+	"github.com/gin-gonic/gin"
+)
+
+type res struct {
+	Status int    `json:"status"`
+	Msg    string `json:"msg"`
+	Data   any    `json:"data"`
+	Err    any    `json:"err"`
+}
+
+func R200(c *gin.Context, data any, msgs ...string) {
+	r := &res{
+		Status: 200,
+		Msg:    Msg200,
+		Data:   data,
+	}
+
+	if len(msgs) > 0 && msgs[0] != "" {
+		r.Msg = msgs[0]
+	}
+
+	c.AbortWithStatusJSON(200, r)
+}
+
+func RE(c *gin.Context, err error) {
+	var re *Error
+
+	if errors.As(err, &re) {
+		_r(c, re._r())
+		return
+	}
+
+	R500(c, "", nil, err)
+}
+
+func _r(c *gin.Context, r *res, args ...any) {
+	length := len(args)
+	switch length {
+	case 0:
+		break
+	case 1:
+		if msg, ok := args[0].(string); ok {
+			r.Msg = msg
+		}
+	case 2:
+		r.Data = args[1]
+	case 3:
+		r.Err = args[2]
+	}
+
+	if r.Msg == "" {
+		r.Msg = Msg(r.Status)
+	}
+
+	c.AbortWithStatusJSON(r.Status, r)
+}
+
+func R400(c *gin.Context, args ...any) {
+	r := &res{
+		Status: 400,
+	}
+
+	_r(c, r, args...)
+}
+
+func R401(c *gin.Context, args ...any) {
+	r := &res{
+		Status: 401,
+	}
+
+	_r(c, r, args...)
+}
+
+func R403(c *gin.Context, args ...any) {
+	r := &res{
+		Status: 403,
+	}
+
+	_r(c, r, args...)
+}
+
+func R500(c *gin.Context, args ...any) {
+	r := &res{
+		Status: 500,
+	}
+
+	_r(c, r, args...)
+}
+
+func R501(c *gin.Context, args ...any) {
+	r := &res{
+		Status: 501,
+	}
+
+	_r(c, r, args...)
+}