team/sim-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-02-08 16:19:37 +08:00
commit 958df98745
569 changed files with 61311 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

28
app/main/api/internal/handler/admin_agent/AdminGetAgentRankingHandler.go Normal file
View File

@@ -0,0 +1,28 @@
package admin_agent
import (
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
"sim-server/app/main/api/internal/logic/admin_agent"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
)
func AdminGetAgentRankingHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminGetAgentRankingReq
if err := httpx.Parse(r, &req); err != nil {
httpx.ErrorCtx(r.Context(), w, err)
return
}
l := admin_agent.NewAdminGetAgentRankingLogic(r.Context(), svcCtx)
resp, err := l.AdminGetAgentRanking(&req)
if err != nil {
httpx.ErrorCtx(r.Context(), w, err)
} else {
httpx.OkJsonCtx(r.Context(), w, resp)
}
}
}

28
app/main/api/internal/handler/admin_agent/AdminGetAgentTrendsHandler.go Normal file
View File

@@ -0,0 +1,28 @@
package admin_agent
import (
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
"sim-server/app/main/api/internal/logic/admin_agent"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
)
func AdminGetAgentTrendsHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminGetAgentTrendsReq
if err := httpx.Parse(r, &req); err != nil {
httpx.ErrorCtx(r.Context(), w, err)
return
}
l := admin_agent.NewAdminGetAgentTrendsLogic(r.Context(), svcCtx)
resp, err := l.AdminGetAgentTrends(&req)
if err != nil {
httpx.ErrorCtx(r.Context(), w, err)
} else {
httpx.OkJsonCtx(r.Context(), w, resp)
}
}
}

28
app/main/api/internal/handler/admin_agent/AdminGetOrderTrendsHandler.go Normal file
View File

@@ -0,0 +1,28 @@
package admin_agent
import (
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
"sim-server/app/main/api/internal/logic/admin_agent"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
)
func AdminGetOrderTrendsHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminGetOrderTrendsReq
if err := httpx.Parse(r, &req); err != nil {
httpx.ErrorCtx(r.Context(), w, err)
return
}
l := admin_agent.NewAdminGetOrderTrendsLogic(r.Context(), svcCtx)
resp, err := l.AdminGetOrderTrends(&req)
if err != nil {
httpx.ErrorCtx(r.Context(), w, err)
} else {
httpx.OkJsonCtx(r.Context(), w, resp)
}
}
}

21
app/main/api/internal/handler/admin_agent/AdminGetProductDistributionHandler.go Normal file
View File

@@ -0,0 +1,21 @@
package admin_agent
import (
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
"sim-server/app/main/api/internal/logic/admin_agent"
"sim-server/app/main/api/internal/svc"
)
func AdminGetProductDistributionHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
l := admin_agent.NewAdminGetProductDistributionLogic(r.Context(), svcCtx)
resp, err := l.AdminGetProductDistribution()
if err != nil {
httpx.ErrorCtx(r.Context(), w, err)
} else {
httpx.OkJsonCtx(r.Context(), w, resp)
}
}
}

21
app/main/api/internal/handler/admin_agent/AdminGetRegionDistributionHandler.go Normal file
View File

@@ -0,0 +1,21 @@
package admin_agent
import (
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
"sim-server/app/main/api/internal/logic/admin_agent"
"sim-server/app/main/api/internal/svc"
)
func AdminGetRegionDistributionHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
l := admin_agent.NewAdminGetRegionDistributionLogic(r.Context(), svcCtx)
resp, err := l.AdminGetRegionDistribution()
if err != nil {
httpx.ErrorCtx(r.Context(), w, err)
} else {
httpx.OkJsonCtx(r.Context(), w, resp)
}
}
}

21
app/main/api/internal/handler/admin_agent/AdminGetStatisticsOverviewHandler.go Normal file
View File

@@ -0,0 +1,21 @@
package admin_agent
import (
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
"sim-server/app/main/api/internal/logic/admin_agent"
"sim-server/app/main/api/internal/svc"
)
func AdminGetStatisticsOverviewHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
l := admin_agent.NewAdminGetStatisticsOverviewLogic(r.Context(), svcCtx)
resp, err := l.AdminGetStatisticsOverview()
if err != nil {
httpx.ErrorCtx(r.Context(), w, err)
} else {
httpx.OkJsonCtx(r.Context(), w, resp)
}
}
}

