feat:1.数据库建表+增删改查接口

README.md

@@ -1,6 +1,6 @@
 # udeServer
 
-基于 [go-zero](https://go-zero.dev/) 的 HTTP API 服务。项目由 `goctl` 生成，包含示例接口 `GET /from/:name` 和数据库连通性检查接口 `GET /db/ping`。
+基于 [go-zero](https://go-zero.dev/) 的 HTTP API 服务。项目由 `goctl` 生成，包含示例接口、数据库连通性检查，以及 `t_directory`、`t_key`、`t_service` 三张表的完整 CRUD 接口。
 
 ## 技术栈
 
@@ -20,9 +20,11 @@
 ├── etc/
 │   └── udeserver-api.yaml     # 配置文件
 ├── internal/
+│   ├── apierr/                # HTTP 状态码错误封装
 │   ├── config/                # 配置结构体
 │   ├── handler/               # HTTP handler 与路由注册
 │   ├── logic/                 # 业务逻辑
+│   ├── model/                 # goctl 生成的 model 与自定义查询
 │   ├── svc/                   # ServiceContext，管理依赖
 │   └── types/                 # 请求/响应类型
 ├── go.mod
@@ -60,6 +62,43 @@ go build -o bin/udeserver.exe udeserver.go
 .\bin\udeserver.exe -f etc\udeserver-api.yaml
 ```
 
+## API 接口
+
+三张表各有一组 CRUD 接口：
+
+| 资源 | 新增 | 列表 | 详情 | 更新 | 删除 |
+| --- | --- | --- | --- | --- | --- |
+| 保护目录 `t_directory` | `POST /directories` | `GET /directories` | `GET /directories/:id` | `PUT /directories/:id` | `DELETE /directories/:id` |
+| 密钥 `t_key` | `POST /keys` | `GET /keys` | `GET /keys/:id` | `PUT /keys/:id` | `DELETE /keys/:id` |
+| 服务 `t_service` | `POST /services` | `GET /services` | `GET /services/:id` | `PUT /services/:id` | `DELETE /services/:id` |
+
+服务接口示例：
+
+```powershell
+# 新增：id 必填，三张表的主键都没有 AUTO_INCREMENT
+curl -X POST http://127.0.0.1:8080/services `
+  -H "Content-Type: application/json" `
+  -d "{\"id\":1,\"name\":\"demo\",\"ip\":\"10.0.0.1\",\"port\":\"8080\",\"iden\":\"svc-1\",\"keyIden\":\"key-1\",\"keyAlgo\":\"AES\",\"status\":\"active\"}"
+
+# 列表 / 详情
+curl http://127.0.0.1:8080/services
+curl http://127.0.0.1:8080/services/1
+
+# 更新：id 放在路径中，请求体为完整字段
+curl -X PUT http://127.0.0.1:8080/services/1 `
+  -H "Content-Type: application/json" `
+  -d "{\"name\":\"demo-updated\",\"ip\":\"10.0.0.2\",\"port\":\"9090\",\"iden\":\"svc-1\",\"keyIden\":\"key-1\",\"keyAlgo\":\"SM4\",\"status\":\"disabled\"}"
+
+# 删除
+curl -X DELETE http://127.0.0.1:8080/services/1
+```
+
+说明：
+
+- `PUT` 为全量更新，未传的可选字段会写成 `NULL`（空字符串、`serviceId=0` 均按 `NULL` 处理）。
+- 列表接口返回全部数据，暂未分页。
+- 错误响应统一为 `{"code":404,"msg":"service id=1 not found"}` 格式。
+
 ## 修改接口
 
 1. 编辑 `udeServer.api`（新增 type、service、路由）。
@@ -101,7 +140,9 @@ var count int64
 err := l.svcCtx.DB.QueryRowCtx(l.ctx, &count, "SELECT COUNT(*) FROM your_table")
 ```
 
-- 当前 `ude` 库中还没有表，因此暂未生成 model。建表后可按表生成：
+- 已为三张表生成 model（`internal/model/`）：`TDirectoryModel`、`TKeyModel`、`TServiceModel`，并在自定义 model 文件中补充了列表查询 `FindAll`。
+- 三张表的主键都是普通 `int`，没有 `AUTO_INCREMENT`，因此新增接口必须显式传 `id`。
+- 新增表后可按表继续生成 model：
 
 ```powershell
 C:\Users\Administrator\go\bin\goctl.exe model mysql datasource ^

internal/apierr/apierr.go

@@ -0,0 +1,43 @@
+// Package apierr provides HTTP-aware errors and a default error handler.
+package apierr
+
+import (
+	"errors"
+	"fmt"
+	"net/http"
+)
+
+// Error carries the HTTP status code that should be returned to the client.
+type Error struct {
+	Status int
+	Msg    string
+}
+
+func (e *Error) Error() string {
+	return e.Msg
+}
+
+// New returns an error with the given HTTP status code.
+func New(status int, msg string) error {
+	return &Error{Status: status, Msg: msg}
+}
+
+// BadRequest returns a 400 error.
+func BadRequest(format string, args ...any) error {
+	return New(http.StatusBadRequest, fmt.Sprintf(format, args...))
+}
+
+// NotFound returns a 404 error.
+func NotFound(kind string, id int64) error {
+	return New(http.StatusNotFound, fmt.Sprintf("%s id=%d not found", kind, id))
+}
+
+// Status resolves the HTTP status code of err.
+func Status(err error) int {
+	var e *Error
+	if errors.As(err, &e) {
+		return e.Status
+	}
+
+	return http.StatusBadRequest
+}

internal/handler/createdirectoryhandler.go

@@ -0,0 +1,31 @@
+// Code scaffolded by goctl. Safe to edit.
+// goctl 1.10.2
+
+package handler
+
+import (
+	"net/http"
+
+	"github.com/zeromicro/go-zero/rest/httpx"
+	"udeServer/internal/logic"
+	"udeServer/internal/svc"
+	"udeServer/internal/types"
+)
+
+func CreateDirectoryHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var req types.CreateDirectoryReq
+		if err := httpx.Parse(r, &req); err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+			return
+		}
+
+		l := logic.NewCreateDirectoryLogic(r.Context(), svcCtx)
+		resp, err := l.CreateDirectory(&req)
+		if err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+		} else {
+			httpx.OkJsonCtx(r.Context(), w, resp)
+		}
+	}
+}

internal/handler/createkeyhandler.go

@@ -0,0 +1,31 @@
+// Code scaffolded by goctl. Safe to edit.
+// goctl 1.10.2
+
+package handler
+
+import (
+	"net/http"
+
+	"github.com/zeromicro/go-zero/rest/httpx"
+	"udeServer/internal/logic"
+	"udeServer/internal/svc"
+	"udeServer/internal/types"
+)
+
+func CreateKeyHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var req types.CreateKeyReq
+		if err := httpx.Parse(r, &req); err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+			return
+		}
+
+		l := logic.NewCreateKeyLogic(r.Context(), svcCtx)
+		resp, err := l.CreateKey(&req)
+		if err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+		} else {
+			httpx.OkJsonCtx(r.Context(), w, resp)
+		}
+	}
+}

internal/handler/createservicehandler.go

@@ -0,0 +1,31 @@
+// Code scaffolded by goctl. Safe to edit.
+// goctl 1.10.2
+
+package handler
+
+import (
+	"net/http"
+
+	"github.com/zeromicro/go-zero/rest/httpx"
+	"udeServer/internal/logic"
+	"udeServer/internal/svc"
+	"udeServer/internal/types"
+)
+
+func CreateServiceHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var req types.CreateServiceReq
+		if err := httpx.Parse(r, &req); err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+			return
+		}
+
+		l := logic.NewCreateServiceLogic(r.Context(), svcCtx)
+		resp, err := l.CreateService(&req)
+		if err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+		} else {
+			httpx.OkJsonCtx(r.Context(), w, resp)
+		}
+	}
+}

internal/handler/dbpinghandler.go

