team/ycc-proxy-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
2025-11-27 13:09:54 +08:00
commit 3440744179
570 changed files with 61861 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

114
app/main/api/internal/config/config.go Normal file
View File

@@ -0,0 +1,114 @@
package config
import (
"github.com/zeromicro/go-zero/core/stores/cache"
"github.com/zeromicro/go-zero/rest"
)
type Config struct {
rest.RestConf
DataSource string
CacheRedis cache.CacheConf
JwtAuth JwtAuth // JWT 鉴权相关配置
VerifyCode VerifyCode
Encrypt Encrypt
Alipay AlipayConfig
Wxpay WxpayConfig
Applepay ApplepayConfig
Tianyuanapi TianyuanapiConfig
SystemConfig SystemConfig
WechatH5 WechatH5Config
Authorization AuthorizationConfig // 授权书配置
WechatMini WechatMiniConfig
Query QueryConfig
AdminConfig AdminConfig
AdminPromotion AdminPromotion
TaxConfig TaxConfig
}
// JwtAuth 用于 JWT 鉴权配置
type JwtAuth struct {
AccessSecret string // JWT 密钥，用于签发 Token
AccessExpire int64 // Token 过期时间，单位为秒
RefreshAfter int64
}
type VerifyCode struct {
AccessKeyID string
AccessKeySecret string
EndpointURL string
SignName string
TemplateCode string
ValidTime int
}
type Encrypt struct {
SecretKey string
}
type AlipayConfig struct {
AppID string
PrivateKey string
AlipayPublicKey string
AppCertPath string // 应用公钥证书路径
AlipayCertPath string // 支付宝公钥证书路径
AlipayRootCertPath string // 根证书路径
IsProduction bool
NotifyUrl string
ReturnURL string
}
type WxpayConfig struct {
AppID string
MchID string
MchCertificateSerialNumber string
MchApiv3Key string
MchPrivateKeyPath string
MchPublicKeyID string
MchPublicKeyPath string
NotifyUrl string
RefundNotifyUrl string
}
type ApplepayConfig struct {
ProductionVerifyURL string
SandboxVerifyURL string // 沙盒环境的验证 URL
Sandbox bool
BundleID string
IssuerID string
KeyID string
LoadPrivateKeyPath string
}
type SystemConfig struct {
ThreeVerify bool
}
type WechatH5Config struct {
AppID string
AppSecret string
}
type WechatMiniConfig struct {
AppID string
AppSecret string
}
type QueryConfig struct {
ShareLinkExpire int64
}
type AdminConfig struct {
AccessSecret string
AccessExpire int64
RefreshAfter int64
}
type AdminPromotion struct {
URLDomain string
}
type TaxConfig struct {
TaxRate float64
TaxExemptionAmount float64
}
type TianyuanapiConfig struct {
AccessID string
Key string
BaseURL string
Timeout int64
}
type AuthorizationConfig struct {
FileBaseURL string // 授权书文件访问基础URL
}

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

@@ -0,0 +1,28 @@
package admin_agent
import (
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
"ycc-server/app/main/api/internal/logic/admin_agent"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
)
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 {
httpx.ErrorCtx(r.Context(), w, err)
return
}
l := admin_agent.NewAdminAuditAgentLogic(r.Context(), svcCtx)
resp, err := l.AdminAuditAgent(&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/adminauditrealnamehandler.go Normal file
View File

@@ -0,0 +1,28 @@
package admin_agent
import (
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
"ycc-server/app/main/api/internal/logic/admin_agent"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
)
func AdminAuditRealNameHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminAuditRealNameReq
if err := httpx.Parse(r, &req); err != nil {
httpx.ErrorCtx(r.Context(), w, err)
return
}
l := admin_agent.NewAdminAuditRealNameLogic(r.Context(), svcCtx)
resp, err := l.AdminAuditRealName(&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/adminauditwithdrawalhandler.go Normal file
View File

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

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

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

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

@@ -0,0 +1,21 @@
package admin_agent
import (
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
"ycc-server/app/main/api/internal/logic/admin_agent"
"ycc-server/app/main/api/internal/svc"
)
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()
if err != nil {
httpx.ErrorCtx(r.Context(), w, err)
} else {
httpx.OkJsonCtx(r.Context(), w, resp)
}
}
}

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

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

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