30
app/main/api/internal/handler/admin_agent/AdminSendAgentComplaintNotifyHandler.go Normal file
View File

@@ -0,0 +1,30 @@
package admin_agent
import (
"net/http"
"sim-server/app/main/api/internal/logic/admin_agent"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func AdminSendAgentComplaintNotifyHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminSendAgentComplaintNotifyReq
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_agent.NewAdminSendAgentComplaintNotifyLogic(r.Context(), svcCtx)
resp, err := l.AdminSendAgentComplaintNotify(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/admin_agent/adminauditagenthandler.go Normal file
View File

@@ -0,0 +1,30 @@
package admin_agent
import (
"net/http"
"sim-server/app/main/api/internal/logic/admin_agent"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func AdminAuditAgentHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminAuditAgentReq
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_agent.NewAdminAuditAgentLogic(r.Context(), svcCtx)
resp, err := l.AdminAuditAgent(&req)
result.HttpResult(r, w, resp, err)
}
}

29
app/main/api/internal/handler/admin_agent/adminauditagentwithdrawhandler.go Normal file
View File

@@ -0,0 +1,29 @@
package admin_agent
import (
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
"sim-server/app/main/api/internal/logic/admin_agent"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-server/pkg/lzkit/validator"
)
func AdminAuditAgentWithdrawHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminAuditAgentWithdrawReq
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_agent.NewAdminAuditAgentWithdrawLogic(r.Context(), svcCtx)
resp, err := l.AdminAuditAgentWithdraw(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/admin_agent/admingetagentcommissionlisthandler.go Normal file
View File

@@ -0,0 +1,30 @@
package admin_agent
import (
"net/http"
"sim-server/app/main/api/internal/logic/admin_agent"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func AdminGetAgentCommissionListHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminGetAgentCommissionListReq
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_agent.NewAdminGetAgentCommissionListLogic(r.Context(), svcCtx)
resp, err := l.AdminGetAgentCommissionList(&req)
result.HttpResult(r, w, resp, err)
}
}

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

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

30
app/main/api/internal/handler/admin_agent/admingetagentlinklisthandler.go Normal file
View File

@@ -0,0 +1,30 @@
package admin_agent
import (
"net/http"
"sim-server/app/main/api/internal/logic/admin_agent"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func AdminGetAgentLinkListHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminGetAgentLinkListReq
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_agent.NewAdminGetAgentLinkListLogic(r.Context(), svcCtx)
resp, err := l.AdminGetAgentLinkList(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/admin_agent/admingetagentlisthandler.go Normal file
View File

@@ -0,0 +1,30 @@
package admin_agent
import (
"net/http"
"sim-server/app/main/api/internal/logic/admin_agent"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func AdminGetAgentListHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminGetAgentListReq
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_agent.NewAdminGetAgentListLogic(r.Context(), svcCtx)
resp, err := l.AdminGetAgentList(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/admin_agent/admingetagentorderlisthandler.go Normal file
View File

@@ -0,0 +1,30 @@
package admin_agent
import (
"net/http"
"sim-server/app/main/api/internal/logic/admin_agent"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func AdminGetAgentOrderListHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminGetAgentOrderListReq
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_agent.NewAdminGetAgentOrderListLogic(r.Context(), svcCtx)
resp, err := l.AdminGetAgentOrderList(&req)
result.HttpResult(r, w, resp, err)
}
}

29
app/main/api/internal/handler/admin_agent/admingetagentorderslisthandler.go Normal file
View File

@@ -0,0 +1,29 @@
package admin_agent
import (
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
"sim-server/app/main/api/internal/logic/admin_agent"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-server/pkg/lzkit/validator"
)
func AdminGetAgentOrdersListHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminGetAgentOrdersListReq
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_agent.NewAdminGetAgentOrdersListLogic(r.Context(), svcCtx)
resp, err := l.AdminGetAgentOrdersList(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/admin_agent/admingetagentproductconfiglisthandler.go Normal file
View File

@@ -0,0 +1,30 @@
package admin_agent
import (
"net/http"
"sim-server/app/main/api/internal/logic/admin_agent"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func AdminGetAgentProductConfigListHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminGetAgentProductConfigListReq
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_agent.NewAdminGetAgentProductConfigListLogic(r.Context(), svcCtx)
resp, err := l.AdminGetAgentProductConfigList(&req)
result.HttpResult(r, w, resp, err)
}
}

29
app/main/api/internal/handler/admin_agent/admingetagentwithdrawlisthandler.go Normal file
View File

@@ -0,0 +1,29 @@
package admin_agent
import (
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
"sim-server/app/main/api/internal/logic/admin_agent"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-server/pkg/lzkit/validator"
)
func AdminGetAgentWithdrawListHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminGetAgentWithdrawListReq
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_agent.NewAdminGetAgentWithdrawListLogic(r.Context(), svcCtx)
resp, err := l.AdminGetAgentWithdrawList(&req)
result.HttpResult(r, w, resp, err)
}
}

29
app/main/api/internal/handler/admin_agent/adminrefundagentorderhandler.go Normal file
View File

@@ -0,0 +1,29 @@
package admin_agent
import (
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
"sim-server/app/main/api/internal/logic/admin_agent"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-server/pkg/lzkit/validator"
)
func AdminRefundAgentOrderHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminRefundAgentOrderReq
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_agent.NewAdminRefundAgentOrderLogic(r.Context(), svcCtx)
resp, err := l.AdminRefundAgentOrder(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/admin_agent/adminupdateagentconfighandler.go Normal file
View File

@@ -0,0 +1,30 @@
package admin_agent
import (
"net/http"
"sim-server/app/main/api/internal/logic/admin_agent"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func AdminUpdateAgentConfigHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminUpdateAgentConfigReq
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_agent.NewAdminUpdateAgentConfigLogic(r.Context(), svcCtx)
resp, err := l.AdminUpdateAgentConfig(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/admin_agent/adminupdateagentproductconfighandler.go Normal file
View File

@@ -0,0 +1,30 @@
package admin_agent
import (
"net/http"
"sim-server/app/main/api/internal/logic/admin_agent"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func AdminUpdateAgentProductConfigHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminUpdateAgentProductConfigReq
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_agent.NewAdminUpdateAgentProductConfigLogic(r.Context(), svcCtx)
resp, err := l.AdminUpdateAgentProductConfig(&req)
result.HttpResult(r, w, resp, err)
}
}

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

@@ -0,0 +1,30 @@
package admin_api
import (
"net/http"
"sim-server/app/main/api/internal/logic/admin_api"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-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"
"sim-server/app/main/api/internal/logic/admin_api"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-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"
"sim-server/app/main/api/internal/logic/admin_api"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-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"
"sim-server/app/main/api/internal/logic/admin_api"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-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"
"sim-server/app/main/api/internal/logic/admin_api"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-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"
"sim-server/app/main/api/internal/logic/admin_api"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-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"
"sim-server/app/main/api/internal/logic/admin_auth"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-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"
"sim-server/app/main/api/internal/logic/admin_feature"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-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"
"sim-server/app/main/api/internal/logic/admin_feature"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-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"
"sim-server/app/main/api/internal/logic/admin_feature"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-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"
"sim-server/app/main/api/internal/logic/admin_feature"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-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"
"sim-server/app/main/api/internal/logic/admin_feature"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-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"
"sim-server/app/main/api/internal/logic/admin_feature"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-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"
"sim-server/app/main/api/internal/logic/admin_feature"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-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"
"sim-server/app/main/api/internal/logic/admin_menu"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-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"
"sim-server/app/main/api/internal/logic/admin_menu"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-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"
"sim-server/app/main/api/internal/logic/admin_menu"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-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"
"sim-server/app/main/api/internal/logic/admin_menu"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-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"
"sim-server/app/main/api/internal/logic/admin_menu"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-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"
"sim-server/app/main/api/internal/logic/admin_menu"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-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"
"sim-server/app/main/api/internal/logic/admin_notification"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-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"
"sim-server/app/main/api/internal/logic/admin_notification"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-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"
"sim-server/app/main/api/internal/logic/admin_notification"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-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"
"sim-server/app/main/api/internal/logic/admin_notification"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-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"
"sim-server/app/main/api/internal/logic/admin_notification"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-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)
}
}

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

@@ -0,0 +1,30 @@
package admin_order
import (
"net/http"
"sim-server/app/main/api/internal/logic/admin_order"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
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)
}
}

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

