team/hm-server-v2
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

first commit

Browse Source
This commit is contained in:
liangzai
2025-10-07 11:48:29 +08:00
commit ea18abdb04
555 changed files with 58225 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -0,0 +1,129 @@
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
Ali AliConfig
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 AliConfig struct {
Code string
}
type ApplepayConfig struct {
ProductionVerifyURL string
SandboxVerifyURL string // 沙盒环境的验证 URL
Sandbox bool
BundleID string
IssuerID string
KeyID string
LoadPrivateKeyPath string
}
type WestConfig struct {
Url string
Key string
SecretId string
SecretSecondId string
}
type YushanConfig struct {
ApiKey string
AcctID string
Url 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
}

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

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

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

@@ -0,0 +1,30 @@
package admin_agent
import (
"net/http"
"hm-server/app/main/api/internal/logic/admin_agent"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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"
"hm-server/app/main/api/internal/logic/admin_agent"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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/admingetagentmembershipconfiglisthandler.go Normal file
View File

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,30 @@
package admin_agent
import (
"net/http"
"hm-server/app/main/api/internal/logic/admin_agent"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func AdminUpdateAgentProductionConfigHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.AdminUpdateAgentProductionConfigReq
if err := httpx.Parse(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.NewAdminUpdateAgentProductionConfigLogic(r.Context(), svcCtx)
resp, err := l.AdminUpdateAgentProductionConfig(&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"
"hm-server/app/main/api/internal/logic/admin_api"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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"
"hm-server/app/main/api/internal/logic/admin_api"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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"
"hm-server/app/main/api/internal/logic/admin_api"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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"
"hm-server/app/main/api/internal/logic/admin_api"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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"
"hm-server/app/main/api/internal/logic/admin_api"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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"
"hm-server/app/main/api/internal/logic/admin_api"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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"
"hm-server/app/main/api/internal/logic/admin_auth"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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"
"hm-server/app/main/api/internal/logic/admin_feature"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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"
"hm-server/app/main/api/internal/logic/admin_feature"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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"
"hm-server/app/main/api/internal/logic/admin_feature"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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"
"hm-server/app/main/api/internal/logic/admin_feature"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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"
"hm-server/app/main/api/internal/logic/admin_feature"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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"
"hm-server/app/main/api/internal/logic/admin_feature"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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"
"hm-server/app/main/api/internal/logic/admin_feature"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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"
"hm-server/app/main/api/internal/logic/admin_menu"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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"
"hm-server/app/main/api/internal/logic/admin_menu"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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"
"hm-server/app/main/api/internal/logic/admin_menu"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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"
"hm-server/app/main/api/internal/logic/admin_menu"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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"
"hm-server/app/main/api/internal/logic/admin_menu"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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"
"hm-server/app/main/api/internal/logic/admin_menu"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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"
"hm-server/app/main/api/internal/logic/admin_notification"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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"
"hm-server/app/main/api/internal/logic/admin_notification"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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"
"hm-server/app/main/api/internal/logic/admin_notification"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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"
"hm-server/app/main/api/internal/logic/admin_notification"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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"
"hm-server/app/main/api/internal/logic/admin_notification"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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"
"hm-server/app/main/api/internal/logic/admin_order"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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"
"hm-server/app/main/api/internal/logic/admin_order"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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"
"hm-server/app/main/api/internal/logic/admin_order"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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"
"hm-server/app/main/api/internal/logic/admin_order"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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"
"hm-server/app/main/api/internal/logic/admin_order"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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)
}
}

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

@@ -0,0 +1,30 @@
package admin_order
import (
"net/http"
"hm-server/app/main/api/internal/logic/admin_order"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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"
"hm-server/app/main/api/internal/logic/admin_platform_user"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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"
"hm-server/app/main/api/internal/logic/admin_platform_user"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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"
"hm-server/app/main/api/internal/logic/admin_platform_user"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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"
"hm-server/app/main/api/internal/logic/admin_platform_user"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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"
"hm-server/app/main/api/internal/logic/admin_platform_user"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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"
"hm-server/app/main/api/internal/logic/admin_product"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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"
"hm-server/app/main/api/internal/logic/admin_product"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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"
"hm-server/app/main/api/internal/logic/admin_product"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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"
"hm-server/app/main/api/internal/logic/admin_product"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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"
"hm-server/app/main/api/internal/logic/admin_product"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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"
"hm-server/app/main/api/internal/logic/admin_product"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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"
"hm-server/app/main/api/internal/logic/admin_product"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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"
"hm-server/app/main/api/internal/logic/admin_promotion"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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"
"hm-server/app/main/api/internal/logic/admin_promotion"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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"
"hm-server/app/main/api/internal/logic/admin_promotion"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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"
"hm-server/app/main/api/internal/logic/admin_promotion"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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"
"hm-server/app/main/api/internal/logic/admin_promotion"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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"
"hm-server/app/main/api/internal/logic/admin_promotion"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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"
"hm-server/app/main/api/internal/logic/admin_promotion"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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"
"hm-server/app/main/api/internal/logic/admin_promotion"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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"
"hm-server/app/main/api/internal/logic/admin_query"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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"
"hm-server/app/main/api/internal/logic/admin_query"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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"
"hm-server/app/main/api/internal/logic/admin_query"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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"
"hm-server/app/main/api/internal/logic/admin_query"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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"
"hm-server/app/main/api/internal/logic/admin_query"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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"
"hm-server/app/main/api/internal/logic/admin_role"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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"
"hm-server/app/main/api/internal/logic/admin_role"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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"
"hm-server/app/main/api/internal/logic/admin_role"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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"
"hm-server/app/main/api/internal/logic/admin_role"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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"
"hm-server/app/main/api/internal/logic/admin_role"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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"
"hm-server/app/main/api/internal/logic/admin_role_api"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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"
"hm-server/app/main/api/internal/logic/admin_role_api"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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"
"hm-server/app/main/api/internal/logic/admin_role_api"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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"
"hm-server/app/main/api/internal/logic/admin_role_api"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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"
"hm-server/app/main/api/internal/logic/admin_role_api"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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"
"hm-server/app/main/api/internal/logic/admin_user"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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"
"hm-server/app/main/api/internal/logic/admin_user"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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"
"hm-server/app/main/api/internal/logic/admin_user"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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"
"hm-server/app/main/api/internal/logic/admin_user"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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)
}
}

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

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

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

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

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

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

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

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