@@ -6,9 +6,10 @@ package handler
 import (
 	"net/http"
 
-	"github.com/zeromicro/go-zero/rest/httpx"
 	"udeServer/internal/logic"
 	"udeServer/internal/svc"
+
+	"github.com/zeromicro/go-zero/rest/httpx"
 )
 
 func DbPingHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {

internal/handler/deletedirectoryhandler.go

@@ -0,0 +1,31 @@
+// Code scaffolded by goctl. Safe to edit.
+// goctl 1.10.2
+
+package handler
+
+import (
+	"net/http"
+
+	"github.com/zeromicro/go-zero/rest/httpx"
+	"udeServer/internal/logic"
+	"udeServer/internal/svc"
+	"udeServer/internal/types"
+)
+
+func DeleteDirectoryHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var req types.DirectoryIdReq
+		if err := httpx.Parse(r, &req); err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+			return
+		}
+
+		l := logic.NewDeleteDirectoryLogic(r.Context(), svcCtx)
+		resp, err := l.DeleteDirectory(&req)
+		if err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+		} else {
+			httpx.OkJsonCtx(r.Context(), w, resp)
+		}
+	}
+}

internal/handler/deletekeyhandler.go

@@ -0,0 +1,31 @@
+// Code scaffolded by goctl. Safe to edit.
+// goctl 1.10.2
+
+package handler
+
+import (
+	"net/http"
+
+	"github.com/zeromicro/go-zero/rest/httpx"
+	"udeServer/internal/logic"
+	"udeServer/internal/svc"
+	"udeServer/internal/types"
+)
+
+func DeleteKeyHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var req types.KeyIdReq
+		if err := httpx.Parse(r, &req); err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+			return
+		}
+
+		l := logic.NewDeleteKeyLogic(r.Context(), svcCtx)
+		resp, err := l.DeleteKey(&req)
+		if err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+		} else {
+			httpx.OkJsonCtx(r.Context(), w, resp)
+		}
+	}
+}

internal/handler/deleteservicehandler.go

@@ -0,0 +1,31 @@
+// Code scaffolded by goctl. Safe to edit.
+// goctl 1.10.2
+
+package handler
+
+import (
+	"net/http"
+
+	"github.com/zeromicro/go-zero/rest/httpx"
+	"udeServer/internal/logic"
+	"udeServer/internal/svc"
+	"udeServer/internal/types"
+)
+
+func DeleteServiceHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var req types.ServiceIdReq
+		if err := httpx.Parse(r, &req); err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+			return
+		}
+
+		l := logic.NewDeleteServiceLogic(r.Context(), svcCtx)
+		resp, err := l.DeleteService(&req)
+		if err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+		} else {
+			httpx.OkJsonCtx(r.Context(), w, resp)
+		}
+	}
+}

internal/handler/getdirectoryhandler.go

@@ -0,0 +1,31 @@
+// Code scaffolded by goctl. Safe to edit.
+// goctl 1.10.2
+
+package handler
+
+import (
+	"net/http"
+
+	"github.com/zeromicro/go-zero/rest/httpx"
+	"udeServer/internal/logic"
+	"udeServer/internal/svc"
+	"udeServer/internal/types"
+)
+
+func GetDirectoryHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var req types.DirectoryIdReq
+		if err := httpx.Parse(r, &req); err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+			return
+		}
+
+		l := logic.NewGetDirectoryLogic(r.Context(), svcCtx)
+		resp, err := l.GetDirectory(&req)
+		if err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+		} else {
+			httpx.OkJsonCtx(r.Context(), w, resp)
+		}
+	}
+}

internal/handler/getkeyhandler.go

@@ -0,0 +1,31 @@
+// Code scaffolded by goctl. Safe to edit.
+// goctl 1.10.2
+
+package handler
+
+import (
+	"net/http"
+
+	"github.com/zeromicro/go-zero/rest/httpx"
+	"udeServer/internal/logic"
+	"udeServer/internal/svc"
+	"udeServer/internal/types"
+)
+
+func GetKeyHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var req types.KeyIdReq
+		if err := httpx.Parse(r, &req); err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+			return
+		}
+
+		l := logic.NewGetKeyLogic(r.Context(), svcCtx)
+		resp, err := l.GetKey(&req)
+		if err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+		} else {
+			httpx.OkJsonCtx(r.Context(), w, resp)
+		}
+	}
+}

internal/handler/getservicehandler.go

@@ -0,0 +1,31 @@
+// Code scaffolded by goctl. Safe to edit.
+// goctl 1.10.2
+
+package handler
+
+import (
+	"net/http"
+
+	"github.com/zeromicro/go-zero/rest/httpx"
+	"udeServer/internal/logic"
+	"udeServer/internal/svc"
+	"udeServer/internal/types"
+)
+
+func GetServiceHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var req types.ServiceIdReq
+		if err := httpx.Parse(r, &req); err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+			return
+		}
+
+		l := logic.NewGetServiceLogic(r.Context(), svcCtx)
+		resp, err := l.GetService(&req)
+		if err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+		} else {
+			httpx.OkJsonCtx(r.Context(), w, resp)
+		}
+	}
+}

internal/handler/listdirectorieshandler.go

@@ -0,0 +1,24 @@
+// Code scaffolded by goctl. Safe to edit.
+// goctl 1.10.2
+
+package handler
+
+import (
+	"net/http"
+
+	"github.com/zeromicro/go-zero/rest/httpx"
+	"udeServer/internal/logic"
+	"udeServer/internal/svc"
+)
+
+func ListDirectoriesHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		l := logic.NewListDirectoriesLogic(r.Context(), svcCtx)
+		resp, err := l.ListDirectories()
+		if err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+		} else {
+			httpx.OkJsonCtx(r.Context(), w, resp)
+		}
+	}
+}

internal/handler/listkeyshandler.go

@@ -0,0 +1,24 @@
+// Code scaffolded by goctl. Safe to edit.
+// goctl 1.10.2
+
+package handler
+
+import (
+	"net/http"
+
+	"github.com/zeromicro/go-zero/rest/httpx"
+	"udeServer/internal/logic"
+	"udeServer/internal/svc"
+)
+
+func ListKeysHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		l := logic.NewListKeysLogic(r.Context(), svcCtx)
+		resp, err := l.ListKeys()
+		if err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+		} else {
+			httpx.OkJsonCtx(r.Context(), w, resp)
+		}
+	}
+}

internal/handler/listserviceshandler.go

@@ -0,0 +1,24 @@
+// Code scaffolded by goctl. Safe to edit.
+// goctl 1.10.2
+
+package handler
+
+import (
+	"net/http"
+
+	"github.com/zeromicro/go-zero/rest/httpx"
+	"udeServer/internal/logic"
+	"udeServer/internal/svc"
+)
+
+func ListServicesHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		l := logic.NewListServicesLogic(r.Context(), svcCtx)
+		resp, err := l.ListServices()
+		if err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+		} else {
+			httpx.OkJsonCtx(r.Context(), w, resp)
+		}
+	}
+}

internal/handler/routes.go

@@ -19,11 +19,86 @@ func RegisterHandlers(server *rest.Server, serverCtx *svc.ServiceContext) {
 				Path:    "/db/ping",
 				Handler: DbPingHandler(serverCtx),
 			},
+			{
+				Method:  http.MethodPost,
+				Path:    "/directories",
+				Handler: CreateDirectoryHandler(serverCtx),
+			},
+			{
+				Method:  http.MethodGet,
+				Path:    "/directories",
+				Handler: ListDirectoriesHandler(serverCtx),
+			},
+			{
+				Method:  http.MethodGet,
+				Path:    "/directories/:id",
+				Handler: GetDirectoryHandler(serverCtx),
+			},
+			{
+				Method:  http.MethodPut,
+				Path:    "/directories/:id",
+				Handler: UpdateDirectoryHandler(serverCtx),
+			},
+			{
+				Method:  http.MethodDelete,
+				Path:    "/directories/:id",
+				Handler: DeleteDirectoryHandler(serverCtx),
+			},
 			{
 				Method:  http.MethodGet,
 				Path:    "/from/:name",
 				Handler: UdeServerHandler(serverCtx),
 			},