@@ -0,0 +1,30 @@
package admin_order
import (
"net/http"
"sim-server/app/main/api/internal/logic/admin_order"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
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"
"sim-server/app/main/api/internal/logic/admin_order"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-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"
"sim-server/app/main/api/internal/logic/admin_order"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-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)
}
}

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

@@ -0,0 +1,30 @@
package admin_order
import (
"net/http"
"sim-server/app/main/api/internal/logic/admin_order"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
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"
"sim-server/app/main/api/internal/logic/admin_order"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-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)
}
}

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

@@ -0,0 +1,30 @@
package admin_order
import (
"net/http"
"sim-server/app/main/api/internal/logic/admin_order"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
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"
"sim-server/app/main/api/internal/logic/admin_platform_user"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-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"
"sim-server/app/main/api/internal/logic/admin_platform_user"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-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"
"sim-server/app/main/api/internal/logic/admin_platform_user"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-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"
"sim-server/app/main/api/internal/logic/admin_platform_user"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-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"
"sim-server/app/main/api/internal/logic/admin_platform_user"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-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"
"sim-server/app/main/api/internal/logic/admin_product"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-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"
"sim-server/app/main/api/internal/logic/admin_product"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-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"
"sim-server/app/main/api/internal/logic/admin_product"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-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"
"sim-server/app/main/api/internal/logic/admin_product"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-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"
"sim-server/app/main/api/internal/logic/admin_product"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-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"
"sim-server/app/main/api/internal/logic/admin_product"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-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"
"sim-server/app/main/api/internal/logic/admin_product"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-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"
"sim-server/app/main/api/internal/logic/admin_query"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-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"
"sim-server/app/main/api/internal/logic/admin_query"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-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"
"sim-server/app/main/api/internal/logic/admin_query"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-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"
"sim-server/app/main/api/internal/logic/admin_query"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-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"
"sim-server/app/main/api/internal/logic/admin_query"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-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"
"sim-server/app/main/api/internal/logic/admin_role"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-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"
"sim-server/app/main/api/internal/logic/admin_role"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-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"
"sim-server/app/main/api/internal/logic/admin_role"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-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"
"sim-server/app/main/api/internal/logic/admin_role"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-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"
"sim-server/app/main/api/internal/logic/admin_role"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-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"
"sim-server/app/main/api/internal/logic/admin_role_api"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-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"
"sim-server/app/main/api/internal/logic/admin_role_api"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-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"
"sim-server/app/main/api/internal/logic/admin_role_api"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-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"
"sim-server/app/main/api/internal/logic/admin_role_api"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-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"
"sim-server/app/main/api/internal/logic/admin_role_api"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-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"
"sim-server/app/main/api/internal/logic/admin_user"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-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"
"sim-server/app/main/api/internal/logic/admin_user"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-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"
"sim-server/app/main/api/internal/logic/admin_user"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-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"
"sim-server/app/main/api/internal/logic/admin_user"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-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"
"sim-server/app/main/api/internal/logic/admin_user"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-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"
"sim-server/app/main/api/internal/logic/admin_user"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-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"
"sim-server/app/main/api/internal/logic/admin_user"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-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)
}
}

