yvan/kra
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

后端重构

Browse Source
This commit is contained in:
Yvan
2026-01-08 20:16:27 +08:00
parent 9cb6b965e0
commit f5f77b32fe
23 changed files with 1450 additions and 2 deletions
Download Patch File Download Diff File Expand all files Collapse all files
internal/server/gin.go
+4
View File
@@ -41,10 +41,12 @@ func NewGinRouter(
exportTemplateUsecase *system.ExportTemplateUsecase,
autoCodeUsecase *system.AutoCodeUsecase,
autoCodeHistoryUsecase *system.AutoCodeHistoryUsecase,
autoCodePackageUsecase *system.AutoCodePackageUsecase,
// Example usecases
fileUploadUsecase *example.FileUploadUsecase,
customerUsecase *example.CustomerUsecase,
attachmentCategoryUsecase *example.AttachmentCategoryUsecase,
breakpointContinueUsecase *example.BreakpointContinueUsecase,
) *gin.Engine {
gin.SetMode(gin.DebugMode)
@@ -91,6 +93,7 @@ func NewGinRouter(
exportTemplateUsecase,
autoCodeUsecase,
autoCodeHistoryUsecase,
autoCodePackageUsecase,
)
handler.SetJWTInstance(jwtPkg)
@@ -99,6 +102,7 @@ func NewGinRouter(
fileUploadUsecase,
customerUsecase,
attachmentCategoryUsecase,
breakpointContinueUsecase,
)
// 创建路由组
internal/server/handler/example/enter.go
+3
View File
@@ -14,6 +14,7 @@ var (
fileUploadUsecase *example.FileUploadUsecase
customerUsecase *example.CustomerUsecase
attachmentCategoryUsecase *example.AttachmentCategoryUsecase
breakpointContinueUsecase *example.BreakpointContinueUsecase
)
// InitUsecases 初始化业务层依赖
@@ -21,8 +22,10 @@ func InitUsecases(
fileUpload *example.FileUploadUsecase,
customer *example.CustomerUsecase,
attachmentCategory *example.AttachmentCategoryUsecase,
breakpointContinue *example.BreakpointContinueUsecase,
) {
fileUploadUsecase = fileUpload
customerUsecase = customer
attachmentCategoryUsecase = attachmentCategory
breakpointContinueUsecase = breakpointContinue
}
internal/server/handler/example/exa_breakpoint_continue.go
+141
View File
@@ -0,0 +1,141 @@
package example
import (
"io"
"strconv"
"strings"
"kra/internal/biz/example"
"kra/pkg/response"
"kra/pkg/utils"
"github.com/gin-gonic/gin"
)
// BreakpointContinue 断点续传到服务器
func (f *FileUploadApi) BreakpointContinue(c *gin.Context) {
fileMd5 := c.Request.FormValue("fileMd5")
fileName := c.Request.FormValue("fileName")
chunkMd5 := c.Request.FormValue("chunkMd5")
chunkNumber, _ := strconv.Atoi(c.Request.FormValue("chunkNumber"))
chunkTotal, _ := strconv.Atoi(c.Request.FormValue("chunkTotal"))
_, FileHeader, err := c.Request.FormFile("file")
if err != nil {
response.FailWithMessage("接收文件失败", c)
return
}
file, err := FileHeader.Open()
if err != nil {
response.FailWithMessage("文件读取失败", c)
return
}
defer file.Close()
content, _ := io.ReadAll(file)
if !utils.CheckMd5(content, chunkMd5) {
response.FailWithMessage("检查md5失败", c)
return
}
exaFile, err := breakpointContinueUsecase.FindOrCreateFile(c.Request.Context(), fileMd5, fileName, chunkTotal)
if err != nil {
response.FailWithMessage("查找或创建记录失败: "+err.Error(), c)
return
}
pathC, err := utils.BreakPointContinue(content, fileName, chunkNumber, chunkTotal, fileMd5)
if err != nil {
response.FailWithMessage("断点续传失败: "+err.Error(), c)
return
}
if err = breakpointContinueUsecase.CreateFileChunk(c.Request.Context(), exaFile.ID, pathC, chunkNumber); err != nil {
response.FailWithMessage("创建文件记录失败: "+err.Error(), c)
return
}
response.OkWithMessage("切片创建成功", c)
}
// FindFile 查找文件
func (f *FileUploadApi) FindFile(c *gin.Context) {
fileMd5 := c.Query("fileMd5")
fileName := c.Query("fileName")
chunkTotal, _ := strconv.Atoi(c.Query("chunkTotal"))
file, err := breakpointContinueUsecase.FindOrCreateFile(c.Request.Context(), fileMd5, fileName, chunkTotal)
if err != nil {
response.FailWithMessage("查找失败: "+err.Error(), c)
return
}
response.OkWithDetailed(gin.H{"file": toFileResponse(file)}, "查找成功", c)
}
// BreakpointContinueFinish 创建文件（合并切片）
func (f *FileUploadApi) BreakpointContinueFinish(c *gin.Context) {
fileMd5 := c.Query("fileMd5")
fileName := c.Query("fileName")
filePath, err := utils.MakeFile(fileName, fileMd5)
if err != nil {
response.FailWithDetailed(gin.H{"filePath": filePath}, "文件创建失败", c)
return
}
response.OkWithDetailed(gin.H{"filePath": filePath}, "文件创建成功", c)
}
// RemoveChunk 删除切片
func (f *FileUploadApi) RemoveChunk(c *gin.Context) {
var req struct {
FileMd5 string `json:"fileMd5"`
FilePath string `json:"filePath"`
}
if err := c.ShouldBindJSON(&req); err != nil {
response.FailWithMessage(err.Error(), c)
return
}
// 路径穿越拦截
if strings.Contains(req.FilePath, "..") || strings.Contains(req.FilePath, "../") ||
strings.Contains(req.FilePath, "./") || strings.Contains(req.FilePath, ".\\") {
response.FailWithMessage("非法路径，禁止删除", c)
return
}
if err := utils.RemoveChunk(req.FileMd5); err != nil {
response.FailWithMessage("缓存切片删除失败: "+err.Error(), c)
return
}
if err := breakpointContinueUsecase.DeleteFileChunk(c.Request.Context(), req.FileMd5, req.FilePath); err != nil {
response.FailWithMessage(err.Error(), c)
return
}
response.OkWithMessage("缓存切片删除成功", c)
}
func toFileResponse(file *example.ExaFile) map[string]interface{} {
chunks := make([]map[string]interface{}, len(file.ExaFileChunk))
for i, chunk := range file.ExaFileChunk {
chunks[i] = map[string]interface{}{
"ID": chunk.ID,
"exaFileID": chunk.ExaFileID,
"fileChunkNumber": chunk.FileChunkNumber,
"fileChunkPath": chunk.FileChunkPath,
}
}
return map[string]interface{}{
"ID": file.ID,
"fileName": file.FileName,
"fileMd5": file.FileMd5,
"filePath": file.FilePath,
"chunkTotal": file.ChunkTotal,
"isFinish": file.IsFinish,
"exaFileChunk": chunks,
}
}
internal/server/handler/system/enter.go
+11
View File
@@ -22,6 +22,9 @@ type ApiGroup struct {
DBApi
AutoCodeApi
AutoCodeHistoryApi
AutoCodePackageApi
AutoCodeTemplateApi
AutoCodePluginApi
}
// 业务层依赖
@@ -42,6 +45,7 @@ var (
exportTemplateUsecase *system.ExportTemplateUsecase
autoCodeUsecase *system.AutoCodeUsecase
autoCodeHistoryUsecase *system.AutoCodeHistoryUsecase
autoCodePackageUsecase *system.AutoCodePackageUsecase
)
// InitUsecases 初始化业务层依赖
@@ -62,6 +66,7 @@ func InitUsecases(
exportTemplate *system.ExportTemplateUsecase,
autoCode *system.AutoCodeUsecase,
autoCodeHistory *system.AutoCodeHistoryUsecase,
autoCodePackage *system.AutoCodePackageUsecase,
) {
userUsecase = user
apiUsecase = api
@@ -79,4 +84,10 @@ func InitUsecases(
exportTemplateUsecase = exportTemplate
autoCodeUsecase = autoCode
autoCodeHistoryUsecase = autoCodeHistory
autoCodePackageUsecase = autoCodePackage
}
// Api类型定义
type AutoCodePackageApi struct{}
type AutoCodeTemplateApi struct{}
type AutoCodePluginApi struct{}
internal/server/handler/system/sys_auto_code_package.go
+60
View File
@@ -0,0 +1,60 @@
package system
import (
"kra/pkg/response"
"github.com/gin-gonic/gin"
)
// GetPackages 获取所有包
// @Tags AutoCodePackage
// @Summary 获取所有包
// @Security ApiKeyAuth
// @Produce application/json
// @Success 200 {object} response.Response{data=[]system.SysAutoCodePackage} "获取成功"
// @Router /autoCode/getPackage [post]
func GetPackages(c *gin.Context) {
pkgs, err := autoCodePackageUsecase.All(c.Request.Context())
if err != nil {
response.FailWithMessage("获取失败: "+err.Error(), c)
return
}
response.OkWithDetailed(pkgs, "获取成功", c)
}
// DeletePackage 删除包
// @Tags AutoCodePackage
// @Summary 删除包
// @Security ApiKeyAuth
// @accept application/json
// @Produce application/json
// @Param data body request.GetById true "删除包"
// @Success 200 {object} response.Response{msg=string} "删除成功"
// @Router /autoCode/delPackage [post]
func DeletePackage(c *gin.Context) {
var req struct {
ID uint `json:"id"`
}
if err := c.ShouldBindJSON(&req); err != nil {
response.FailWithMessage(err.Error(), c)
return
}
if err := autoCodePackageUsecase.Delete(c.Request.Context(), req.ID); err != nil {
response.FailWithMessage("删除失败: "+err.Error(), c)
return
}
response.OkWithMessage("删除成功", c)
}
// GetTemplates 获取所有模版
// @Tags AutoCodePackage
// @Summary 获取所有模版
// @Security ApiKeyAuth
// @Produce application/json
// @Success 200 {object} response.Response{data=[]string} "获取成功"
// @Router /autoCode/getTemplates [get]
func GetTemplates(c *gin.Context) {
// 返回固定的模版列表
templates := []string{"package", "plugin"}
response.OkWithDetailed(templates, "获取成功", c)
}
internal/server/handler/system/sys_auto_code_plugin.go
+63
View File
@@ -0,0 +1,63 @@
package system
import (
"kra/pkg/response"
"github.com/gin-gonic/gin"
)
// InstallPlugin 安装插件
// @Tags AutoCodePlugin
// @Summary 安装插件
// @Security ApiKeyAuth
// @accept multipart/form-data
// @Produce application/json
// @Param plug formData file true "插件文件"
// @Success 200 {object} response.Response{data=[]interface{}} "安装成功"
// @Router /autoCode/installPlugin [post]
func InstallPlugin(c *gin.Context) {
// TODO: 实现插件安装功能
response.FailWithMessage("功能开发中", c)
}
// PackagedPlugin 打包插件
// @Tags AutoCodePlugin
// @Summary 打包插件
// @Security ApiKeyAuth
// @accept application/json
// @Produce application/json
// @Param plugName query string true "插件名称"
// @Success 200 {object} response.Response{msg=string} "打包成功"
// @Router /autoCode/pubPlug [post]
func PackagedPlugin(c *gin.Context) {
// TODO: 实现插件打包功能
response.FailWithMessage("功能开发中", c)
}
// InitPluginMenu 初始化插件菜单
// @Tags AutoCodePlugin
// @Summary 初始化插件菜单
// @Security ApiKeyAuth
// @accept application/json
// @Produce application/json
// @Param data body map[string]interface{} true "菜单信息"
// @Success 200 {object} response.Response{msg=string} "初始化成功"
// @Router /autoCode/initMenu [post]
func InitPluginMenu(c *gin.Context) {
// TODO: 实现插件菜单初始化功能
response.FailWithMessage("功能开发中", c)
}
// InitPluginAPI 初始化插件API
// @Tags AutoCodePlugin
// @Summary 初始化插件API
// @Security ApiKeyAuth
// @accept application/json
// @Produce application/json
// @Param data body map[string]interface{} true "API信息"
// @Success 200 {object} response.Response{msg=string} "初始化成功"
// @Router /autoCode/initAPI [post]
func InitPluginAPI(c *gin.Context) {
// TODO: 实现插件API初始化功能
response.FailWithMessage("功能开发中", c)
}
internal/server/handler/system/sys_auto_code_template.go
+49
View File
@@ -0,0 +1,49 @@
package system
import (
"kra/pkg/response"
"github.com/gin-gonic/gin"
)
// PreviewCode 预览代码
// @Tags AutoCodeTemplate
// @Summary 预览创建后的代码
// @Security ApiKeyAuth
// @accept application/json
// @Produce application/json
// @Param data body map[string]interface{} true "预览创建代码"
// @Success 200 {object} response.Response{data=map[string]interface{}} "预览成功"
// @Router /autoCode/preview [post]
func PreviewCode(c *gin.Context) {
// TODO: 实现代码预览功能
response.FailWithMessage("功能开发中", c)
}
// CreateCode 创建代码
// @Tags AutoCodeTemplate
// @Summary 自动代码模板
// @Security ApiKeyAuth
// @accept application/json
// @Produce application/json
// @Param data body map[string]interface{} true "创建自动代码"
// @Success 200 {object} response.Response{msg=string} "创建成功"
// @Router /autoCode/createTemp [post]
func CreateCode(c *gin.Context) {
// TODO: 实现代码创建功能
response.FailWithMessage("功能开发中", c)
}
// AddFunc 增加方法
// @Tags AutoCodeTemplate
// @Summary 增加方法
// @Security ApiKeyAuth
// @accept application/json
// @Produce application/json
// @Param data body map[string]interface{} true "增加方法"
// @Success 200 {object} response.Response{msg=string} "注入成功"
// @Router /autoCode/addFunc [post]
func AddFunc(c *gin.Context) {
// TODO: 实现方法注入功能
response.FailWithMessage("功能开发中", c)
}
internal/server/middleware/gin_error.go
+86
View File
@@ -0,0 +1,86 @@
package middleware
import (
"kra/pkg/response"
"github.com/gin-gonic/gin"
"go.uber.org/zap"
)
// 全局错误日志实例
var errorLogger *zap.Logger
// ErrorCreator 错误记录创建接口
type ErrorCreator interface {
CreateError(form, info string) error
}
// 全局错误创建器
var errorCreator ErrorCreator
// SetErrorLogger 设置错误日志
func SetErrorLogger(logger *zap.Logger) {
errorLogger = logger
}
// SetErrorCreator 设置错误创建器
func SetErrorCreator(creator ErrorCreator) {
errorCreator = creator
}
// ErrorHandler 错误处理中间件
// 用于统一处理请求过程中产生的错误
func ErrorHandler() gin.HandlerFunc {
return func(c *gin.Context) {
c.Next()
// 处理请求过程中产生的错误
if len(c.Errors) > 0 {
for _, e := range c.Errors {
// 记录错误日志
if errorLogger != nil {
errorLogger.Error("请求错误",
zap.String("path", c.Request.URL.Path),
zap.String("method", c.Request.Method),
zap.String("error", e.Error()),
)
}
// 保存错误到数据库
if errorCreator != nil {
_ = errorCreator.CreateError(c.Request.URL.Path, e.Error())
}
}
// 如果还没有写入响应，返回错误信息
if !c.Writer.Written() {
lastErr := c.Errors.Last()
response.FailWithMessage(lastErr.Error(), c)
}
}
}
}
// ErrorResponse 错误响应结构
type ErrorResponse struct {
Code int `json:"code"`
Message string `json:"message"`
Detail string `json:"detail,omitempty"`
}
// HandleError 处理错误并返回响应
func HandleError(c *gin.Context, err error, message string) {
if errorLogger != nil {
errorLogger.Error(message,
zap.String("path", c.Request.URL.Path),
zap.Error(err),
)
}
// 保存错误到数据库
if errorCreator != nil {
_ = errorCreator.CreateError(c.Request.URL.Path, err.Error())
}
response.FailWithMessage(message, c)
}
internal/server/middleware/gin_limit_ip.go
+99
View File
@@ -0,0 +1,99 @@
package middleware
import (
"context"
"errors"
"net/http"
"time"
"kra/pkg/response"
"github.com/gin-gonic/gin"
"github.com/redis/go-redis/v9"
)
// LimitConfig IP限流配置
type LimitConfig struct {
// GenerationKey 根据业务生成key
GenerationKey func(c *gin.Context) string
// CheckOrMark 检查函数
CheckOrMark func(key string, expire int, limit int) error
// Expire key 过期时间（秒）
Expire int
// Limit 周期内限制次数
Limit int
}
var redisClient redis.UniversalClient
// SetRedisClient 设置Redis客户端
func SetRedisClient(client redis.UniversalClient) {
redisClient = client
}
// LimitWithTime 返回限流中间件
func (l LimitConfig) LimitWithTime() gin.HandlerFunc {
return func(c *gin.Context) {
if err := l.CheckOrMark(l.GenerationKey(c), l.Expire, l.Limit); err != nil {
c.JSON(http.StatusOK, gin.H{"code": response.ERROR, "msg": err.Error()})
c.Abort()
return
}
c.Next()
}
}
// DefaultGenerationKey 默认生成key
func DefaultGenerationKey(c *gin.Context) string {
return "KRA_Limit" + c.ClientIP()
}
// DefaultCheckOrMark 默认检查函数
func DefaultCheckOrMark(key string, expire int, limit int) error {
if redisClient == nil {
return nil // Redis未配置，跳过限流
}
return SetLimitWithTime(key, limit, time.Duration(expire)*time.Second)
}
// DefaultLimit 默认限流中间件
func DefaultLimit(expire, limit int) gin.HandlerFunc {
return LimitConfig{
GenerationKey: DefaultGenerationKey,
CheckOrMark: DefaultCheckOrMark,
Expire: expire,
Limit: limit,
}.LimitWithTime()
}
// SetLimitWithTime 设置访问次数
func SetLimitWithTime(key string, limit int, expiration time.Duration) error {
ctx := context.Background()
count, err := redisClient.Exists(ctx, key).Result()
if err != nil {
return err
}
if count == 0 {
pipe := redisClient.TxPipeline()
pipe.Incr(ctx, key)
pipe.Expire(ctx, key, expiration)
_, err = pipe.Exec(ctx)
return err
}
times, err := redisClient.Get(ctx, key).Int()
if err != nil {
return err
}
if times >= limit {
t, err := redisClient.PTTL(ctx, key).Result()
if err != nil {
return errors.New("请求太过频繁，请稍后再试")
}
return errors.New("请求太过频繁, 请 " + t.String() + " 后尝试")
}
return redisClient.Incr(ctx, key).Err()
}
internal/server/middleware/gin_logger.go
+95
View File
@@ -0,0 +1,95 @@
package middleware
import (
"bytes"
"encoding/json"
"fmt"
"io"
"strings"
"time"
"github.com/gin-gonic/gin"
)
// LogLayout 日志layout
type LogLayout struct {
Time time.Time `json:"time"`
Metadata map[string]interface{} `json:"metadata,omitempty"`
Path string `json:"path"`
Query string `json:"query,omitempty"`
Body string `json:"body,omitempty"`
IP string `json:"ip"`
UserAgent string `json:"user_agent"`
Error string `json:"error,omitempty"`
Cost time.Duration `json:"cost"`
Source string `json:"source"`
}
// Logger 日志中间件配置
type Logger struct {
// Filter 用户自定义过滤
Filter func(c *gin.Context) bool
// FilterKeyword 关键字过滤
FilterKeyword func(layout *LogLayout) bool
// AuthProcess 鉴权处理
AuthProcess func(c *gin.Context, layout *LogLayout)
// Print 日志处理
Print func(LogLayout)
// Source 服务唯一标识
Source string
}
// SetLoggerMiddleware 设置日志中间件
func (l Logger) SetLoggerMiddleware() gin.HandlerFunc {
return func(c *gin.Context) {
start := time.Now()
path := c.Request.URL.Path
query := c.Request.URL.RawQuery
var body []byte
if l.Filter != nil && !l.Filter(c) {
body, _ = c.GetRawData()
// 将原body塞回去
c.Request.Body = io.NopCloser(bytes.NewBuffer(body))
}
c.Next()
cost := time.Since(start)
layout := LogLayout{
Time: time.Now(),
Path: path,
Query: query,
IP: c.ClientIP(),
UserAgent: c.Request.UserAgent(),
Error: strings.TrimRight(c.Errors.ByType(gin.ErrorTypePrivate).String(), "\n"),
Cost: cost,
Source: l.Source,
}
if l.Filter != nil && !l.Filter(c) {
layout.Body = string(body)
}
if l.AuthProcess != nil {
l.AuthProcess(c, &layout)
}
if l.FilterKeyword != nil {
l.FilterKeyword(&layout)
}
l.Print(layout)
}
}
// DefaultLogger 默认日志中间件
func DefaultLogger() gin.HandlerFunc {
return Logger{
Print: func(layout LogLayout) {
v, _ := json.Marshal(layout)
fmt.Println(string(v))
},
Source: "KRA",
}.SetLoggerMiddleware()
}
internal/server/middleware/gin_timeout.go
+55
View File
@@ -0,0 +1,55 @@
package middleware
import (
"context"
"net/http"
"time"
"github.com/gin-gonic/gin"
)
// TimeoutMiddleware 创建超时中间件
// timeout: 超时时间（例如：time.Second * 30）
// 使用示例: router.GET("path", middleware.TimeoutMiddleware(30*time.Second), HandleFunc)
func TimeoutMiddleware(timeout time.Duration) gin.HandlerFunc {
return func(c *gin.Context) {
ctx, cancel := context.WithTimeout(c.Request.Context(), timeout)
defer cancel()
c.Request = c.Request.WithContext(ctx)
// 使用 buffered channel 避免 goroutine 泄漏
done := make(chan struct{}, 1)
panicChan := make(chan interface{}, 1)
go func() {
defer func() {
if p := recover(); p != nil {
select {
case panicChan <- p:
default:
}
}
select {
case done <- struct{}{}:
default:
}
}()
c.Next()
}()
select {
case p := <-panicChan:
panic(p)
case <-done:
return
case <-ctx.Done():
c.Header("Connection", "close")
c.AbortWithStatusJSON(http.StatusGatewayTimeout, gin.H{
"code": 504,
"msg": "请求超时",
})
return
}
}
}
internal/server/router/example/exa_file_upload.go
+5
View File
@@ -18,8 +18,13 @@ func (r *FileUploadRouter) InitFileUploadRouter(Router *gin.RouterGroup) {
fileUploadRouter.POST("deleteFile", api.DeleteFile)
fileUploadRouter.POST("editFileName", api.EditFileName)
fileUploadRouter.POST("importURL", api.ImportURL)
// 断点续传
fileUploadRouter.POST("breakpointContinue", api.BreakpointContinue)
fileUploadRouter.POST("breakpointContinueFinish", api.BreakpointContinueFinish)
fileUploadRouter.POST("removeChunk", api.RemoveChunk)
}
{
fileUploadRouterWithoutRecord.POST("getFileList", api.GetFileList)
fileUploadRouterWithoutRecord.GET("findFile", api.FindFile)
}
}
internal/server/router/system/sys_auto_code.go
+24 -2
View File
@@ -1,6 +1,7 @@
package system
import (
handler "kra/internal/server/handler/system"
"kra/internal/server/middleware"
"github.com/gin-gonic/gin"
@@ -12,11 +13,32 @@ type AutoCodeRouter struct{}
func (s *AutoCodeRouter) InitAutoCodeRouter(Router *gin.RouterGroup, PublicRouter *gin.RouterGroup) {
autoCodeRouter := Router.Group("autoCode").Use(middleware.OperationRecordMiddleware())
autoCodeRouterWithoutRecord := Router.Group("autoCode")
publicAutoCodeRouter := PublicRouter.Group("autoCode")
{
autoCodeRouterWithoutRecord.GET("getDB", autoCodeApi.GetDB) // 获取数据库
autoCodeRouterWithoutRecord.GET("getTables", autoCodeApi.GetTables) // 获取对应数据库的表
autoCodeRouterWithoutRecord.GET("getColumn", autoCodeApi.GetColumn) // 获取指定表所有字段信息
}
// 预留其他路由
_ = autoCodeRouter
{
// 代码包管理
autoCodeRouter.POST("getPackage", handler.GetPackages) // 获取所有包
autoCodeRouter.POST("delPackage", handler.DeletePackage) // 删除包
autoCodeRouter.GET("getTemplates", handler.GetTemplates) // 获取所有模版
}
{
// 代码模板
autoCodeRouter.POST("preview", handler.PreviewCode) // 预览代码
autoCodeRouter.POST("createTemp", handler.CreateCode) // 创建代码
autoCodeRouter.POST("addFunc", handler.AddFunc) // 增加方法
}
{
// 插件管理
autoCodeRouter.POST("pubPlug", handler.PackagedPlugin) // 打包插件
autoCodeRouter.POST("installPlugin", handler.InstallPlugin) // 安装插件
}
{
// 公开路由
publicAutoCodeRouter.POST("initMenu", handler.InitPluginMenu) // 初始化插件菜单
publicAutoCodeRouter.POST("initAPI", handler.InitPluginAPI) // 初始化插件API
}
}