+			{
+				Method:  http.MethodPost,
+				Path:    "/keys",
+				Handler: CreateKeyHandler(serverCtx),
+			},
+			{
+				Method:  http.MethodGet,
+				Path:    "/keys",
+				Handler: ListKeysHandler(serverCtx),
+			},
+			{
+				Method:  http.MethodGet,
+				Path:    "/keys/:id",
+				Handler: GetKeyHandler(serverCtx),
+			},
+			{
+				Method:  http.MethodPut,
+				Path:    "/keys/:id",
+				Handler: UpdateKeyHandler(serverCtx),
+			},
+			{
+				Method:  http.MethodDelete,
+				Path:    "/keys/:id",
+				Handler: DeleteKeyHandler(serverCtx),
+			},
+			{
+				Method:  http.MethodPost,
+				Path:    "/services",
+				Handler: CreateServiceHandler(serverCtx),
+			},
+			{
+				Method:  http.MethodGet,
+				Path:    "/services",
+				Handler: ListServicesHandler(serverCtx),
+			},
+			{
+				Method:  http.MethodGet,
+				Path:    "/services/:id",
+				Handler: GetServiceHandler(serverCtx),
+			},
+			{
+				Method:  http.MethodPut,
+				Path:    "/services/:id",
+				Handler: UpdateServiceHandler(serverCtx),
+			},
+			{
+				Method:  http.MethodDelete,
+				Path:    "/services/:id",
+				Handler: DeleteServiceHandler(serverCtx),
+			},
 		},
 	)
 }

internal/handler/updatedirectoryhandler.go

@@ -0,0 +1,31 @@
+// Code scaffolded by goctl. Safe to edit.
+// goctl 1.10.2
+
+package handler
+
+import (
+	"net/http"
+
+	"github.com/zeromicro/go-zero/rest/httpx"
+	"udeServer/internal/logic"
+	"udeServer/internal/svc"
+	"udeServer/internal/types"
+)
+
+func UpdateDirectoryHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var req types.UpdateDirectoryReq
+		if err := httpx.Parse(r, &req); err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+			return
+		}
+
+		l := logic.NewUpdateDirectoryLogic(r.Context(), svcCtx)
+		resp, err := l.UpdateDirectory(&req)
+		if err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+		} else {
+			httpx.OkJsonCtx(r.Context(), w, resp)
+		}
+	}
+}

internal/handler/updatekeyhandler.go

@@ -0,0 +1,31 @@
+// Code scaffolded by goctl. Safe to edit.
+// goctl 1.10.2
+
+package handler
+
+import (
+	"net/http"
+
+	"github.com/zeromicro/go-zero/rest/httpx"
+	"udeServer/internal/logic"
+	"udeServer/internal/svc"
+	"udeServer/internal/types"
+)
+
+func UpdateKeyHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var req types.UpdateKeyReq
+		if err := httpx.Parse(r, &req); err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+			return
+		}
+
+		l := logic.NewUpdateKeyLogic(r.Context(), svcCtx)
+		resp, err := l.UpdateKey(&req)
+		if err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+		} else {
+			httpx.OkJsonCtx(r.Context(), w, resp)
+		}
+	}
+}

internal/handler/updateservicehandler.go

@@ -0,0 +1,31 @@
+// Code scaffolded by goctl. Safe to edit.
+// goctl 1.10.2
+
+package handler
+
+import (
+	"net/http"
+
+	"github.com/zeromicro/go-zero/rest/httpx"
+	"udeServer/internal/logic"
+	"udeServer/internal/svc"
+	"udeServer/internal/types"
+)
+
+func UpdateServiceHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var req types.UpdateServiceReq
+		if err := httpx.Parse(r, &req); err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+			return
+		}
+
+		l := logic.NewUpdateServiceLogic(r.Context(), svcCtx)
+		resp, err := l.UpdateService(&req)
+		if err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+		} else {
+			httpx.OkJsonCtx(r.Context(), w, resp)
+		}
+	}
+}

internal/logic/createdirectorylogic.go

