Standardization

internal/app/api/api.go

@@ -3,11 +3,9 @@ package api
 import (
 	"net/http"
 	"reflect"
-	"strconv"
 
 	"github.com/lzh-1625/go_process_manager/internal/app/constants"
 	"github.com/lzh-1625/go_process_manager/internal/app/repository"
-	"github.com/lzh-1625/go_process_manager/log"
 
 	"github.com/gin-gonic/gin"
 )
@@ -23,20 +21,6 @@ func rOk(ctx *gin.Context, message string, data any) {
 	ctx.JSON(http.StatusOK, jsonData)
 }
 
-func errCheck(ctx *gin.Context, isErr bool, errData any) {
-	if !isErr {
-		return
-	}
-	if err, ok := errData.(error); ok {
-		log.Logger.Warn(errData)
-		ctx.Set(constants.CTXFLG_ERR, err.Error())
-	}
-	if err, ok := errData.(string); ok {
-		ctx.Set(constants.CTXFLG_ERR, err)
-	}
-	panic(0)
-}
-
 func getRole(ctx *gin.Context) constants.Role {
 	if v, ok := ctx.Get(constants.CTXFLG_ROLE); ok {
 		return v.(constants.Role)
@@ -55,21 +39,3 @@ func isAdmin(ctx *gin.Context) bool {
 func hasOprPermission(ctx *gin.Context, uuid int, op constants.OprPermission) bool {
 	return isAdmin(ctx) || reflect.ValueOf(repository.PermissionRepository.GetPermission(getUserName(ctx), uuid)).FieldByName(string(op)).Bool()
 }
-
-func getQueryInt(ctx *gin.Context, query string) (i int) {
-	i, err := strconv.Atoi(ctx.Query(query))
-	errCheck(ctx, err != nil, "Invalid parameters!")
-	return
-}
-
-func getQueryString(ctx *gin.Context, query string) (s string) {
-	s = ctx.Query(query)
-	errCheck(ctx, s == "", "Invalid parameters!")
-	return
-}
-
-func bind[T any](ctx *gin.Context) T {
-	var data T
-	errCheck(ctx, ctx.ShouldBind(&data) != nil, "Invalid parameters!")
-	return data
-}

internal/app/api/config.go

@@ -1,6 +1,8 @@
 package api
 
 import (
+	"errors"
+
 	"github.com/lzh-1625/go_process_manager/internal/app/logic"
 
 	"github.com/gin-gonic/gin"
@@ -10,18 +12,26 @@ type configApi struct{}
 
 var ConfigApi = new(configApi)
 
-func (c *configApi) GetSystemConfiguration(ctx *gin.Context) {
+func (c *configApi) GetSystemConfiguration(ctx *gin.Context, _ any) error {
 	result := logic.ConfigLogic.GetSystemConfiguration()
 	rOk(ctx, "Operation successful!", result)
+	return nil
 }
 
-func (c *configApi) SetSystemConfiguration(ctx *gin.Context) {
+func (c *configApi) SetSystemConfiguration(ctx *gin.Context, _ any) (err error) {
-	req := bind[map[string]string](ctx)
+	req := map[string]string{}
-	errCheck(ctx, logic.ConfigLogic.SetSystemConfiguration(req) != nil, "Set config fail!")
+	if err = ctx.BindJSON(&req); err != nil {
-	rOk(ctx, "Operation successful!", nil)
+		return
+	}
+	if err = logic.ConfigLogic.SetSystemConfiguration(req); err != nil {
+		return
+	}
+	return
 }
 
-func (c *configApi) EsConfigReload(ctx *gin.Context) {
+func (c *configApi) EsConfigReload(ctx *gin.Context, _ any) (err error) {
-	errCheck(ctx, !logic.EsLogic.InitEs(), "Incorrect username or password!")
+	if !logic.EsLogic.InitEs() {
-	rOk(ctx, "Operation successful!", nil)
+		return errors.New("es init fail")
+	}
+	return
 }

internal/app/api/file.go

@@ -2,6 +2,7 @@ package api
 
 import (
 	"github.com/lzh-1625/go_process_manager/internal/app/logic"
+	"github.com/lzh-1625/go_process_manager/internal/app/model"
 
 	"github.com/gin-gonic/gin"
 )
@@ -10,24 +11,27 @@ type file struct{}
 
 var FileApi = new(file)
 
-func (f *file) FilePathHandler(ctx *gin.Context) {
+func (f *file) FilePathHandler(ctx *gin.Context, req model.FilePathHandlerReq) (err error) {
-	path := getQueryString(ctx, "path")
+	rOk(ctx, "Operation successful!", logic.FileLogic.GetFileAndDirByPath(req.Path))
-	rOk(ctx, "Operation successful!", logic.FileLogic.GetFileAndDirByPath(path))
+	return
 }
 
-func (f *file) FileWriteHandler(ctx *gin.Context) {
+func (f *file) FileWriteHandler(ctx *gin.Context, _ any) (err error) {
 	path := ctx.PostForm("filePath")
 	fi, err := ctx.FormFile("data")
-	errCheck(ctx, err != nil, "Read file data failed!")
+	if err != nil {
+		return
+	}
 	fiReader, _ := fi.Open()
 	err = logic.FileLogic.UpdateFileData(path, fiReader, fi.Size)
-	errCheck(ctx, err != nil, "Update file data operation failed!")
+	return
-	rOk(ctx, "Operation successful!", nil)
 }
 
-func (f *file) FileReadHandler(ctx *gin.Context) {
+func (f *file) FileReadHandler(ctx *gin.Context, req model.FileReadHandlerReq) (err error) {
-	path := getQueryString(ctx, "filePath")
+	bytes, err := logic.FileLogic.ReadFileFromPath(req.FilePath)
-	bytes, err := logic.FileLogic.ReadFileFromPath(path)
+	if err != nil {
-	errCheck(ctx, err != nil, "Operation failed!")
+		return
+	}
 	rOk(ctx, "Operation successful!", string(bytes))
+	return
 }

internal/app/api/log.go

@@ -1,6 +1,7 @@
 package api
 
 import (
+	"errors"
 	"slices"
 
 	"github.com/lzh-1625/go_process_manager/internal/app/constants"
@@ -15,8 +16,7 @@ type logApi struct{}
 
 var LogApi = new(logApi)
 
-func (a *logApi) GetLog(ctx *gin.Context) {
+func (a *logApi) GetLog(ctx *gin.Context, req model.GetLogReq) (err error) {
-	req := bind[model.GetLogReq](ctx)
 	if isAdmin(ctx) {
 		rOk(ctx, "Query successful!", logic.LogLogicImpl.Search(req, req.FilterName...))
 	} else {
@@ -27,11 +27,15 @@ func (a *logApi) GetLog(ctx *gin.Context) {
 		if len(filterName) == 0 {
 			filterName = processNameList
 		}
-		errCheck(ctx, len(filterName) == 0, "No information found!")
+		if len(filterName) == 0 {
+			return errors.New("no information found")
+		}
 		rOk(ctx, "Query successful!", logic.LogLogicImpl.Search(req, filterName...))
 	}
+	return
 }
 
-func (a *logApi) GetRunningLog(ctx *gin.Context) {
+func (a *logApi) GetRunningLog(ctx *gin.Context, _ any) error {
 	rOk(ctx, "Query successful!", logic.Loghandler.GetRunning())
+	return nil
 }

internal/app/api/permission.go

@@ -11,14 +11,12 @@ var PermissionApi = new(permissionApi)
 
 type permissionApi struct{}
 
-func (p *permissionApi) EditPermssion(ctx *gin.Context) {
+func (p *permissionApi) EditPermssion(ctx *gin.Context, req model.Permission) (err error) {
-	req := bind[model.Permission](ctx)
+	return repository.PermissionRepository.EditPermssion(req)
-	err := repository.PermissionRepository.EditPermssion(req)
-	errCheck(ctx, err != nil, err)
-	rOk(ctx, "Operation successful!", nil)
 }
 
-func (p *permissionApi) GetPermissionList(ctx *gin.Context) {
+func (p *permissionApi) GetPermissionList(ctx *gin.Context, req model.GetPermissionListReq) (err error) {
-	result := repository.PermissionRepository.GetPermssionList(getQueryString(ctx, "account"))
+	result := repository.PermissionRepository.GetPermssionList(req.Account)
 	rOk(ctx, "Query successful!", result)
+	return
 }

internal/app/api/proc.go

@@ -1,6 +1,7 @@
 package api
 
 import (
+	"errors"
 	"time"
 
 	"github.com/google/uuid"
@@ -16,114 +17,117 @@ type procApi struct{}
 
 var ProcApi = new(procApi)
 
-func (p *procApi) CreateNewProcess(ctx *gin.Context) {
+func (p *procApi) CreateNewProcess(ctx *gin.Context, req model.Process) (err error) {
-	req := bind[model.Process](ctx)
 	index, err := repository.ProcessRepository.AddProcessConfig(req)
-	errCheck(ctx, err != nil, err)
+	if err != nil {
+		return
+	}
 	req.Uuid = index
 	proc, err := logic.ProcessCtlLogic.NewProcess(req)
-	errCheck(ctx, err != nil, err)
+	if err != nil {
+		return
+	}
 	logic.ProcessCtlLogic.AddProcess(req.Uuid, proc)
 	rOk(ctx, "Operation successful!", gin.H{
 		"id": req.Uuid,
 	})
+	return
 }
 
-func (p *procApi) DeleteNewProcess(ctx *gin.Context) {
+func (p *procApi) DeleteNewProcess(ctx *gin.Context, req model.ProcessUuidReq) (err error) {
-	uuid := getQueryInt(ctx, "uuid")
+	logic.ProcessCtlLogic.KillProcess(req.Uuid)
-	logic.ProcessCtlLogic.KillProcess(uuid)
+	logic.ProcessCtlLogic.DeleteProcess(req.Uuid)
-	logic.ProcessCtlLogic.DeleteProcess(uuid)
+	return repository.ProcessRepository.DeleteProcessConfig(req.Uuid)
-	err := repository.ProcessRepository.DeleteProcessConfig(uuid)
-	errCheck(ctx, err != nil, err)
-	rOk(ctx, "Operation successful!", nil)
 }
 
-func (p *procApi) KillProcess(ctx *gin.Context) {
+func (p *procApi) KillProcess(ctx *gin.Context, req model.ProcessUuidReq) (err error) {
-	uuid := getQueryInt(ctx, "uuid")
+	return logic.ProcessCtlLogic.KillProcess(req.Uuid)
-	err := logic.ProcessCtlLogic.KillProcess(uuid)
-	errCheck(ctx, err != nil, err)
-	rOk(ctx, "Operation successful!", nil)
 }
 
-func (p *procApi) StartProcess(ctx *gin.Context) {
+func (p *procApi) StartProcess(ctx *gin.Context, req model.ProcessUuidReq) (err error) {
-	uuid := getQueryInt(ctx, "uuid")
+	prod, err := logic.ProcessCtlLogic.GetProcess(req.Uuid)
-	prod, err := logic.ProcessCtlLogic.GetProcess(uuid)
 	if err != nil { // 进程不存在则创建
-		proc, err := logic.ProcessCtlLogic.RunNewProcess(repository.ProcessRepository.GetProcessConfigById(uuid))
+		proc, err1 := logic.ProcessCtlLogic.RunNewProcess(repository.ProcessRepository.GetProcessConfigById(req.Uuid))
-		errCheck(ctx, err != nil, err)
+		if err1 != nil {
-		logic.ProcessCtlLogic.AddProcess(uuid, proc)
+			return err1
+		}
+		logic.ProcessCtlLogic.AddProcess(req.Uuid, proc)
 		rOk(ctx, "Operation successful!", nil)
-		return
+		return nil
+	}
+	if prod.State.State == 1 {
+		return errors.New("process is currently running")
 	}
-	errCheck(ctx, prod.State.State == 1, "The process is currently running.")
 	prod.ResetRestartTimes()
 	err = prod.Start()
-	errCheck(ctx, err != nil, err)
+	return
-	rOk(ctx, "Operation successful!", nil)
+
 }
 
-func (p *procApi) StartAllProcess(ctx *gin.Context) {
+func (p *procApi) StartAllProcess(ctx *gin.Context, _ any) (err error) {
 	if isAdmin(ctx) {
 		logic.ProcessCtlLogic.ProcessStartAll()
 	} else {
 		logic.ProcessCtlLogic.ProcesStartAllByUsername(getUserName(ctx))
 	}
-	rOk(ctx, "Operation successful!", nil)
+	return
 }
 
-func (p *procApi) KillAllProcess(ctx *gin.Context) {
+func (p *procApi) KillAllProcess(ctx *gin.Context, _ any) (err error) {
 	if isAdmin(ctx) {
 		logic.ProcessCtlLogic.KillAllProcess()
 	} else {
 		logic.ProcessCtlLogic.KillAllProcessByUserName(getUserName(ctx))
 	}
-	rOk(ctx, "Operation successful!", nil)
+	return
 }
 
-func (p *procApi) GetProcessList(ctx *gin.Context) {
+func (p *procApi) GetProcessList(ctx *gin.Context, _ any) (err error) {
 	if isAdmin(ctx) {
 		rOk(ctx, "Query successful!", logic.ProcessCtlLogic.GetProcessList())
 	} else {
 		rOk(ctx, "Query successful!", logic.ProcessCtlLogic.GetProcessListByUser(getUserName(ctx)))
 	}
+	return
 }
 
-func (p *procApi) UpdateProcessConfig(ctx *gin.Context) {
+func (p *procApi) UpdateProcessConfig(ctx *gin.Context, req model.Process) (err error) {
-	req := bind[model.Process](ctx)
 	logic.ProcessCtlLogic.UpdateProcessConfig(req)
-	err := repository.ProcessRepository.UpdateProcessConfig(req)
+	err = repository.ProcessRepository.UpdateProcessConfig(req)
-	errCheck(ctx, err != nil, err)
+	return
-	rOk(ctx, "Operation successful!", nil)
 }
 
-func (p *procApi) GetProcessConfig(ctx *gin.Context) {
+func (p *procApi) GetProcessConfig(ctx *gin.Context, req model.ProcessUuidReq) (err error) {
-	uuid := getQueryInt(ctx, "uuid")
+	data := repository.ProcessRepository.GetProcessConfigById(req.Uuid)
-	data := repository.ProcessRepository.GetProcessConfigById(uuid)
+	if data.Uuid == 0 {
-	errCheck(ctx, data.Uuid == 0, "No information found!")
+		return errors.New("no information found")
-	rOk(ctx, "Query successful!", data)
+	}
+	return
 }
 
-func (p *procApi) ProcessControl(ctx *gin.Context) {
+func (p *procApi) ProcessControl(ctx *gin.Context, req model.ProcessUuidReq) (err error) {
 	user := getUserName(ctx)
-	uuid := getQueryInt(ctx, "uuid")
+	proc, err := logic.ProcessCtlLogic.GetProcess(req.Uuid)
-	proc, err := logic.ProcessCtlLogic.GetProcess(uuid)
+	if err != nil {
-	errCheck(ctx, err != nil, err)
+		return
+	}
 	proc.ProcessControl(user)
-	rOk(ctx, "Operation successful!", nil)
+	return
 }
 
-func (p *procApi) ProcessCreateShare(ctx *gin.Context) {
+func (p *procApi) ProcessCreateShare(ctx *gin.Context, req model.ProcessShare) (err error) {
-	req := bind[model.ProcessShare](ctx)
 	token := utils.UnwarpIgnore(uuid.NewRandom()).String()
-	err := repository.WsShare.AddShareData(model.WsShare{
+	if err = repository.WsShare.AddShareData(model.WsShare{
 		ExpireTime: time.Now().Add(time.Minute * time.Duration(req.Minutes)),
 		Write:      req.Write,
 		Token:      token,
 		Pid:        req.Pid,
 		CreateBy:   getUserName(ctx),
-	})
+	}); err != nil {
-	errCheck(ctx, err != nil, err)
+		return
+	}
 	rOk(ctx, "Operation successful!", gin.H{
 		"token": token,
 	})
+	return
 }

internal/app/api/push.go

@@ -11,32 +11,27 @@ type pushApi struct{}
 
 var PushApi = new(pushApi)
 
-func (p *pushApi) GetPushList(ctx *gin.Context) {
+func (p *pushApi) GetPushList(ctx *gin.Context, __ any) (err error) {
 	rOk(ctx, "Query successful!", repository.PushRepository.GetPushList())
+	return
 }
 
-func (p *pushApi) GetPushById(ctx *gin.Context) {
+func (p *pushApi) GetPushById(ctx *gin.Context, req model.PushIdReq) (err error) {
-	id := getQueryInt(ctx, "id")
+	rOk(ctx, "Query successful!", repository.PushRepository.GetPushConfigById(req.Id))
-	rOk(ctx, "Query successful!", repository.PushRepository.GetPushConfigById(id))
+	return
 }
 
-func (p *pushApi) AddPushConfig(ctx *gin.Context) {
+func (p *pushApi) AddPushConfig(ctx *gin.Context, req model.Push) (err error) {
-	req := bind[model.Push](ctx)
+	err = repository.PushRepository.AddPushConfig(req)
-	err := repository.PushRepository.AddPushConfig(req)
+	return
-	errCheck(ctx, err != nil, err)
-	rOk(ctx, "Operation successful!", nil)
 }
 
-func (p *pushApi) UpdatePushConfig(ctx *gin.Context) {
+func (p *pushApi) UpdatePushConfig(ctx *gin.Context, req model.Push) (err error) {
-	req := bind[model.Push](ctx)
+	err = repository.PushRepository.UpdatePushConfig(req)
-	err := repository.PushRepository.UpdatePushConfig(req)
+	return
-	errCheck(ctx, err != nil, err)
-	rOk(ctx, "Operation successful!", nil)
 }
 
-func (p *pushApi) DeletePushConfig(ctx *gin.Context) {
+func (p *pushApi) DeletePushConfig(ctx *gin.Context, req model.PushIdReq) (err error) {
-	id := getQueryInt(ctx, "id")
+	err = repository.PushRepository.DeletePushConfig(req.Id)
-	err := repository.PushRepository.DeletePushConfig(id)
+	return
-	errCheck(ctx, err != nil, err)
-	rOk(ctx, "Operation successful!", nil)
 }

internal/app/api/task.go

@@ -1,6 +1,8 @@
 package api
 
 import (
+	"errors"
+
 	"github.com/lzh-1625/go_process_manager/internal/app/logic"
 	"github.com/lzh-1625/go_process_manager/internal/app/model"
 	"github.com/lzh-1625/go_process_manager/internal/app/repository"
@@ -12,62 +14,55 @@ type taskApi struct{}
 
 var TaskApi = new(taskApi)
 
-func (t *taskApi) CreateTask(ctx *gin.Context) {
+func (t *taskApi) CreateTask(ctx *gin.Context, req model.Task) (err error) {
-	req := bind[model.Task](ctx)
+	return logic.TaskLogic.CreateTask(req)
-	err := logic.TaskLogic.CreateTask(req)
-	errCheck(ctx, err != nil, err)
-	rOk(ctx, "Operation successful!", nil)
 }
 
-func (t *taskApi) GetTaskById(ctx *gin.Context) {
+func (t *taskApi) GetTaskById(ctx *gin.Context, req model.TaskIdReq) (err error) {
-	result, err := repository.TaskRepository.GetTaskById(getQueryInt(ctx, "id"))
+	result, err := repository.TaskRepository.GetTaskById(req.Id)
-	errCheck(ctx, err != nil, "Query failed!")
+	if err != nil {
+		return
+	}
 	rOk(ctx, "Operation successful!", result)
+	return
 }
 
-func (t *taskApi) GetTaskList(ctx *gin.Context) {
+func (t *taskApi) GetTaskList(ctx *gin.Context, _ any) (err error) {
 	result := logic.TaskLogic.GetAllTaskJob()
 	rOk(ctx, "Operation successful!", result)
+	return
 }
 
-func (t *taskApi) DeleteTaskById(ctx *gin.Context) {
+func (t *taskApi) DeleteTaskById(ctx *gin.Context, req model.TaskIdReq) (err error) {
-	err := logic.TaskLogic.DeleteTask(getQueryInt(ctx, "id"))
+	return logic.TaskLogic.DeleteTask(req.Id)
-	errCheck(ctx, err != nil, err)
+
-	rOk(ctx, "Operation successful!", nil)
 }
 
-func (t *taskApi) StartTask(ctx *gin.Context) {
+func (t *taskApi) StartTask(ctx *gin.Context, req model.TaskIdReq) (err error) {
-	go logic.TaskLogic.RunTaskById(getQueryInt(ctx, "id"))
+	go logic.TaskLogic.RunTaskById(req.Id)
-	rOk(ctx, "Operation successful!", nil)
+	return
 }
 
-func (t *taskApi) StopTask(ctx *gin.Context) {
+func (t *taskApi) StopTask(ctx *gin.Context, req model.TaskIdReq) (err error) {
-	errCheck(ctx, logic.TaskLogic.StopTaskJob(getQueryInt(ctx, "id")) != nil, "Operation failed!")
+	if logic.TaskLogic.StopTaskJob(req.Id) != nil {
-	rOk(ctx, "Operation successful!", nil)
+		return errors.New("operation failed")
+	}
+	return
 }
 
-func (t *taskApi) EditTask(ctx *gin.Context) {
+func (t *taskApi) EditTask(ctx *gin.Context, req model.Task) (err error) {
-	req := bind[model.Task](ctx)
+	return logic.TaskLogic.EditTask(req)
-	err := logic.TaskLogic.EditTask(req)
-	errCheck(ctx, err != nil, err)
-	rOk(ctx, "Operation successful!", nil)
 }
 
-func (t *taskApi) EditTaskEnable(ctx *gin.Context) {
+func (t *taskApi) EditTaskEnable(ctx *gin.Context, req model.Task) (err error) {
-	req := bind[model.Task](ctx)
+	return logic.TaskLogic.EditTaskEnable(req.Id, req.Enable)
-	err := logic.TaskLogic.EditTaskEnable(req.Id, req.Enable)
-	errCheck(ctx, err != nil, err)
-	rOk(ctx, "Operation successful!", nil)
 }
 
-func (t *taskApi) RunTaskByKey(ctx *gin.Context) {
+func (t *taskApi) RunTaskByKey(ctx *gin.Context, _ any) (err error) {
-	err := logic.TaskLogic.RunTaskByKey(ctx.Param("key"))
+	return logic.TaskLogic.RunTaskByKey(ctx.Param("key"))
-	errCheck(ctx, err != nil, err)
+
-	rOk(ctx, "Operation successful!", nil)
 }
 
-func (t *taskApi) CreateTaskApiKey(ctx *gin.Context) {
+func (t *taskApi) CreateTaskApiKey(ctx *gin.Context, req model.TaskIdReq) (err error) {
-	err := logic.TaskLogic.CreateApiKey(getQueryInt(ctx, "id"))
+	return logic.TaskLogic.CreateApiKey(req.Id)
-	errCheck(ctx, err != nil, err)
-	rOk(ctx, "Operation successful!", nil)
 }

internal/app/api/user.go

@@ -1,6 +1,8 @@
 package api
 
 import (
+	"errors"
+
 	"github.com/lzh-1625/go_process_manager/config"
 	"github.com/lzh-1625/go_process_manager/internal/app/constants"
 	"github.com/lzh-1625/go_process_manager/internal/app/model"
@@ -16,57 +18,65 @@ var UserApi = new(userApi)
 
 const DEFAULT_ROOT_PASSWORD = "root"
 
-func (u *userApi) LoginHandler(ctx *gin.Context) {
+func (u *userApi) LoginHandler(ctx *gin.Context, req model.LoginHandlerReq) (err error) {
-	req := bind[map[string]string](ctx)
+	if !u.checkLoginInfo(req.Account, req.Password) {
-	account := req["account"]
+		return errors.New("incorrect username or password")
-	password := req["password"]
+	}
-	errCheck(ctx, !u.checkLoginInfo(account, password), "Incorrect username or password!")
+	token, err := utils.GenToken(req.Account)
-	token, err := utils.GenToken(account)
+	if err != nil {
-	errCheck(ctx, err != nil, err)
+		return
+	}
 	rOk(ctx, "Operation successful!", gin.H{
 		"token":    token,
-		"username": account,
+		"username": req.Account,
-		"role":     repository.UserRepository.GetUserByName(account).Role,
+		"role":     repository.UserRepository.GetUserByName(req.Account).Role,
 	})
+	return
 }
 
-func (u *userApi) CreateUser(ctx *gin.Context) {
+func (u *userApi) CreateUser(ctx *gin.Context, req model.User) (err error) {
-	req := bind[model.User](ctx)
+	if req.Role == constants.ROLE_ROOT {
-	errCheck(ctx, req.Role == constants.ROLE_ROOT, "Creation of root accounts is forbidden!")
+		return errors.New("creation of root accounts is forbidden")
-	errCheck(ctx, req.Account == constants.CONSOLE, "Operation failed!")
+	}
-	errCheck(ctx, len(req.Password) < config.CF.UserPassWordMinLength, "Password is too short")
+	if req.Account == constants.CONSOLE {
-	err := repository.UserRepository.CreateUser(req)
+		return errors.New("operation failed")
-	errCheck(ctx, err != nil, err)
+	}
-	rOk(ctx, "Operation successful!", nil)
+	if len(req.Password) < config.CF.UserPassWordMinLength {
+		return errors.New("password is too short")
+	}
+	err = repository.UserRepository.CreateUser(req)
+	return
 }
 
-func (u *userApi) ChangePassword(ctx *gin.Context) {
+func (u *userApi) ChangePassword(ctx *gin.Context, req model.User) (err error) {
-	req := bind[model.User](ctx)
 	reqUser := getUserName(ctx)
-	errCheck(ctx, getRole(ctx) != constants.ROLE_ROOT && req.Account != "", "Invalid parameters!")
+	if getRole(ctx) != constants.ROLE_ROOT && req.Account != "" {
+		return errors.New("invalid parameters")
+	}
 	var userName string
 	if req.Account != "" {
 		userName = req.Account
 	} else {
 		userName = reqUser
 	}
-	errCheck(ctx, len(req.Password) < config.CF.UserPassWordMinLength, "Password is too short")
+	if len(req.Password) < config.CF.UserPassWordMinLength {
-	err := repository.UserRepository.UpdatePassword(userName, req.Password)
+		return errors.New("password is too short")
-	errCheck(ctx, err != nil, err)
+	}
-	rOk(ctx, "Operation successful!", nil)
+	err = repository.UserRepository.UpdatePassword(userName, req.Password)
-
+	return
 }
 
-func (u *userApi) DeleteUser(ctx *gin.Context) {
+func (u *userApi) DeleteUser(ctx *gin.Context, req model.User) (err error) {
-	account := getQueryString(ctx, "account")
+	if req.Account == "root" {
-	errCheck(ctx, account == "root", "Deletion of root accounts is forbidden!")
+		return errors.New("deletion of root accounts is forbidden")
-	err := repository.UserRepository.DeleteUser(account)
+	}
-	errCheck(ctx, err != nil, "Deletion of root accounts failed!")
+	err = repository.UserRepository.DeleteUser(req.Account)
-	rOk(ctx, "Operation successful!", nil)
+	return
 }
 
-func (u *userApi) GetUserList(ctx *gin.Context) {
+func (u *userApi) GetUserList(ctx *gin.Context, _ any) error {
 	rOk(ctx, "Query successful!", repository.UserRepository.GetUserList())
+	return nil
 }
 
 func (u *userApi) checkLoginInfo(account, password string) bool {

internal/app/api/ws.go

@@ -2,6 +2,7 @@ package api
 
 import (
 	"context"
+	"errors"
 	"strconv"
 	"sync"
 	"time"
@@ -9,6 +10,7 @@ import (
 	"github.com/lzh-1625/go_process_manager/config"
 	"github.com/lzh-1625/go_process_manager/internal/app/constants"
 	"github.com/lzh-1625/go_process_manager/internal/app/logic"
+	"github.com/lzh-1625/go_process_manager/internal/app/model"
 	"github.com/lzh-1625/go_process_manager/internal/app/repository"
 	"github.com/lzh-1625/go_process_manager/log"
 	"github.com/lzh-1625/go_process_manager/utils"
@@ -47,19 +49,22 @@ var upgrader = websocket.Upgrader{
 	WriteBufferSize: 1024,
 }
 
-func (w *wsApi) WebsocketHandle(ctx *gin.Context) {
+func (w *wsApi) WebsocketHandle(ctx *gin.Context, req model.WebsocketHandleReq) (err error) {
 	reqUser := getUserName(ctx)
-	uuid := getQueryInt(ctx, "uuid")
+	proc, err := logic.ProcessCtlLogic.GetProcess(req.Uuid)
-	proc, err := logic.ProcessCtlLogic.GetProcess(uuid)
+	if err != nil {
-	errCheck(ctx, err != nil, "Operation failed!")
+		return
-	errCheck(ctx, proc.HasWsConn(reqUser), "A connection already exists; unable to establish a new one!")
+	}
-	errCheck(ctx, proc.Control.Controller != reqUser && !proc.VerifyControl(), "Insufficient permissions; please check your access rights!")
+	if !proc.HasWsConn(reqUser) {
+		return errors.New("connection already exists; unable to establish a new one")
+	}
+	if proc.Control.Controller == reqUser || proc.VerifyControl() {
+		return errors.New("insufficient permissions; please check your access rights")
+	}
 	conn, err := upgrader.Upgrade(ctx.Writer, ctx.Request, nil)
-	errCheck(ctx, err != nil, "WebSocket connection upgrade failed!")
+	if err != nil {
-
+		return
-	log.Logger.AddAdditionalInfo("processName", proc.Name)
+	}
-	log.Logger.AddAdditionalInfo("userName", reqUser)
-	defer log.Logger.DeleteAdditionalInfo(2)
 
 	log.Logger.Infow("ws连接成功")
 
@@ -72,7 +77,7 @@ func (w *wsApi) WebsocketHandle(ctx *gin.Context) {
 	proc.ReadCache(wci)
 	if proc.State.State == 1 {
 		proc.SetTerminalSize(utils.GetIntByString(ctx.Query("cols")), utils.GetIntByString(ctx.Query("rows")))
-		w.startWsConnect(wci, cancel, proc, hasOprPermission(ctx, uuid, constants.OPERATION_TERMINAL_WRITE))
+		w.startWsConnect(wci, cancel, proc, hasOprPermission(ctx, req.Uuid, constants.OPERATION_TERMINAL_WRITE))
 		proc.AddConn(reqUser, wci)
 		defer proc.DeleteConn(reqUser)
 	}
@@ -89,21 +94,35 @@ func (w *wsApi) WebsocketHandle(ctx *gin.Context) {
 		log.Logger.Infow("ws连接断开", "操作类型", "tcp连接建立已被关闭")
 	}
 	conn.Close()
+	return
 }
 
-func (w *wsApi) WebsocketShareHandle(ctx *gin.Context) {
+func (w *wsApi) WebsocketShareHandle(ctx *gin.Context, req model.WebsocketHandleReq) (err error) {
-	token := getQueryString(ctx, "token")
+	data, err := repository.WsShare.GetWsShareDataByToken(req.Token)
-	data, err := repository.WsShare.GetWsShareDataByToken(token)
+	if err != nil {
-	errCheck(ctx, err != nil, "Operation failed!")
+		return
-	errCheck(ctx, data.ExpireTime.Unix() <= time.Now().Unix(), "Share expired!")
+	}
+	if data.ExpireTime.Unix() <= time.Now().Unix() {
+		return errors.New("share expired")
+	}
 	proc, err := logic.ProcessCtlLogic.GetProcess(data.Pid)
-	errCheck(ctx, err != nil, err)
+	if err != nil {
+		return
+	}
 	guestName := "guest-" + strconv.Itoa(int(data.ID)) // 构造访客用户名
-	errCheck(ctx, proc.HasWsConn(guestName), "A connection already exists; unable to establish a new one!")
+	if proc.HasWsConn(guestName) {
-	errCheck(ctx, proc.State.State != 1, "The process is currently running.")
+		return errors.New("connection already exists; unable to establish a new one")
-	errCheck(ctx, !proc.VerifyControl(), "Insufficient permissions; please check your access rights!")
+	}
+	if proc.State.State != 1 {
+		return errors.New("process is currently running")
+	}
+	if !proc.VerifyControl() {
+		return errors.New("insufficient permissions; please check your access rights")
+	}
 	conn, err := upgrader.Upgrade(ctx.Writer, ctx.Request, nil)
-	errCheck(ctx, err != nil, "WebSocket connection upgrade failed!")
+	if err != nil {
+		return
+	}
 
 	log.Logger.Infow("ws连接成功")
 	data.UpdatedAt = time.Now()
@@ -135,6 +154,7 @@ func (w *wsApi) WebsocketShareHandle(ctx *gin.Context) {
 		log.Logger.Infow("ws连接断开", "操作类型", "分享时间已结束")
 	}
 	conn.Close()
+	return
 }
 
 func (w *wsApi) startWsConnect(wci *WsConnetInstance, cancel context.CancelFunc, proc logic.Process, write bool) {
@@ -183,7 +203,8 @@ func GetWsShareList(ctx *gin.Context) {
 }
 
 func DeleteWsShareById(ctx *gin.Context) {
-	err := logic.WsSahreLogic.DeleteById(ctx.GetInt("id"))
+	if err := logic.WsSahreLogic.DeleteById(ctx.GetInt("id")); err != nil {
-	errCheck(ctx, err != nil, err)
+		return
+	}
 	rOk(ctx, "Operation successful!", nil)
 }

internal/app/constants/bind.go

@@ -1,8 +0,0 @@
-package constants
-
-const (
-	BIND_NONE          = 0
-	BIND_OPTION_HEADER = 1 << iota
-	BIND_OPTION_BODY
-	BIND_OPTION_QUERY
-)

internal/app/model/file.go

@@ -4,3 +4,11 @@ type FileStruct struct {
 	Name  string `json:"name"`
 	IsDir bool   `json:"isDir"`
 }
+
+type FilePathHandlerReq struct {
+	Path string `form:"path"`
+}
+
+type FileReadHandlerReq struct {
+	FilePath string `form:"filePath"`
+}

internal/app/model/permission.go

@@ -29,3 +29,7 @@ type PermissionPo struct {
 	Write    bool   `gorm:"column:write;NOT NULL" json:"write"`
 	Log      bool   `gorm:"column:log;NOT NULL" json:"log"`
 }
+
+type GetPermissionListReq struct {
+	Account string `form:"account"`
+}

internal/app/model/process.go

@@ -26,3 +26,7 @@ type ProcessShare struct {
 	Pid     int  `json:"pid"`
 	Write   bool `json:"write"`
 }
+
+type ProcessUuidReq struct {
+	Uuid int `form:"uuid"`
+}

internal/app/model/push_msg.go

@@ -12,3 +12,7 @@ type Push struct {
 func (*Push) TableName() string {
 	return "push"
 }
+
+type PushIdReq struct {
+	Id int `form:"id"`
+}

internal/app/model/task.go

@@ -45,3 +45,7 @@ type TaskVo struct {
 	StartTime   time.Time `json:"startTime"`
 	Running     bool      `json:"running"`
 }
+
+type TaskIdReq struct {
+	Id int `form:"id"`
+}

internal/app/model/user.go

@@ -17,3 +17,12 @@ type User struct {
 func (*User) TableName() string {
 	return "users"
 }
+
+type LoginHandlerReq struct {
+	Account  string `form:"account"`
+	Password string `form:"password"`
+}
+
+type DeleteUserReq struct {
+	Account string `form:"account"`
+}

internal/app/model/ws.go

@@ -14,3 +14,14 @@ type WsShare struct {
 	CreateBy   string    `gorm:"column:create_by" json:"createBy"`
 	Token      string    `gorm:"column:token" json:"token"`
 }
+
+func (WsShare) TableName() string {
+	return "ws_share"
+}
+
+type WebsocketHandleReq struct {
+	Uuid  int    `json:"uuid"`
+	Cols  int    `json:"cols"`
+	Rows  int    `json:"rows"`
+	Token string `json:"token"`
+}

internal/app/route/route.go

@@ -51,6 +51,7 @@ func pprofInit(r *gin.Engine) {
 }
 
 func routePathInit(r *gin.Engine) {
+
 	apiGroup := r.Group("/api")
 	apiGroup.Use(middle.CheckToken())
 	apiGroup.Use(middle.PanicMiddle())
@@ -58,107 +59,114 @@ func routePathInit(r *gin.Engine) {
 	{
 		wsGroup := apiGroup.Group("/ws")
 		{
-			wsGroup.GET("", middle.OprPermission(constants.OPERATION_TERMINAL), api.WsApi.WebsocketHandle)
+			wsGroup.GET("", middle.OprPermission(constants.OPERATION_TERMINAL), bind(api.WsApi.WebsocketHandle, Query))
-			wsGroup.GET("/share", api.WsApi.WebsocketShareHandle)
+			wsGroup.GET("/share", bind(api.WsApi.WebsocketShareHandle, Query))
 		}
 
 		processGroup := apiGroup.Group("/process")
 		{
-			processGroup.DELETE("", middle.OprPermission(constants.OPERATION_STOP), api.ProcApi.KillProcess)
+			processGroup.DELETE("", middle.OprPermission(constants.OPERATION_STOP), bind(api.ProcApi.KillProcess, Query))
-			processGroup.GET("", api.ProcApi.GetProcessList)
+			processGroup.GET("", bind(api.ProcApi.GetProcessList, None))
-			processGroup.GET("/wait", middle.ProcessWaitCond.WaitGetMiddel, api.ProcApi.GetProcessList)
+			processGroup.GET("/wait", middle.ProcessWaitCond.WaitGetMiddel, bind(api.ProcApi.GetProcessList, None))
-			processGroup.PUT("", middle.OprPermission(constants.OPERATION_START), api.ProcApi.StartProcess)
+			processGroup.PUT("", middle.OprPermission(constants.OPERATION_START), bind(api.ProcApi.StartProcess, Body))
-			processGroup.PUT("/all", api.ProcApi.StartAllProcess)
+			processGroup.PUT("/all", bind(api.ProcApi.StartAllProcess, None))
-			processGroup.DELETE("/all", api.ProcApi.KillAllProcess)
+			processGroup.DELETE("/all", bind(api.ProcApi.KillAllProcess, None))
-			processGroup.POST("/share", middle.RolePermission(constants.ROLE_ADMIN), api.ProcApi.ProcessCreateShare)
+			processGroup.POST("/share", middle.RolePermission(constants.ROLE_ADMIN), bind(api.ProcApi.ProcessCreateShare, Body))
-			processGroup.GET("/control", middle.RolePermission(constants.ROLE_ROOT), middle.ProcessWaitCond.WaitTriggerMiddel, api.ProcApi.ProcessControl)
+			processGroup.GET("/control", middle.RolePermission(constants.ROLE_ROOT), middle.ProcessWaitCond.WaitTriggerMiddel, bind(api.ProcApi.ProcessControl, Query))
 
 			proConfigGroup := processGroup.Group("/config")
 			{
-				proConfigGroup.POST("", middle.RolePermission(constants.ROLE_ROOT), middle.ProcessWaitCond.WaitTriggerMiddel, api.ProcApi.CreateNewProcess)
+				proConfigGroup.POST("", middle.RolePermission(constants.ROLE_ROOT), middle.ProcessWaitCond.WaitTriggerMiddel, bind(api.ProcApi.CreateNewProcess, Body))
-				proConfigGroup.DELETE("", middle.RolePermission(constants.ROLE_ROOT), middle.ProcessWaitCond.WaitTriggerMiddel, api.ProcApi.DeleteNewProcess)
+				proConfigGroup.DELETE("", middle.RolePermission(constants.ROLE_ROOT), middle.ProcessWaitCond.WaitTriggerMiddel, bind(api.ProcApi.DeleteNewProcess, Query))
-				proConfigGroup.PUT("", middle.RolePermission(constants.ROLE_ROOT), api.ProcApi.UpdateProcessConfig)
+				proConfigGroup.PUT("", middle.RolePermission(constants.ROLE_ROOT), bind(api.ProcApi.UpdateProcessConfig, Body))
-				proConfigGroup.GET("", middle.RolePermission(constants.ROLE_ADMIN), api.ProcApi.GetProcessConfig)
+				proConfigGroup.GET("", middle.RolePermission(constants.ROLE_ADMIN), bind(api.ProcApi.GetProcessConfig, Query))
 			}
 		}
 
 		taskGroup := apiGroup.Group("/task")
 		{
-			taskGroup.GET("", middle.RolePermission(constants.ROLE_ADMIN), api.TaskApi.GetTaskById)
+			taskGroup.GET("", middle.RolePermission(constants.ROLE_ADMIN), bind(api.TaskApi.GetTaskById, Query))
-			taskGroup.GET("/all", middle.RolePermission(constants.ROLE_ADMIN), api.TaskApi.GetTaskList)
+			taskGroup.GET("/all", middle.RolePermission(constants.ROLE_ADMIN), bind(api.TaskApi.GetTaskList, None))
-			taskGroup.GET("/all/wait", middle.RolePermission(constants.ROLE_ADMIN), middle.TaskWaitCond.WaitGetMiddel, api.TaskApi.GetTaskList)
+			taskGroup.GET("/all/wait", middle.RolePermission(constants.ROLE_ADMIN), middle.TaskWaitCond.WaitGetMiddel, bind(api.TaskApi.GetTaskList, None))
-			taskGroup.POST("", middle.RolePermission(constants.ROLE_ADMIN), middle.TaskWaitCond.WaitTriggerMiddel, api.TaskApi.CreateTask)
+			taskGroup.POST("", middle.RolePermission(constants.ROLE_ADMIN), middle.TaskWaitCond.WaitTriggerMiddel, bind(api.TaskApi.CreateTask, Body))
-			taskGroup.DELETE("", middle.RolePermission(constants.ROLE_ADMIN), middle.TaskWaitCond.WaitTriggerMiddel, api.TaskApi.DeleteTaskById)
+			taskGroup.DELETE("", middle.RolePermission(constants.ROLE_ADMIN), middle.TaskWaitCond.WaitTriggerMiddel, bind(api.TaskApi.DeleteTaskById, Query))
-			taskGroup.PUT("", middle.RolePermission(constants.ROLE_ADMIN), middle.TaskWaitCond.WaitTriggerMiddel, api.TaskApi.EditTask)
+			taskGroup.PUT("", middle.RolePermission(constants.ROLE_ADMIN), middle.TaskWaitCond.WaitTriggerMiddel, bind(api.TaskApi.EditTask, Body))
-			taskGroup.PUT("/enable", middle.RolePermission(constants.ROLE_ADMIN), middle.TaskWaitCond.WaitTriggerMiddel, api.TaskApi.EditTaskEnable)
+			taskGroup.PUT("/enable", middle.RolePermission(constants.ROLE_ADMIN), middle.TaskWaitCond.WaitTriggerMiddel, bind(api.TaskApi.EditTaskEnable, Body))
-			taskGroup.GET("/start", middle.RolePermission(constants.ROLE_ADMIN), api.TaskApi.StartTask)
+			taskGroup.GET("/start", middle.RolePermission(constants.ROLE_ADMIN), bind(api.TaskApi.StartTask, Query))
-			taskGroup.GET("/stop", middle.RolePermission(constants.ROLE_ADMIN), api.TaskApi.StopTask)
+			taskGroup.GET("/stop", middle.RolePermission(constants.ROLE_ADMIN), bind(api.TaskApi.StopTask, Query))
-			taskGroup.POST("/key", middle.RolePermission(constants.ROLE_ADMIN), api.TaskApi.CreateTaskApiKey)
+			taskGroup.POST("/key", middle.RolePermission(constants.ROLE_ADMIN), bind(api.TaskApi.CreateTaskApiKey, Body))
-			taskGroup.GET("/api-key/:key", api.TaskApi.RunTaskByKey)
+			taskGroup.GET("/api-key/:key", bind(api.TaskApi.RunTaskByKey, None))
 		}
 
 		userGroup := apiGroup.Group("/user")
 		{
-			userGroup.POST("/login", api.UserApi.LoginHandler)
+			userGroup.POST("/login", bind(api.UserApi.LoginHandler, Body))
-			userGroup.POST("", middle.RolePermission(constants.ROLE_ROOT), api.UserApi.CreateUser)
+			userGroup.POST("", middle.RolePermission(constants.ROLE_ROOT), bind(api.UserApi.CreateUser, Body))
-			userGroup.PUT("/password", middle.RolePermission(constants.ROLE_USER), api.UserApi.ChangePassword)
+			userGroup.PUT("/password", middle.RolePermission(constants.ROLE_USER), bind(api.UserApi.ChangePassword, Body))
-			userGroup.DELETE("", middle.RolePermission(constants.ROLE_ROOT), api.UserApi.DeleteUser)
+			userGroup.DELETE("", middle.RolePermission(constants.ROLE_ROOT), bind(api.UserApi.DeleteUser, Query))
-			userGroup.GET("", middle.RolePermission(constants.ROLE_ROOT), api.UserApi.GetUserList)
+			userGroup.GET("", middle.RolePermission(constants.ROLE_ROOT), bind(api.UserApi.GetUserList, None))
 		}
 
 		pushGroup := apiGroup.Group("/push").Use(middle.RolePermission(constants.ROLE_ADMIN))
 		{
-			pushGroup.GET("/list", api.PushApi.GetPushList)
+			pushGroup.GET("/list", bind(api.PushApi.GetPushList, None))
-			pushGroup.GET("", api.PushApi.GetPushById)
+			pushGroup.GET("", bind(api.PushApi.GetPushById, Query))
-			pushGroup.POST("", api.PushApi.AddPushConfig)
+			pushGroup.POST("", bind(api.PushApi.AddPushConfig, Body))
-			pushGroup.PUT("", api.PushApi.UpdatePushConfig)
+			pushGroup.PUT("", bind(api.PushApi.UpdatePushConfig, Body))
-			pushGroup.DELETE("", api.PushApi.DeletePushConfig)
+			pushGroup.DELETE("", bind(api.PushApi.DeletePushConfig, Query))
 		}
 
 		fileGroup := apiGroup.Group("/file").Use(middle.RolePermission(constants.ROLE_ADMIN))
 		{
-			fileGroup.GET("/list", api.FileApi.FilePathHandler)
+			fileGroup.GET("/list", bind(api.FileApi.FilePathHandler, Query))
-			fileGroup.PUT("", api.FileApi.FileWriteHandler)
+			fileGroup.PUT("", bind(api.FileApi.FileWriteHandler, None))
-			fileGroup.GET("", api.FileApi.FileReadHandler)
+			fileGroup.GET("", bind(api.FileApi.FileReadHandler, Query))
 		}
 
 		permissionGroup := apiGroup.Group("/permission").Use(middle.RolePermission(constants.ROLE_ROOT))
 		{
-			permissionGroup.GET("/list", api.PermissionApi.GetPermissionList)
+			permissionGroup.GET("/list", bind(api.PermissionApi.GetPermissionList, Query))
-			permissionGroup.PUT("", middle.ProcessWaitCond.WaitTriggerMiddel, api.PermissionApi.EditPermssion)
+			permissionGroup.PUT("", middle.ProcessWaitCond.WaitTriggerMiddel, bind(api.PermissionApi.EditPermssion, Body))
 		}
 
 		logGroup := apiGroup.Group("/log").Use(middle.RolePermission(constants.ROLE_USER))
 		{
-			logGroup.POST("", api.LogApi.GetLog)
+			logGroup.POST("", bind(api.LogApi.GetLog, Body))
-			logGroup.GET("/running", api.LogApi.GetRunningLog)
+			logGroup.GET("/running", bind(api.LogApi.GetRunningLog, None))
 		}
 
 		configGroup := apiGroup.Group("/config").Use(middle.RolePermission(constants.ROLE_ROOT))
 		{
-			configGroup.GET("", api.ConfigApi.GetSystemConfiguration)
+			configGroup.GET("", bind(api.ConfigApi.GetSystemConfiguration, None))
-			configGroup.PUT("", api.ConfigApi.SetSystemConfiguration)
+			configGroup.PUT("", bind(api.ConfigApi.SetSystemConfiguration, None))
-			configGroup.PUT("/es", api.ConfigApi.EsConfigReload)
+			configGroup.PUT("/es", bind(api.ConfigApi.EsConfigReload, None))
 		}
 	}
 }
 
-func bind[T any](fn func(*gin.Context, *T) error, bindOption int) func(*gin.Context) {
+const (
+	None   = 0
+	Header = 1 << iota
+	Body
+	Query
+)
+
+func bind[T any](fn func(*gin.Context, T) error, bindOption int) func(*gin.Context) {
 	return func(ctx *gin.Context) {
-		var req *T
+		var req T
-		if bindOption&constants.BIND_OPTION_BODY != 0 {
+		if bindOption&Body != 0 {
 			if err := ctx.BindJSON(req); err != nil {
 				rErr(ctx, err)
 				return
 			}
 		}
-		if bindOption&constants.BIND_OPTION_HEADER != 0 {
+		if bindOption&Header != 0 {
 			if err := ctx.BindHeader(req); err != nil {
 				rErr(ctx, err)
 				return
 			}
 		}
-		if bindOption&constants.BIND_OPTION_QUERY != 0 {
+		if bindOption&Query != 0 {
 			if err := ctx.BindQuery(req); err != nil {
 				rErr(ctx, err)
 				return
@@ -167,9 +175,15 @@ func bind[T any](fn func(*gin.Context, *T) error, bindOption int) func(*gin.Cont
 		err := fn(ctx, req)
 		if err != nil {
 			rErr(ctx, err)
+			return
+		}
+		if ctx.Writer.Status() == 0 {
+			ctx.JSON(200, gin.H{
+				"code":    0,
+				"message": "success",
+			})
 		}
 	}
-
 }
 
 func rErr(ctx *gin.Context, err error) {