@@ -0,0 +1,28 @@
package admin_agent
import (
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
"ycc-server/app/main/api/internal/logic/admin_agent"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
)
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 {
httpx.ErrorCtx(r.Context(), w, err)
return
}
l := admin_agent.NewAdminGetAgentOrderListLogic(r.Context(), svcCtx)
resp, err := l.AdminGetAgentOrderList(&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/admingetagentproductconfiglisthandler.go Normal file
View File

@@ -0,0 +1,28 @@
package admin_agent
import (
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
"ycc-server/app/main/api/internal/logic/admin_agent"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
)
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 {
httpx.ErrorCtx(r.Context(), w, err)
return
}
l := admin_agent.NewAdminGetAgentProductConfigListLogic(r.Context(), svcCtx)
resp, err := l.AdminGetAgentProductConfigList(&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/admingetagentrealnamelisthandler.go Normal file
View File

@@ -0,0 +1,28 @@
package admin_agent
import (
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
"ycc-server/app/main/api/internal/logic/admin_agent"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
)
func AdminGetAgentRealNameListHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminGetAgentRealNameListReq
if err := httpx.Parse(r, &req); err != nil {
httpx.ErrorCtx(r.Context(), w, err)
return
}
l := admin_agent.NewAdminGetAgentRealNameListLogic(r.Context(), svcCtx)
resp, err := l.AdminGetAgentRealNameList(&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/admingetagentrebatelisthandler.go Normal file
View File

@@ -0,0 +1,28 @@
package admin_agent
import (
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
"ycc-server/app/main/api/internal/logic/admin_agent"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
)
func AdminGetAgentRebateListHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminGetAgentRebateListReq
if err := httpx.Parse(r, &req); err != nil {
httpx.ErrorCtx(r.Context(), w, err)
return
}
l := admin_agent.NewAdminGetAgentRebateListLogic(r.Context(), svcCtx)
resp, err := l.AdminGetAgentRebateList(&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/admingetagentupgradelisthandler.go Normal file
View File

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

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

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

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

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

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

@@ -0,0 +1,28 @@
package admin_agent
import (
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
"ycc-server/app/main/api/internal/logic/admin_agent"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
)
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 {
httpx.ErrorCtx(r.Context(), w, err)
return
}
l := admin_agent.NewAdminUpdateAgentConfigLogic(r.Context(), svcCtx)
resp, err := l.AdminUpdateAgentConfig(&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/adminupdateagentproductconfighandler.go Normal file
View File

@@ -0,0 +1,28 @@
package admin_agent
import (
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
"ycc-server/app/main/api/internal/logic/admin_agent"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
)
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 {
httpx.ErrorCtx(r.Context(), w, err)
return
}
l := admin_agent.NewAdminUpdateAgentProductConfigLogic(r.Context(), svcCtx)
resp, err := l.AdminUpdateAgentProductConfig(&req)
if err != nil {
httpx.ErrorCtx(r.Context(), w, err)
} else {
httpx.OkJsonCtx(r.Context(), w, resp)
}
}
}

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

@@ -0,0 +1,30 @@
package admin_api
import (
"net/http"
"ycc-server/app/main/api/internal/logic/admin_api"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
"ycc-server/common/result"
"ycc-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"
"ycc-server/app/main/api/internal/logic/admin_api"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
"ycc-server/common/result"
"ycc-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"
"ycc-server/app/main/api/internal/logic/admin_api"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
"ycc-server/common/result"
"ycc-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"
"ycc-server/app/main/api/internal/logic/admin_api"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
"ycc-server/common/result"
"ycc-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"
"ycc-server/app/main/api/internal/logic/admin_api"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
"ycc-server/common/result"
"ycc-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"
"ycc-server/app/main/api/internal/logic/admin_api"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
"ycc-server/common/result"
"ycc-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"
"ycc-server/app/main/api/internal/logic/admin_auth"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
"ycc-server/common/result"
"ycc-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"
"ycc-server/app/main/api/internal/logic/admin_feature"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
"ycc-server/common/result"
"ycc-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"
"ycc-server/app/main/api/internal/logic/admin_feature"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
"ycc-server/common/result"
"ycc-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"
"ycc-server/app/main/api/internal/logic/admin_feature"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
"ycc-server/common/result"
"ycc-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"
"ycc-server/app/main/api/internal/logic/admin_feature"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
"ycc-server/common/result"
"ycc-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"
"ycc-server/app/main/api/internal/logic/admin_feature"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
"ycc-server/common/result"
"ycc-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"
"ycc-server/app/main/api/internal/logic/admin_feature"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
"ycc-server/common/result"
"ycc-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"
"ycc-server/app/main/api/internal/logic/admin_feature"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
"ycc-server/common/result"
"ycc-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"
"ycc-server/app/main/api/internal/logic/admin_menu"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
"ycc-server/common/result"
"ycc-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"
"ycc-server/app/main/api/internal/logic/admin_menu"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
"ycc-server/common/result"
"ycc-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"
"ycc-server/app/main/api/internal/logic/admin_menu"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
"ycc-server/common/result"
"ycc-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"
"ycc-server/app/main/api/internal/logic/admin_menu"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
"ycc-server/common/result"
"ycc-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"
"ycc-server/app/main/api/internal/logic/admin_menu"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
"ycc-server/common/result"
"ycc-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"
"ycc-server/app/main/api/internal/logic/admin_menu"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
"ycc-server/common/result"
"ycc-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"
"ycc-server/app/main/api/internal/logic/admin_notification"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
"ycc-server/common/result"
"ycc-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"
"ycc-server/app/main/api/internal/logic/admin_notification"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
"ycc-server/common/result"
"ycc-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"
"ycc-server/app/main/api/internal/logic/admin_notification"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
"ycc-server/common/result"
"ycc-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"
"ycc-server/app/main/api/internal/logic/admin_notification"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
"ycc-server/common/result"
"ycc-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"
"ycc-server/app/main/api/internal/logic/admin_notification"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
"ycc-server/common/result"
"ycc-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"
"ycc-server/app/main/api/internal/logic/admin_order"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
"ycc-server/common/result"
"ycc-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"
"ycc-server/app/main/api/internal/logic/admin_order"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
"ycc-server/common/result"
"ycc-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"
"ycc-server/app/main/api/internal/logic/admin_order"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
"ycc-server/common/result"
"ycc-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"
"ycc-server/app/main/api/internal/logic/admin_order"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
"ycc-server/common/result"
"ycc-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"
"ycc-server/app/main/api/internal/logic/admin_order"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
"ycc-server/common/result"
"ycc-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"
"ycc-server/app/main/api/internal/logic/admin_order"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
"ycc-server/common/result"
"ycc-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"
"ycc-server/app/main/api/internal/logic/admin_order"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
"ycc-server/common/result"
"ycc-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"
"ycc-server/app/main/api/internal/logic/admin_platform_user"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
"ycc-server/common/result"
"ycc-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"
"ycc-server/app/main/api/internal/logic/admin_platform_user"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
"ycc-server/common/result"
"ycc-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"
"ycc-server/app/main/api/internal/logic/admin_platform_user"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
"ycc-server/common/result"
"ycc-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"
"ycc-server/app/main/api/internal/logic/admin_platform_user"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
"ycc-server/common/result"
"ycc-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"
"ycc-server/app/main/api/internal/logic/admin_platform_user"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
"ycc-server/common/result"
"ycc-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"
"ycc-server/app/main/api/internal/logic/admin_product"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
"ycc-server/common/result"
"ycc-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"
"ycc-server/app/main/api/internal/logic/admin_product"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
"ycc-server/common/result"
"ycc-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"
"ycc-server/app/main/api/internal/logic/admin_product"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
"ycc-server/common/result"
"ycc-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"
"ycc-server/app/main/api/internal/logic/admin_product"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
"ycc-server/common/result"
"ycc-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"
"ycc-server/app/main/api/internal/logic/admin_product"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
"ycc-server/common/result"
"ycc-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"
"ycc-server/app/main/api/internal/logic/admin_product"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
"ycc-server/common/result"
"ycc-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"
"ycc-server/app/main/api/internal/logic/admin_product"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
"ycc-server/common/result"
"ycc-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_promotion/createpromotionlinkhandler.go Normal file
View File

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

30
app/main/api/internal/handler/admin_promotion/deletepromotionlinkhandler.go Normal file
View File

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

30
app/main/api/internal/handler/admin_promotion/getpromotionlinkdetailhandler.go Normal file
View File

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

30
app/main/api/internal/handler/admin_promotion/getpromotionlinklisthandler.go Normal file
View File

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

30
app/main/api/internal/handler/admin_promotion/getpromotionstatshistoryhandler.go Normal file
View File

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

30
app/main/api/internal/handler/admin_promotion/getpromotionstatstotalhandler.go Normal file
View File

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

30
app/main/api/internal/handler/admin_promotion/recordlinkclickhandler.go Normal file
View File

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

30
app/main/api/internal/handler/admin_promotion/updatepromotionlinkhandler.go Normal file
View File

@@ -0,0 +1,30 @@
package admin_promotion
import (
"net/http"
"ycc-server/app/main/api/internal/logic/admin_promotion"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
"ycc-server/common/result"
"ycc-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func UpdatePromotionLinkHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.UpdatePromotionLinkReq
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_promotion.NewUpdatePromotionLinkLogic(r.Context(), svcCtx)
err := l.UpdatePromotionLink(&req)
result.HttpResult(r, w, nil, 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"
"ycc-server/app/main/api/internal/logic/admin_query"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
"ycc-server/common/result"
"ycc-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"
"ycc-server/app/main/api/internal/logic/admin_query"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
"ycc-server/common/result"
"ycc-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"
"ycc-server/app/main/api/internal/logic/admin_query"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
"ycc-server/common/result"
"ycc-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"
"ycc-server/app/main/api/internal/logic/admin_query"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
"ycc-server/common/result"
"ycc-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"
"ycc-server/app/main/api/internal/logic/admin_query"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
"ycc-server/common/result"
"ycc-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"
"ycc-server/app/main/api/internal/logic/admin_role"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
"ycc-server/common/result"
"ycc-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"
"ycc-server/app/main/api/internal/logic/admin_role"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
"ycc-server/common/result"
"ycc-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"
"ycc-server/app/main/api/internal/logic/admin_role"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
"ycc-server/common/result"
"ycc-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"
"ycc-server/app/main/api/internal/logic/admin_role"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
"ycc-server/common/result"
"ycc-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"
"ycc-server/app/main/api/internal/logic/admin_role"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
"ycc-server/common/result"
"ycc-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"
"ycc-server/app/main/api/internal/logic/admin_role_api"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
"ycc-server/common/result"
"ycc-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"
"ycc-server/app/main/api/internal/logic/admin_role_api"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
"ycc-server/common/result"
"ycc-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"
"ycc-server/app/main/api/internal/logic/admin_role_api"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
"ycc-server/common/result"
"ycc-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"
"ycc-server/app/main/api/internal/logic/admin_role_api"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
"ycc-server/common/result"
"ycc-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"
"ycc-server/app/main/api/internal/logic/admin_role_api"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
"ycc-server/common/result"
"ycc-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"
"ycc-server/app/main/api/internal/logic/admin_user"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
"ycc-server/common/result"
"ycc-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"
"ycc-server/app/main/api/internal/logic/admin_user"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
"ycc-server/common/result"
"ycc-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"
"ycc-server/app/main/api/internal/logic/admin_user"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
"ycc-server/common/result"
"ycc-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"
"ycc-server/app/main/api/internal/logic/admin_user"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
"ycc-server/common/result"
"ycc-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"
"ycc-server/app/main/api/internal/logic/admin_user"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
"ycc-server/common/result"
"ycc-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"
"ycc-server/app/main/api/internal/logic/admin_user"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
"ycc-server/common/result"
"ycc-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"
"ycc-server/app/main/api/internal/logic/admin_user"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
"ycc-server/common/result"
"ycc-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"
"ycc-server/app/main/api/internal/logic/agent"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
"ycc-server/common/result"
"ycc-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)
}
}

28
app/main/api/internal/handler/agent/applyupgradehandler.go Normal file
View File

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

28
app/main/api/internal/handler/agent/applywithdrawalhandler.go Normal file
View File

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

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

@@ -0,0 +1,29 @@
package agent
import (
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
"ycc-server/app/main/api/internal/logic/agent"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
"ycc-server/common/result"
"ycc-server/pkg/lzkit/validator"
)
func GenerateInviteCodeHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.GenerateInviteCodeReq
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.NewGenerateInviteCodeLogic(r.Context(), svcCtx)
resp, err := l.GenerateInviteCode(&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"
"ycc-server/app/main/api/internal/logic/agent"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
"ycc-server/common/result"
"ycc-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/getagentinfohandler.go Normal file
View File

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

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

@@ -0,0 +1,28 @@
package agent
import (
"net/http"
"github.com/zeromicro/go-zero/rest/httpx"
"ycc-server/app/main/api/internal/logic/agent"
"ycc-server/app/main/api/internal/svc"
"ycc-server/app/main/api/internal/types"
)
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 {
httpx.ErrorCtx(r.Context(), w, err)
return
}
l := agent.NewGetCommissionListLogic(r.Context(), svcCtx)
resp, err := l.GetCommissionList(&req)
if err != nil {
httpx.ErrorCtx(r.Context(), w, err)
} else {
httpx.OkJsonCtx(r.Context(), w, resp)
}
}
}

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