x

demo/main.go

@@ -1,78 +0,0 @@
-package main
-
-import (
-	"context"
-	"fmt"
-	"github.com/gorilla/mux"
-	"log"
-	"net/http"
-)
-
-type FilterFunc func(http.Handler) http.Handler
-
-func FilterChain(filters ...FilterFunc) FilterFunc {
-	return func(next http.Handler) http.Handler {
-		for i := len(filters) - 1; i >= 0; i-- {
-			next = filters[i](next)
-		}
-		return next
-	}
-}
-
-type Context struct {
-	context.Context
-	req *http.Request
-	res http.ResponseWriter
-}
-
-func (c *Context) String(code int, str string) error {
-	c.res.WriteHeader(code)
-	_, err := c.res.Write([]byte(str))
-	return err
-}
-
-func (c *Context) Result(code int, str string) error {
-	c.res.WriteHeader(code)
-	_, err := c.res.Write([]byte(str))
-	return err
-}
-
-type HandleFunc func(Context) error
-
-func IndexPage(ctx Context) error {
-	//return errors.New("xxx")
-	return ctx.String(200, "hello index")
-}
-func Logger() HandleFunc {
-	return func(c Context) error {
-		return nil
-	}
-}
-
-func main() {
-	app := mux.NewRouter()
-	next := http.Handler(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
-		ctx := Context{
-			res: res,
-			req: req,
-		}
-		h := Logger()
-		h(ctx)
-		if err := IndexPage(ctx); err != nil {
-			ctx.Result(500, "err:"+err.Error())
-		}
-	}))
-	next = FilterChain(func(handler http.Handler) http.Handler {
-		return http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {
-			fmt.Println("start")
-			handler.ServeHTTP(writer, request)
-			fmt.Println("end")
-		})
-	})(next)
-	app.Handle("/", next).Methods("GET")
-	srv := http.Server{
-		Addr:    ":9999",
-		Handler: app,
-	}
-	log.Fatal(srv.ListenAndServe())
-}

example/main.go

@@ -3,33 +3,22 @@ package main
 import (
 	"fmt"
 	"git.diulo.com/mogfee/protoc-gen-kit/example/service"
+	"git.diulo.com/mogfee/protoc-gen-kit/log"
 	"git.diulo.com/mogfee/protoc-gen-kit/middleware"
 	"git.diulo.com/mogfee/protoc-gen-kit/pkg/xjson"
 	user "git.diulo.com/mogfee/protoc-gen-kit/proto/v1"
 	"github.com/gin-gonic/gin"
-	"github.com/sirupsen/logrus"
-	"os"
 )
 
 func main() {
 	gin.SetMode(gin.ReleaseMode)
 	app := gin.Default()
 	srv := service.UserService{}
-	l := logrus.New()
-	f, err := os.Create("./app.log")
-	if err != nil {
-		panic(err)
-	}
-	defer f.Close()
-	l.SetOutput(f)
-
-	l.SetFormatter(&logrus.JSONFormatter{})
-	l.SetReportCaller(false)
-
 	app.GET("/user/:name", func(c *gin.Context) {
 		xjson.PrintData(c.FullPath())
 	})
-	user.RegisterUserHandler(app, &srv, middleware.Logger("user-server", l), middleware.Validate())
+	logger := log.With(log.DefaultLogger)
+	user.RegisterUserHandler(app, &srv, middleware.Logger(logger), middleware.Validate())
 	fmt.Println("http://localhost:8888")
 	app.Run("localhost:8888")
 }

log/mq/nsq.go