@@ -0,0 +1,51 @@
+// Code scaffolded by goctl. Safe to edit.
+// goctl 1.10.2
+
+package logic
+
+import (
+	"context"
+
+	"udeServer/internal/model"
+	"udeServer/internal/svc"
+	"udeServer/internal/types"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type CreateDirectoryLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewCreateDirectoryLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CreateDirectoryLogic {
+	return &CreateDirectoryLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *CreateDirectoryLogic) CreateDirectory(req *types.CreateDirectoryReq) (*types.DirectoryResp, error) {
+	if err := checkId(req.Id); err != nil {
+		return nil, err
+	}
+
+	data := &model.TDirectory{
+		Id:        req.Id,
+		ServiceId: nullInt64(req.ServiceId),
+		Directory: nullString(req.Directory),
+	}
+	if _, err := l.svcCtx.DirectoryModel.Insert(l.ctx, data); err != nil {
+		l.Errorf("insert directory %d failed: %v", req.Id, err)
+		return nil, err
+	}
+
+	created, err := findDirectory(l.ctx, l.svcCtx.DirectoryModel, req.Id)
+	if err != nil {
+		return nil, err
+	}
+
+	return toDirectoryResp(created), nil
+}

internal/logic/createkeylogic.go

@@ -0,0 +1,53 @@
+// Code scaffolded by goctl. Safe to edit.
+// goctl 1.10.2
+
+package logic
+
+import (
+	"context"
+
+	"udeServer/internal/model"
+	"udeServer/internal/svc"
+	"udeServer/internal/types"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type CreateKeyLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewCreateKeyLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CreateKeyLogic {
+	return &CreateKeyLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *CreateKeyLogic) CreateKey(req *types.CreateKeyReq) (*types.KeyResp, error) {
+	if err := checkId(req.Id); err != nil {
+		return nil, err
+	}
+
+	data := &model.TKey{
+		Id:      req.Id,
+		Iden:    nullString(req.Iden),
+		Name:    nullString(req.Name),
+		Content: nullString(req.Content),
+		Status:  nullString(req.Status),
+	}
+	if _, err := l.svcCtx.KeyModel.Insert(l.ctx, data); err != nil {
+		l.Errorf("insert key %d failed: %v", req.Id, err)
+		return nil, err
+	}
+
+	created, err := findKey(l.ctx, l.svcCtx.KeyModel, req.Id)
+	if err != nil {
+		return nil, err
+	}
+
+	return toKeyResp(created), nil
+}

internal/logic/createservicelogic.go

@@ -0,0 +1,56 @@
+// Code scaffolded by goctl. Safe to edit.
+// goctl 1.10.2
+
+package logic
+
+import (
+	"context"
+
+	"udeServer/internal/model"
+	"udeServer/internal/svc"
+	"udeServer/internal/types"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type CreateServiceLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewCreateServiceLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CreateServiceLogic {
+	return &CreateServiceLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *CreateServiceLogic) CreateService(req *types.CreateServiceReq) (*types.ServiceResp, error) {
+	if err := checkId(req.Id); err != nil {
+		return nil, err
+	}
+
+	data := &model.TService{
+		Id:      req.Id,
+		Name:    nullString(req.Name),
+		Ip:      nullString(req.Ip),
+		Port:    nullString(req.Port),
+		Iden:    nullString(req.Iden),
+		KeyIden: nullString(req.KeyIden),
+		KeyAlgo: nullString(req.KeyAlgo),
+		Status:  nullString(req.Status),
+	}
+	if _, err := l.svcCtx.ServiceModel.Insert(l.ctx, data); err != nil {
+		l.Errorf("insert service %d failed: %v", req.Id, err)
+		return nil, err
+	}
+
+	created, err := findService(l.ctx, l.svcCtx.ServiceModel, req.Id)
+	if err != nil {
+		return nil, err
+	}
+
+	return toServiceResp(created), nil
+}

internal/logic/deletedirectorylogic.go

@@ -0,0 +1,43 @@
+// Code scaffolded by goctl. Safe to edit.
+// goctl 1.10.2
+
+package logic
+
+import (
+	"context"
+
+	"udeServer/internal/svc"
+	"udeServer/internal/types"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type DeleteDirectoryLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewDeleteDirectoryLogic(ctx context.Context, svcCtx *svc.ServiceContext) *DeleteDirectoryLogic {
+	return &DeleteDirectoryLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *DeleteDirectoryLogic) DeleteDirectory(req *types.DirectoryIdReq) (*types.DeleteResp, error) {
+	if err := checkId(req.Id); err != nil {
+		return nil, err
+	}
+	if _, err := findDirectory(l.ctx, l.svcCtx.DirectoryModel, req.Id); err != nil {
+		return nil, err
+	}
+
+	if err := l.svcCtx.DirectoryModel.Delete(l.ctx, req.Id); err != nil {
+		l.Errorf("delete directory %d failed: %v", req.Id, err)
+		return nil, err
+	}
+
+	return &types.DeleteResp{Ok: true}, nil
+}

internal/logic/deletekeylogic.go

@@ -0,0 +1,43 @@
+// Code scaffolded by goctl. Safe to edit.
+// goctl 1.10.2
+
+package logic
+
+import (
+	"context"
+
+	"udeServer/internal/svc"
+	"udeServer/internal/types"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type DeleteKeyLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewDeleteKeyLogic(ctx context.Context, svcCtx *svc.ServiceContext) *DeleteKeyLogic {
+	return &DeleteKeyLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *DeleteKeyLogic) DeleteKey(req *types.KeyIdReq) (*types.DeleteResp, error) {
+	if err := checkId(req.Id); err != nil {
+		return nil, err
+	}
+	if _, err := findKey(l.ctx, l.svcCtx.KeyModel, req.Id); err != nil {
+		return nil, err
+	}
+
+	if err := l.svcCtx.KeyModel.Delete(l.ctx, req.Id); err != nil {
+		l.Errorf("delete key %d failed: %v", req.Id, err)
+		return nil, err
+	}
+
+	return &types.DeleteResp{Ok: true}, nil
+}

internal/logic/deleteservicelogic.go

@@ -0,0 +1,43 @@
+// Code scaffolded by goctl. Safe to edit.
+// goctl 1.10.2
+
+package logic
+
+import (
+	"context"
+
+	"udeServer/internal/svc"
+	"udeServer/internal/types"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type DeleteServiceLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewDeleteServiceLogic(ctx context.Context, svcCtx *svc.ServiceContext) *DeleteServiceLogic {
+	return &DeleteServiceLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *DeleteServiceLogic) DeleteService(req *types.ServiceIdReq) (*types.DeleteResp, error) {
+	if err := checkId(req.Id); err != nil {
+		return nil, err
+	}
+	if _, err := findService(l.ctx, l.svcCtx.ServiceModel, req.Id); err != nil {
+		return nil, err
+	}
+
+	if err := l.svcCtx.ServiceModel.Delete(l.ctx, req.Id); err != nil {
+		l.Errorf("delete service %d failed: %v", req.Id, err)
+		return nil, err
+	}
+
+	return &types.DeleteResp{Ok: true}, nil
+}

internal/logic/getdirectorylogic.go

@@ -0,0 +1,40 @@
+// Code scaffolded by goctl. Safe to edit.
+// goctl 1.10.2
+
+package logic
+
+import (
+	"context"
+
+	"udeServer/internal/svc"
+	"udeServer/internal/types"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type GetDirectoryLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewGetDirectoryLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetDirectoryLogic {
+	return &GetDirectoryLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *GetDirectoryLogic) GetDirectory(req *types.DirectoryIdReq) (*types.DirectoryResp, error) {
+	if err := checkId(req.Id); err != nil {
+		return nil, err
+	}
+
+	data, err := findDirectory(l.ctx, l.svcCtx.DirectoryModel, req.Id)
+	if err != nil {
+		return nil, err
+	}
+
+	return toDirectoryResp(data), nil
+}

internal/logic/getkeylogic.go

@@ -0,0 +1,40 @@
+// Code scaffolded by goctl. Safe to edit.
+// goctl 1.10.2
+
+package logic
+
+import (
+	"context"
+
+	"udeServer/internal/svc"
+	"udeServer/internal/types"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type GetKeyLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewGetKeyLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetKeyLogic {
+	return &GetKeyLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *GetKeyLogic) GetKey(req *types.KeyIdReq) (*types.KeyResp, error) {
+	if err := checkId(req.Id); err != nil {
+		return nil, err
+	}
+
+	data, err := findKey(l.ctx, l.svcCtx.KeyModel, req.Id)
+	if err != nil {
+		return nil, err
+	}
+
+	return toKeyResp(data), nil
+}

internal/logic/getservicelogic.go

@@ -0,0 +1,40 @@
+// Code scaffolded by goctl. Safe to edit.
+// goctl 1.10.2
+
+package logic
+
+import (
+	"context"
+
+	"udeServer/internal/svc"
+	"udeServer/internal/types"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type GetServiceLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewGetServiceLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetServiceLogic {
+	return &GetServiceLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *GetServiceLogic) GetService(req *types.ServiceIdReq) (*types.ServiceResp, error) {
+	if err := checkId(req.Id); err != nil {
+		return nil, err
+	}
+
+	data, err := findService(l.ctx, l.svcCtx.ServiceModel, req.Id)
+	if err != nil {
+		return nil, err
+	}
+
+	return toServiceResp(data), nil
+}

internal/logic/helpers.go

@@ -0,0 +1,121 @@
+package logic
+
+import (
+	"context"
+	"database/sql"
+	"errors"
+	"time"
+
+	"udeServer/internal/apierr"
+	"udeServer/internal/model"
+	"udeServer/internal/types"
+)
+
+func nullString(v string) sql.NullString {
+	return sql.NullString{String: v, Valid: v != ""}
+}
+
+func nullInt64(v int64) sql.NullInt64 {
+	return sql.NullInt64{Int64: v, Valid: v != 0}
+}
+
+func stringValue(v sql.NullString) string {
+	if !v.Valid {
+		return ""
+	}
+
+	return v.String
+}
+
+func int64Value(v sql.NullInt64) int64 {
+	if !v.Valid {
+		return 0
+	}
+
+	return v.Int64
+}
+
+func timeValue(t time.Time) string {
+	if t.IsZero() {
+		return ""
+	}
+
+	return t.Format(time.RFC3339)
+}
+
+func checkId(id int64) error {
+	if id <= 0 {
+		return apierr.BadRequest("id must be greater than 0")
+	}
+
+	return nil
+}
+
+func findDirectory(ctx context.Context, m model.TDirectoryModel, id int64) (*model.TDirectory, error) {
+	data, err := m.FindOne(ctx, id)
+	if errors.Is(err, model.ErrNotFound) {
+		return nil, apierr.NotFound("directory", id)
+	}
+	if err != nil {
+		return nil, err
+	}
+
+	return data, nil
+}
+
+func findKey(ctx context.Context, m model.TKeyModel, id int64) (*model.TKey, error) {
+	data, err := m.FindOne(ctx, id)
+	if errors.Is(err, model.ErrNotFound) {
+		return nil, apierr.NotFound("key", id)
+	}
+	if err != nil {
+		return nil, err
+	}
+
+	return data, nil
+}
+
+func findService(ctx context.Context, m model.TServiceModel, id int64) (*model.TService, error) {
+	data, err := m.FindOne(ctx, id)
+	if errors.Is(err, model.ErrNotFound) {
+		return nil, apierr.NotFound("service", id)
+	}
+	if err != nil {
+		return nil, err
+	}
+
+	return data, nil
+}
+
+func toDirectoryResp(data *model.TDirectory) *types.DirectoryResp {
+	return &types.DirectoryResp{
+		Id:        data.Id,
+		ServiceId: int64Value(data.ServiceId),
+		Directory: stringValue(data.Directory),
+	}
+}
+
+func toKeyResp(data *model.TKey) *types.KeyResp {
+	return &types.KeyResp{
+		Id:       data.Id,
+		Iden:     stringValue(data.Iden),
+		Name:     stringValue(data.Name),
+		Content:  stringValue(data.Content),
+		Status:   stringValue(data.Status),
+		CreateAt: timeValue(data.CreateAt),
+	}
+}
+
+func toServiceResp(data *model.TService) *types.ServiceResp {
+	return &types.ServiceResp{
+		Id:       data.Id,
+		Name:     stringValue(data.Name),
+		Ip:       stringValue(data.Ip),
+		Port:     stringValue(data.Port),
+		Iden:     stringValue(data.Iden),
+		KeyIden:  stringValue(data.KeyIden),
+		KeyAlgo:  stringValue(data.KeyAlgo),
+		Status:   stringValue(data.Status),
+		CreateAt: timeValue(data.CreateAt),
+	}
+}

internal/logic/listdirectorieslogic.go

@@ -0,0 +1,44 @@
+// Code scaffolded by goctl. Safe to edit.
+// goctl 1.10.2
+
+package logic
+
+import (
+	"context"
+
+	"udeServer/internal/svc"
+	"udeServer/internal/types"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type ListDirectoriesLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewListDirectoriesLogic(ctx context.Context, svcCtx *svc.ServiceContext) *ListDirectoriesLogic {
+	return &ListDirectoriesLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *ListDirectoriesLogic) ListDirectories() (*types.DirectoryListResp, error) {
+	list, err := l.svcCtx.DirectoryModel.FindAll(l.ctx)
+	if err != nil {
+		l.Errorf("list directories failed: %v", err)
+		return nil, err
+	}
+
+	resp := &types.DirectoryListResp{
+		List: make([]types.DirectoryResp, 0, len(list)),
+	}
+	for i := range list {
+		resp.List = append(resp.List, *toDirectoryResp(&list[i]))
+	}
+
+	return resp, nil
+}

internal/logic/listkeyslogic.go

@@ -0,0 +1,44 @@
+// Code scaffolded by goctl. Safe to edit.
+// goctl 1.10.2
+
+package logic
+
+import (
+	"context"
+
+	"udeServer/internal/svc"
+	"udeServer/internal/types"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type ListKeysLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewListKeysLogic(ctx context.Context, svcCtx *svc.ServiceContext) *ListKeysLogic {
+	return &ListKeysLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *ListKeysLogic) ListKeys() (*types.KeyListResp, error) {
+	list, err := l.svcCtx.KeyModel.FindAll(l.ctx)
+	if err != nil {
+		l.Errorf("list keys failed: %v", err)
+		return nil, err
+	}
+
+	resp := &types.KeyListResp{
+		List: make([]types.KeyResp, 0, len(list)),
+	}
+	for i := range list {
+		resp.List = append(resp.List, *toKeyResp(&list[i]))
+	}
+
+	return resp, nil
+}

internal/logic/listserviceslogic.go

@@ -0,0 +1,44 @@
+// Code scaffolded by goctl. Safe to edit.
+// goctl 1.10.2
+
+package logic
+
+import (
+	"context"
+
+	"udeServer/internal/svc"
+	"udeServer/internal/types"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type ListServicesLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewListServicesLogic(ctx context.Context, svcCtx *svc.ServiceContext) *ListServicesLogic {
+	return &ListServicesLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *ListServicesLogic) ListServices() (*types.ServiceListResp, error) {
+	list, err := l.svcCtx.ServiceModel.FindAll(l.ctx)
+	if err != nil {
+		l.Errorf("list services failed: %v", err)
+		return nil, err
+	}
+
+	resp := &types.ServiceListResp{
+		List: make([]types.ServiceResp, 0, len(list)),
+	}
+	for i := range list {
+		resp.List = append(resp.List, *toServiceResp(&list[i]))
+	}
+
+	return resp, nil
+}

internal/logic/updatedirectorylogic.go

@@ -0,0 +1,54 @@
+// Code scaffolded by goctl. Safe to edit.
+// goctl 1.10.2
+
+package logic
+
+import (
+	"context"
+
+	"udeServer/internal/model"
+	"udeServer/internal/svc"
+	"udeServer/internal/types"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type UpdateDirectoryLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewUpdateDirectoryLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UpdateDirectoryLogic {
+	return &UpdateDirectoryLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *UpdateDirectoryLogic) UpdateDirectory(req *types.UpdateDirectoryReq) (*types.DirectoryResp, error) {
+	if err := checkId(req.Id); err != nil {
+		return nil, err
+	}
+	if _, err := findDirectory(l.ctx, l.svcCtx.DirectoryModel, req.Id); err != nil {
+		return nil, err
+	}
+
+	data := &model.TDirectory{
+		Id:        req.Id,
+		ServiceId: nullInt64(req.ServiceId),
+		Directory: nullString(req.Directory),
+	}
+	if err := l.svcCtx.DirectoryModel.Update(l.ctx, data); err != nil {
+		l.Errorf("update directory %d failed: %v", req.Id, err)
+		return nil, err
+	}
+
+	updated, err := findDirectory(l.ctx, l.svcCtx.DirectoryModel, req.Id)
+	if err != nil {
+		return nil, err
+	}
+
+	return toDirectoryResp(updated), nil
+}

internal/logic/updatekeylogic.go

@@ -0,0 +1,56 @@
+// Code scaffolded by goctl. Safe to edit.
+// goctl 1.10.2
+
+package logic
+
+import (
+	"context"
+
+	"udeServer/internal/model"
+	"udeServer/internal/svc"
+	"udeServer/internal/types"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type UpdateKeyLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewUpdateKeyLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UpdateKeyLogic {
+	return &UpdateKeyLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *UpdateKeyLogic) UpdateKey(req *types.UpdateKeyReq) (*types.KeyResp, error) {
+	if err := checkId(req.Id); err != nil {
+		return nil, err
+	}
+	if _, err := findKey(l.ctx, l.svcCtx.KeyModel, req.Id); err != nil {
+		return nil, err
+	}
+
+	data := &model.TKey{
+		Id:      req.Id,
+		Iden:    nullString(req.Iden),
+		Name:    nullString(req.Name),
+		Content: nullString(req.Content),
+		Status:  nullString(req.Status),
+	}
+	if err := l.svcCtx.KeyModel.Update(l.ctx, data); err != nil {
+		l.Errorf("update key %d failed: %v", req.Id, err)
+		return nil, err
+	}
+
+	updated, err := findKey(l.ctx, l.svcCtx.KeyModel, req.Id)
+	if err != nil {
+		return nil, err
+	}
+
+	return toKeyResp(updated), nil
+}

internal/logic/updateservicelogic.go

@@ -0,0 +1,59 @@
+// Code scaffolded by goctl. Safe to edit.
+// goctl 1.10.2
+
+package logic
+
+import (
+	"context"
+
+	"udeServer/internal/model"
+	"udeServer/internal/svc"
+	"udeServer/internal/types"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type UpdateServiceLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewUpdateServiceLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UpdateServiceLogic {
+	return &UpdateServiceLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *UpdateServiceLogic) UpdateService(req *types.UpdateServiceReq) (*types.ServiceResp, error) {
+	if err := checkId(req.Id); err != nil {
+		return nil, err
+	}
+	if _, err := findService(l.ctx, l.svcCtx.ServiceModel, req.Id); err != nil {
+		return nil, err
+	}
+
+	data := &model.TService{
+		Id:      req.Id,
+		Name:    nullString(req.Name),
+		Ip:      nullString(req.Ip),
+		Port:    nullString(req.Port),
+		Iden:    nullString(req.Iden),
+		KeyIden: nullString(req.KeyIden),
+		KeyAlgo: nullString(req.KeyAlgo),
+		Status:  nullString(req.Status),
+	}
+	if err := l.svcCtx.ServiceModel.Update(l.ctx, data); err != nil {
+		l.Errorf("update service %d failed: %v", req.Id, err)
+		return nil, err
+	}
+
+	updated, err := findService(l.ctx, l.svcCtx.ServiceModel, req.Id)
+	if err != nil {
+		return nil, err
+	}
+
+	return toServiceResp(updated), nil
+}

internal/model/tdirectorymodel.go

@@ -0,0 +1,45 @@
+package model
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/zeromicro/go-zero/core/stores/sqlx"
+)
+
+var _ TDirectoryModel = (*customTDirectoryModel)(nil)
+
+type (
+	// TDirectoryModel is an interface to be customized, add more methods here,
+	// and implement the added methods in customTDirectoryModel.
+	TDirectoryModel interface {
+		tDirectoryModel
+		FindAll(ctx context.Context) ([]TDirectory, error)
+		withSession(session sqlx.Session) TDirectoryModel
+	}
+
+	customTDirectoryModel struct {
+		*defaultTDirectoryModel
+	}
+)
+
+// NewTDirectoryModel returns a model for the database table.
+func NewTDirectoryModel(conn sqlx.SqlConn) TDirectoryModel {
+	return &customTDirectoryModel{
+		defaultTDirectoryModel: newTDirectoryModel(conn),
+	}
+}
+
+func (m *customTDirectoryModel) FindAll(ctx context.Context) ([]TDirectory, error) {
+	query := fmt.Sprintf("select %s from %s order by `id`", tDirectoryRows, m.table)
+	var resp []TDirectory
+	if err := m.conn.QueryRowsCtx(ctx, &resp, query); err != nil {
+		return nil, err
+	}
+
+	return resp, nil
+}
+
+func (m *customTDirectoryModel) withSession(session sqlx.Session) TDirectoryModel {
+	return NewTDirectoryModel(sqlx.NewSqlConnFromSession(session))
+}

internal/model/tdirectorymodel_gen.go

@@ -0,0 +1,86 @@
+// Code generated by goctl. DO NOT EDIT.
+// versions:
+//  goctl version: 1.10.2
+
+package model
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"strings"
+
+	"github.com/zeromicro/go-zero/core/stores/builder"
+	"github.com/zeromicro/go-zero/core/stores/sqlx"
+	"github.com/zeromicro/go-zero/core/stringx"
+)
+
+var (
+	tDirectoryFieldNames          = builder.RawFieldNames(&TDirectory{})
+	tDirectoryRows                = strings.Join(tDirectoryFieldNames, ",")
+	tDirectoryRowsExpectAutoSet   = strings.Join(stringx.Remove(tDirectoryFieldNames, "`create_at`", "`create_time`", "`created_at`", "`update_at`", "`update_time`", "`updated_at`"), ",")
+	tDirectoryRowsWithPlaceHolder = strings.Join(stringx.Remove(tDirectoryFieldNames, "`id`", "`create_at`", "`create_time`", "`created_at`", "`update_at`", "`update_time`", "`updated_at`"), "=?,") + "=?"
+)
+
+type (
+	tDirectoryModel interface {
+		Insert(ctx context.Context, data *TDirectory) (sql.Result, error)
+		FindOne(ctx context.Context, id int64) (*TDirectory, error)
+		Update(ctx context.Context, data *TDirectory) error
+		Delete(ctx context.Context, id int64) error
+	}
+
+	defaultTDirectoryModel struct {
+		conn  sqlx.SqlConn
+		table string
+	}
+
+	TDirectory struct {
+		Id        int64          `db:"id"`
+		ServiceId sql.NullInt64  `db:"service_id"` // 服务id
+		Directory sql.NullString `db:"directory"`  // 保护目录
+	}
+)
+
+func newTDirectoryModel(conn sqlx.SqlConn) *defaultTDirectoryModel {
+	return &defaultTDirectoryModel{
+		conn:  conn,
+		table: "`t_directory`",
+	}
+}
+
+func (m *defaultTDirectoryModel) Delete(ctx context.Context, id int64) error {
+	query := fmt.Sprintf("delete from %s where `id` = ?", m.table)
+	_, err := m.conn.ExecCtx(ctx, query, id)
+	return err
+}
+
+func (m *defaultTDirectoryModel) FindOne(ctx context.Context, id int64) (*TDirectory, error) {
+	query := fmt.Sprintf("select %s from %s where `id` = ? limit 1", tDirectoryRows, m.table)
+	var resp TDirectory
+	err := m.conn.QueryRowCtx(ctx, &resp, query, id)
+	switch err {
+	case nil:
+		return &resp, nil
+	case sqlx.ErrNotFound:
+		return nil, ErrNotFound
+	default:
+		return nil, err
+	}
+}
+
+func (m *defaultTDirectoryModel) Insert(ctx context.Context, data *TDirectory) (sql.Result, error) {
+	query := fmt.Sprintf("insert into %s (%s) values (?, ?, ?)", m.table, tDirectoryRowsExpectAutoSet)
+	ret, err := m.conn.ExecCtx(ctx, query, data.Id, data.ServiceId, data.Directory)
+	return ret, err
+}
+
+func (m *defaultTDirectoryModel) Update(ctx context.Context, data *TDirectory) error {
+	query := fmt.Sprintf("update %s set %s where `id` = ?", m.table, tDirectoryRowsWithPlaceHolder)
+	_, err := m.conn.ExecCtx(ctx, query, data.ServiceId, data.Directory, data.Id)
+	return err
+}
+
+func (m *defaultTDirectoryModel) tableName() string {
+	return m.table
+}

internal/model/tkeymodel.go

@@ -0,0 +1,45 @@
+package model
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/zeromicro/go-zero/core/stores/sqlx"
+)
+
+var _ TKeyModel = (*customTKeyModel)(nil)
+
+type (
+	// TKeyModel is an interface to be customized, add more methods here,
+	// and implement the added methods in customTKeyModel.
+	TKeyModel interface {
+		tKeyModel
+		FindAll(ctx context.Context) ([]TKey, error)
+		withSession(session sqlx.Session) TKeyModel
+	}
+
+	customTKeyModel struct {
+		*defaultTKeyModel
+	}
+)
+
+// NewTKeyModel returns a model for the database table.
+func NewTKeyModel(conn sqlx.SqlConn) TKeyModel {
+	return &customTKeyModel{
+		defaultTKeyModel: newTKeyModel(conn),
+	}
+}
+
+func (m *customTKeyModel) FindAll(ctx context.Context) ([]TKey, error) {
+	query := fmt.Sprintf("select %s from %s order by `id`", tKeyRows, m.table)
+	var resp []TKey
+	if err := m.conn.QueryRowsCtx(ctx, &resp, query); err != nil {
+		return nil, err
+	}
+
+	return resp, nil
+}
+
+func (m *customTKeyModel) withSession(session sqlx.Session) TKeyModel {
+	return NewTKeyModel(sqlx.NewSqlConnFromSession(session))
+}

internal/model/tkeymodel_gen.go

@@ -0,0 +1,90 @@
+// Code generated by goctl. DO NOT EDIT.
+// versions:
+//  goctl version: 1.10.2
+
+package model
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/zeromicro/go-zero/core/stores/builder"
+	"github.com/zeromicro/go-zero/core/stores/sqlx"
+	"github.com/zeromicro/go-zero/core/stringx"
+)
+
+var (
+	tKeyFieldNames          = builder.RawFieldNames(&TKey{})
+	tKeyRows                = strings.Join(tKeyFieldNames, ",")
+	tKeyRowsExpectAutoSet   = strings.Join(stringx.Remove(tKeyFieldNames, "`create_at`", "`create_time`", "`created_at`", "`update_at`", "`update_time`", "`updated_at`"), ",")
+	tKeyRowsWithPlaceHolder = strings.Join(stringx.Remove(tKeyFieldNames, "`id`", "`create_at`", "`create_time`", "`created_at`", "`update_at`", "`update_time`", "`updated_at`"), "=?,") + "=?"
+)
+
+type (
+	tKeyModel interface {
+		Insert(ctx context.Context, data *TKey) (sql.Result, error)
+		FindOne(ctx context.Context, id int64) (*TKey, error)
+		Update(ctx context.Context, data *TKey) error
+		Delete(ctx context.Context, id int64) error
+	}
+
+	defaultTKeyModel struct {
+		conn  sqlx.SqlConn
+		table string
+	}
+
+	TKey struct {
+		Id       int64          `db:"id"`
+		Iden     sql.NullString `db:"iden"`      // 密钥标识
+		Name     sql.NullString `db:"name"`      // 密钥别名
+		Content  sql.NullString `db:"content"`   // 密钥内容
+		Status   sql.NullString `db:"status"`    // 密钥状态
+		CreateAt time.Time      `db:"create_at"` // 生成时间
+	}
+)
+
+func newTKeyModel(conn sqlx.SqlConn) *defaultTKeyModel {
+	return &defaultTKeyModel{
+		conn:  conn,
+		table: "`t_key`",
+	}
+}
+
+func (m *defaultTKeyModel) Delete(ctx context.Context, id int64) error {
+	query := fmt.Sprintf("delete from %s where `id` = ?", m.table)
+	_, err := m.conn.ExecCtx(ctx, query, id)
+	return err
+}
+
+func (m *defaultTKeyModel) FindOne(ctx context.Context, id int64) (*TKey, error) {
+	query := fmt.Sprintf("select %s from %s where `id` = ? limit 1", tKeyRows, m.table)
+	var resp TKey
+	err := m.conn.QueryRowCtx(ctx, &resp, query, id)
+	switch err {
+	case nil:
+		return &resp, nil
+	case sqlx.ErrNotFound:
+		return nil, ErrNotFound
+	default:
+		return nil, err
+	}
+}
+
+func (m *defaultTKeyModel) Insert(ctx context.Context, data *TKey) (sql.Result, error) {
+	query := fmt.Sprintf("insert into %s (%s) values (?, ?, ?, ?, ?)", m.table, tKeyRowsExpectAutoSet)
+	ret, err := m.conn.ExecCtx(ctx, query, data.Id, data.Iden, data.Name, data.Content, data.Status)
+	return ret, err
+}
+
+func (m *defaultTKeyModel) Update(ctx context.Context, data *TKey) error {
+	query := fmt.Sprintf("update %s set %s where `id` = ?", m.table, tKeyRowsWithPlaceHolder)
+	_, err := m.conn.ExecCtx(ctx, query, data.Iden, data.Name, data.Content, data.Status, data.Id)
+	return err
+}
+
+func (m *defaultTKeyModel) tableName() string {
+	return m.table
+}

internal/model/tservicemodel.go

@@ -0,0 +1,45 @@
+package model
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/zeromicro/go-zero/core/stores/sqlx"
+)
+
+var _ TServiceModel = (*customTServiceModel)(nil)
+
+type (
+	// TServiceModel is an interface to be customized, add more methods here,
+	// and implement the added methods in customTServiceModel.
+	TServiceModel interface {
+		tServiceModel
+		FindAll(ctx context.Context) ([]TService, error)
+		withSession(session sqlx.Session) TServiceModel
+	}
+
+	customTServiceModel struct {
+		*defaultTServiceModel
+	}
+)
+
+// NewTServiceModel returns a model for the database table.
+func NewTServiceModel(conn sqlx.SqlConn) TServiceModel {
+	return &customTServiceModel{
+		defaultTServiceModel: newTServiceModel(conn),
+	}
+}
+
+func (m *customTServiceModel) FindAll(ctx context.Context) ([]TService, error) {
+	query := fmt.Sprintf("select %s from %s order by `id`", tServiceRows, m.table)
+	var resp []TService
+	if err := m.conn.QueryRowsCtx(ctx, &resp, query); err != nil {
+		return nil, err
+	}
+
+	return resp, nil
+}
+
+func (m *customTServiceModel) withSession(session sqlx.Session) TServiceModel {
+	return NewTServiceModel(sqlx.NewSqlConnFromSession(session))
+}

internal/model/tservicemodel_gen.go

@@ -0,0 +1,93 @@
+// Code generated by goctl. DO NOT EDIT.
+// versions:
+//  goctl version: 1.10.2
+
+package model
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/zeromicro/go-zero/core/stores/builder"
+	"github.com/zeromicro/go-zero/core/stores/sqlx"
+	"github.com/zeromicro/go-zero/core/stringx"
+)
+
+var (
+	tServiceFieldNames          = builder.RawFieldNames(&TService{})
+	tServiceRows                = strings.Join(tServiceFieldNames, ",")
+	tServiceRowsExpectAutoSet   = strings.Join(stringx.Remove(tServiceFieldNames, "`create_at`", "`create_time`", "`created_at`", "`update_at`", "`update_time`", "`updated_at`"), ",")
+	tServiceRowsWithPlaceHolder = strings.Join(stringx.Remove(tServiceFieldNames, "`id`", "`create_at`", "`create_time`", "`created_at`", "`update_at`", "`update_time`", "`updated_at`"), "=?,") + "=?"
+)
+
+type (
+	tServiceModel interface {
+		Insert(ctx context.Context, data *TService) (sql.Result, error)
+		FindOne(ctx context.Context, id int64) (*TService, error)
+		Update(ctx context.Context, data *TService) error
+		Delete(ctx context.Context, id int64) error
+	}
+
+	defaultTServiceModel struct {
+		conn  sqlx.SqlConn
+		table string
+	}
+
+	TService struct {
+		Id       int64          `db:"id"`
+		Name     sql.NullString `db:"name"`      // 服务名称
+		Ip       sql.NullString `db:"ip"`        // 外挂服务ip
+		Port     sql.NullString `db:"port"`      // 外挂服务端口
+		Iden     sql.NullString `db:"iden"`      // 唯一标识
+		KeyIden  sql.NullString `db:"key_iden"`  // 密钥标识
+		KeyAlgo  sql.NullString `db:"key_algo"`  // 密钥算法
+		Status   sql.NullString `db:"status"`    // 服务状态
+		CreateAt time.Time      `db:"create_at"` // 创建时间
+	}
+)
+
+func newTServiceModel(conn sqlx.SqlConn) *defaultTServiceModel {
+	return &defaultTServiceModel{
+		conn:  conn,
+		table: "`t_service`",
+	}
+}
+
+func (m *defaultTServiceModel) Delete(ctx context.Context, id int64) error {
+	query := fmt.Sprintf("delete from %s where `id` = ?", m.table)
+	_, err := m.conn.ExecCtx(ctx, query, id)
+	return err
+}
+
+func (m *defaultTServiceModel) FindOne(ctx context.Context, id int64) (*TService, error) {
+	query := fmt.Sprintf("select %s from %s where `id` = ? limit 1", tServiceRows, m.table)
+	var resp TService
+	err := m.conn.QueryRowCtx(ctx, &resp, query, id)
+	switch err {
+	case nil:
+		return &resp, nil
+	case sqlx.ErrNotFound:
+		return nil, ErrNotFound
+	default:
+		return nil, err
+	}
+}
+
+func (m *defaultTServiceModel) Insert(ctx context.Context, data *TService) (sql.Result, error) {
+	query := fmt.Sprintf("insert into %s (%s) values (?, ?, ?, ?, ?, ?, ?, ?)", m.table, tServiceRowsExpectAutoSet)
+	ret, err := m.conn.ExecCtx(ctx, query, data.Id, data.Name, data.Ip, data.Port, data.Iden, data.KeyIden, data.KeyAlgo, data.Status)
+	return ret, err
+}
+
+func (m *defaultTServiceModel) Update(ctx context.Context, data *TService) error {
+	query := fmt.Sprintf("update %s set %s where `id` = ?", m.table, tServiceRowsWithPlaceHolder)
+	_, err := m.conn.ExecCtx(ctx, query, data.Name, data.Ip, data.Port, data.Iden, data.KeyIden, data.KeyAlgo, data.Status, data.Id)
+	return err
+}
+
+func (m *defaultTServiceModel) tableName() string {
+	return m.table
+}

internal/model/vars.go

@@ -0,0 +1,5 @@
+package model
+
+import "github.com/zeromicro/go-zero/core/stores/sqlx"
+
+var ErrNotFound = sqlx.ErrNotFound

internal/svc/servicecontext.go

@@ -5,18 +5,26 @@ package svc
 
 import (
 	"udeServer/internal/config"
+	"udeServer/internal/model"
 
 	"github.com/zeromicro/go-zero/core/stores/sqlx"
 )
 
 type ServiceContext struct {
-	Config config.Config
-	DB     sqlx.SqlConn
+	Config         config.Config
+	DB             sqlx.SqlConn
+	DirectoryModel model.TDirectoryModel
+	KeyModel       model.TKeyModel
+	ServiceModel   model.TServiceModel
 }
 
 func NewServiceContext(c config.Config) *ServiceContext {
+	conn := sqlx.MustNewConn(c.MySQL)
 	return &ServiceContext{
-		Config: c,
-		DB:     sqlx.MustNewConn(c.MySQL),
+		Config:         c,
+		DB:             conn,
+		DirectoryModel: model.NewTDirectoryModel(conn),
+		KeyModel:       model.NewTKeyModel(conn),
+		ServiceModel:   model.NewTServiceModel(conn),
 	}
 }

internal/types/types.go

@@ -3,12 +3,72 @@
 
 package types
 
+type CreateDirectoryReq struct {
+	Id        int64  `json:"id"`
+	ServiceId int64  `json:"serviceId,optional"`
+	Directory string `json:"directory,optional"`
+}
+
+type CreateKeyReq struct {
+	Id      int64  `json:"id"`
+	Iden    string `json:"iden,optional"`
+	Name    string `json:"name,optional"`
+	Content string `json:"content,optional"`
+	Status  string `json:"status,optional"`
+}
+
+type CreateServiceReq struct {
+	Id      int64  `json:"id"`
+	Name    string `json:"name,optional"`
+	Ip      string `json:"ip,optional"`
+	Port    string `json:"port,optional"`
+	Iden    string `json:"iden,optional"`
+	KeyIden string `json:"keyIden,optional"`
+	KeyAlgo string `json:"keyAlgo,optional"`
+	Status  string `json:"status,optional"`
+}
+
 type DbPingResponse struct {
 	Ok       bool   `json:"ok"`
 	Version  string `json:"version"`
 	Database string `json:"database"`
 }
 
+type DeleteResp struct {
+	Ok bool `json:"ok"`
+}
+
+type DirectoryIdReq struct {
+	Id int64 `path:"id"`
+}
+
+type DirectoryListResp struct {
+	List []DirectoryResp `json:"list"`
+}
+
+type DirectoryResp struct {
+	Id        int64  `json:"id"`
+	ServiceId int64  `json:"serviceId"`
+	Directory string `json:"directory"`
+}
+
+type KeyIdReq struct {
+	Id int64 `path:"id"`
+}
+
+type KeyListResp struct {
+	List []KeyResp `json:"list"`
+}
+
+type KeyResp struct {
+	Id       int64  `json:"id"`
+	Iden     string `json:"iden"`
+	Name     string `json:"name"`
+	Content  string `json:"content"`
+	Status   string `json:"status"`
+	CreateAt string `json:"createAt"`
+}
+
 type Request struct {
 	Name string `path:"name,options=you|me"`
 }
@@ -16,3 +76,48 @@ type Request struct {
 type Response struct {
 	Message string `json:"message"`
 }
+
+type ServiceIdReq struct {
+	Id int64 `path:"id"`
+}
+
+type ServiceListResp struct {
+	List []ServiceResp `json:"list"`
+}
+
+type ServiceResp struct {
+	Id       int64  `json:"id"`
+	Name     string `json:"name"`
+	Ip       string `json:"ip"`
+	Port     string `json:"port"`
+	Iden     string `json:"iden"`
+	KeyIden  string `json:"keyIden"`
+	KeyAlgo  string `json:"keyAlgo"`
+	Status   string `json:"status"`
+	CreateAt string `json:"createAt"`
+}
+
+type UpdateDirectoryReq struct {
+	Id        int64  `path:"id"`
+	ServiceId int64  `json:"serviceId,optional"`
+	Directory string `json:"directory,optional"`
+}
+
+type UpdateKeyReq struct {
+	Id      int64  `path:"id"`
+	Iden    string `json:"iden,optional"`
+	Name    string `json:"name,optional"`
+	Content string `json:"content,optional"`
+	Status  string `json:"status,optional"`
+}
+
+type UpdateServiceReq struct {
+	Id      int64  `path:"id"`
+	Name    string `json:"name,optional"`
+	Ip      string `json:"ip,optional"`
+	Port    string `json:"port,optional"`
+	Iden    string `json:"iden,optional"`
+	KeyIden string `json:"keyIden,optional"`
+	KeyAlgo string `json:"keyAlgo,optional"`
+	Status  string `json:"status,optional"`
+}

udeServer.api

@@ -14,11 +14,161 @@ type DbPingResponse {
 	Database string `json:"database"`
 }
 
+type DeleteResp {
+	Ok bool `json:"ok"`
+}
+
+type CreateDirectoryReq {
+	Id        int64  `json:"id"`
+	ServiceId int64  `json:"serviceId,optional"`
+	Directory string `json:"directory,optional"`
+}
+
+type UpdateDirectoryReq {
+	Id        int64  `path:"id"`
+	ServiceId int64  `json:"serviceId,optional"`
+	Directory string `json:"directory,optional"`
+}
+
+type DirectoryIdReq {
+	Id int64 `path:"id"`
+}
+
+type DirectoryResp {
+	Id        int64  `json:"id"`
+	ServiceId int64  `json:"serviceId"`
+	Directory string `json:"directory"`
+}
+
+type DirectoryListResp {
+	List []DirectoryResp `json:"list"`
+}
+
+type CreateKeyReq {
+	Id      int64  `json:"id"`
+	Iden    string `json:"iden,optional"`
+	Name    string `json:"name,optional"`
+	Content string `json:"content,optional"`
+	Status  string `json:"status,optional"`
+}
+
+type UpdateKeyReq {
+	Id      int64  `path:"id"`
+	Iden    string `json:"iden,optional"`
+	Name    string `json:"name,optional"`
+	Content string `json:"content,optional"`
+	Status  string `json:"status,optional"`
+}
+
+type KeyIdReq {
+	Id int64 `path:"id"`
+}
+
+type KeyResp {
+	Id       int64  `json:"id"`
+	Iden     string `json:"iden"`
+	Name     string `json:"name"`
+	Content  string `json:"content"`
+	Status   string `json:"status"`
+	CreateAt string `json:"createAt"`
+}
+
+type KeyListResp {
+	List []KeyResp `json:"list"`
+}
+
+type CreateServiceReq {
+	Id      int64  `json:"id"`
+	Name    string `json:"name,optional"`
+	Ip      string `json:"ip,optional"`
+	Port    string `json:"port,optional"`
+	Iden    string `json:"iden,optional"`
+	KeyIden string `json:"keyIden,optional"`
+	KeyAlgo string `json:"keyAlgo,optional"`
+	Status  string `json:"status,optional"`
+}
+
+type UpdateServiceReq {
+	Id      int64  `path:"id"`
+	Name    string `json:"name,optional"`
+	Ip      string `json:"ip,optional"`
+	Port    string `json:"port,optional"`
+	Iden    string `json:"iden,optional"`
+	KeyIden string `json:"keyIden,optional"`
+	KeyAlgo string `json:"keyAlgo,optional"`
+	Status  string `json:"status,optional"`
+}
+
+type ServiceIdReq {
+	Id int64 `path:"id"`
+}
+
+type ServiceResp {
+	Id       int64  `json:"id"`
+	Name     string `json:"name"`
+	Ip       string `json:"ip"`
+	Port     string `json:"port"`
+	Iden     string `json:"iden"`
+	KeyIden  string `json:"keyIden"`
+	KeyAlgo  string `json:"keyAlgo"`
+	Status   string `json:"status"`
+	CreateAt string `json:"createAt"`
+}
+
+type ServiceListResp {
+	List []ServiceResp `json:"list"`
+}
+
 service udeServer-api {
 	@handler UdeServerHandler
 	get /from/:name (Request) returns (Response)
 
 	@handler DbPingHandler
 	get /db/ping returns (DbPingResponse)
+
+	@handler CreateDirectoryHandler
+	post /directories (CreateDirectoryReq) returns (DirectoryResp)
+
+	@handler ListDirectoriesHandler
+	get /directories returns (DirectoryListResp)
+
+	@handler GetDirectoryHandler
+	get /directories/:id (DirectoryIdReq) returns (DirectoryResp)
+
+	@handler UpdateDirectoryHandler
+	put /directories/:id (UpdateDirectoryReq) returns (DirectoryResp)
+
+	@handler DeleteDirectoryHandler
+	delete /directories/:id (DirectoryIdReq) returns (DeleteResp)
+
+	@handler CreateKeyHandler
+	post /keys (CreateKeyReq) returns (KeyResp)
+
+	@handler ListKeysHandler
+	get /keys returns (KeyListResp)
+
+	@handler GetKeyHandler
+	get /keys/:id (KeyIdReq) returns (KeyResp)
+
+	@handler UpdateKeyHandler
+	put /keys/:id (UpdateKeyReq) returns (KeyResp)
+
+	@handler DeleteKeyHandler
+	delete /keys/:id (KeyIdReq) returns (DeleteResp)
+
+	@handler CreateServiceHandler
+	post /services (CreateServiceReq) returns (ServiceResp)
+
+	@handler ListServicesHandler
+	get /services returns (ServiceListResp)
+
+	@handler GetServiceHandler
+	get /services/:id (ServiceIdReq) returns (ServiceResp)
+
+	@handler UpdateServiceHandler
+	put /services/:id (UpdateServiceReq) returns (ServiceResp)
+
+	@handler DeleteServiceHandler
+	delete /services/:id (ServiceIdReq) returns (DeleteResp)
 }
 

udeserver.go

@@ -7,12 +7,14 @@ import (
 	"flag"
 	"fmt"
 
+	"udeServer/internal/apierr"
 	"udeServer/internal/config"
 	"udeServer/internal/handler"
 	"udeServer/internal/svc"
 
 	"github.com/zeromicro/go-zero/core/conf"
 	"github.com/zeromicro/go-zero/rest"
+	"github.com/zeromicro/go-zero/rest/httpx"
 )
 
 var configFile = flag.String("f", "etc/udeserver-api.yaml", "the config file")
@@ -23,6 +25,14 @@ func main() {
 	var c config.Config
 	conf.MustLoad(*configFile, &c)
 
+	httpx.SetErrorHandler(func(err error) (int, any) {
+		status := apierr.Status(err)
+		return status, map[string]any{
+			"code": status,
+			"msg":  err.Error(),
+		}
+	})
+
 	server := rest.MustNewServer(c.RestConf)
 	defer server.Stop()