@@ -0,0 +1,30 @@
package agent
import (
"net/http"
"hm-server/app/main/api/internal/logic/agent"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-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/getagentauditstatushandler.go Normal file
View File

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

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

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

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

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

36
app/main/api/internal/handler/agent/getagentpromotionqrcodehandler.go Normal file
View File

@@ -0,0 +1,36 @@
package agent
import (
"net/http"
"hm-server/app/main/api/internal/logic/agent"
"hm-server/app/main/api/internal/svc"
"hm-server/app/main/api/internal/types"
"hm-server/common/result"
"hm-server/pkg/lzkit/validator"
"github.com/zeromicro/go-zero/rest/httpx"
)
func GetAgentPromotionQrcodeHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req types.GetAgentPromotionQrcodeReq
if err := httpx.Parse(r, &req); err != nil {
result.ParamErrorResult(r, w, err)
return
}
if err := validator.Validate(req); err != nil {
result.ParamValidateErrorResult(r, w, err)
return
}
// 注意：这里传入了 ResponseWriter，用于直接写入图片数据
l := agent.NewGetAgentPromotionQrcodeLogic(r.Context(), svcCtx, w)
err := l.GetAgentPromotionQrcode(&req)
if err != nil {
// 如果处理过程中出错，返回JSON错误响应
result.HttpResult(r, w, nil, err)
}
// 成功时，图片数据已经通过logic直接写入ResponseWriter，不需要额外处理
}
}

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

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

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

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

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

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

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