mirror of
https://github.com/veops/oneterm.git
synced 2025-10-05 07:16:57 +08:00
133 lines
2.8 KiB
Go
133 lines
2.8 KiB
Go
package api
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"net/http"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/gin-gonic/gin"
|
|
"github.com/nicksnyder/go-i18n/v2/i18n"
|
|
"go.uber.org/zap"
|
|
|
|
"github.com/veops/oneterm/acl"
|
|
"github.com/veops/oneterm/api/controller"
|
|
myi18n "github.com/veops/oneterm/i18n"
|
|
"github.com/veops/oneterm/logger"
|
|
)
|
|
|
|
var (
|
|
errUnauthorized = &controller.ApiError{Code: controller.ErrUnauthorized}
|
|
)
|
|
|
|
func ginLogger() gin.HandlerFunc {
|
|
return func(ctx *gin.Context) {
|
|
start := time.Now()
|
|
|
|
ctx.Next()
|
|
|
|
cost := time.Since(start)
|
|
logger.L().Info(ctx.Request.URL.String(),
|
|
zap.String("method", ctx.Request.Method),
|
|
zap.Int("status", ctx.Writer.Status()),
|
|
zap.String("ip", ctx.ClientIP()),
|
|
zap.Duration("cost", cost),
|
|
)
|
|
|
|
}
|
|
}
|
|
|
|
func auth() gin.HandlerFunc {
|
|
return func(ctx *gin.Context) {
|
|
var (
|
|
sess *acl.Session
|
|
err error
|
|
cookie string
|
|
)
|
|
|
|
m := make(map[string]any)
|
|
ctx.ShouldBindBodyWithJSON(&m)
|
|
if ctx.Request.Method == "GET" {
|
|
if _, ok := ctx.GetQuery("_key"); ok {
|
|
m["_key"] = ctx.Query("_key")
|
|
m["_secret"] = ctx.Query("_secret")
|
|
}
|
|
}
|
|
if _, ok := m["_key"]; ok {
|
|
sess, err = acl.AuthWithKey(ctx.Request.URL.Path, m)
|
|
if err != nil {
|
|
logger.L().Error("cannot authwithkey", zap.Error(err))
|
|
ctx.AbortWithError(http.StatusUnauthorized, errUnauthorized)
|
|
return
|
|
}
|
|
ctx.Set("isAuthWithKey", true)
|
|
} else {
|
|
cookie, err = ctx.Cookie("session")
|
|
if err != nil || cookie == "" {
|
|
logger.L().Error("cannot get cookie.session", zap.Error(err))
|
|
ctx.AbortWithError(http.StatusUnauthorized, errUnauthorized)
|
|
return
|
|
}
|
|
sess, err = acl.ParseCookie(cookie)
|
|
}
|
|
|
|
if err != nil {
|
|
ctx.AbortWithStatus(http.StatusUnauthorized)
|
|
return
|
|
}
|
|
ctx.Set("session", sess)
|
|
ctx.Next()
|
|
}
|
|
}
|
|
|
|
type bodyWriter struct {
|
|
gin.ResponseWriter
|
|
body *bytes.Buffer
|
|
}
|
|
|
|
func (w bodyWriter) Write(b []byte) (int, error) {
|
|
return w.body.Write(b)
|
|
}
|
|
|
|
func Error2Resp() gin.HandlerFunc {
|
|
return func(ctx *gin.Context) {
|
|
if strings.Contains(ctx.Request.URL.String(), "session/replay") {
|
|
ctx.Next()
|
|
return
|
|
}
|
|
|
|
wb := &bodyWriter{
|
|
body: &bytes.Buffer{},
|
|
ResponseWriter: ctx.Writer,
|
|
}
|
|
ctx.Writer = wb
|
|
|
|
ctx.Next()
|
|
|
|
obj := make(map[string]any)
|
|
json.Unmarshal(wb.body.Bytes(), &obj)
|
|
if len(ctx.Errors) > 0 {
|
|
if v, ok := obj["code"]; !ok || v == 0 {
|
|
obj["code"] = ctx.Writer.Status()
|
|
}
|
|
|
|
if v, ok := obj["message"]; !ok || v == "" {
|
|
e := ctx.Errors.Last().Err
|
|
obj["message"] = e.Error()
|
|
|
|
ae, ok := e.(*controller.ApiError)
|
|
if ok {
|
|
lang := ctx.PostForm("lang")
|
|
accept := ctx.GetHeader("Accept-Language")
|
|
localizer := i18n.NewLocalizer(myi18n.Bundle, lang, accept)
|
|
obj["message"] = ae.Message(localizer)
|
|
|
|
}
|
|
}
|
|
}
|
|
bs, _ := json.Marshal(obj)
|
|
wb.ResponseWriter.Write(bs)
|
|
}
|
|
}
|