30
app/main/api/internal/handler/agent/applyforagenthandler.go Normal file
View File

@@ -0,0 +1,30 @@
package agent
import (
"net/http"
"sim-server/app/main/api/internal/logic/agent"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func ApplyForAgentHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AgentApplyReq
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 := agent.NewApplyForAgentLogic(r.Context(), svcCtx)
resp, err := l.ApplyForAgent(&req)
result.HttpResult(r, w, resp, err)
}
}

29
app/main/api/internal/handler/agent/createwithdrawhandler.go Normal file
View File

@@ -0,0 +1,29 @@
package agent
import (
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
"sim-server/app/main/api/internal/logic/agent"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-server/pkg/lzkit/validator"
)
func CreateWithdrawHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.CreateWithdrawReq
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 := agent.NewCreateWithdrawLogic(r.Context(), svcCtx)
resp, err := l.CreateWithdraw(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/agent/generatinglinkhandler.go Normal file
View File

@@ -0,0 +1,30 @@
package agent
import (
"net/http"
"sim-server/app/main/api/internal/logic/agent"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func GeneratingLinkHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AgentGeneratingLinkReq
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 := agent.NewGeneratingLinkLogic(r.Context(), svcCtx)
resp, err := l.GeneratingLink(&req)
result.HttpResult(r, w, resp, err)
}
}

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

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

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

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

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

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

