team/in-server
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

first commit

Browse Source
This commit is contained in:
liangzai
2026-03-18 00:01:48 +08:00
commit a0c623fd81
425 changed files with 42318 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

30
app/main/api/internal/handler/admin_api/adminbatchupdateapistatushandler.go Normal file
View File

@@ -0,0 +1,30 @@
package admin_api
import (
"net/http"
"in-server/app/main/api/internal/logic/admin_api"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func AdminBatchUpdateApiStatusHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminBatchUpdateApiStatusReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := admin_api.NewAdminBatchUpdateApiStatusLogic(r.Context(), svcCtx)
resp, err := l.AdminBatchUpdateApiStatus(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/admin_api/admincreateapihandler.go Normal file
View File

@@ -0,0 +1,30 @@
package admin_api
import (
"net/http"
"in-server/app/main/api/internal/logic/admin_api"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func AdminCreateApiHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminCreateApiReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := admin_api.NewAdminCreateApiLogic(r.Context(), svcCtx)
resp, err := l.AdminCreateApi(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/admin_api/admindeleteapihandler.go Normal file
View File

@@ -0,0 +1,30 @@
package admin_api
import (
"net/http"
"in-server/app/main/api/internal/logic/admin_api"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func AdminDeleteApiHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminDeleteApiReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := admin_api.NewAdminDeleteApiLogic(r.Context(), svcCtx)
resp, err := l.AdminDeleteApi(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/admin_api/admingetapidetailhandler.go Normal file
View File

@@ -0,0 +1,30 @@
package admin_api
import (
"net/http"
"in-server/app/main/api/internal/logic/admin_api"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func AdminGetApiDetailHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminGetApiDetailReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := admin_api.NewAdminGetApiDetailLogic(r.Context(), svcCtx)
resp, err := l.AdminGetApiDetail(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/admin_api/admingetapilisthandler.go Normal file
View File

@@ -0,0 +1,30 @@
package admin_api
import (
"net/http"
"in-server/app/main/api/internal/logic/admin_api"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func AdminGetApiListHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminGetApiListReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := admin_api.NewAdminGetApiListLogic(r.Context(), svcCtx)
resp, err := l.AdminGetApiList(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/admin_api/adminupdateapihandler.go Normal file
View File

@@ -0,0 +1,30 @@
package admin_api
import (
"net/http"
"in-server/app/main/api/internal/logic/admin_api"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func AdminUpdateApiHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminUpdateApiReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := admin_api.NewAdminUpdateApiLogic(r.Context(), svcCtx)
resp, err := l.AdminUpdateApi(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/admin_auth/adminloginhandler.go Normal file
View File

@@ -0,0 +1,30 @@
package admin_auth
import (
"net/http"
"in-server/app/main/api/internal/logic/admin_auth"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func AdminLoginHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminLoginReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := admin_auth.NewAdminLoginLogic(r.Context(), svcCtx)
resp, err := l.AdminLogin(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/admin_feature/adminconfigfeatureexamplehandler.go Normal file
View File

@@ -0,0 +1,30 @@
package admin_feature
import (
"net/http"
"in-server/app/main/api/internal/logic/admin_feature"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func AdminConfigFeatureExampleHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminConfigFeatureExampleReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := admin_feature.NewAdminConfigFeatureExampleLogic(r.Context(), svcCtx)
resp, err := l.AdminConfigFeatureExample(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/admin_feature/admincreatefeaturehandler.go Normal file
View File

@@ -0,0 +1,30 @@
package admin_feature
import (
"net/http"
"in-server/app/main/api/internal/logic/admin_feature"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func AdminCreateFeatureHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminCreateFeatureReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := admin_feature.NewAdminCreateFeatureLogic(r.Context(), svcCtx)
resp, err := l.AdminCreateFeature(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/admin_feature/admindeletefeaturehandler.go Normal file
View File

@@ -0,0 +1,30 @@
package admin_feature
import (
"net/http"
"in-server/app/main/api/internal/logic/admin_feature"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func AdminDeleteFeatureHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminDeleteFeatureReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := admin_feature.NewAdminDeleteFeatureLogic(r.Context(), svcCtx)
resp, err := l.AdminDeleteFeature(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/admin_feature/admingetfeaturedetailhandler.go Normal file
View File

@@ -0,0 +1,30 @@
package admin_feature
import (
"net/http"
"in-server/app/main/api/internal/logic/admin_feature"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func AdminGetFeatureDetailHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminGetFeatureDetailReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := admin_feature.NewAdminGetFeatureDetailLogic(r.Context(), svcCtx)
resp, err := l.AdminGetFeatureDetail(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/admin_feature/admingetfeatureexamplehandler.go Normal file
View File

@@ -0,0 +1,30 @@
package admin_feature
import (
"net/http"
"in-server/app/main/api/internal/logic/admin_feature"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func AdminGetFeatureExampleHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminGetFeatureExampleReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := admin_feature.NewAdminGetFeatureExampleLogic(r.Context(), svcCtx)
resp, err := l.AdminGetFeatureExample(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/admin_feature/admingetfeaturelisthandler.go Normal file
View File

@@ -0,0 +1,30 @@
package admin_feature
import (
"net/http"
"in-server/app/main/api/internal/logic/admin_feature"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func AdminGetFeatureListHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminGetFeatureListReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := admin_feature.NewAdminGetFeatureListLogic(r.Context(), svcCtx)
resp, err := l.AdminGetFeatureList(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/admin_feature/adminupdatefeaturehandler.go Normal file
View File

@@ -0,0 +1,30 @@
package admin_feature
import (
"net/http"
"in-server/app/main/api/internal/logic/admin_feature"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func AdminUpdateFeatureHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminUpdateFeatureReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := admin_feature.NewAdminUpdateFeatureLogic(r.Context(), svcCtx)
resp, err := l.AdminUpdateFeature(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/admin_menu/createmenuhandler.go Normal file
View File

@@ -0,0 +1,30 @@
package admin_menu
import (
"net/http"
"in-server/app/main/api/internal/logic/admin_menu"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func CreateMenuHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.CreateMenuReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := admin_menu.NewCreateMenuLogic(r.Context(), svcCtx)
resp, err := l.CreateMenu(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/admin_menu/deletemenuhandler.go Normal file
View File

@@ -0,0 +1,30 @@
package admin_menu
import (
"net/http"
"in-server/app/main/api/internal/logic/admin_menu"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func DeleteMenuHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.DeleteMenuReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := admin_menu.NewDeleteMenuLogic(r.Context(), svcCtx)
resp, err := l.DeleteMenu(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/admin_menu/getmenuallhandler.go Normal file
View File

@@ -0,0 +1,30 @@
package admin_menu
import (
"net/http"
"in-server/app/main/api/internal/logic/admin_menu"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func GetMenuAllHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.GetMenuAllReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := admin_menu.NewGetMenuAllLogic(r.Context(), svcCtx)
resp, err := l.GetMenuAll(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/admin_menu/getmenudetailhandler.go Normal file
View File

@@ -0,0 +1,30 @@
package admin_menu
import (
"net/http"
"in-server/app/main/api/internal/logic/admin_menu"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func GetMenuDetailHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.GetMenuDetailReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := admin_menu.NewGetMenuDetailLogic(r.Context(), svcCtx)
resp, err := l.GetMenuDetail(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/admin_menu/getmenulisthandler.go Normal file
View File

@@ -0,0 +1,30 @@
package admin_menu
import (
"net/http"
"in-server/app/main/api/internal/logic/admin_menu"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func GetMenuListHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.GetMenuListReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := admin_menu.NewGetMenuListLogic(r.Context(), svcCtx)
resp, err := l.GetMenuList(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/admin_menu/updatemenuhandler.go Normal file
View File

@@ -0,0 +1,30 @@
package admin_menu
import (
"net/http"
"in-server/app/main/api/internal/logic/admin_menu"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func UpdateMenuHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.UpdateMenuReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := admin_menu.NewUpdateMenuLogic(r.Context(), svcCtx)
resp, err := l.UpdateMenu(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/admin_notification/admincreatenotificationhandler.go Normal file
View File

@@ -0,0 +1,30 @@
package admin_notification
import (
"net/http"
"in-server/app/main/api/internal/logic/admin_notification"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func AdminCreateNotificationHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminCreateNotificationReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := admin_notification.NewAdminCreateNotificationLogic(r.Context(), svcCtx)
resp, err := l.AdminCreateNotification(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/admin_notification/admindeletenotificationhandler.go Normal file
View File

@@ -0,0 +1,30 @@
package admin_notification
import (
"net/http"
"in-server/app/main/api/internal/logic/admin_notification"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func AdminDeleteNotificationHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminDeleteNotificationReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := admin_notification.NewAdminDeleteNotificationLogic(r.Context(), svcCtx)
resp, err := l.AdminDeleteNotification(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/admin_notification/admingetnotificationdetailhandler.go Normal file
View File

@@ -0,0 +1,30 @@
package admin_notification
import (
"net/http"
"in-server/app/main/api/internal/logic/admin_notification"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func AdminGetNotificationDetailHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminGetNotificationDetailReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := admin_notification.NewAdminGetNotificationDetailLogic(r.Context(), svcCtx)
resp, err := l.AdminGetNotificationDetail(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/admin_notification/admingetnotificationlisthandler.go Normal file
View File

@@ -0,0 +1,30 @@
package admin_notification
import (
"net/http"
"in-server/app/main/api/internal/logic/admin_notification"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func AdminGetNotificationListHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminGetNotificationListReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := admin_notification.NewAdminGetNotificationListLogic(r.Context(), svcCtx)
resp, err := l.AdminGetNotificationList(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/admin_notification/adminupdatenotificationhandler.go Normal file
View File

@@ -0,0 +1,30 @@
package admin_notification
import (
"net/http"
"in-server/app/main/api/internal/logic/admin_notification"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func AdminUpdateNotificationHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminUpdateNotificationReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := admin_notification.NewAdminUpdateNotificationLogic(r.Context(), svcCtx)
resp, err := l.AdminUpdateNotification(&req)
result.HttpResult(r, w, resp, err)
}
}

29
app/main/api/internal/handler/admin_order/admincreateorderhandler.go Normal file
View File

@@ -0,0 +1,29 @@
package admin_order
import (
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
"in-server/app/main/api/internal/logic/admin_order"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
)
func AdminCreateOrderHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminCreateOrderReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := admin_order.NewAdminCreateOrderLogic(r.Context(), svcCtx)
resp, err := l.AdminCreateOrder(&req)
result.HttpResult(r, w, resp, err)
}
}

29
app/main/api/internal/handler/admin_order/admindeleteorderhandler.go Normal file
View File

@@ -0,0 +1,29 @@
package admin_order
import (
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
"in-server/app/main/api/internal/logic/admin_order"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
)
func AdminDeleteOrderHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminDeleteOrderReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := admin_order.NewAdminDeleteOrderLogic(r.Context(), svcCtx)
resp, err := l.AdminDeleteOrder(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/admin_order/admingetorderdetailhandler.go Normal file
View File

@@ -0,0 +1,30 @@
package admin_order
import (
"net/http"
"in-server/app/main/api/internal/logic/admin_order"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func AdminGetOrderDetailHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminGetOrderDetailReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := admin_order.NewAdminGetOrderDetailLogic(r.Context(), svcCtx)
resp, err := l.AdminGetOrderDetail(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/admin_order/admingetorderlisthandler.go Normal file
View File

@@ -0,0 +1,30 @@
package admin_order
import (
"net/http"
"in-server/app/main/api/internal/logic/admin_order"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func AdminGetOrderListHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminGetOrderListReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := admin_order.NewAdminGetOrderListLogic(r.Context(), svcCtx)
resp, err := l.AdminGetOrderList(&req)
result.HttpResult(r, w, resp, err)
}
}

29
app/main/api/internal/handler/admin_order/adminrefundorderhandler.go Normal file
View File

@@ -0,0 +1,29 @@
package admin_order
import (
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
"in-server/app/main/api/internal/logic/admin_order"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
)
func AdminRefundOrderHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminRefundOrderReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := admin_order.NewAdminRefundOrderLogic(r.Context(), svcCtx)
resp, err := l.AdminRefundOrder(&req)
result.HttpResult(r, w, resp, err)
}
}

29
app/main/api/internal/handler/admin_order/adminretryagentprocesshandler.go Normal file
View File

@@ -0,0 +1,29 @@
package admin_order
import (
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
"in-server/app/main/api/internal/logic/admin_order"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
)
func AdminRetryAgentProcessHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminRetryAgentProcessReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := admin_order.NewAdminRetryAgentProcessLogic(r.Context(), svcCtx)
resp, err := l.AdminRetryAgentProcess(&req)
result.HttpResult(r, w, resp, err)
}
}

29
app/main/api/internal/handler/admin_order/adminupdateorderhandler.go Normal file
View File

@@ -0,0 +1,29 @@
package admin_order
import (
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
"in-server/app/main/api/internal/logic/admin_order"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
)
func AdminUpdateOrderHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminUpdateOrderReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := admin_order.NewAdminUpdateOrderLogic(r.Context(), svcCtx)
resp, err := l.AdminUpdateOrder(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/admin_platform_user/admincreateplatformuserhandler.go Normal file
View File

@@ -0,0 +1,30 @@
package admin_platform_user
import (
"net/http"
"in-server/app/main/api/internal/logic/admin_platform_user"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func AdminCreatePlatformUserHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminCreatePlatformUserReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := admin_platform_user.NewAdminCreatePlatformUserLogic(r.Context(), svcCtx)
resp, err := l.AdminCreatePlatformUser(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/admin_platform_user/admindeleteplatformuserhandler.go Normal file
View File

@@ -0,0 +1,30 @@
package admin_platform_user
import (
"net/http"
"in-server/app/main/api/internal/logic/admin_platform_user"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func AdminDeletePlatformUserHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminDeletePlatformUserReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := admin_platform_user.NewAdminDeletePlatformUserLogic(r.Context(), svcCtx)
resp, err := l.AdminDeletePlatformUser(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/admin_platform_user/admingetplatformuserdetailhandler.go Normal file
View File

@@ -0,0 +1,30 @@
package admin_platform_user
import (
"net/http"
"in-server/app/main/api/internal/logic/admin_platform_user"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func AdminGetPlatformUserDetailHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminGetPlatformUserDetailReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := admin_platform_user.NewAdminGetPlatformUserDetailLogic(r.Context(), svcCtx)
resp, err := l.AdminGetPlatformUserDetail(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/admin_platform_user/admingetplatformuserlisthandler.go Normal file
View File

@@ -0,0 +1,30 @@
package admin_platform_user
import (
"net/http"
"in-server/app/main/api/internal/logic/admin_platform_user"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func AdminGetPlatformUserListHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminGetPlatformUserListReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := admin_platform_user.NewAdminGetPlatformUserListLogic(r.Context(), svcCtx)
resp, err := l.AdminGetPlatformUserList(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/admin_platform_user/adminupdateplatformuserhandler.go Normal file
View File

@@ -0,0 +1,30 @@
package admin_platform_user
import (
"net/http"
"in-server/app/main/api/internal/logic/admin_platform_user"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func AdminUpdatePlatformUserHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminUpdatePlatformUserReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := admin_platform_user.NewAdminUpdatePlatformUserLogic(r.Context(), svcCtx)
resp, err := l.AdminUpdatePlatformUser(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/admin_product/admincreateproducthandler.go Normal file
View File

@@ -0,0 +1,30 @@
package admin_product
import (
"net/http"
"in-server/app/main/api/internal/logic/admin_product"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func AdminCreateProductHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminCreateProductReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := admin_product.NewAdminCreateProductLogic(r.Context(), svcCtx)
resp, err := l.AdminCreateProduct(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/admin_product/admindeleteproducthandler.go Normal file
View File

@@ -0,0 +1,30 @@
package admin_product
import (
"net/http"
"in-server/app/main/api/internal/logic/admin_product"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func AdminDeleteProductHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminDeleteProductReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := admin_product.NewAdminDeleteProductLogic(r.Context(), svcCtx)
resp, err := l.AdminDeleteProduct(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/admin_product/admingetproductdetailhandler.go Normal file
View File

@@ -0,0 +1,30 @@
package admin_product
import (
"net/http"
"in-server/app/main/api/internal/logic/admin_product"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func AdminGetProductDetailHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminGetProductDetailReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := admin_product.NewAdminGetProductDetailLogic(r.Context(), svcCtx)
resp, err := l.AdminGetProductDetail(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/admin_product/admingetproductfeaturelisthandler.go Normal file
View File

@@ -0,0 +1,30 @@
package admin_product
import (
"net/http"
"in-server/app/main/api/internal/logic/admin_product"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func AdminGetProductFeatureListHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminGetProductFeatureListReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := admin_product.NewAdminGetProductFeatureListLogic(r.Context(), svcCtx)
resp, err := l.AdminGetProductFeatureList(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/admin_product/admingetproductlisthandler.go Normal file
View File

@@ -0,0 +1,30 @@
package admin_product
import (
"net/http"
"in-server/app/main/api/internal/logic/admin_product"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func AdminGetProductListHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminGetProductListReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := admin_product.NewAdminGetProductListLogic(r.Context(), svcCtx)
resp, err := l.AdminGetProductList(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/admin_product/adminupdateproductfeatureshandler.go Normal file
View File

@@ -0,0 +1,30 @@
package admin_product
import (
"net/http"
"in-server/app/main/api/internal/logic/admin_product"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func AdminUpdateProductFeaturesHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminUpdateProductFeaturesReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := admin_product.NewAdminUpdateProductFeaturesLogic(r.Context(), svcCtx)
resp, err := l.AdminUpdateProductFeatures(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/admin_product/adminupdateproducthandler.go Normal file
View File

@@ -0,0 +1,30 @@
package admin_product
import (
"net/http"
"in-server/app/main/api/internal/logic/admin_product"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func AdminUpdateProductHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminUpdateProductReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := admin_product.NewAdminUpdateProductLogic(r.Context(), svcCtx)
resp, err := l.AdminUpdateProduct(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/admin_query/admingetquerycleanupconfiglisthandler.go Normal file
View File

@@ -0,0 +1,30 @@
package admin_query
import (
"net/http"
"in-server/app/main/api/internal/logic/admin_query"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func AdminGetQueryCleanupConfigListHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminGetQueryCleanupConfigListReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := admin_query.NewAdminGetQueryCleanupConfigListLogic(r.Context(), svcCtx)
resp, err := l.AdminGetQueryCleanupConfigList(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/admin_query/admingetquerycleanupdetaillisthandler.go Normal file
View File

@@ -0,0 +1,30 @@
package admin_query
import (
"net/http"
"in-server/app/main/api/internal/logic/admin_query"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func AdminGetQueryCleanupDetailListHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminGetQueryCleanupDetailListReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := admin_query.NewAdminGetQueryCleanupDetailListLogic(r.Context(), svcCtx)
resp, err := l.AdminGetQueryCleanupDetailList(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/admin_query/admingetquerycleanuploglisthandler.go Normal file
View File

@@ -0,0 +1,30 @@
package admin_query
import (
"net/http"
"in-server/app/main/api/internal/logic/admin_query"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func AdminGetQueryCleanupLogListHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminGetQueryCleanupLogListReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := admin_query.NewAdminGetQueryCleanupLogListLogic(r.Context(), svcCtx)
resp, err := l.AdminGetQueryCleanupLogList(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/admin_query/admingetquerydetailbyorderidhandler.go Normal file
View File

@@ -0,0 +1,30 @@
package admin_query
import (
"net/http"
"in-server/app/main/api/internal/logic/admin_query"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func AdminGetQueryDetailByOrderIdHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminGetQueryDetailByOrderIdReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := admin_query.NewAdminGetQueryDetailByOrderIdLogic(r.Context(), svcCtx)
resp, err := l.AdminGetQueryDetailByOrderId(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/admin_query/adminupdatequerycleanupconfighandler.go Normal file
View File

@@ -0,0 +1,30 @@
package admin_query
import (
"net/http"
"in-server/app/main/api/internal/logic/admin_query"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func AdminUpdateQueryCleanupConfigHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminUpdateQueryCleanupConfigReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := admin_query.NewAdminUpdateQueryCleanupConfigLogic(r.Context(), svcCtx)
resp, err := l.AdminUpdateQueryCleanupConfig(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/admin_role/createrolehandler.go Normal file
View File

@@ -0,0 +1,30 @@
package admin_role
import (
"net/http"
"in-server/app/main/api/internal/logic/admin_role"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func CreateRoleHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.CreateRoleReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := admin_role.NewCreateRoleLogic(r.Context(), svcCtx)
resp, err := l.CreateRole(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/admin_role/deleterolehandler.go Normal file
View File

@@ -0,0 +1,30 @@
package admin_role
import (
"net/http"
"in-server/app/main/api/internal/logic/admin_role"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func DeleteRoleHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.DeleteRoleReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := admin_role.NewDeleteRoleLogic(r.Context(), svcCtx)
resp, err := l.DeleteRole(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/admin_role/getroledetailhandler.go Normal file
View File

@@ -0,0 +1,30 @@
package admin_role
import (
"net/http"
"in-server/app/main/api/internal/logic/admin_role"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func GetRoleDetailHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.GetRoleDetailReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := admin_role.NewGetRoleDetailLogic(r.Context(), svcCtx)
resp, err := l.GetRoleDetail(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/admin_role/getrolelisthandler.go Normal file
View File

@@ -0,0 +1,30 @@
package admin_role
import (
"net/http"
"in-server/app/main/api/internal/logic/admin_role"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func GetRoleListHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.GetRoleListReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := admin_role.NewGetRoleListLogic(r.Context(), svcCtx)
resp, err := l.GetRoleList(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/admin_role/updaterolehandler.go Normal file
View File

@@ -0,0 +1,30 @@
package admin_role
import (
"net/http"
"in-server/app/main/api/internal/logic/admin_role"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func UpdateRoleHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.UpdateRoleReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := admin_role.NewUpdateRoleLogic(r.Context(), svcCtx)
resp, err := l.UpdateRole(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/admin_role_api/adminassignroleapihandler.go Normal file
View File

@@ -0,0 +1,30 @@
package admin_role_api
import (
"net/http"
"in-server/app/main/api/internal/logic/admin_role_api"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func AdminAssignRoleApiHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminAssignRoleApiReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := admin_role_api.NewAdminAssignRoleApiLogic(r.Context(), svcCtx)
resp, err := l.AdminAssignRoleApi(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/admin_role_api/admingetallapilisthandler.go Normal file
View File

@@ -0,0 +1,30 @@
package admin_role_api
import (
"net/http"
"in-server/app/main/api/internal/logic/admin_role_api"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func AdminGetAllApiListHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminGetAllApiListReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := admin_role_api.NewAdminGetAllApiListLogic(r.Context(), svcCtx)
resp, err := l.AdminGetAllApiList(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/admin_role_api/admingetroleapilisthandler.go Normal file
View File

@@ -0,0 +1,30 @@
package admin_role_api
import (
"net/http"
"in-server/app/main/api/internal/logic/admin_role_api"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func AdminGetRoleApiListHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminGetRoleApiListReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := admin_role_api.NewAdminGetRoleApiListLogic(r.Context(), svcCtx)
resp, err := l.AdminGetRoleApiList(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/admin_role_api/adminremoveroleapihandler.go Normal file
View File

@@ -0,0 +1,30 @@
package admin_role_api
import (
"net/http"
"in-server/app/main/api/internal/logic/admin_role_api"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func AdminRemoveRoleApiHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminRemoveRoleApiReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := admin_role_api.NewAdminRemoveRoleApiLogic(r.Context(), svcCtx)
resp, err := l.AdminRemoveRoleApi(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/admin_role_api/adminupdateroleapihandler.go Normal file
View File

@@ -0,0 +1,30 @@
package admin_role_api
import (
"net/http"
"in-server/app/main/api/internal/logic/admin_role_api"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func AdminUpdateRoleApiHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminUpdateRoleApiReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := admin_role_api.NewAdminUpdateRoleApiLogic(r.Context(), svcCtx)
resp, err := l.AdminUpdateRoleApi(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/admin_user/admincreateuserhandler.go Normal file
View File

@@ -0,0 +1,30 @@
package admin_user
import (
"net/http"
"in-server/app/main/api/internal/logic/admin_user"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func AdminCreateUserHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminCreateUserReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := admin_user.NewAdminCreateUserLogic(r.Context(), svcCtx)
resp, err := l.AdminCreateUser(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/admin_user/admindeleteuserhandler.go Normal file
View File

@@ -0,0 +1,30 @@
package admin_user
import (
"net/http"
"in-server/app/main/api/internal/logic/admin_user"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func AdminDeleteUserHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminDeleteUserReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := admin_user.NewAdminDeleteUserLogic(r.Context(), svcCtx)
resp, err := l.AdminDeleteUser(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/admin_user/admingetuserdetailhandler.go Normal file
View File

@@ -0,0 +1,30 @@
package admin_user
import (
"net/http"
"in-server/app/main/api/internal/logic/admin_user"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func AdminGetUserDetailHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminGetUserDetailReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := admin_user.NewAdminGetUserDetailLogic(r.Context(), svcCtx)
resp, err := l.AdminGetUserDetail(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/admin_user/admingetuserlisthandler.go Normal file
View File

@@ -0,0 +1,30 @@
package admin_user
import (
"net/http"
"in-server/app/main/api/internal/logic/admin_user"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func AdminGetUserListHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminGetUserListReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := admin_user.NewAdminGetUserListLogic(r.Context(), svcCtx)
resp, err := l.AdminGetUserList(&req)
result.HttpResult(r, w, resp, err)
}
}

29
app/main/api/internal/handler/admin_user/adminresetpasswordhandler.go Normal file
View File

@@ -0,0 +1,29 @@
package admin_user
import (
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
"in-server/app/main/api/internal/logic/admin_user"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
)
func AdminResetPasswordHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminResetPasswordReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := admin_user.NewAdminResetPasswordLogic(r.Context(), svcCtx)
resp, err := l.AdminResetPassword(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/admin_user/adminupdateuserhandler.go Normal file
View File

@@ -0,0 +1,30 @@
package admin_user
import (
"net/http"
"in-server/app/main/api/internal/logic/admin_user"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func AdminUpdateUserHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminUpdateUserReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := admin_user.NewAdminUpdateUserLogic(r.Context(), svcCtx)
resp, err := l.AdminUpdateUser(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/admin_user/adminuserinfohandler.go Normal file
View File

@@ -0,0 +1,30 @@
package admin_user
import (
"net/http"
"in-server/app/main/api/internal/logic/admin_user"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func AdminUserInfoHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminUserInfoReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := admin_user.NewAdminUserInfoLogic(r.Context(), svcCtx)
resp, err := l.AdminUserInfo(&req)
result.HttpResult(r, w, resp, err)
}
}

17
app/main/api/internal/handler/app/getappconfighandler.go Normal file
View File

@@ -0,0 +1,17 @@
package app
import (
"net/http"
"in-server/app/main/api/internal/logic/app"
"in-server/app/main/api/internal/svc"
"in-server/common/result"
)
func GetAppConfigHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
l := app.NewGetAppConfigLogic(r.Context(), svcCtx)
resp, err := l.GetAppConfig()
result.HttpResult(r, w, resp, err)
}
}

17
app/main/api/internal/handler/app/getappversionhandler.go Normal file
View File

@@ -0,0 +1,17 @@
package app
import (
"net/http"
"in-server/app/main/api/internal/logic/app"
"in-server/app/main/api/internal/svc"
"in-server/common/result"
)
func GetAppVersionHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
l := app.NewGetAppVersionLogic(r.Context(), svcCtx)
resp, err := l.GetAppVersion()
result.HttpResult(r, w, resp, err)
}
}

17
app/main/api/internal/handler/app/healthcheckhandler.go Normal file
View File

@@ -0,0 +1,17 @@
package app
import (
"net/http"
"in-server/app/main/api/internal/logic/app"
"in-server/app/main/api/internal/svc"
"in-server/common/result"
)
func HealthCheckHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
l := app.NewHealthCheckLogic(r.Context(), svcCtx)
resp, err := l.HealthCheck()
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/auth/sendsmshandler.go Normal file
View File

@@ -0,0 +1,30 @@
package auth
import (
"net/http"
"in-server/app/main/api/internal/logic/auth"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func SendSmsHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.SendSmsReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := auth.NewSendSmsLogic(r.Context(), svcCtx)
err := l.SendSms(&req)
result.HttpResult(r, w, nil, err)
}
}

30
app/main/api/internal/handler/authorization/downloadauthorizationdocumenthandler.go Normal file
View File

@@ -0,0 +1,30 @@
package authorization
import (
"net/http"
"in-server/app/main/api/internal/logic/authorization"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func DownloadAuthorizationDocumentHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.DownloadAuthorizationDocumentReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := authorization.NewDownloadAuthorizationDocumentLogic(r.Context(), svcCtx)
resp, err := l.DownloadAuthorizationDocument(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/authorization/getauthorizationdocumentbyorderhandler.go Normal file
View File

@@ -0,0 +1,30 @@
package authorization
import (
"net/http"
"in-server/app/main/api/internal/logic/authorization"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func GetAuthorizationDocumentByOrderHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.GetAuthorizationDocumentByOrderReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := authorization.NewGetAuthorizationDocumentByOrderLogic(r.Context(), svcCtx)
resp, err := l.GetAuthorizationDocumentByOrder(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/authorization/getauthorizationdocumenthandler.go Normal file
View File

@@ -0,0 +1,30 @@
package authorization
import (
"net/http"
"in-server/app/main/api/internal/logic/authorization"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func GetAuthorizationDocumentHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.GetAuthorizationDocumentReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := authorization.NewGetAuthorizationDocumentLogic(r.Context(), svcCtx)
resp, err := l.GetAuthorizationDocument(&req)
result.HttpResult(r, w, resp, err)
}
}

17
app/main/api/internal/handler/notification/getnotificationshandler.go Normal file
View File

@@ -0,0 +1,17 @@
package notification
import (
"net/http"
"in-server/app/main/api/internal/logic/notification"
"in-server/app/main/api/internal/svc"
"in-server/common/result"
)
func GetNotificationsHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
l := notification.NewGetNotificationsLogic(r.Context(), svcCtx)
resp, err := l.GetNotifications()
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/product/getproductappbyenhandler.go Normal file
View File

@@ -0,0 +1,30 @@
package product
import (
"net/http"
"in-server/app/main/api/internal/logic/product"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func GetProductAppByEnHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.GetProductByEnRequest
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := product.NewGetProductAppByEnLogic(r.Context(), svcCtx)
resp, err := l.GetProductAppByEn(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/product/getproductbyenhandler.go Normal file
View File

@@ -0,0 +1,30 @@
package product
import (
"net/http"
"in-server/app/main/api/internal/logic/product"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func GetProductByEnHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.GetProductByEnRequest
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := product.NewGetProductByEnLogic(r.Context(), svcCtx)
resp, err := l.GetProductByEn(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/product/getproductbyidhandler.go Normal file
View File

@@ -0,0 +1,30 @@
package product
import (
"net/http"
"in-server/app/main/api/internal/logic/product"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func GetProductByIDHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.GetProductByIDRequest
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := product.NewGetProductByIDLogic(r.Context(), svcCtx)
resp, err := l.GetProductByID(&req)
result.HttpResult(r, w, resp, err)
}
}

38
app/main/api/internal/handler/query/downloadreportpdfhandler.go Normal file
View File

@@ -0,0 +1,38 @@
package query
import (
"net/http"
"in-server/app/main/api/internal/logic/query"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func DownloadReportPdfHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.DownloadReportPdfReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := query.NewDownloadReportPdfLogic(r.Context(), svcCtx)
resp, err := l.DownloadReportPdf(&req)
if err != nil {
result.HttpResult(r, w, nil, err)
return
}
// 直接以 PDF 文件流返回
w.Header().Set("Content-Type", "application/pdf")
w.Header().Set("Content-Disposition", "attachment; filename=\""+resp.FileName+"\"")
_, _ = w.Write(resp.Content)
}
}

30
app/main/api/internal/handler/query/querydetailbyorderidhandler.go Normal file
View File

@@ -0,0 +1,30 @@
package query
import (
"net/http"
"in-server/app/main/api/internal/logic/query"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func QueryDetailByOrderIdHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.QueryDetailByOrderIdReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := query.NewQueryDetailByOrderIdLogic(r.Context(), svcCtx)
resp, err := l.QueryDetailByOrderId(&req)
result.HttpResult(r, w, resp, err)
}
}

29
app/main/api/internal/handler/query/querydetailbyorderidpublichandler.go Normal file
View File

@@ -0,0 +1,29 @@
package query
import (
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
"in-server/app/main/api/internal/logic/query"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
)
func QueryDetailByOrderIdPublicHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.QueryDetailByOrderIdReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := query.NewQueryDetailByOrderIdPublicLogic(r.Context(), svcCtx)
resp, err := l.QueryDetailByOrderIdPublic(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/query/querydetailbyordernohandler.go Normal file
View File

@@ -0,0 +1,30 @@
package query
import (
"net/http"
"in-server/app/main/api/internal/logic/query"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func QueryDetailByOrderNoHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.QueryDetailByOrderNoReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := query.NewQueryDetailByOrderNoLogic(r.Context(), svcCtx)
resp, err := l.QueryDetailByOrderNo(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/query/queryexamplehandler.go Normal file
View File

@@ -0,0 +1,30 @@
package query
import (
"net/http"
"in-server/app/main/api/internal/logic/query"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func QueryExampleHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.QueryExampleReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := query.NewQueryExampleLogic(r.Context(), svcCtx)
resp, err := l.QueryExample(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/query/querygeneratesharelinkhandler.go Normal file
View File

@@ -0,0 +1,30 @@
package query
import (
"net/http"
"in-server/app/main/api/internal/logic/query"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func QueryGenerateShareLinkHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.QueryGenerateShareLinkReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := query.NewQueryGenerateShareLinkLogic(r.Context(), svcCtx)
resp, err := l.QueryGenerateShareLink(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/query/querylisthandler.go Normal file
View File

@@ -0,0 +1,30 @@
package query
import (
"net/http"
"in-server/app/main/api/internal/logic/query"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func QueryListHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.QueryListReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := query.NewQueryListLogic(r.Context(), svcCtx)
resp, err := l.QueryList(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/query/queryprovisionalorderhandler.go Normal file
View File

@@ -0,0 +1,30 @@
package query
import (
"net/http"
"in-server/app/main/api/internal/logic/query"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func QueryProvisionalOrderHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.QueryProvisionalOrderReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := query.NewQueryProvisionalOrderLogic(r.Context(), svcCtx)
resp, err := l.QueryProvisionalOrder(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/query/queryretryhandler.go Normal file
View File

@@ -0,0 +1,30 @@
package query
import (
"net/http"
"in-server/app/main/api/internal/logic/query"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func QueryRetryHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.QueryRetryReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := query.NewQueryRetryLogic(r.Context(), svcCtx)
resp, err := l.QueryRetry(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/query/queryserviceagenthandler.go Normal file
View File

@@ -0,0 +1,30 @@
package query
import (
"net/http"
"in-server/app/main/api/internal/logic/query"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func QueryServiceAgentHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.QueryServiceReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := query.NewQueryServiceLogic(r.Context(), svcCtx)
resp, err := l.QueryService(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/query/queryserviceapphandler.go Normal file
View File

@@ -0,0 +1,30 @@
package query
import (
"net/http"
"in-server/app/main/api/internal/logic/query"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func QueryServiceAppHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.QueryServiceReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := query.NewQueryServiceLogic(r.Context(), svcCtx)
resp, err := l.QueryService(&req)
result.HttpResult(r, w, resp, err)
}
}

25
app/main/api/internal/handler/query/queryservicehandler.go Normal file
View File

@@ -0,0 +1,25 @@
package query
import (
"net/http"
"in-server/app/main/api/internal/logic/query"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"github.com/zeromicro/go-zero/rest/httpx"
)
func QueryServiceHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.QueryServiceReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
l := query.NewQueryServiceLogic(r.Context(), svcCtx)
resp, err := l.QueryService(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/query/querysharedetailhandler.go Normal file
View File

@@ -0,0 +1,30 @@
package query
import (
"net/http"
"in-server/app/main/api/internal/logic/query"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func QueryShareDetailHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.QueryShareDetailReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := query.NewQueryShareDetailLogic(r.Context(), svcCtx)
resp, err := l.QueryShareDetail(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/query/querysingletesthandler.go Normal file
View File

@@ -0,0 +1,30 @@
package query
import (
"net/http"
"in-server/app/main/api/internal/logic/query"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func QuerySingleTestHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.QuerySingleTestReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := query.NewQuerySingleTestLogic(r.Context(), svcCtx)
resp, err := l.QuerySingleTest(&req)
result.HttpResult(r, w, resp, err)
}
}

31
app/main/api/internal/handler/query/updatequerydatahandler.go Normal file
View File

@@ -0,0 +1,31 @@
package query
import (
"net/http"
"in-server/app/main/api/internal/logic/query"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
// 更新查询数据
func UpdateQueryDataHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.UpdateQueryDataReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := query.NewUpdateQueryDataLogic(r.Context(), svcCtx)
resp, err := l.UpdateQueryData(&req)
result.HttpResult(r, w, resp, err)
}
}

35
app/main/api/internal/handler/report/downloadreportpdfhandler.go Normal file
View File

@@ -0,0 +1,35 @@
package report
import (
"net/http"
"in-server/app/main/api/internal/logic/report"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"github.com/zeromicro/go-zero/rest/httpx"
)
func DownloadReportPdfHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.DownloadReportPdfReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
l := report.NewDownloadReportPdfLogic(r.Context(), svcCtx)
resp, err := l.DownloadReportPdf(&req)
if err != nil {
result.HttpResult(r, w, nil, err)
return
}
// 直接以文件流形式返回，前端更易处理下载
w.Header().Set("Content-Type", "application/pdf")
w.Header().Set("Content-Disposition", "attachment; filename=\""+resp.FileName+"\"")
_, _ = w.Write(resp.Content)
}
}

794
app/main/api/internal/handler/routes.go Normal file
View File

@@ -0,0 +1,794 @@
// Code generated by goctl. DO NOT EDIT.
package handler
import (
"net/http"
admin_api "in-server/app/main/api/internal/handler/admin_api"
admin_auth "in-server/app/main/api/internal/handler/admin_auth"
admin_feature "in-server/app/main/api/internal/handler/admin_feature"
admin_menu "in-server/app/main/api/internal/handler/admin_menu"
admin_notification "in-server/app/main/api/internal/handler/admin_notification"
admin_order "in-server/app/main/api/internal/handler/admin_order"
admin_platform_user "in-server/app/main/api/internal/handler/admin_platform_user"
admin_product "in-server/app/main/api/internal/handler/admin_product"
admin_query "in-server/app/main/api/internal/handler/admin_query"
admin_role "in-server/app/main/api/internal/handler/admin_role"
admin_role_api "in-server/app/main/api/internal/handler/admin_role_api"
admin_user "in-server/app/main/api/internal/handler/admin_user"
app "in-server/app/main/api/internal/handler/app"
auth "in-server/app/main/api/internal/handler/auth"
authorization "in-server/app/main/api/internal/handler/authorization"
notification "in-server/app/main/api/internal/handler/notification"
product "in-server/app/main/api/internal/handler/product"
query "in-server/app/main/api/internal/handler/query"
user "in-server/app/main/api/internal/handler/user"
"in-server/app/main/api/internal/svc"
"github.com/zeromicro/go-zero/rest"
)
func RegisterHandlers(server *rest.Server, serverCtx *svc.ServiceContext) {
server.AddRoutes(
rest.WithMiddlewares(
[]rest.Middleware{serverCtx.AdminAuthInterceptor},
[]rest.Route{
{
Method: http.MethodPut,
Path: "/admin/api/batch-update-status",
Handler: admin_api.AdminBatchUpdateApiStatusHandler(serverCtx),
},
{
Method: http.MethodPost,
Path: "/admin/api/create",
Handler: admin_api.AdminCreateApiHandler(serverCtx),
},
{
Method: http.MethodDelete,
Path: "/admin/api/delete/:id",
Handler: admin_api.AdminDeleteApiHandler(serverCtx),
},
{
Method: http.MethodGet,
Path: "/admin/api/detail/:id",
Handler: admin_api.AdminGetApiDetailHandler(serverCtx),
},
{
Method: http.MethodGet,
Path: "/admin/api/list",
Handler: admin_api.AdminGetApiListHandler(serverCtx),
},
{
Method: http.MethodPut,
Path: "/admin/api/update/:id",
Handler: admin_api.AdminUpdateApiHandler(serverCtx),
},
}...,
),
rest.WithPrefix("/api/v1"),
)
server.AddRoutes(
[]rest.Route{
{
// 登录
Method: http.MethodPost,
Path: "/login",
Handler: admin_auth.AdminLoginHandler(serverCtx),
},
},
rest.WithPrefix("/api/v1/admin/auth"),
)
server.AddRoutes(
rest.WithMiddlewares(
[]rest.Middleware{serverCtx.AdminAuthInterceptor},
[]rest.Route{
{
Method: http.MethodPost,
Path: "/config-example",
Handler: admin_feature.AdminConfigFeatureExampleHandler(serverCtx),
},
{
Method: http.MethodPost,
Path: "/create",
Handler: admin_feature.AdminCreateFeatureHandler(serverCtx),
},
{
Method: http.MethodDelete,
Path: "/delete/:id",
Handler: admin_feature.AdminDeleteFeatureHandler(serverCtx),
},
{
Method: http.MethodGet,
Path: "/detail/:id",
Handler: admin_feature.AdminGetFeatureDetailHandler(serverCtx),
},
{
Method: http.MethodGet,
Path: "/example/:feature_id",
Handler: admin_feature.AdminGetFeatureExampleHandler(serverCtx),
},
{
Method: http.MethodGet,
Path: "/list",
Handler: admin_feature.AdminGetFeatureListHandler(serverCtx),
},
{
Method: http.MethodPut,
Path: "/update/:id",
Handler: admin_feature.AdminUpdateFeatureHandler(serverCtx),
},
}...,
),
rest.WithPrefix("/api/v1/admin/feature"),
)
server.AddRoutes(
rest.WithMiddlewares(
[]rest.Middleware{serverCtx.AdminAuthInterceptor},
[]rest.Route{
{
// 获取所有菜单(树形结构)
Method: http.MethodGet,
Path: "/all",
Handler: admin_menu.GetMenuAllHandler(serverCtx),
},
{
// 创建菜单
Method: http.MethodPost,
Path: "/create",
Handler: admin_menu.CreateMenuHandler(serverCtx),
},
{
// 删除菜单
Method: http.MethodDelete,
Path: "/delete/:id",
Handler: admin_menu.DeleteMenuHandler(serverCtx),
},
{
// 获取菜单详情
Method: http.MethodGet,
Path: "/detail/:id",
Handler: admin_menu.GetMenuDetailHandler(serverCtx),
},
{
// 获取菜单列表
Method: http.MethodGet,
Path: "/list",
Handler: admin_menu.GetMenuListHandler(serverCtx),
},
{
// 更新菜单
Method: http.MethodPut,
Path: "/update/:id",
Handler: admin_menu.UpdateMenuHandler(serverCtx),
},
}...,
),
rest.WithPrefix("/api/v1/admin/menu"),
)
server.AddRoutes(
rest.WithMiddlewares(
[]rest.Middleware{serverCtx.AdminAuthInterceptor},
[]rest.Route{
{
Method: http.MethodPost,
Path: "/create",
Handler: admin_notification.AdminCreateNotificationHandler(serverCtx),
},
{
Method: http.MethodDelete,
Path: "/delete/:id",
Handler: admin_notification.AdminDeleteNotificationHandler(serverCtx),
},
{
Method: http.MethodGet,
Path: "/detail/:id",
Handler: admin_notification.AdminGetNotificationDetailHandler(serverCtx),
},
{
Method: http.MethodGet,
Path: "/list",
Handler: admin_notification.AdminGetNotificationListHandler(serverCtx),
},
{
Method: http.MethodPut,
Path: "/update/:id",
Handler: admin_notification.AdminUpdateNotificationHandler(serverCtx),
},
}...,
),
rest.WithPrefix("/api/v1/admin/notification"),
)
server.AddRoutes(
rest.WithMiddlewares(
[]rest.Middleware{serverCtx.AdminAuthInterceptor},
[]rest.Route{
{
// 创建订单
Method: http.MethodPost,
Path: "/create",
Handler: admin_order.AdminCreateOrderHandler(serverCtx),
},
{
// 删除订单
Method: http.MethodDelete,
Path: "/delete/:id",
Handler: admin_order.AdminDeleteOrderHandler(serverCtx),
},
{
// 获取订单详情
Method: http.MethodGet,
Path: "/detail/:id",
Handler: admin_order.AdminGetOrderDetailHandler(serverCtx),
},
{
// 获取订单列表
Method: http.MethodGet,
Path: "/list",
Handler: admin_order.AdminGetOrderListHandler(serverCtx),
},
{
// 订单退款
Method: http.MethodPost,
Path: "/refund/:id",
Handler: admin_order.AdminRefundOrderHandler(serverCtx),
},
{
// 重新执行代理处理
Method: http.MethodPost,
Path: "/retry-agent-process/:id",
Handler: admin_order.AdminRetryAgentProcessHandler(serverCtx),
},
{
// 更新订单
Method: http.MethodPut,
Path: "/update/:id",
Handler: admin_order.AdminUpdateOrderHandler(serverCtx),
},
}...,
),
rest.WithPrefix("/api/v1/admin/order"),
)
server.AddRoutes(
rest.WithMiddlewares(
[]rest.Middleware{serverCtx.AdminAuthInterceptor},
[]rest.Route{
{
Method: http.MethodPost,
Path: "/create",
Handler: admin_platform_user.AdminCreatePlatformUserHandler(serverCtx),
},
{
Method: http.MethodDelete,
Path: "/delete/:id",
Handler: admin_platform_user.AdminDeletePlatformUserHandler(serverCtx),
},
{
Method: http.MethodGet,
Path: "/detail/:id",
Handler: admin_platform_user.AdminGetPlatformUserDetailHandler(serverCtx),
},
{
Method: http.MethodGet,
Path: "/list",
Handler: admin_platform_user.AdminGetPlatformUserListHandler(serverCtx),
},
{
Method: http.MethodPut,
Path: "/update/:id",
Handler: admin_platform_user.AdminUpdatePlatformUserHandler(serverCtx),
},
}...,
),
rest.WithPrefix("/api/v1/admin/platform_user"),
)
server.AddRoutes(
rest.WithMiddlewares(
[]rest.Middleware{serverCtx.AdminAuthInterceptor},
[]rest.Route{
{
Method: http.MethodPost,
Path: "/create",
Handler: admin_product.AdminCreateProductHandler(serverCtx),
},
{
Method: http.MethodDelete,
Path: "/delete/:id",
Handler: admin_product.AdminDeleteProductHandler(serverCtx),
},
{
Method: http.MethodGet,
Path: "/detail/:id",
Handler: admin_product.AdminGetProductDetailHandler(serverCtx),
},
{
Method: http.MethodGet,
Path: "/feature/list/:product_id",
Handler: admin_product.AdminGetProductFeatureListHandler(serverCtx),
},
{
Method: http.MethodPut,
Path: "/feature/update/:product_id",
Handler: admin_product.AdminUpdateProductFeaturesHandler(serverCtx),
},
{
Method: http.MethodGet,
Path: "/list",
Handler: admin_product.AdminGetProductListHandler(serverCtx),
},
{
Method: http.MethodPut,
Path: "/update/:id",
Handler: admin_product.AdminUpdateProductHandler(serverCtx),
},
}...,
),
rest.WithPrefix("/api/v1/admin/product"),
)
server.AddRoutes(
rest.WithMiddlewares(
[]rest.Middleware{serverCtx.AdminAuthInterceptor},
[]rest.Route{
{
// 更新清理配置
Method: http.MethodPut,
Path: "/cleanup/config",
Handler: admin_query.AdminUpdateQueryCleanupConfigHandler(serverCtx),
},
{
// 获取清理配置列表
Method: http.MethodGet,
Path: "/cleanup/configs",
Handler: admin_query.AdminGetQueryCleanupConfigListHandler(serverCtx),
},
{
// 获取清理详情列表
Method: http.MethodGet,
Path: "/cleanup/details/:log_id",
Handler: admin_query.AdminGetQueryCleanupDetailListHandler(serverCtx),
},
{
// 获取清理日志列表
Method: http.MethodGet,
Path: "/cleanup/logs",
Handler: admin_query.AdminGetQueryCleanupLogListHandler(serverCtx),
},
{
// 获取查询详情
Method: http.MethodGet,
Path: "/detail/:order_id",
Handler: admin_query.AdminGetQueryDetailByOrderIdHandler(serverCtx),
},
}...,
),
rest.WithPrefix("/api/v1/admin/query"),
)
server.AddRoutes(
rest.WithMiddlewares(
[]rest.Middleware{serverCtx.AdminAuthInterceptor},
[]rest.Route{
{
// 创建角色
Method: http.MethodPost,
Path: "/create",
Handler: admin_role.CreateRoleHandler(serverCtx),
},
{
// 删除角色
Method: http.MethodDelete,
Path: "/delete/:id",
Handler: admin_role.DeleteRoleHandler(serverCtx),
},
{
// 获取角色详情
Method: http.MethodGet,
Path: "/detail/:id",
Handler: admin_role.GetRoleDetailHandler(serverCtx),
},
{
// 获取角色列表
Method: http.MethodGet,
Path: "/list",
Handler: admin_role.GetRoleListHandler(serverCtx),
},
{
// 更新角色
Method: http.MethodPut,
Path: "/update/:id",
Handler: admin_role.UpdateRoleHandler(serverCtx),
},
}...,
),
rest.WithPrefix("/api/v1/admin/role"),
)
server.AddRoutes(
rest.WithMiddlewares(
[]rest.Middleware{serverCtx.AdminAuthInterceptor},
[]rest.Route{
{
Method: http.MethodGet,
Path: "/admin/api/all",
Handler: admin_role_api.AdminGetAllApiListHandler(serverCtx),
},
{
Method: http.MethodGet,
Path: "/admin/role/:role_id/api/list",
Handler: admin_role_api.AdminGetRoleApiListHandler(serverCtx),
},
{
Method: http.MethodPost,
Path: "/admin/role/api/assign",
Handler: admin_role_api.AdminAssignRoleApiHandler(serverCtx),
},
{
Method: http.MethodPost,
Path: "/admin/role/api/remove",
Handler: admin_role_api.AdminRemoveRoleApiHandler(serverCtx),
},
{
Method: http.MethodPut,
Path: "/admin/role/api/update",
Handler: admin_role_api.AdminUpdateRoleApiHandler(serverCtx),
},
}...,
),
rest.WithPrefix("/api/v1"),
)
server.AddRoutes(
rest.WithMiddlewares(
[]rest.Middleware{serverCtx.AdminAuthInterceptor},
[]rest.Route{
{
// 创建用户
Method: http.MethodPost,
Path: "/create",
Handler: admin_user.AdminCreateUserHandler(serverCtx),
},
{
// 删除用户
Method: http.MethodDelete,
Path: "/delete/:id",
Handler: admin_user.AdminDeleteUserHandler(serverCtx),
},
{
// 获取用户详情
Method: http.MethodGet,
Path: "/detail/:id",
Handler: admin_user.AdminGetUserDetailHandler(serverCtx),
},
{
// 用户信息
Method: http.MethodGet,
Path: "/info",
Handler: admin_user.AdminUserInfoHandler(serverCtx),
},
{
// 获取用户列表
Method: http.MethodGet,
Path: "/list",
Handler: admin_user.AdminGetUserListHandler(serverCtx),
},
{
// 重置管理员密码
Method: http.MethodPut,
Path: "/reset-password/:id",
Handler: admin_user.AdminResetPasswordHandler(serverCtx),
},
{
// 更新用户
Method: http.MethodPut,
Path: "/update/:id",
Handler: admin_user.AdminUpdateUserHandler(serverCtx),
},
}...,
),
rest.WithPrefix("/api/v1/admin/user"),
)
server.AddRoutes(
[]rest.Route{
{
Method: http.MethodGet,
Path: "/app/config",
Handler: app.GetAppConfigHandler(serverCtx),
},
{
Method: http.MethodGet,
Path: "/app/version",
Handler: app.GetAppVersionHandler(serverCtx),
},
{
// 心跳检测接口
Method: http.MethodGet,
Path: "/health/check",
Handler: app.HealthCheckHandler(serverCtx),
},
},
rest.WithPrefix("/api/v1"),
)
server.AddRoutes(
[]rest.Route{
{
// get mobile verify code
Method: http.MethodPost,
Path: "/auth/sendSms",
Handler: auth.SendSmsHandler(serverCtx),
},
},
rest.WithPrefix("/api/v1"),
)
server.AddRoutes(
[]rest.Route{
{
Method: http.MethodGet,
Path: "/authorization/document/:documentId",
Handler: authorization.GetAuthorizationDocumentHandler(serverCtx),
},
{
Method: http.MethodGet,
Path: "/authorization/document/order/:orderId",
Handler: authorization.GetAuthorizationDocumentByOrderHandler(serverCtx),
},
{
Method: http.MethodGet,
Path: "/authorization/download/:documentId",
Handler: authorization.DownloadAuthorizationDocumentHandler(serverCtx),
},
},
rest.WithPrefix("/api/v1"),
)
server.AddRoutes(
[]rest.Route{
{
// get notifications
Method: http.MethodGet,
Path: "/notification/list",
Handler: notification.GetNotificationsHandler(serverCtx),
},
},
rest.WithPrefix("/api/v1"),
)
server.AddRoutes(
[]rest.Route{
{
Method: http.MethodGet,
Path: "/:id",
Handler: product.GetProductByIDHandler(serverCtx),
},
{
Method: http.MethodGet,
Path: "/en/:product_en",
Handler: product.GetProductByEnHandler(serverCtx),
},
},
rest.WithPrefix("/api/v1/product"),
)
server.AddRoutes(
[]rest.Route{
{
Method: http.MethodGet,
Path: "/app_en/:product_en",
Handler: product.GetProductAppByEnHandler(serverCtx),
},
},
rest.WithPrefix("/api/v1/product"),
)
server.AddRoutes(
rest.WithMiddlewares(
[]rest.Middleware{serverCtx.AuthInterceptor},
[]rest.Route{
{
// query service agent
Method: http.MethodPost,
Path: "/query/service_agent/:product",
Handler: query.QueryServiceAgentHandler(serverCtx),
},
{
Method: http.MethodPost,
Path: "/query/service_app/:product",
Handler: query.QueryServiceAppHandler(serverCtx),
},
}...,
),
rest.WithPrefix("/api/v1"),
)
server.AddRoutes(
rest.WithMiddlewares(
[]rest.Middleware{serverCtx.AuthInterceptor},
[]rest.Route{
{
// query service
Method: http.MethodPost,
Path: "/query/service/:product",
Handler: query.QueryServiceHandler(serverCtx),
},
}...,
),
rest.WithJwt(serverCtx.Config.JwtAuth.AccessSecret),
rest.WithPrefix("/api/v1"),
)
server.AddRoutes(
rest.WithMiddlewares(
[]rest.Middleware{serverCtx.AuthInterceptor},
[]rest.Route{
{
// 生成分享链接
Method: http.MethodPost,
Path: "/query/generate_share_link",
Handler: query.QueryGenerateShareLinkHandler(serverCtx),
},
{
// 查询列表
Method: http.MethodGet,
Path: "/query/list",
Handler: query.QueryListHandler(serverCtx),
},
{
// 查询详情 按订单号 付款查询时
Method: http.MethodGet,
Path: "/query/orderId/:order_id",
Handler: query.QueryDetailByOrderIdHandler(serverCtx),
},
{
// 查询详情 按订单号
Method: http.MethodGet,
Path: "/query/orderNo/:order_no",
Handler: query.QueryDetailByOrderNoHandler(serverCtx),
},
{
// 获取查询临时订单
Method: http.MethodGet,
Path: "/query/provisional_order/:id",
Handler: query.QueryProvisionalOrderHandler(serverCtx),
},
{
// 重试查询
Method: http.MethodPost,
Path: "/query/retry/:id",
Handler: query.QueryRetryHandler(serverCtx),
},
{
// 更新查询数据
Method: http.MethodPost,
Path: "/query/update_data",
Handler: query.UpdateQueryDataHandler(serverCtx),
},
}...,
),
rest.WithJwt(serverCtx.Config.JwtAuth.AccessSecret),
rest.WithPrefix("/api/v1"),
)
server.AddRoutes(
[]rest.Route{
{
// 查询示例
Method: http.MethodGet,
Path: "/query/example",
Handler: query.QueryExampleHandler(serverCtx),
},
{
// 查询详情
Method: http.MethodGet,
Path: "/query/share/:id",
Handler: query.QueryShareDetailHandler(serverCtx),
},
{
Method: http.MethodPost,
Path: "/query/single/test",
Handler: query.QuerySingleTestHandler(serverCtx),
},
{
// 下载报告 PDF
Method: http.MethodGet,
Path: "/report/pdf",
Handler: query.DownloadReportPdfHandler(serverCtx),
},
},
rest.WithPrefix("/api/v1"),
)
server.AddRoutes(
[]rest.Route{
{
// PDF 专用：按订单 ID 获取报告详情（免登录）
Method: http.MethodGet,
Path: "/query/orderId/public/:order_id",
Handler: query.QueryDetailByOrderIdPublicHandler(serverCtx),
},
},
rest.WithPrefix("/api/v1"),
)
server.AddRoutes(
[]rest.Route{
{
// unified auth
Method: http.MethodPost,
Path: "/user/auth",
Handler: user.AuthHandler(serverCtx),
},
{
// password login
Method: http.MethodPost,
Path: "/user/passwordLogin",
Handler: user.PasswordLoginHandler(serverCtx),
},
{
// wechat mini auth
Method: http.MethodPost,
Path: "/user/wxMiniAuth",
Handler: user.WxMiniAuthHandler(serverCtx),
},
{
// wechat h5 auth
Method: http.MethodPost,
Path: "/user/wxh5Auth",
Handler: user.WxH5AuthHandler(serverCtx),
},
{
Method: http.MethodPost,
Path: "/wechat/getSignature",
Handler: user.GetSignatureHandler(serverCtx),
},
},
rest.WithPrefix("/api/v1"),
)
server.AddRoutes(
rest.WithMiddlewares(
[]rest.Middleware{serverCtx.AuthInterceptor},
[]rest.Route{
{
// 绑定手机号
Method: http.MethodPost,
Path: "/user/bindMobile",
Handler: user.BindMobileHandler(serverCtx),
},
}...,
),
rest.WithPrefix("/api/v1"),
)
server.AddRoutes(
[]rest.Route{
{
Method: http.MethodPost,
Path: "/user/cancelOut",
Handler: user.CancelOutHandler(serverCtx),
},
{
// get user info
Method: http.MethodGet,
Path: "/user/detail",
Handler: user.DetailHandler(serverCtx),
},
{
// get new token
Method: http.MethodPost,
Path: "/user/getToken",
Handler: user.GetTokenHandler(serverCtx),
},
},
rest.WithJwt(serverCtx.Config.JwtAuth.AccessSecret),
rest.WithPrefix("/api/v1"),
)
}

25
app/main/api/internal/handler/user/authhandler.go Normal file
View File

@@ -0,0 +1,25 @@
package user
import (
"net/http"
logic "in-server/app/main/api/internal/logic/user"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"github.com/zeromicro/go-zero/rest/httpx"
)
func AuthHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AuthReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
l := logic.NewAuthLogic(r.Context(), svcCtx)
resp, err := l.Auth(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/user/bindmobilehandler.go Normal file
View File

@@ -0,0 +1,30 @@
package user
import (
"net/http"
"in-server/app/main/api/internal/logic/user"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func BindMobileHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.BindMobileReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := user.NewBindMobileLogic(r.Context(), svcCtx)
resp, err := l.BindMobile(&req)
result.HttpResult(r, w, resp, err)
}
}

17
app/main/api/internal/handler/user/cancelouthandler.go Normal file
View File

@@ -0,0 +1,17 @@
package user
import (
"net/http"
"in-server/app/main/api/internal/logic/user"
"in-server/app/main/api/internal/svc"
"in-server/common/result"
)
func CancelOutHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
l := user.NewCancelOutLogic(r.Context(), svcCtx)
err := l.CancelOut()
result.HttpResult(r, w, nil, err)
}
}

17
app/main/api/internal/handler/user/detailhandler.go Normal file
View File

@@ -0,0 +1,17 @@
package user
import (
"net/http"
"in-server/app/main/api/internal/logic/user"
"in-server/app/main/api/internal/svc"
"in-server/common/result"
)
func DetailHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
l := user.NewDetailLogic(r.Context(), svcCtx)
resp, err := l.Detail()
result.HttpResult(r, w, resp, err)
}
}

29
app/main/api/internal/handler/user/getsignaturehandler.go Normal file
View File

@@ -0,0 +1,29 @@
package user
import (
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
"in-server/app/main/api/internal/logic/user"
"in-server/app/main/api/internal/svc"
"in-server/app/main/api/internal/types"
"in-server/common/result"
"in-server/pkg/lzkit/validator"
)
func GetSignatureHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.GetSignatureReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
l := user.NewGetSignatureLogic(r.Context(), svcCtx)
resp, err := l.GetSignature(&req)
result.HttpResult(r, w, resp, err)
}
}

17
app/main/api/internal/handler/user/gettokenhandler.go Normal file
View File

@@ -0,0 +1,17 @@
package user
import (
"net/http"
"in-server/app/main/api/internal/logic/user"
"in-server/app/main/api/internal/svc"
"in-server/common/result"
)
func GetTokenHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
l := user.NewGetTokenLogic(r.Context(), svcCtx)
resp, err := l.GetToken()
result.HttpResult(r, w, resp, err)
}
}

Some files were not shown because too many files have changed in this diff Show More