@@ -21,11 +21,10 @@ type nsqLogger struct {
 
 func (s *nsqLogger) Start() error {
 	xgo.Go(func() {
-		for {
+		for v := range s.list {
 			if s.stop.Load() {
 				break
 			}
-			for v := range s.list {
 			fmt.Println(string(v))
 			func(v []byte) {
 				s.wg.Add(1)
@@ -35,8 +34,8 @@ func (s *nsqLogger) Start() error {
 				}
 			}(v)
 		}
-		}
 	})
+	fmt.Println("xx")
 	return nil
 }
 

log/mq/nsq_test.go

@@ -1,14 +1,19 @@
 package mq
 
 import (
+	"context"
+	"fmt"
 	"git.diulo.com/mogfee/protoc-gen-kit/log"
 	"testing"
 )
 
 func Test_nsqLogger_Log(t *testing.T) {
-	logger := log.With(NewNsqLogger("localhost:4150", "app_log"),
+	nsqWriter := NewNsqLogger("localhost:4150", "app_log")
+	nsqWriter.Start()
+	logger := log.With(nsqWriter,
 		"ts", log.DefaultTimestamp,
 		"caller", log.DefaultCaller,
 	)
 	logger.Log(log.LevelInfo, "user name ttt")
+	fmt.Println(nsqWriter.Shutdown(context.Background()))
 }

middleware/logger.go

@@ -2,38 +2,15 @@ package middleware
 
 import (
 	"context"
-	"git.diulo.com/mogfee/protoc-gen-kit/pkg/xlog"
-	"github.com/sirupsen/logrus"
-	"google.golang.org/grpc/metadata"
-	"time"
+	"git.diulo.com/mogfee/protoc-gen-kit/log"
 )
 
-func Logger(serverName string, log *logrus.Logger) Middleware {
-	baseEntry := log.WithFields(logrus.Fields{
-		"serverName": serverName,
-	})
+func Logger(logger log.Logger) Middleware {
+	//helper:=log.NewHelper(logger)
 	return func(handler Handler) Handler {
 		return func(ctx context.Context, a any) (any, error) {
-			st := time.Now()
-			entry := baseEntry.WithFields(logrus.Fields{
-				"used_time": time.Since(st),
-				"param":     a,
-			})
-			if md, ok := metadata.FromIncomingContext(ctx); ok {
-				entry = entry.WithFields(logrus.Fields{
-					"ip":        md.Get("remote_ip")[0],
-					"full_path": md.Get("full_path")[0],
-				})
-			}
-
-			ctx = xlog.WithContext(ctx, entry)
-			resp, err := handler(ctx, a)
-			if err != nil {
-				entry.WithContext(ctx).Errorf("%+v", err)
-			} else {
-				entry.WithContext(ctx).Info("")
-			}
-			return resp, err
+			//helper.Infof("")
+			return handler(ctx, a)
 		}
 	}
 }

pkg/php_session_decoder/common.go

@@ -1,7 +0,0 @@
-package php_session_decoder
-
-import "git.diulo.com/mogfee/protoc-gen-kit/pkg/php_session_decoder/php_serialize"
-
-const SEPARATOR_VALUE_NAME rune = '|'
-
-type PhpSession map[string]php_serialize.PhpValue

pkg/serialize/common.go

@@ -1,4 +1,8 @@
-package php_serialize
+package serialize
+
+const SEPARATOR_VALUE_NAME rune = '|'
+
+type PhpSession map[string]PhpValue
 
 const (
 	TOKEN_NULL              rune = 'N'

pkg/serialize/common_helper.go

@@ -1,4 +1,4 @@
-package php_serialize
+package serialize
 
 import (
 	"strconv"

pkg/serialize/decoder.go

@@ -1,27 +1,26 @@
-package php_session_decoder
+package serialize
 
 import (
 	"bytes"
-	"git.diulo.com/mogfee/protoc-gen-kit/pkg/php_session_decoder/php_serialize"
 	"io"
 	"strings"
 )
 
 type PhpDecoder struct {
 	source  *strings.Reader
-	decoder *php_serialize.UnSerializer
+	decoder *UnSerializer
 }
 
 func NewPhpDecoder(phpSession string) *PhpDecoder {
 	decoder := &PhpDecoder{
 		source:  strings.NewReader(phpSession),
-		decoder: php_serialize.NewUnSerializer(""),
+		decoder: NewUnSerializer(""),
 	}
 	decoder.decoder.SetReader(decoder.source)
 	return decoder
 }
 
-func (self *PhpDecoder) SetSerializedDecodeFunc(f php_serialize.SerializedDecodeFunc) {
+func (self *PhpDecoder) SetSerializedDecodeFunc(f SerializedDecodeFunc) {
 	self.decoder.SetSerializedDecodeFunc(f)
 }
 
@@ -29,7 +28,7 @@ func (self *PhpDecoder) Decode() (PhpSession, error) {
 	var (
 		name  string
 		err   error
-		value php_serialize.PhpValue
+		value PhpValue
 	)
 	res := make(PhpSession)
 

pkg/serialize/encoder.go

@@ -1,24 +1,23 @@
-package php_session_decoder
+package serialize
 
 import (
 	"bytes"
 	"fmt"
-	"git.diulo.com/mogfee/protoc-gen-kit/pkg/php_session_decoder/php_serialize"
 )
 
 type PhpEncoder struct {
 	data    PhpSession
-	encoder *php_serialize.Serializer
+	encoder *Serializer
 }
 
 func NewPhpEncoder(data PhpSession) *PhpEncoder {
 	return &PhpEncoder{
 		data:    data,
-		encoder: php_serialize.NewSerializer(),
+		encoder: NewSerializer(),
 	}
 }
 
-func (self *PhpEncoder) SetSerializedEncodeFunc(f php_serialize.SerializedEncodeFunc) {
+func (self *PhpEncoder) SetSerializedEncodeFunc(f SerializedEncodeFunc) {
 	self.encoder.SetSerializedEncodeFunc(f)
 }
 

pkg/serialize/serialize.go

@@ -1,4 +1,4 @@
-package php_serialize
+package serialize
 
 import (
 	"bytes"

pkg/serialize/unserialize.go

@@ -1,4 +1,4 @@
-package php_serialize
+package serialize
 
 import (
 	"bytes"

pkg/xaes/xaes.go

@@ -6,47 +6,6 @@ import (
 	"crypto/cipher"
 )
 
-//#;AES加解密使用 长度 16, 24, 32
-//const aesKey = "sfe023f_9fd&fwfl"
-
-////加密字符串
-//func AesEncrypt(hstring string) (string, error) {
-//	if result, err := aesEncrypt([]byte(hstring), []byte(aesKey)); err != nil {
-//		return "", err
-//	} else {
-//		return base64.StdEncoding.EncodeToString(result), nil
-//	}
-//}
-//
-////解密字符串
-//func AesDecrypt(hstring string) (string, error) {
-//	if bye, err := base64.StdEncoding.DecodeString(hstring); err != nil {
-//		return "", err
-//	} else {
-//		if result, err := aesDecrypt(bye, []byte(aesKey)); err != nil {
-//			return "", err
-//		} else {
-//			return string(result), nil
-//		}
-//	}
-//}
-//func AESTestCode() {
-//	// AES-128。key长度：16, 24, 32 bytes 对应 AES-128, AES-192, AES-256
-//	key := []byte("sfe023f_9fd&fwfl")
-//	result, err := aesEncrypt([]byte("polaris@studygolang"), key)
-//	if err != nil {
-//		panic(err)
-//	}
-//	fmt.Println(result)
-//	a, _ := AesEncrypt("polaris@studygolang")
-//	aa, _ := base64.StdEncoding.DecodeString(a)
-//	origData, err := aesDecrypt(aa, key)
-//	if err != nil {
-//		panic(err)
-//	}
-//	fmt.Println(string(origData))
-//}
-
 func Encrypt(origData, key []byte) ([]byte, error) {
 	block, err := aes.NewCipher(key)
 	if err != nil {
@@ -54,11 +13,8 @@ func Encrypt(origData, key []byte) ([]byte, error) {
 	}
 	blockSize := block.BlockSize()
 	origData = pKCS5Padding(origData, blockSize)
-	// origData = ZeroPadding(origData, block.BlockSize())
 	blockMode := cipher.NewCBCEncrypter(block, key[:blockSize])
 	crypted := make([]byte, len(origData))
-	// 根据CryptBlocks方法的说明，如下方式初始化crypted也可以
-	// crypted := origData
 	blockMode.CryptBlocks(crypted, origData)
 	return crypted, nil
 }
@@ -71,26 +27,11 @@ func Decrypt(crypted, key []byte) ([]byte, error) {
 	blockSize := block.BlockSize()
 	blockMode := cipher.NewCBCDecrypter(block, key[:blockSize])
 	origData := make([]byte, len(crypted))
-	// origData := crypted
-
 	blockMode.CryptBlocks(origData, crypted)
-
 	origData = pKCS5UnPadding(origData)
-	// origData = ZeroUnPadding(origData)
 	return origData, nil
 }
 
-//	func zeroPadding(ciphertext []byte, blockSize int) []byte {
-//		padding := blockSize - len(ciphertext)%blockSize
-//		padtext := bytes.Repeat([]byte{0}, padding)
-//		return append(ciphertext, padtext...)
-//	}
-//
-//	func zeroUnPadding(origData []byte) []byte {
-//		length := len(origData)
-//		unpadding := int(origData[length-1])
-//		return origData[:(length - unpadding)]
-//	}
 func pKCS5Padding(ciphertext []byte, blockSize int) []byte {
 	padding := blockSize - len(ciphertext)%blockSize
 	padtext := bytes.Repeat([]byte{byte(padding)}, padding)

pkg/xbase64/xbase64.go

@@ -1,14 +1,14 @@
 package xbase64
 
 import (
-	b64 "encoding/base64"
+	"encoding/base64"
 )
 
 func Encode(s string) string {
-	return b64.StdEncoding.EncodeToString([]byte(s))
+	return base64.StdEncoding.EncodeToString([]byte(s))
 }
 
 func Decode(s string) (string, error) {
-	ds, err := b64.StdEncoding.DecodeString(s)
+	ds, err := base64.StdEncoding.DecodeString(s)
 	return string(ds), err
 }

pkg/xerrors/errors.go

@@ -74,9 +74,5 @@ func FromError(err error) *Error {
 	if se := new(Error); errors.As(err, &se) {
 		return se
 	}
-	//gs, ok := status.FromError(err)
-	//if !ok {
 	return New(UnknownCode, UnknownReason, err.Error())
-	//}
-	//
 }

pkg/xhttp/xhttp.go

@@ -125,8 +125,6 @@ func PostJson(u, post string, headers map[string]string) (*[]byte, error) {
 	}
 
 	headers["Content-Type"] = "application/json;charset=UTF-8"
-	fmt.Printf("%+v\n", post)
-	fmt.Printf("%+v\n", headers)
 	return fetcher("POST", u, post, headers, 60)
 }
 
@@ -142,19 +140,14 @@ type apiRes struct {
 }
 
 func SenEmail(u string, data map[string]string) error {
-	fmt.Println(u)
-	postByte, _ := json.Marshal(data)
-	fmt.Printf("%s\n", postByte)
 	values := url.Values{}
 	for k, v := range data {
 		values.Add(k, v)
 	}
-	fmt.Println(data)
 	res, err := PostForm(u, values.Encode(), nil)
 	if err != nil {
 		return err
 	}
-	fmt.Printf("%s\n", *res)
 	result := apiRes{}
 	if err := json.Unmarshal(*res, &result); err != nil {
 		return err

pkg/xip/xip.go

@@ -1,13 +0,0 @@
-package xip
-
-import (
-	"context"
-	"github.com/gin-gonic/gin"
-)
-
-func GetIpFromContext(ctx context.Context) string {
-	if v, ok := ctx.(*gin.Context); ok {
-		return v.ClientIP()
-	}
-	return ""
-}

pkg/xmath/math.go

@@ -2,7 +2,6 @@ package xmath
 
 import (
 	"fmt"
-	//"github.com/shopspring/decimal"
 	"math"
 	"math/rand"
 	"strconv"

pkg/xpage/xpage.go

@@ -1,8 +0,0 @@
-package xpage
-
-func GetPageOffset(page int32, size int32) int {
-	if page < 1 {
-		page = 1
-	}
-	return int((page - 1) * size)
-}

pkg/xstring/xstring.go

@@ -5,7 +5,6 @@ import (
 	"encoding/base64"
 	"encoding/json"
 	"fmt"
-	"github.com/pkg/errors"
 	"reflect"
 	"regexp"
 	"sort"
@@ -579,7 +578,7 @@ func Base64Encode(s string) string {
 func Base64Decode(s string) (string, error) {
 	b, err := base64.StdEncoding.DecodeString(s)
 	if err != nil {
-		return "", errors.Wrap(err, "")
+		return "", err
 	}
 	return string(b), nil
 }

pkg/xtime/xtime_test.go

@@ -1,10 +0,0 @@
-package xtime
-
-import (
-	"fmt"
-	"testing"
-)
-
-func TestLeaTime(t *testing.T) {
-	fmt.Println(LeaTime(1651812894))
-}

pkg/xtoken/xtoken.go

@@ -11,9 +11,9 @@ import (
 	"time"
 )
 
-const (
+var (
 	// expiredTime 授权结束时间
-	expiredTime = 7200
+	expiredTime int64 = 7200
 
 	tokenKey = "68Tz&xWUW5U$Id45"
 )