30
app/main/api/internal/handler/agent/getcommissionlisthandler.go Normal file
View File

@@ -0,0 +1,30 @@
package agent
import (
"net/http"
"sim-server/app/main/api/internal/logic/agent"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func GetCommissionListHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.GetCommissionListReq
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 := agent.NewGetCommissionListLogic(r.Context(), svcCtx)
resp, err := l.GetCommissionList(&req)
result.HttpResult(r, w, resp, err)
}
}

30
app/main/api/internal/handler/agent/getlinkdatahandler.go Normal file
View File

@@ -0,0 +1,30 @@
package agent
import (
"net/http"
"sim-server/app/main/api/internal/logic/agent"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func GetLinkDataHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.GetLinkDataReq
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 := agent.NewGetLinkDataLogic(r.Context(), svcCtx)
resp, err := l.GetLinkData(&req)
result.HttpResult(r, w, resp, err)
}
}

31
app/main/api/internal/handler/agent/getpromotionquerylisthandler.go Normal file
View File

@@ -0,0 +1,31 @@
package agent
import (
"net/http"
"sim-server/app/main/api/internal/logic/agent"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func GetPromotionQueryListHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.GetPromotionQueryListReq
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 := agent.NewGetPromotionQueryListLogic(r.Context(), svcCtx)
resp, err := l.GetPromotionQueryList(&req)
result.HttpResult(r, w, resp, err)
}
}

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

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

29
app/main/api/internal/handler/agent/getwithdrawlisthandler.go Normal file
View File

@@ -0,0 +1,29 @@
package agent
import (
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
"sim-server/app/main/api/internal/logic/agent"
"sim-server/app/main/api/internal/svc"
"sim-server/app/main/api/internal/types"
"sim-server/common/result"
"sim-server/pkg/lzkit/validator"
)
func GetWithdrawListHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.GetWithdrawListReq
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 := agent.NewGetWithdrawListLogic(r.Context(), svcCtx)
resp, err := l.GetWithdrawList(&req)
result.HttpResult(r, w, resp, err)
}
}

29
app/main/api/internal/handler/agent/shortlinkredirecthandler.go Normal file
View File

@@ -0,0 +1,29 @@
package agent
import (
"net/http"
"sim-server/app/main/api/internal/logic/agent"
"sim-server/app/main/api/internal/svc"
"github.com/zeromicro/go-zero/rest/httpx"
)
func ShortLinkRedirectHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
// 从URL.Path解析shortCode
// 路径格式：/s/{shortCode}
path := r.URL.Path
var shortCode string
if len(path) >= 3 && path[:3] == "/s/" {
shortCode = path[3:]
}
l := agent.NewShortLinkRedirectLogic(r.Context(), svcCtx)
err := l.ShortLinkRedirect(shortCode, r, w)
if err != nil {
httpx.ErrorCtx(r.Context(), w, err)
}
}
}

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

@@ -0,0 +1,17 @@
package app
import (
"net/http"
"sim-server/app/main/api/internal/logic/app"
"sim-server/app/main/api/internal/svc"
"sim-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"
"sim-server/app/main/api/internal/logic/app"
"sim-server/app/main/api/internal/svc"
"sim-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)
}
}

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