temp

app/main/api/internal/config/config.go

@@ -22,6 +22,7 @@ type Config struct {
 	SystemConfig   SystemConfig
 	AdminConfig    AdminConfig
 	AdminPromotion AdminPromotion
+	CleanTask      CleanTask
 }
 
 // JwtAuth 用于 JWT 鉴权配置
@@ -43,6 +44,7 @@ type Encrypt struct {
 }
 
 type AlipayConfig struct {
+	Enabled         bool
 	AppID           string
 	PrivateKey      string
 	AlipayPublicKey string
@@ -51,6 +53,7 @@ type AlipayConfig struct {
 	ReturnURL       string
 }
 type WxpayConfig struct {
+	Enabled                    bool
 	AppID                      string
 	AppSecret                  string
 	MchID                      string
@@ -64,6 +67,7 @@ type AliConfig struct {
 	Code string
 }
 type ApplepayConfig struct {
+	Enabled             bool
 	ProductionVerifyURL string
 	SandboxVerifyURL    string // 沙盒环境的验证 URL
 	Sandbox             bool
@@ -100,3 +104,8 @@ type AdminConfig struct {
 type AdminPromotion struct {
 	URLDomain string
 }
+type CleanTask struct {
+	Enabled bool
+	Time    string
+	Days    int
+}

app/main/api/internal/handler/admin_feature/admincreatefeaturehandler.go

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

app/main/api/internal/handler/admin_feature/admindeletefeaturehandler.go

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

app/main/api/internal/handler/admin_feature/admingetfeaturedetailhandler.go

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

app/main/api/internal/handler/admin_feature/admingetfeaturelisthandler.go

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

app/main/api/internal/handler/admin_feature/adminupdatefeaturehandler.go

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

app/main/api/internal/handler/admin_notification/admincreatenotificationhandler.go

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

app/main/api/internal/handler/admin_notification/admindeletenotificationhandler.go

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

app/main/api/internal/handler/admin_notification/admingetnotificationdetailhandler.go

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

app/main/api/internal/handler/admin_notification/admingetnotificationlisthandler.go

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

app/main/api/internal/handler/admin_notification/adminupdatenotificationhandler.go

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

app/main/api/internal/handler/admin_order/admincreateorderhandler.go

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

app/main/api/internal/handler/admin_order/admindeleteorderhandler.go

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

app/main/api/internal/handler/admin_order/admingetorderdetailhandler.go

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

app/main/api/internal/handler/admin_order/admingetorderlisthandler.go

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

app/main/api/internal/handler/admin_order/adminrefundorderhandler.go

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

app/main/api/internal/handler/admin_order/adminupdateorderhandler.go

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

app/main/api/internal/handler/admin_platform_user/admincreateplatformuserhandler.go

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

app/main/api/internal/handler/admin_platform_user/admindeleteplatformuserhandler.go

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

app/main/api/internal/handler/admin_platform_user/admingetplatformuserdetailhandler.go

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

app/main/api/internal/handler/admin_platform_user/admingetplatformuserlisthandler.go

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

app/main/api/internal/handler/admin_platform_user/adminupdateplatformuserhandler.go

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

app/main/api/internal/handler/admin_product/admincreateproducthandler.go

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

app/main/api/internal/handler/admin_product/admindeleteproducthandler.go

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

app/main/api/internal/handler/admin_product/admingetproductdetailhandler.go

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

app/main/api/internal/handler/admin_product/admingetproductfeaturelisthandler.go

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

app/main/api/internal/handler/admin_product/admingetproductlisthandler.go

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

app/main/api/internal/handler/admin_product/adminupdateproductfeatureshandler.go

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

app/main/api/internal/handler/admin_product/adminupdateproducthandler.go

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

app/main/api/internal/handler/routes.go

@@ -5,7 +5,12 @@ import (
 	"net/http"
 
 	admin_auth "tyc-server/app/main/api/internal/handler/admin_auth"
+	admin_feature "tyc-server/app/main/api/internal/handler/admin_feature"
 	admin_menu "tyc-server/app/main/api/internal/handler/admin_menu"
+	admin_notification "tyc-server/app/main/api/internal/handler/admin_notification"
+	admin_order "tyc-server/app/main/api/internal/handler/admin_order"
+	admin_platform_user "tyc-server/app/main/api/internal/handler/admin_platform_user"
+	admin_product "tyc-server/app/main/api/internal/handler/admin_product"
 	admin_promotion "tyc-server/app/main/api/internal/handler/admin_promotion"
 	admin_role "tyc-server/app/main/api/internal/handler/admin_role"
 	admin_user "tyc-server/app/main/api/internal/handler/admin_user"
@@ -33,6 +38,37 @@ func RegisterHandlers(server *rest.Server, serverCtx *svc.ServiceContext) {
 		rest.WithPrefix("/api/v1/admin/auth"),
 	)
 
+	server.AddRoutes(
+		[]rest.Route{
+			{
+				Method:  http.MethodPost,
+				Path:    "/create",
+				Handler: admin_feature.AdminCreateFeatureHandler(serverCtx),
+			},
+			{
+				Method:  http.MethodDelete,
+				Path:    "/delete/:id",
+				Handler: admin_feature.AdminDeleteFeatureHandler(serverCtx),
+			},
+			{
+				Method:  http.MethodGet,
+				Path:    "/detail/:id",
+				Handler: admin_feature.AdminGetFeatureDetailHandler(serverCtx),
+			},
+			{
+				Method:  http.MethodGet,
+				Path:    "/list",
+				Handler: admin_feature.AdminGetFeatureListHandler(serverCtx),
+			},
+			{
+				Method:  http.MethodPut,
+				Path:    "/update/:id",
+				Handler: admin_feature.AdminUpdateFeatureHandler(serverCtx),
+			},
+		},
+		rest.WithPrefix("/api/v1/admin/feature"),
+	)
+
 	server.AddRoutes(
 		[]rest.Route{
 			{
@@ -76,6 +112,153 @@ func RegisterHandlers(server *rest.Server, serverCtx *svc.ServiceContext) {
 		rest.WithPrefix("/api/v1/admin/menu"),
 	)
 
+	server.AddRoutes(
+		[]rest.Route{
+			{
+				Method:  http.MethodPost,
+				Path:    "/create",
+				Handler: admin_notification.AdminCreateNotificationHandler(serverCtx),
+			},
+			{
+				Method:  http.MethodDelete,
+				Path:    "/delete/:id",
+				Handler: admin_notification.AdminDeleteNotificationHandler(serverCtx),
+			},
+			{
+				Method:  http.MethodGet,
+				Path:    "/detail/:id",
+				Handler: admin_notification.AdminGetNotificationDetailHandler(serverCtx),
+			},
+			{
+				Method:  http.MethodGet,
+				Path:    "/list",
+				Handler: admin_notification.AdminGetNotificationListHandler(serverCtx),
+			},
+			{
+				Method:  http.MethodPut,
+				Path:    "/update/:id",
+				Handler: admin_notification.AdminUpdateNotificationHandler(serverCtx),
+			},
+		},
+		rest.WithPrefix("/api/v1/admin/notification"),
+	)
+
+	server.AddRoutes(
+		[]rest.Route{
+			{
+				// 创建订单
+				Method:  http.MethodPost,
+				Path:    "/create",
+				Handler: admin_order.AdminCreateOrderHandler(serverCtx),
+			},
+			{
+				// 删除订单
+				Method:  http.MethodDelete,
+				Path:    "/delete/:id",
+				Handler: admin_order.AdminDeleteOrderHandler(serverCtx),
+			},
+			{
+				// 获取订单详情
+				Method:  http.MethodGet,
+				Path:    "/detail/:id",
+				Handler: admin_order.AdminGetOrderDetailHandler(serverCtx),
+			},
+			{
+				// 获取订单列表
+				Method:  http.MethodGet,
+				Path:    "/list",
+				Handler: admin_order.AdminGetOrderListHandler(serverCtx),
+			},
+			{
+				// 订单退款
+				Method:  http.MethodPost,
+				Path:    "/refund/:id",
+				Handler: admin_order.AdminRefundOrderHandler(serverCtx),
+			},
+			{
+				// 更新订单
+				Method:  http.MethodPut,
+				Path:    "/update/:id",
+				Handler: admin_order.AdminUpdateOrderHandler(serverCtx),
+			},
+		},
+		rest.WithJwt(serverCtx.Config.JwtAuth.AccessSecret),
+		rest.WithPrefix("/api/v1/admin/order"),
+	)
+
+	server.AddRoutes(
+		[]rest.Route{
+			{
+				Method:  http.MethodPost,
+				Path:    "/create",
+				Handler: admin_platform_user.AdminCreatePlatformUserHandler(serverCtx),
+			},
+			{
+				Method:  http.MethodDelete,
+				Path:    "/delete/:id",
+				Handler: admin_platform_user.AdminDeletePlatformUserHandler(serverCtx),
+			},
+			{
+				Method:  http.MethodGet,
+				Path:    "/detail/:id",
+				Handler: admin_platform_user.AdminGetPlatformUserDetailHandler(serverCtx),
+			},
+			{
+				Method:  http.MethodGet,
+				Path:    "/list",
+				Handler: admin_platform_user.AdminGetPlatformUserListHandler(serverCtx),
+			},
+			{
+				Method:  http.MethodPut,
+				Path:    "/update/:id",
+				Handler: admin_platform_user.AdminUpdatePlatformUserHandler(serverCtx),
+			},
+		},
+		rest.WithJwt(serverCtx.Config.JwtAuth.AccessSecret),
+		rest.WithPrefix("/api/v1/admin/platform_user"),
+	)
+
+	server.AddRoutes(
+		[]rest.Route{
+			{
+				Method:  http.MethodPost,
+				Path:    "/create",
+				Handler: admin_product.AdminCreateProductHandler(serverCtx),
+			},
+			{
+				Method:  http.MethodDelete,
+				Path:    "/delete/:id",
+				Handler: admin_product.AdminDeleteProductHandler(serverCtx),
+			},
+			{
+				Method:  http.MethodGet,
+				Path:    "/detail/:id",
+				Handler: admin_product.AdminGetProductDetailHandler(serverCtx),
+			},
+			{
+				Method:  http.MethodGet,
+				Path:    "/feature/list/:product_id",
+				Handler: admin_product.AdminGetProductFeatureListHandler(serverCtx),
+			},
+			{
+				Method:  http.MethodPut,
+				Path:    "/feature/update/:product_id",
+				Handler: admin_product.AdminUpdateProductFeaturesHandler(serverCtx),
+			},
+			{
+				Method:  http.MethodGet,
+				Path:    "/list",
+				Handler: admin_product.AdminGetProductListHandler(serverCtx),
+			},
+			{
+				Method:  http.MethodPut,
+				Path:    "/update/:id",
+				Handler: admin_product.AdminUpdateProductHandler(serverCtx),
+			},
+		},
+		rest.WithPrefix("/api/v1/admin/product"),
+	)
+
 	server.AddRoutes(
 		[]rest.Route{
 			{

app/main/api/internal/logic/admin_feature/admincreatefeaturelogic.go

@@ -0,0 +1,45 @@
+package admin_feature
+
+import (
+	"context"
+	"tyc-server/app/main/api/internal/svc"
+	"tyc-server/app/main/api/internal/types"
+	"tyc-server/app/main/model"
+	"tyc-server/common/xerr"
+
+	"github.com/pkg/errors"
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type AdminCreateFeatureLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewAdminCreateFeatureLogic(ctx context.Context, svcCtx *svc.ServiceContext) *AdminCreateFeatureLogic {
+	return &AdminCreateFeatureLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *AdminCreateFeatureLogic) AdminCreateFeature(req *types.AdminCreateFeatureReq) (resp *types.AdminCreateFeatureResp, err error) {
+	// 1. 数据转换
+	data := &model.Feature{
+		ApiId: req.ApiId,
+		Name:  req.Name,
+	}
+
+	// 2. 数据库操作
+	result, err := l.svcCtx.FeatureModel.Insert(l.ctx, nil, data)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR),
+			"创建功能失败, err: %v, req: %+v", err, req)
+	}
+
+	// 3. 返回结果
+	id, _ := result.LastInsertId()
+	return &types.AdminCreateFeatureResp{Id: id}, nil
+}

app/main/api/internal/logic/admin_feature/admindeletefeaturelogic.go

@@ -0,0 +1,44 @@
+package admin_feature
+
+import (
+	"context"
+	"tyc-server/app/main/api/internal/svc"
+	"tyc-server/app/main/api/internal/types"
+	"tyc-server/common/xerr"
+
+	"github.com/pkg/errors"
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type AdminDeleteFeatureLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewAdminDeleteFeatureLogic(ctx context.Context, svcCtx *svc.ServiceContext) *AdminDeleteFeatureLogic {
+	return &AdminDeleteFeatureLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *AdminDeleteFeatureLogic) AdminDeleteFeature(req *types.AdminDeleteFeatureReq) (resp *types.AdminDeleteFeatureResp, err error) {
+	// 1. 查询记录是否存在
+	record, err := l.svcCtx.FeatureModel.FindOne(l.ctx, req.Id)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR),
+			"查找功能失败, err: %v, id: %d", err, req.Id)
+	}
+
+	// 2. 执行软删除
+	err = l.svcCtx.FeatureModel.DeleteSoft(l.ctx, nil, record)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR),
+			"删除功能失败, err: %v, id: %d", err, req.Id)
+	}
+
+	// 3. 返回结果
+	return &types.AdminDeleteFeatureResp{Success: true}, nil
+}

app/main/api/internal/logic/admin_feature/admingetfeaturedetaillogic.go

@@ -0,0 +1,45 @@
+package admin_feature
+
+import (
+	"context"
+	"tyc-server/app/main/api/internal/svc"
+	"tyc-server/app/main/api/internal/types"
+	"tyc-server/common/xerr"
+
+	"github.com/pkg/errors"
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type AdminGetFeatureDetailLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewAdminGetFeatureDetailLogic(ctx context.Context, svcCtx *svc.ServiceContext) *AdminGetFeatureDetailLogic {
+	return &AdminGetFeatureDetailLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *AdminGetFeatureDetailLogic) AdminGetFeatureDetail(req *types.AdminGetFeatureDetailReq) (resp *types.AdminGetFeatureDetailResp, err error) {
+	// 1. 查询记录
+	record, err := l.svcCtx.FeatureModel.FindOne(l.ctx, req.Id)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR),
+			"查找功能失败, err: %v, id: %d", err, req.Id)
+	}
+
+	// 2. 构建响应
+	resp = &types.AdminGetFeatureDetailResp{
+		Id:         record.Id,
+		ApiId:      record.ApiId,
+		Name:       record.Name,
+		CreateTime: record.CreateTime.Format("2006-01-02 15:04:05"),
+		UpdateTime: record.UpdateTime.Format("2006-01-02 15:04:05"),
+	}
+
+	return resp, nil
+}

app/main/api/internal/logic/admin_feature/admingetfeaturelistlogic.go

@@ -0,0 +1,65 @@
+package admin_feature
+
+import (
+	"context"
+	"tyc-server/app/main/api/internal/svc"
+	"tyc-server/app/main/api/internal/types"
+	"tyc-server/common/xerr"
+
+	"github.com/pkg/errors"
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type AdminGetFeatureListLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewAdminGetFeatureListLogic(ctx context.Context, svcCtx *svc.ServiceContext) *AdminGetFeatureListLogic {
+	return &AdminGetFeatureListLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *AdminGetFeatureListLogic) AdminGetFeatureList(req *types.AdminGetFeatureListReq) (resp *types.AdminGetFeatureListResp, err error) {
+	// 1. 构建查询条件
+	builder := l.svcCtx.FeatureModel.SelectBuilder()
+
+	// 2. 添加查询条件
+	if req.ApiId != nil && *req.ApiId != "" {
+		builder = builder.Where("api_id LIKE ?", "%"+*req.ApiId+"%")
+	}
+	if req.Name != nil && *req.Name != "" {
+		builder = builder.Where("name LIKE ?", "%"+*req.Name+"%")
+	}
+
+	// 3. 执行分页查询
+	list, total, err := l.svcCtx.FeatureModel.FindPageListByPageWithTotal(
+		l.ctx, builder, req.Page, req.PageSize, "id DESC")
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR),
+			"查询功能列表失败, err: %v, req: %+v", err, req)
+	}
+
+	// 4. 构建响应列表
+	items := make([]types.FeatureListItem, 0, len(list))
+	for _, item := range list {
+		listItem := types.FeatureListItem{
+			Id:         item.Id,
+			ApiId:      item.ApiId,
+			Name:       item.Name,
+			CreateTime: item.CreateTime.Format("2006-01-02 15:04:05"),
+			UpdateTime: item.UpdateTime.Format("2006-01-02 15:04:05"),
+		}
+		items = append(items, listItem)
+	}
+
+	// 5. 返回结果
+	return &types.AdminGetFeatureListResp{
+		Total: total,
+		Items: items,
+	}, nil
+}

app/main/api/internal/logic/admin_feature/adminupdatefeaturelogic.go

@@ -0,0 +1,30 @@
+package admin_feature
+
+import (
+	"context"
+
+	"tyc-server/app/main/api/internal/svc"
+	"tyc-server/app/main/api/internal/types"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type AdminUpdateFeatureLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewAdminUpdateFeatureLogic(ctx context.Context, svcCtx *svc.ServiceContext) *AdminUpdateFeatureLogic {
+	return &AdminUpdateFeatureLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *AdminUpdateFeatureLogic) AdminUpdateFeature(req *types.AdminUpdateFeatureReq) (resp *types.AdminUpdateFeatureResp, err error) {
+	// todo: add your logic here and delete this line
+
+	return
+}

app/main/api/internal/logic/admin_notification/admincreatenotificationlogic.go

@@ -0,0 +1,49 @@
+package admin_notification
+
+import (
+	"context"
+	"database/sql"
+	"time"
+	"tyc-server/app/main/api/internal/svc"
+	"tyc-server/app/main/api/internal/types"
+	"tyc-server/app/main/model"
+	"tyc-server/common/xerr"
+
+	"github.com/pkg/errors"
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type AdminCreateNotificationLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewAdminCreateNotificationLogic(ctx context.Context, svcCtx *svc.ServiceContext) *AdminCreateNotificationLogic {
+	return &AdminCreateNotificationLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *AdminCreateNotificationLogic) AdminCreateNotification(req *types.AdminCreateNotificationReq) (resp *types.AdminCreateNotificationResp, err error) {
+	startDate, _ := time.Parse("2006-01-02", req.StartDate)
+	endDate, _ := time.Parse("2006-01-02", req.EndDate)
+	data := &model.GlobalNotifications{
+		Title:            req.Title,
+		Content:          req.Content,
+		NotificationPage: req.NotificationPage,
+		StartDate:        sql.NullTime{Time: startDate, Valid: req.StartDate != ""},
+		EndDate:          sql.NullTime{Time: endDate, Valid: req.EndDate != ""},
+		StartTime:        req.StartTime,
+		EndTime:          req.EndTime,
+		Status:           req.Status,
+	}
+	result, err := l.svcCtx.GlobalNotificationsModel.Insert(l.ctx, nil, data)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "创建通知失败, err: %v, req: %+v", err, req)
+	}
+	id, _ := result.LastInsertId()
+	return &types.AdminCreateNotificationResp{Id: id}, nil
+}

app/main/api/internal/logic/admin_notification/admindeletenotificationlogic.go

@@ -0,0 +1,38 @@
+package admin_notification
+
+import (
+	"context"
+
+	"tyc-server/app/main/api/internal/svc"
+	"tyc-server/app/main/api/internal/types"
+	"tyc-server/common/xerr"
+
+	"github.com/pkg/errors"
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type AdminDeleteNotificationLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewAdminDeleteNotificationLogic(ctx context.Context, svcCtx *svc.ServiceContext) *AdminDeleteNotificationLogic {
+	return &AdminDeleteNotificationLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *AdminDeleteNotificationLogic) AdminDeleteNotification(req *types.AdminDeleteNotificationReq) (resp *types.AdminDeleteNotificationResp, err error) {
+	notification, err := l.svcCtx.GlobalNotificationsModel.FindOne(l.ctx, req.Id)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "查找通知失败, err: %v, id: %d", err, req.Id)
+	}
+	err = l.svcCtx.GlobalNotificationsModel.DeleteSoft(l.ctx, nil, notification)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "删除通知失败, err: %v, id: %d", err, req.Id)
+	}
+	return &types.AdminDeleteNotificationResp{Success: true}, nil
+}

app/main/api/internal/logic/admin_notification/admingetnotificationdetaillogic.go

@@ -0,0 +1,53 @@
+package admin_notification
+
+import (
+	"context"
+
+	"tyc-server/app/main/api/internal/svc"
+	"tyc-server/app/main/api/internal/types"
+	"tyc-server/common/xerr"
+
+	"github.com/pkg/errors"
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type AdminGetNotificationDetailLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewAdminGetNotificationDetailLogic(ctx context.Context, svcCtx *svc.ServiceContext) *AdminGetNotificationDetailLogic {
+	return &AdminGetNotificationDetailLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *AdminGetNotificationDetailLogic) AdminGetNotificationDetail(req *types.AdminGetNotificationDetailReq) (resp *types.AdminGetNotificationDetailResp, err error) {
+	notification, err := l.svcCtx.GlobalNotificationsModel.FindOne(l.ctx, req.Id)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "查找通知失败, err: %v, id: %d", err, req.Id)
+	}
+	resp = &types.AdminGetNotificationDetailResp{
+		Id:               notification.Id,
+		Title:            notification.Title,
+		Content:          notification.Content,
+		NotificationPage: notification.NotificationPage,
+		StartDate:        "",
+		StartTime:        notification.StartTime,
+		EndDate:          "",
+		EndTime:          notification.EndTime,
+		Status:           notification.Status,
+		CreateTime:       notification.CreateTime.Format("2006-01-02 15:04:05"),
+		UpdateTime:       notification.UpdateTime.Format("2006-01-02 15:04:05"),
+	}
+	if notification.StartDate.Valid {
+		resp.StartDate = notification.StartDate.Time.Format("2006-01-02")
+	}
+	if notification.EndDate.Valid {
+		resp.EndDate = notification.EndDate.Time.Format("2006-01-02")
+	}
+	return resp, nil
+}

app/main/api/internal/logic/admin_notification/admingetnotificationlistlogic.go

@@ -0,0 +1,83 @@
+package admin_notification
+
+import (
+	"context"
+
+	"tyc-server/app/main/api/internal/svc"
+	"tyc-server/app/main/api/internal/types"
+	"tyc-server/common/xerr"
+
+	"time"
+
+	"github.com/pkg/errors"
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type AdminGetNotificationListLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewAdminGetNotificationListLogic(ctx context.Context, svcCtx *svc.ServiceContext) *AdminGetNotificationListLogic {
+	return &AdminGetNotificationListLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *AdminGetNotificationListLogic) AdminGetNotificationList(req *types.AdminGetNotificationListReq) (resp *types.AdminGetNotificationListResp, err error) {
+	builder := l.svcCtx.GlobalNotificationsModel.SelectBuilder()
+	if req.Title != nil {
+		builder = builder.Where("title LIKE ?", "%"+*req.Title+"%")
+	}
+	if req.NotificationPage != nil {
+		builder = builder.Where("notification_page = ?", *req.NotificationPage)
+	}
+	if req.Status != nil {
+		builder = builder.Where("status = ?", *req.Status)
+	}
+	if req.StartDate != nil {
+		if t, err := time.Parse("2006-01-02", *req.StartDate); err == nil {
+			builder = builder.Where("start_date >= ?", t)
+		}
+	}
+	if req.EndDate != nil {
+		if t, err := time.Parse("2006-01-02", *req.EndDate); err == nil {
+			builder = builder.Where("end_date <= ?", t)
+		}
+	}
+	list, total, err := l.svcCtx.GlobalNotificationsModel.FindPageListByPageWithTotal(l.ctx, builder, req.Page, req.PageSize, "id DESC")
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "查询通知列表失败, err: %v, req: %+v", err, req)
+	}
+	items := make([]types.NotificationListItem, 0, len(list))
+	for _, n := range list {
+		item := types.NotificationListItem{
+			Id:               n.Id,
+			Title:            n.Title,
+			NotificationPage: n.NotificationPage,
+			Content:          n.Content,
+			StartDate:        "",
+			StartTime:        n.StartTime,
+			EndDate:          "",
+			EndTime:          n.EndTime,
+			Status:           n.Status,
+			CreateTime:       n.CreateTime.Format("2006-01-02 15:04:05"),
+			UpdateTime:       n.UpdateTime.Format("2006-01-02 15:04:05"),
+		}
+		if n.StartDate.Valid {
+			item.StartDate = n.StartDate.Time.Format("2006-01-02")
+		}
+		if n.EndDate.Valid {
+			item.EndDate = n.EndDate.Time.Format("2006-01-02")
+		}
+		items = append(items, item)
+	}
+	resp = &types.AdminGetNotificationListResp{
+		Total: total,
+		Items: items,
+	}
+	return resp, nil
+}

app/main/api/internal/logic/admin_notification/adminupdatenotificationlogic.go

@@ -0,0 +1,65 @@
+package admin_notification
+
+import (
+	"context"
+	"database/sql"
+	"time"
+	"tyc-server/app/main/api/internal/svc"
+	"tyc-server/app/main/api/internal/types"
+	"tyc-server/common/xerr"
+
+	"github.com/pkg/errors"
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type AdminUpdateNotificationLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewAdminUpdateNotificationLogic(ctx context.Context, svcCtx *svc.ServiceContext) *AdminUpdateNotificationLogic {
+	return &AdminUpdateNotificationLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *AdminUpdateNotificationLogic) AdminUpdateNotification(req *types.AdminUpdateNotificationReq) (resp *types.AdminUpdateNotificationResp, err error) {
+	notification, err := l.svcCtx.GlobalNotificationsModel.FindOne(l.ctx, req.Id)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "查找通知失败, err: %v, id: %d", err, req.Id)
+	}
+	if req.StartDate != nil {
+		startDate, _ := time.Parse("2006-01-02", *req.StartDate)
+		notification.StartDate = sql.NullTime{Time: startDate, Valid: true}
+	}
+	if req.EndDate != nil {
+		endDate, _ := time.Parse("2006-01-02", *req.EndDate)
+		notification.EndDate = sql.NullTime{Time: endDate, Valid: true}
+	}
+	if req.Title != nil {
+		notification.Title = *req.Title
+	}
+	if req.Content != nil {
+		notification.Content = *req.Content
+	}
+	if req.NotificationPage != nil {
+		notification.NotificationPage = *req.NotificationPage
+	}
+	if req.StartTime != nil {
+		notification.StartTime = *req.StartTime
+	}
+	if req.EndTime != nil {
+		notification.EndTime = *req.EndTime
+	}
+	if req.Status != nil {
+		notification.Status = *req.Status
+	}
+	_, err = l.svcCtx.GlobalNotificationsModel.Update(l.ctx, nil, notification)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "更新通知失败, err: %v, req: %+v", err, req)
+	}
+	return &types.AdminUpdateNotificationResp{Success: true}, nil
+}

app/main/api/internal/logic/admin_order/admincreateorderlogic.go

@@ -0,0 +1,99 @@
+package admin_order
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"time"
+
+	"tyc-server/app/main/api/internal/svc"
+	"tyc-server/app/main/api/internal/types"
+	"tyc-server/app/main/model"
+	"tyc-server/common/xerr"
+
+	"github.com/pkg/errors"
+	"github.com/zeromicro/go-zero/core/logx"
+	"github.com/zeromicro/go-zero/core/stores/sqlx"
+)
+
+type AdminCreateOrderLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewAdminCreateOrderLogic(ctx context.Context, svcCtx *svc.ServiceContext) *AdminCreateOrderLogic {
+	return &AdminCreateOrderLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *AdminCreateOrderLogic) AdminCreateOrder(req *types.AdminCreateOrderReq) (resp *types.AdminCreateOrderResp, err error) {
+	// 生成订单号
+	orderNo := fmt.Sprintf("%dADMIN", time.Now().UnixNano())
+
+	// 根据产品名称查询产品ID
+	builder := l.svcCtx.ProductModel.SelectBuilder()
+	builder = builder.Where("product_name = ? AND del_state = ?", req.ProductName, 0)
+	products, err := l.svcCtx.ProductModel.FindAll(l.ctx, builder, "")
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "AdminCreateOrder, 查询产品失败 err: %v", err)
+	}
+	if len(products) == 0 {
+		return nil, errors.Wrapf(xerr.NewErrMsg(fmt.Sprintf("产品不存在: %s", req.ProductName)), "AdminCreateOrder, 查询产品失败 err: %v", err)
+	}
+	product := products[0]
+
+	// 创建订单对象
+	order := &model.Order{
+		OrderNo:         orderNo,
+		PlatformOrderId: sql.NullString{String: req.PlatformOrderId, Valid: req.PlatformOrderId != ""},
+		ProductId:       product.Id,
+		PaymentPlatform: req.PaymentPlatform,
+		PaymentScene:    req.PaymentScene,
+		Amount:          req.Amount,
+		Status:          req.Status,
+	}
+
+	// 使用事务处理订单创建
+	var orderId int64
+	err = l.svcCtx.OrderModel.Trans(l.ctx, func(ctx context.Context, session sqlx.Session) error {
+		// 插入订单
+		result, err := l.svcCtx.OrderModel.Insert(ctx, session, order)
+		if err != nil {
+			return errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "AdminCreateOrder, 创建订单失败 err: %v", err)
+		}
+
+		// 获取订单ID
+		orderId, err = result.LastInsertId()
+		if err != nil {
+			return errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "AdminCreateOrder, 获取订单ID失败 err: %v", err)
+		}
+
+		// 如果是推广订单，创建推广订单记录
+		if req.IsPromotion == 1 {
+			promotionOrder := &model.AdminPromotionOrder{
+				OrderId:    orderId,
+				Version:    1,
+				CreateTime: time.Now(),
+				UpdateTime: time.Now(),
+			}
+			_, err = l.svcCtx.AdminPromotionOrderModel.Insert(ctx, session, promotionOrder)
+			if err != nil {
+				return errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "AdminCreateOrder, 创建推广订单失败 err: %v", err)
+			}
+		}
+
+		return nil
+	})
+
+	if err != nil {
+		return nil, err
+	}
+
+	return &types.AdminCreateOrderResp{
+		Id: orderId,
+	}, nil
+}

app/main/api/internal/logic/admin_order/admindeleteorderlogic.go

@@ -0,0 +1,63 @@
+package admin_order
+
+import (
+	"context"
+
+	"tyc-server/app/main/api/internal/svc"
+	"tyc-server/app/main/api/internal/types"
+	"tyc-server/common/xerr"
+
+	"github.com/pkg/errors"
+	"github.com/zeromicro/go-zero/core/logx"
+	"github.com/zeromicro/go-zero/core/stores/sqlx"
+)
+
+type AdminDeleteOrderLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewAdminDeleteOrderLogic(ctx context.Context, svcCtx *svc.ServiceContext) *AdminDeleteOrderLogic {
+	return &AdminDeleteOrderLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *AdminDeleteOrderLogic) AdminDeleteOrder(req *types.AdminDeleteOrderReq) (resp *types.AdminDeleteOrderResp, err error) {
+	// 获取订单信息
+	order, err := l.svcCtx.OrderModel.FindOne(l.ctx, req.Id)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "AdminDeleteOrder, 查询订单失败 err: %v", err)
+	}
+
+	// 使用事务删除订单
+	err = l.svcCtx.OrderModel.Trans(l.ctx, func(ctx context.Context, session sqlx.Session) error {
+		// 软删除订单
+		err := l.svcCtx.OrderModel.DeleteSoft(ctx, session, order)
+		if err != nil {
+			return errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "AdminDeleteOrder, 删除订单失败 err: %v", err)
+		}
+
+		// 删除关联的推广订单记录
+		promotionOrder, err := l.svcCtx.AdminPromotionOrderModel.FindOneByOrderId(ctx, order.Id)
+		if err == nil && promotionOrder != nil {
+			err = l.svcCtx.AdminPromotionOrderModel.DeleteSoft(ctx, session, promotionOrder)
+			if err != nil {
+				return errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "AdminDeleteOrder, 删除推广订单失败 err: %v", err)
+			}
+		}
+
+		return nil
+	})
+
+	if err != nil {
+		return nil, err
+	}
+
+	return &types.AdminDeleteOrderResp{
+		Success: true,
+	}, nil
+}

app/main/api/internal/logic/admin_order/admingetorderdetaillogic.go

@@ -0,0 +1,72 @@
+package admin_order
+
+import (
+	"context"
+
+	"tyc-server/app/main/api/internal/svc"
+	"tyc-server/app/main/api/internal/types"
+	"tyc-server/common/xerr"
+
+	"github.com/pkg/errors"
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type AdminGetOrderDetailLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewAdminGetOrderDetailLogic(ctx context.Context, svcCtx *svc.ServiceContext) *AdminGetOrderDetailLogic {
+	return &AdminGetOrderDetailLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *AdminGetOrderDetailLogic) AdminGetOrderDetail(req *types.AdminGetOrderDetailReq) (resp *types.AdminGetOrderDetailResp, err error) {
+	// 获取订单信息
+	order, err := l.svcCtx.OrderModel.FindOne(l.ctx, req.Id)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "AdminGetOrderDetail, 查询订单失败 err: %v", err)
+	}
+
+	// 获取产品信息
+	product, err := l.svcCtx.ProductModel.FindOne(l.ctx, order.ProductId)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "AdminGetOrderDetail, 查询产品失败 err: %v", err)
+	}
+
+	// 判断是否为推广订单
+	var isPromotion int64
+	promotionOrder, err := l.svcCtx.AdminPromotionOrderModel.FindOneByOrderId(l.ctx, order.Id)
+	if err == nil && promotionOrder != nil {
+		isPromotion = 1
+	}
+
+	// 构建响应
+	resp = &types.AdminGetOrderDetailResp{
+		Id:              order.Id,
+		OrderNo:         order.OrderNo,
+		PlatformOrderId: order.PlatformOrderId.String,
+		ProductName:     product.ProductName,
+		PaymentPlatform: order.PaymentPlatform,
+		PaymentScene:    order.PaymentScene,
+		Amount:          order.Amount,
+		Status:          order.Status,
+		CreateTime:      order.CreateTime.Format("2006-01-02 15:04:05"),
+		UpdateTime:      order.UpdateTime.Format("2006-01-02 15:04:05"),
+		IsPromotion:     isPromotion,
+	}
+
+	// 处理可选字段
+	if order.PayTime.Valid {
+		resp.PayTime = order.PayTime.Time.Format("2006-01-02 15:04:05")
+	}
+	if order.RefundTime.Valid {
+		resp.RefundTime = order.RefundTime.Time.Format("2006-01-02 15:04:05")
+	}
+
+	return resp, nil
+}

app/main/api/internal/logic/admin_order/admingetorderlistlogic.go

@@ -0,0 +1,159 @@
+package admin_order
+
+import (
+	"context"
+	"sync"
+
+	"tyc-server/app/main/api/internal/svc"
+	"tyc-server/app/main/api/internal/types"
+	"tyc-server/app/main/model"
+	"tyc-server/common/xerr"
+
+	"github.com/pkg/errors"
+	"github.com/zeromicro/go-zero/core/logx"
+	"github.com/zeromicro/go-zero/core/mr"
+)
+
+type AdminGetOrderListLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewAdminGetOrderListLogic(ctx context.Context, svcCtx *svc.ServiceContext) *AdminGetOrderListLogic {
+	return &AdminGetOrderListLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *AdminGetOrderListLogic) AdminGetOrderList(req *types.AdminGetOrderListReq) (resp *types.AdminGetOrderListResp, err error) {
+	// 构建查询条件
+	builder := l.svcCtx.OrderModel.SelectBuilder()
+	if req.OrderNo != "" {
+		builder = builder.Where("order_no = ?", req.OrderNo)
+	}
+	if req.PlatformOrderId != "" {
+		builder = builder.Where("platform_order_id = ?", req.PlatformOrderId)
+	}
+	if req.ProductName != "" {
+		builder = builder.Where("product_id IN (SELECT id FROM product WHERE product_name LIKE ?)", "%"+req.ProductName+"%")
+	}
+	if req.PaymentPlatform != "" {
+		builder = builder.Where("payment_platform = ?", req.PaymentPlatform)
+	}
+	if req.PaymentScene != "" {
+		builder = builder.Where("payment_scene = ?", req.PaymentScene)
+	}
+	if req.Amount > 0 {
+		builder = builder.Where("amount = ?", req.Amount)
+	}
+	if req.Status != "" {
+		builder = builder.Where("status = ?", req.Status)
+	}
+	if req.IsPromotion != -1 {
+		builder = builder.Where("id IN (SELECT order_id FROM admin_promotion_order WHERE del_state = 0)")
+	}
+	// 时间范围查询
+	if req.CreateTimeStart != "" {
+		builder = builder.Where("create_time >= ?", req.CreateTimeStart)
+	}
+	if req.CreateTimeEnd != "" {
+		builder = builder.Where("create_time <= ?", req.CreateTimeEnd)
+	}
+	if req.PayTimeStart != "" {
+		builder = builder.Where("pay_time >= ?", req.PayTimeStart)
+	}
+	if req.PayTimeEnd != "" {
+		builder = builder.Where("pay_time <= ?", req.PayTimeEnd)
+	}
+	if req.RefundTimeStart != "" {
+		builder = builder.Where("refund_time >= ?", req.RefundTimeStart)
+	}
+	if req.RefundTimeEnd != "" {
+		builder = builder.Where("refund_time <= ?", req.RefundTimeEnd)
+	}
+
+	// 并发获取总数和列表
+	var total int64
+	var orders []*model.Order
+	err = mr.Finish(func() error {
+		var err error
+		total, err = l.svcCtx.OrderModel.FindCount(l.ctx, builder, "id")
+		if err != nil {
+			return errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "AdminGetOrderList, 查询订单总数失败 err: %v", err)
+		}
+		return nil
+	}, func() error {
+		var err error
+		orders, err = l.svcCtx.OrderModel.FindPageListByPage(l.ctx, builder, req.Page, req.PageSize, "id DESC")
+		if err != nil {
+			return errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "AdminGetOrderList, 查询订单列表失败 err: %v", err)
+		}
+		return nil
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	// 并发获取产品信息
+	productMap := make(map[int64]string)
+	var mu sync.Mutex
+	err = mr.MapReduceVoid(func(source chan<- interface{}) {
+		for _, order := range orders {
+			source <- order.ProductId
+		}
+	}, func(item interface{}, writer mr.Writer[struct{}], cancel func(error)) {
+		productId := item.(int64)
+		product, err := l.svcCtx.ProductModel.FindOne(l.ctx, productId)
+		if err != nil {
+			cancel(errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "AdminGetOrderList, 查询产品信息失败 err: %v", err))
+			return
+		}
+		mu.Lock()
+		productMap[product.Id] = product.ProductName
+		mu.Unlock()
+		writer.Write(struct{}{})
+	}, func(pipe <-chan struct{}, cancel func(error)) {
+		for range pipe {
+		}
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	// 构建响应
+	resp = &types.AdminGetOrderListResp{
+		Total: total,
+		Items: make([]types.OrderListItem, 0, len(orders)),
+	}
+
+	for _, order := range orders {
+		item := types.OrderListItem{
+			Id:              order.Id,
+			OrderNo:         order.OrderNo,
+			PlatformOrderId: order.PlatformOrderId.String,
+			ProductName:     productMap[order.ProductId],
+			PaymentPlatform: order.PaymentPlatform,
+			PaymentScene:    order.PaymentScene,
+			Amount:          order.Amount,
+			Status:          order.Status,
+			CreateTime:      order.CreateTime.Format("2006-01-02 15:04:05"),
+		}
+		if order.PayTime.Valid {
+			item.PayTime = order.PayTime.Time.Format("2006-01-02 15:04:05")
+		}
+		if order.RefundTime.Valid {
+			item.RefundTime = order.RefundTime.Time.Format("2006-01-02 15:04:05")
+		}
+		// 判断是否为推广订单
+		promotionOrder, err := l.svcCtx.AdminPromotionOrderModel.FindOneByOrderId(l.ctx, order.Id)
+		if err == nil && promotionOrder != nil {
+			item.IsPromotion = 1
+		}
+		resp.Items = append(resp.Items, item)
+	}
+
+	return resp, nil
+}

app/main/api/internal/logic/admin_order/adminrefundorderlogic.go

@@ -0,0 +1,60 @@
+package admin_order
+
+import (
+	"context"
+
+	"tyc-server/app/main/api/internal/service"
+	"tyc-server/app/main/api/internal/svc"
+	"tyc-server/app/main/api/internal/types"
+	"tyc-server/common/xerr"
+
+	"github.com/pkg/errors"
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type AdminRefundOrderLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewAdminRefundOrderLogic(ctx context.Context, svcCtx *svc.ServiceContext) *AdminRefundOrderLogic {
+	return &AdminRefundOrderLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *AdminRefundOrderLogic) AdminRefundOrder(req *types.AdminRefundOrderReq) (resp *types.AdminRefundOrderResp, err error) {
+	// 获取订单信息
+	order, err := l.svcCtx.OrderModel.FindOne(l.ctx, req.Id)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "AdminRefundOrder, 查询订单失败 err: %v", err)
+	}
+
+	// 检查订单状态
+	if order.Status != "paid" {
+		return nil, errors.Wrapf(xerr.NewErrMsg("订单状态不正确，无法退款"), "AdminRefundOrder, 订单状态不正确，无法退款 err: %v", err)
+	}
+
+	// 检查退款金额
+	if req.RefundAmount > order.Amount {
+		return nil, errors.Wrapf(xerr.NewErrMsg("退款金额不能大于订单金额"), "AdminRefundOrder, 退款金额不能大于订单金额 err: %v", err)
+	}
+
+	refundResp, err := l.svcCtx.PayService.Refund(l.ctx, &service.RefundRequest{
+		OrderId:      order.Id,
+		RefundAmount: req.RefundAmount,
+		Reason:       req.RefundReason,
+	})
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "AdminRefundOrder, 退款失败 err: %v", err)
+	}
+
+	return &types.AdminRefundOrderResp{
+		Status:   refundResp.Status,
+		RefundNo: refundResp.RefundNo,
+		Amount:   refundResp.Amount,
+	}, nil
+}

app/main/api/internal/logic/admin_order/adminupdateorderlogic.go

@@ -0,0 +1,113 @@
+package admin_order
+
+import (
+	"context"
+	"database/sql"
+	"time"
+
+	"tyc-server/app/main/api/internal/svc"
+	"tyc-server/app/main/api/internal/types"
+	"tyc-server/app/main/model"
+	"tyc-server/common/xerr"
+
+	"github.com/pkg/errors"
+	"github.com/zeromicro/go-zero/core/logx"
+	"github.com/zeromicro/go-zero/core/stores/sqlx"
+)
+
+type AdminUpdateOrderLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewAdminUpdateOrderLogic(ctx context.Context, svcCtx *svc.ServiceContext) *AdminUpdateOrderLogic {
+	return &AdminUpdateOrderLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *AdminUpdateOrderLogic) AdminUpdateOrder(req *types.AdminUpdateOrderReq) (resp *types.AdminUpdateOrderResp, err error) {
+	// 获取原订单信息
+	order, err := l.svcCtx.OrderModel.FindOne(l.ctx, req.Id)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "AdminUpdateOrder, 查询订单失败 err: %v", err)
+	}
+
+	// 更新订单字段
+	if req.OrderNo != nil {
+		order.OrderNo = *req.OrderNo
+	}
+	if req.PlatformOrderId != nil {
+		order.PlatformOrderId = sql.NullString{String: *req.PlatformOrderId, Valid: true}
+	}
+	if req.PaymentPlatform != nil {
+		order.PaymentPlatform = *req.PaymentPlatform
+	}
+	if req.PaymentScene != nil {
+		order.PaymentScene = *req.PaymentScene
+	}
+	if req.Amount != nil {
+		order.Amount = *req.Amount
+	}
+	if req.Status != nil {
+		order.Status = *req.Status
+	}
+	if req.PayTime != nil {
+		payTime, err := time.Parse("2006-01-02 15:04:05", *req.PayTime)
+		if err == nil {
+			order.PayTime = sql.NullTime{Time: payTime, Valid: true}
+		}
+	}
+	if req.RefundTime != nil {
+		refundTime, err := time.Parse("2006-01-02 15:04:05", *req.RefundTime)
+		if err == nil {
+			order.RefundTime = sql.NullTime{Time: refundTime, Valid: true}
+		}
+	}
+
+	// 使用事务更新订单
+	err = l.svcCtx.OrderModel.Trans(l.ctx, func(ctx context.Context, session sqlx.Session) error {
+		// 更新订单
+		_, err := l.svcCtx.OrderModel.Update(ctx, session, order)
+		if err != nil {
+			return errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "AdminUpdateOrder, 更新订单失败 err: %v", err)
+		}
+
+		// 处理推广订单状态
+		if req.IsPromotion != nil {
+			promotionOrder, err := l.svcCtx.AdminPromotionOrderModel.FindOneByOrderId(ctx, order.Id)
+			if err == nil && promotionOrder != nil {
+				// 如果存在推广订单记录但不需要推广，则删除
+				if *req.IsPromotion == 0 {
+					err = l.svcCtx.AdminPromotionOrderModel.DeleteSoft(ctx, session, promotionOrder)
+					if err != nil {
+						return errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "AdminUpdateOrder, 删除推广订单失败 err: %v", err)
+					}
+				}
+			} else if *req.IsPromotion == 1 {
+				// 如果需要推广但不存在记录，则创建
+				newPromotionOrder := &model.AdminPromotionOrder{
+					OrderId: order.Id,
+					Version: 1,
+				}
+				_, err = l.svcCtx.AdminPromotionOrderModel.Insert(ctx, session, newPromotionOrder)
+				if err != nil {
+					return errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "AdminUpdateOrder, 创建推广订单失败 err: %v", err)
+				}
+			}
+		}
+
+		return nil
+	})
+
+	if err != nil {
+		return nil, err
+	}
+
+	return &types.AdminUpdateOrderResp{
+		Success: true,
+	}, nil
+}

app/main/api/internal/logic/admin_platform_user/admincreateplatformuserlogic.go

@@ -0,0 +1,57 @@
+package admin_platform_user
+
+import (
+	"context"
+	"database/sql"
+
+	"tyc-server/app/main/api/internal/svc"
+	"tyc-server/app/main/api/internal/types"
+	"tyc-server/app/main/model"
+	"tyc-server/common/xerr"
+
+	"github.com/pkg/errors"
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type AdminCreatePlatformUserLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewAdminCreatePlatformUserLogic(ctx context.Context, svcCtx *svc.ServiceContext) *AdminCreatePlatformUserLogic {
+	return &AdminCreatePlatformUserLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *AdminCreatePlatformUserLogic) AdminCreatePlatformUser(req *types.AdminCreatePlatformUserReq) (resp *types.AdminCreatePlatformUserResp, err error) {
+	// 校验手机号唯一性
+	_, err = l.svcCtx.UserModel.FindOneByMobile(l.ctx, req.Mobile)
+	if err == nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "手机号已存在: %s", req.Mobile)
+	}
+	if err != model.ErrNotFound {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "查询手机号失败: %v", err)
+	}
+
+	user := &model.User{
+		Mobile:   req.Mobile,
+		Password: sql.NullString{String: req.Password, Valid: req.Password != ""},
+		Nickname: sql.NullString{String: req.Nickname, Valid: req.Nickname != ""},
+		Info:     req.Info,
+		Inside:   req.Inside,
+	}
+	result, err := l.svcCtx.UserModel.Insert(l.ctx, nil, user)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "创建用户失败: %v", err)
+	}
+	id, err := result.LastInsertId()
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "获取用户ID失败: %v", err)
+	}
+	resp = &types.AdminCreatePlatformUserResp{Id: id}
+	return resp, nil
+}

app/main/api/internal/logic/admin_platform_user/admindeleteplatformuserlogic.go

@@ -0,0 +1,44 @@
+package admin_platform_user
+
+import (
+	"context"
+
+	"tyc-server/app/main/api/internal/svc"
+	"tyc-server/app/main/api/internal/types"
+
+	"time"
+	"tyc-server/common/xerr"
+
+	"github.com/pkg/errors"
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type AdminDeletePlatformUserLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewAdminDeletePlatformUserLogic(ctx context.Context, svcCtx *svc.ServiceContext) *AdminDeletePlatformUserLogic {
+	return &AdminDeletePlatformUserLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *AdminDeletePlatformUserLogic) AdminDeletePlatformUser(req *types.AdminDeletePlatformUserReq) (resp *types.AdminDeletePlatformUserResp, err error) {
+	user, err := l.svcCtx.UserModel.FindOne(l.ctx, req.Id)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "用户不存在: %d, err: %v", req.Id, err)
+	}
+	user.DelState = 1
+	user.DeleteTime.Time = time.Now()
+	user.DeleteTime.Valid = true
+	err = l.svcCtx.UserModel.DeleteSoft(l.ctx, nil, user)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "软删除用户失败: %v", err)
+	}
+	resp = &types.AdminDeletePlatformUserResp{Success: true}
+	return resp, nil
+}

app/main/api/internal/logic/admin_platform_user/admingetplatformuserdetaillogic.go

@@ -0,0 +1,54 @@
+package admin_platform_user
+
+import (
+	"context"
+
+	"tyc-server/app/main/api/internal/svc"
+	"tyc-server/app/main/api/internal/types"
+	"tyc-server/pkg/lzkit/crypto"
+
+	"tyc-server/common/xerr"
+
+	"github.com/pkg/errors"
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type AdminGetPlatformUserDetailLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewAdminGetPlatformUserDetailLogic(ctx context.Context, svcCtx *svc.ServiceContext) *AdminGetPlatformUserDetailLogic {
+	return &AdminGetPlatformUserDetailLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *AdminGetPlatformUserDetailLogic) AdminGetPlatformUserDetail(req *types.AdminGetPlatformUserDetailReq) (resp *types.AdminGetPlatformUserDetailResp, err error) {
+	user, err := l.svcCtx.UserModel.FindOne(l.ctx, req.Id)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "用户不存在: %d, err: %v", req.Id, err)
+	}
+	key := l.svcCtx.Config.Encrypt.SecretKey
+	DecryptMobile, err := crypto.DecryptMobile(user.Mobile, key)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "解密手机号失败: %v", err)
+	}
+	// 查询平台类型（取第一个user_auth）
+	resp = &types.AdminGetPlatformUserDetailResp{
+		Id:         user.Id,
+		Mobile:     DecryptMobile,
+		Nickname:   "",
+		Info:       user.Info,
+		Inside:     user.Inside,
+		CreateTime: user.CreateTime.Format("2006-01-02 15:04:05"),
+		UpdateTime: user.UpdateTime.Format("2006-01-02 15:04:05"),
+	}
+	if user.Nickname.Valid {
+		resp.Nickname = user.Nickname.String
+	}
+	return resp, nil
+}

app/main/api/internal/logic/admin_platform_user/admingetplatformuserlistlogic.go

@@ -0,0 +1,88 @@
+package admin_platform_user
+
+import (
+	"context"
+	"fmt"
+
+	"tyc-server/app/main/api/internal/svc"
+	"tyc-server/app/main/api/internal/types"
+	"tyc-server/pkg/lzkit/crypto"
+
+	"tyc-server/common/xerr"
+
+	"github.com/pkg/errors"
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type AdminGetPlatformUserListLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewAdminGetPlatformUserListLogic(ctx context.Context, svcCtx *svc.ServiceContext) *AdminGetPlatformUserListLogic {
+	return &AdminGetPlatformUserListLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *AdminGetPlatformUserListLogic) AdminGetPlatformUserList(req *types.AdminGetPlatformUserListReq) (resp *types.AdminGetPlatformUserListResp, err error) {
+	builder := l.svcCtx.UserModel.SelectBuilder()
+	if req.Mobile != "" {
+		builder = builder.Where("mobile = ?", req.Mobile)
+	}
+	if req.Nickname != "" {
+		builder = builder.Where("nickname = ?", req.Nickname)
+	}
+	if req.Inside != 0 {
+		builder = builder.Where("inside = ?", req.Inside)
+	}
+	if req.CreateTimeStart != "" {
+		builder = builder.Where("create_time >= ?", req.CreateTimeStart)
+	}
+	if req.CreateTimeEnd != "" {
+		builder = builder.Where("create_time <= ?", req.CreateTimeEnd)
+	}
+
+	orderBy := "id DESC"
+	if req.OrderBy != "" && req.OrderType != "" {
+		orderBy = fmt.Sprintf("%s %s", req.OrderBy, req.OrderType)
+	}
+	users, total, err := l.svcCtx.UserModel.FindPageListByPageWithTotal(l.ctx, builder, req.Page, req.PageSize, orderBy)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "查询用户分页失败: %v", err)
+	}
+	var items []types.PlatformUserListItem
+	secretKey := l.svcCtx.Config.Encrypt.SecretKey
+
+	for _, user := range users {
+		mobile := user.Mobile
+		if mobile != "" {
+			encryptedMobile, err := crypto.DecryptMobile(mobile, secretKey)
+			if err != nil {
+				return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "手机登录, 解密手机号失败: %+v", err)
+			}
+			mobile = encryptedMobile
+		}
+		itemData := types.PlatformUserListItem{
+			Id:         user.Id,
+			Mobile:     mobile,
+			Nickname:   "",
+			Info:       user.Info,
+			Inside:     user.Inside,
+			CreateTime: user.CreateTime.Format("2006-01-02 15:04:05"),
+			UpdateTime: user.UpdateTime.Format("2006-01-02 15:04:05"),
+		}
+		if user.Nickname.Valid {
+			itemData.Nickname = user.Nickname.String
+		}
+		items = append(items, itemData)
+	}
+	resp = &types.AdminGetPlatformUserListResp{
+		Total: total,
+		Items: items,
+	}
+	return resp, nil
+}

app/main/api/internal/logic/admin_platform_user/adminupdateplatformuserlogic.go

@@ -0,0 +1,64 @@
+package admin_platform_user
+
+import (
+	"context"
+	"database/sql"
+
+	"tyc-server/app/main/api/internal/svc"
+	"tyc-server/app/main/api/internal/types"
+	"tyc-server/common/xerr"
+	"tyc-server/pkg/lzkit/crypto"
+
+	"github.com/pkg/errors"
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type AdminUpdatePlatformUserLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewAdminUpdatePlatformUserLogic(ctx context.Context, svcCtx *svc.ServiceContext) *AdminUpdatePlatformUserLogic {
+	return &AdminUpdatePlatformUserLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *AdminUpdatePlatformUserLogic) AdminUpdatePlatformUser(req *types.AdminUpdatePlatformUserReq) (resp *types.AdminUpdatePlatformUserResp, err error) {
+	user, err := l.svcCtx.UserModel.FindOne(l.ctx, req.Id)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "用户不存在: %d, err: %v", req.Id, err)
+	}
+	if req.Mobile != nil {
+		key := l.svcCtx.Config.Encrypt.SecretKey
+		EncryptMobile, err := crypto.EncryptMobile(*req.Mobile, key)
+		if err != nil {
+			return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "加密手机号失败: %v", err)
+		}
+		user.Mobile = EncryptMobile
+	}
+	if req.Nickname != nil {
+		user.Nickname = sql.NullString{String: *req.Nickname, Valid: *req.Nickname != ""}
+	}
+	if req.Info != nil {
+		user.Info = *req.Info
+	}
+	if req.Inside != nil {
+		if *req.Inside != 1 && *req.Inside != 0 {
+			return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "内部用户状态错误: %d", *req.Inside)
+		}
+		user.Inside = *req.Inside
+	}
+	if req.Password != nil {
+		user.Password = sql.NullString{String: *req.Password, Valid: *req.Password != ""}
+	}
+	_, err = l.svcCtx.UserModel.Update(l.ctx, nil, user)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "更新用户失败: %v", err)
+	}
+	resp = &types.AdminUpdatePlatformUserResp{Success: true}
+	return resp, nil
+}

app/main/api/internal/logic/admin_product/admincreateproductlogic.go

@@ -0,0 +1,50 @@
+package admin_product
+
+import (
+	"context"
+	"database/sql"
+	"tyc-server/app/main/api/internal/svc"
+	"tyc-server/app/main/api/internal/types"
+	"tyc-server/app/main/model"
+	"tyc-server/common/xerr"
+
+	"github.com/pkg/errors"
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type AdminCreateProductLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewAdminCreateProductLogic(ctx context.Context, svcCtx *svc.ServiceContext) *AdminCreateProductLogic {
+	return &AdminCreateProductLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *AdminCreateProductLogic) AdminCreateProduct(req *types.AdminCreateProductReq) (resp *types.AdminCreateProductResp, err error) {
+	// 1. 数据转换
+	data := &model.Product{
+		ProductName: req.ProductName,
+		ProductEn:   req.ProductEn,
+		Description: req.Description,
+		Notes:       sql.NullString{String: req.Notes, Valid: req.Notes != ""},
+		CostPrice:   req.CostPrice,
+		SellPrice:   req.SellPrice,
+	}
+
+	// 2. 数据库操作
+	result, err := l.svcCtx.ProductModel.Insert(l.ctx, nil, data)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR),
+			"创建产品失败, err: %v, req: %+v", err, req)
+	}
+
+	// 3. 返回结果
+	id, _ := result.LastInsertId()
+	return &types.AdminCreateProductResp{Id: id}, nil
+}

app/main/api/internal/logic/admin_product/admindeleteproductlogic.go

@@ -0,0 +1,44 @@
+package admin_product
+
+import (
+	"context"
+	"tyc-server/app/main/api/internal/svc"
+	"tyc-server/app/main/api/internal/types"
+	"tyc-server/common/xerr"
+
+	"github.com/pkg/errors"
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type AdminDeleteProductLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewAdminDeleteProductLogic(ctx context.Context, svcCtx *svc.ServiceContext) *AdminDeleteProductLogic {
+	return &AdminDeleteProductLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *AdminDeleteProductLogic) AdminDeleteProduct(req *types.AdminDeleteProductReq) (resp *types.AdminDeleteProductResp, err error) {
+	// 1. 查询记录是否存在
+	record, err := l.svcCtx.ProductModel.FindOne(l.ctx, req.Id)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR),
+			"查找产品失败, err: %v, id: %d", err, req.Id)
+	}
+
+	// 2. 执行软删除
+	err = l.svcCtx.ProductModel.DeleteSoft(l.ctx, nil, record)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR),
+			"删除产品失败, err: %v, id: %d", err, req.Id)
+	}
+
+	// 3. 返回结果
+	return &types.AdminDeleteProductResp{Success: true}, nil
+}

app/main/api/internal/logic/admin_product/admingetproductdetaillogic.go

@@ -0,0 +1,49 @@
+package admin_product
+
+import (
+	"context"
+	"tyc-server/app/main/api/internal/svc"
+	"tyc-server/app/main/api/internal/types"
+	"tyc-server/common/xerr"
+
+	"github.com/pkg/errors"
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type AdminGetProductDetailLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewAdminGetProductDetailLogic(ctx context.Context, svcCtx *svc.ServiceContext) *AdminGetProductDetailLogic {
+	return &AdminGetProductDetailLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *AdminGetProductDetailLogic) AdminGetProductDetail(req *types.AdminGetProductDetailReq) (resp *types.AdminGetProductDetailResp, err error) {
+	// 1. 查询记录
+	record, err := l.svcCtx.ProductModel.FindOne(l.ctx, req.Id)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR),
+			"查找产品失败, err: %v, id: %d", err, req.Id)
+	}
+
+	// 2. 构建响应
+	resp = &types.AdminGetProductDetailResp{
+		Id:          record.Id,
+		ProductName: record.ProductName,
+		ProductEn:   record.ProductEn,
+		Description: record.Description,
+		Notes:       record.Notes.String,
+		CostPrice:   record.CostPrice,
+		SellPrice:   record.SellPrice,
+		CreateTime:  record.CreateTime.Format("2006-01-02 15:04:05"),
+		UpdateTime:  record.UpdateTime.Format("2006-01-02 15:04:05"),
+	}
+
+	return resp, nil
+}

app/main/api/internal/logic/admin_product/admingetproductfeaturelistlogic.go

@@ -0,0 +1,119 @@
+package admin_product
+
+import (
+	"context"
+	"tyc-server/app/main/api/internal/svc"
+	"tyc-server/app/main/api/internal/types"
+	"tyc-server/app/main/model"
+	"tyc-server/common/xerr"
+
+	"github.com/pkg/errors"
+	"github.com/zeromicro/go-zero/core/logx"
+	"github.com/zeromicro/go-zero/core/mr"
+)
+
+type AdminGetProductFeatureListLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewAdminGetProductFeatureListLogic(ctx context.Context, svcCtx *svc.ServiceContext) *AdminGetProductFeatureListLogic {
+	return &AdminGetProductFeatureListLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *AdminGetProductFeatureListLogic) AdminGetProductFeatureList(req *types.AdminGetProductFeatureListReq) (resp *[]types.AdminGetProductFeatureListResp, err error) {
+	// 1. 构建查询条件
+	builder := l.svcCtx.ProductFeatureModel.SelectBuilder().
+		Where("product_id = ?", req.ProductId)
+
+	// 2. 执行查询
+	list, err := l.svcCtx.ProductFeatureModel.FindAll(l.ctx, builder, "sort ASC")
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR),
+			"查询产品功能列表失败, err: %v, product_id: %d", err, req.ProductId)
+	}
+
+	// 3. 获取所有功能ID
+	featureIds := make([]int64, 0, len(list))
+	for _, item := range list {
+		featureIds = append(featureIds, item.FeatureId)
+	}
+
+	// 4. 并发查询功能详情
+	type featureResult struct {
+		feature *model.Feature
+		err     error
+	}
+
+	results := make([]featureResult, len(featureIds))
+	err = mr.MapReduceVoid(func(source chan<- interface{}) {
+		for i, id := range featureIds {
+			source <- struct {
+				index int
+				id    int64
+			}{i, id}
+		}
+	}, func(item interface{}, writer mr.Writer[featureResult], cancel func(error)) {
+		data := item.(struct {
+			index int
+			id    int64
+		})
+		feature, err := l.svcCtx.FeatureModel.FindOne(l.ctx, data.id)
+		writer.Write(featureResult{
+			feature: feature,
+			err:     err,
+		})
+	}, func(pipe <-chan featureResult, cancel func(error)) {
+		for result := range pipe {
+			if result.err != nil {
+				l.Logger.Errorf("查询功能详情失败, feature_id: %d, err: %v", result.feature.Id, result.err)
+				continue
+			}
+			results = append(results, result)
+		}
+	})
+
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR),
+			"并发查询功能详情失败, err: %v", err)
+	}
+
+	// 5. 构建功能ID到详情的映射
+	featureMap := make(map[int64]*model.Feature)
+	for _, result := range results {
+		if result.feature != nil {
+			featureMap[result.feature.Id] = result.feature
+		}
+	}
+
+	// 6. 构建响应列表
+	items := make([]types.AdminGetProductFeatureListResp, 0, len(list))
+	for _, item := range list {
+		feature, exists := featureMap[item.FeatureId]
+		if !exists {
+			continue // 跳过不存在的功能
+		}
+
+		listItem := types.AdminGetProductFeatureListResp{
+			Id:          item.Id,
+			ProductId:   item.ProductId,
+			FeatureId:   item.FeatureId,
+			ApiId:       feature.ApiId,
+			Name:        feature.Name,
+			Sort:        item.Sort,
+			Enable:      item.Enable,
+			IsImportant: item.IsImportant,
+			CreateTime:  item.CreateTime.Format("2006-01-02 15:04:05"),
+			UpdateTime:  item.UpdateTime.Format("2006-01-02 15:04:05"),
+		}
+		items = append(items, listItem)
+	}
+
+	// 7. 返回结果
+	return &items, nil
+}

app/main/api/internal/logic/admin_product/admingetproductlistlogic.go

@@ -0,0 +1,69 @@
+package admin_product
+
+import (
+	"context"
+	"tyc-server/app/main/api/internal/svc"
+	"tyc-server/app/main/api/internal/types"
+	"tyc-server/common/xerr"
+
+	"github.com/pkg/errors"
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type AdminGetProductListLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewAdminGetProductListLogic(ctx context.Context, svcCtx *svc.ServiceContext) *AdminGetProductListLogic {
+	return &AdminGetProductListLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *AdminGetProductListLogic) AdminGetProductList(req *types.AdminGetProductListReq) (resp *types.AdminGetProductListResp, err error) {
+	// 1. 构建查询条件
+	builder := l.svcCtx.ProductModel.SelectBuilder()
+
+	// 2. 添加查询条件
+	if req.ProductName != nil && *req.ProductName != "" {
+		builder = builder.Where("product_name LIKE ?", "%"+*req.ProductName+"%")
+	}
+	if req.ProductEn != nil && *req.ProductEn != "" {
+		builder = builder.Where("product_en LIKE ?", "%"+*req.ProductEn+"%")
+	}
+
+	// 3. 执行分页查询
+	list, total, err := l.svcCtx.ProductModel.FindPageListByPageWithTotal(
+		l.ctx, builder, req.Page, req.PageSize, "id DESC")
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR),
+			"查询产品列表失败, err: %v, req: %+v", err, req)
+	}
+
+	// 4. 构建响应列表
+	items := make([]types.ProductListItem, 0, len(list))
+	for _, item := range list {
+		listItem := types.ProductListItem{
+			Id:          item.Id,
+			ProductName: item.ProductName,
+			ProductEn:   item.ProductEn,
+			Description: item.Description,
+			Notes:       item.Notes.String,
+			CostPrice:   item.CostPrice,
+			SellPrice:   item.SellPrice,
+			CreateTime:  item.CreateTime.Format("2006-01-02 15:04:05"),
+			UpdateTime:  item.UpdateTime.Format("2006-01-02 15:04:05"),
+		}
+		items = append(items, listItem)
+	}
+
+	// 5. 返回结果
+	return &types.AdminGetProductListResp{
+		Total: total,
+		Items: items,
+	}, nil
+}

app/main/api/internal/logic/admin_product/adminupdateproductfeatureslogic.go

@@ -0,0 +1,159 @@
+package admin_product
+
+import (
+	"context"
+	"sync"
+	"tyc-server/app/main/api/internal/svc"
+	"tyc-server/app/main/api/internal/types"
+	"tyc-server/app/main/model"
+	"tyc-server/common/xerr"
+
+	"github.com/pkg/errors"
+	"github.com/zeromicro/go-zero/core/logx"
+	"github.com/zeromicro/go-zero/core/mr"
+	"github.com/zeromicro/go-zero/core/stores/sqlx"
+)
+
+type AdminUpdateProductFeaturesLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewAdminUpdateProductFeaturesLogic(ctx context.Context, svcCtx *svc.ServiceContext) *AdminUpdateProductFeaturesLogic {
+	return &AdminUpdateProductFeaturesLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *AdminUpdateProductFeaturesLogic) AdminUpdateProductFeatures(req *types.AdminUpdateProductFeaturesReq) (resp *types.AdminUpdateProductFeaturesResp, err error) {
+	// 1. 查询现有关联
+	builder := l.svcCtx.ProductFeatureModel.SelectBuilder().
+		Where("product_id = ?", req.ProductId)
+	existingList, err := l.svcCtx.ProductFeatureModel.FindAll(l.ctx, builder, "id ASC")
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR),
+			"查询现有产品功能关联失败, err: %v, product_id: %d", err, req.ProductId)
+	}
+
+	// 2. 构建现有关联的映射
+	existingMap := make(map[int64]*model.ProductFeature)
+	for _, item := range existingList {
+		existingMap[item.FeatureId] = item
+	}
+
+	// 3. 构建新关联的映射
+	newMap := make(map[int64]*types.ProductFeatureItem)
+	for _, item := range req.Features {
+		newMap[item.FeatureId] = &item
+	}
+
+	// 4. 在事务中执行更新操作
+	err = l.svcCtx.ProductFeatureModel.Trans(l.ctx, func(ctx context.Context, session sqlx.Session) error {
+		// 4.1 处理需要删除的关联
+		var mu sync.Mutex
+		var deleteIds []int64
+		err = mr.MapReduceVoid(func(source chan<- interface{}) {
+			for featureId, existing := range existingMap {
+				if _, exists := newMap[featureId]; !exists {
+					source <- existing.Id
+				}
+			}
+		}, func(item interface{}, writer mr.Writer[struct{}], cancel func(error)) {
+			id := item.(int64)
+			mu.Lock()
+			deleteIds = append(deleteIds, id)
+			mu.Unlock()
+		}, func(pipe <-chan struct{}, cancel func(error)) {
+			// 等待所有ID收集完成
+		})
+
+		if err != nil {
+			return errors.Wrapf(err, "收集待删除ID失败")
+		}
+
+		// 批量删除
+		if len(deleteIds) > 0 {
+			for _, id := range deleteIds {
+				err = l.svcCtx.ProductFeatureModel.Delete(ctx, session, id)
+				if err != nil {
+					return errors.Wrapf(err, "删除产品功能关联失败, product_id: %d, id: %d",
+						req.ProductId, id)
+				}
+			}
+		}
+
+		// 4.2 并发处理需要新增或更新的关联
+		var updateErr error
+		err = mr.MapReduceVoid(func(source chan<- interface{}) {
+			for featureId, newItem := range newMap {
+				source <- struct {
+					featureId int64
+					newItem   *types.ProductFeatureItem
+					existing  *model.ProductFeature
+				}{
+					featureId: featureId,
+					newItem:   newItem,
+					existing:  existingMap[featureId],
+				}
+			}
+		}, func(item interface{}, writer mr.Writer[struct{}], cancel func(error)) {
+			data := item.(struct {
+				featureId int64
+				newItem   *types.ProductFeatureItem
+				existing  *model.ProductFeature
+			})
+
+			if data.existing != nil {
+				// 更新现有关联
+				data.existing.Sort = data.newItem.Sort
+				data.existing.Enable = data.newItem.Enable
+				data.existing.IsImportant = data.newItem.IsImportant
+				_, err = l.svcCtx.ProductFeatureModel.Update(ctx, session, data.existing)
+				if err != nil {
+					updateErr = errors.Wrapf(err, "更新产品功能关联失败, product_id: %d, feature_id: %d",
+						req.ProductId, data.featureId)
+					cancel(updateErr)
+					return
+				}
+			} else {
+				// 新增关联
+				newFeature := &model.ProductFeature{
+					ProductId:   req.ProductId,
+					FeatureId:   data.featureId,
+					Sort:        data.newItem.Sort,
+					Enable:      data.newItem.Enable,
+					IsImportant: data.newItem.IsImportant,
+				}
+				_, err = l.svcCtx.ProductFeatureModel.Insert(ctx, session, newFeature)
+				if err != nil {
+					updateErr = errors.Wrapf(err, "新增产品功能关联失败, product_id: %d, feature_id: %d",
+						req.ProductId, data.featureId)
+					cancel(updateErr)
+					return
+				}
+			}
+		}, func(pipe <-chan struct{}, cancel func(error)) {
+			// 等待所有更新完成
+		})
+
+		if err != nil {
+			return errors.Wrapf(err, "并发更新产品功能关联失败")
+		}
+		if updateErr != nil {
+			return updateErr
+		}
+
+		return nil
+	})
+
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR),
+			"更新产品功能关联失败, err: %v, req: %+v", err, req)
+	}
+
+	// 5. 返回结果
+	return &types.AdminUpdateProductFeaturesResp{Success: true}, nil
+}

app/main/api/internal/logic/admin_product/adminupdateproductlogic.go

@@ -0,0 +1,65 @@
+package admin_product
+
+import (
+	"context"
+	"database/sql"
+	"tyc-server/app/main/api/internal/svc"
+	"tyc-server/app/main/api/internal/types"
+	"tyc-server/common/xerr"
+
+	"github.com/pkg/errors"
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type AdminUpdateProductLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewAdminUpdateProductLogic(ctx context.Context, svcCtx *svc.ServiceContext) *AdminUpdateProductLogic {
+	return &AdminUpdateProductLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *AdminUpdateProductLogic) AdminUpdateProduct(req *types.AdminUpdateProductReq) (resp *types.AdminUpdateProductResp, err error) {
+	// 1. 查询记录是否存在
+	record, err := l.svcCtx.ProductModel.FindOne(l.ctx, req.Id)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR),
+			"查找产品失败, err: %v, id: %d", err, req.Id)
+	}
+
+	// 2. 更新字段
+	if req.ProductName != nil {
+		record.ProductName = *req.ProductName
+	}
+	if req.ProductEn != nil {
+		record.ProductEn = *req.ProductEn
+	}
+	if req.Description != nil {
+		record.Description = *req.Description
+	}
+	if req.Notes != nil {
+		record.Notes = sql.NullString{String: *req.Notes, Valid: *req.Notes != ""}
+	}
+	if req.CostPrice != nil {
+		record.CostPrice = *req.CostPrice
+	}
+	if req.SellPrice != nil {
+		record.SellPrice = *req.SellPrice
+	}
+
+	// 3. 执行更新操作
+	_, err = l.svcCtx.ProductModel.Update(l.ctx, nil, record)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR),
+			"更新产品失败, err: %v, req: %+v", err, req)
+	}
+
+	// 4. 返回结果
+	return &types.AdminUpdateProductResp{Success: true}, nil
+}

app/main/api/internal/logic/admin_user/admingetuserlistlogic.go

@@ -29,7 +29,7 @@ func NewAdminGetUserListLogic(ctx context.Context, svcCtx *svc.ServiceContext) *
 
 func (l *AdminGetUserListLogic) AdminGetUserList(req *types.AdminGetUserListReq) (resp *types.AdminGetUserListResp, err error) {
 	resp = &types.AdminGetUserListResp{
-		Items: make([]types.UserListItem, 0),
+		Items: make([]types.AdminUserListItem, 0),
 		Total: 0,
 	}
 
@@ -102,7 +102,7 @@ func (l *AdminGetUserListLogic) AdminGetUserList(req *types.AdminGetUserListReq)
 	wg.Wait()
 
 	// 并发获取每个用户的角色ID
-	var userItems []types.UserListItem
+	var userItems []types.AdminUserListItem
 	var userItemsMutex sync.Mutex
 
 	mr.MapReduceVoid(func(source chan<- interface{}) {
@@ -128,7 +128,7 @@ func (l *AdminGetUserListLogic) AdminGetUserList(req *types.AdminGetUserListReq)
 	}, func(pipe <-chan []int64, cancel func(error)) {
 		for _, user := range users {
 			roleIds := <-pipe
-			item := types.UserListItem{
+			item := types.AdminUserListItem{
 				Id:         user.Id,
 				Username:   user.Username,
 				RealName:   user.RealName,

app/main/api/internal/logic/notification/getnotificationslogic.go

@@ -38,7 +38,7 @@ func (l *GetNotificationsLogic) GetNotifications() (resp *types.GetNotifications
 
 	// 构建查询条件
 	builder := l.svcCtx.GlobalNotificationsModel.SelectBuilder().
-		Where("status = ?", "active").
+		Where("status = ?", 1).
 		Where("(start_date IS NULL OR start_date <= ?)", todayEnd). // start_date 是 NULL 或者小于等于今天结束时间
 		Where("(end_date IS NULL OR end_date >= ?)", todayStart)    // end_date 是 NULL 或者大于等于今天开始时间
 

app/main/api/internal/logic/pay/alipaycallbacklogic.go

@@ -3,8 +3,6 @@ package pay
 import (
 	"context"
 	"net/http"
-	"time"
-	"tyc-server/pkg/lzkit/lzUtils"
 
 	"github.com/smartwalle/alipay/v3"
 
@@ -28,49 +26,11 @@ func NewAlipayCallbackLogic(ctx context.Context, svcCtx *svc.ServiceContext) *Al
 }
 
 func (l *AlipayCallbackLogic) AlipayCallback(w http.ResponseWriter, r *http.Request) error {
-	notification, err := l.svcCtx.AlipayService.HandleAliPaymentNotification(r)
+	err := l.svcCtx.PayService.HandlePaymentCallback(l.ctx, "alipay", r)
 	if err != nil {
 		logx.Errorf("支付宝支付回调，%+v", err)
 		return nil
 	}
-	order, findOrderErr := l.svcCtx.OrderModel.FindOneByOrderNo(l.ctx, notification.OutTradeNo)
-	if findOrderErr != nil {
-		logx.Errorf("支付宝支付回调，查找订单失败: %+v", findOrderErr)
-		return nil
-	}
-	if order.Status != "pending" {
-		alipay.ACKNotification(w)
-		return nil
-	}
-	amount := lzUtils.ToAlipayAmount(order.Amount)
-	// 确保订单金额和状态正确，防止重复更新
-	if amount != notification.TotalAmount {
-		logx.Errorf("支付宝支付回调，金额不一致")
-		return nil
-	}
-	if order.Status != "pending" {
-		w.WriteHeader(http.StatusOK)
-		_, _ = w.Write([]byte("success")) // 确保只写入一次响应
-		return nil
-	}
-	switch notification.TradeStatus {
-	case alipay.TradeStatusSuccess:
-		order.Status = "paid"
-		order.PayTime = lzUtils.TimeToNullTime(time.Now())
-	default:
-		return nil
-	}
-	order.PlatformOrderId = lzUtils.StringToNullString(notification.TradeNo)
-	if updateErr := l.svcCtx.OrderModel.UpdateWithVersion(l.ctx, nil, order); updateErr != nil {
-		logx.Errorf("支付宝支付回调，修改订单信息失败: %+v", updateErr)
-		return nil
-	}
-	if order.Status == "paid" {
-		if asyncErr := l.svcCtx.AsynqService.SendQueryTask(order.Id); asyncErr != nil {
-			logx.Errorf("异步任务调度失败: %v", asyncErr)
-			return asyncErr
-		}
-	}
 	alipay.ACKNotification(w)
 	return nil
 }

app/main/api/internal/logic/pay/paymentlogic.go

@@ -4,15 +4,14 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"tyc-server/app/main/api/internal/service"
 	"tyc-server/app/main/api/internal/svc"
 	"tyc-server/app/main/api/internal/types"
-	"tyc-server/app/main/model"
 	"tyc-server/common/ctxdata"
 	"tyc-server/common/xerr"
 
 	"github.com/pkg/errors"
 	"github.com/zeromicro/go-zero/core/logx"
-	"github.com/zeromicro/go-zero/core/stores/sqlx"
 )
 
 type PaymentLogic struct {
@@ -34,104 +33,45 @@ func (l *PaymentLogic) Payment(req *types.PaymentReq) (resp *types.PaymentResp,
 	if getUidErr != nil {
 		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "生成订单, 获取用户信息失败, %+v", getUidErr)
 	}
-
-	brand, ok := l.ctx.Value("brand").(string)
-	if !ok {
-		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "生成订单, 获取平台失败, %+v", getUidErr)
-	}
+	// 从缓存中获取订单信息
 	outTradeNo := req.Id
 	redisKey := fmt.Sprintf("%d:%s", userID, outTradeNo)
 	cache, cacheErr := l.svcCtx.Redis.GetCtx(l.ctx, redisKey)
 	if cacheErr != nil {
 		return nil, cacheErr
 	}
+
 	var data types.QueryCacheLoad
 	err = json.Unmarshal([]byte(cache), &data)
 	if err != nil {
 		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "生成订单, 解析缓存内容失败, %+v", err)
 	}
-
-	product, err := l.svcCtx.ProductModel.FindOneByProductEn(l.ctx, data.Product)
-	if err != nil {
-		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "生成订单, 查找产品错误: %+v", err)
-	}
-	var prepayData interface{}
-	var amount float64
-	user, err := l.svcCtx.UserModel.FindOne(l.ctx, userID)
-	if err != nil {
-		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "生成订单, 获取用户信息失败: %+v", err)
-	}
-
-	if user.Inside == 1 {
-		amount = 0.01
-	} else {
-		amount = product.SellPrice
-	}
-
-	var createOrderErr error
-	if req.PayMethod == "wechat" {
-		prepayData, createOrderErr = l.svcCtx.WechatPayService.CreateWechatOrder(l.ctx, amount, product.ProductName, outTradeNo)
-	} else if req.PayMethod == "alipay" {
-		prepayData, createOrderErr = l.svcCtx.AlipayService.CreateAlipayOrder(l.ctx, amount, product.ProductName, outTradeNo, brand)
-	} else if req.PayMethod == "appleiap" {
-		prepayData = l.svcCtx.ApplePayService.GetIappayAppID(product.ProductEn)
-	}
-	if createOrderErr != nil {
-		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "生成订单, 创建支付订单失败: %+v", createOrderErr)
-	}
-	var orderID int64
-	transErr := l.svcCtx.OrderModel.Trans(l.ctx, func(ctx context.Context, session sqlx.Session) error {
-		order := model.Order{
-			OrderNo:         outTradeNo,
-			UserId:          userID,
-			ProductId:       product.Id,
-			PaymentPlatform: req.PayMethod,
-			PaymentScene:    "tyc",
-			Amount:          amount,
-			Status:          "pending",
-		}
-		orderInsertResult, insertOrderErr := l.svcCtx.OrderModel.Insert(ctx, session, &order)
-		if insertOrderErr != nil {
-			return errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "生成订单, 保存订单失败: %+v", insertOrderErr)
-		}
-		insertedOrderID, lastInsertIdErr := orderInsertResult.LastInsertId()
-		if lastInsertIdErr != nil {
-			return errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "生成订单, 获取保存订单ID失败: %+v", lastInsertIdErr)
-		}
-		orderID = insertedOrderID
-
-		promoteKey, ok := l.ctx.Value("promoteKey").(string)
-		if ok && promoteKey != "" {
-			// TODO: 在这里添加处理 promoteKey 的逻辑
-			url := fmt.Sprintf("%s/%s", l.svcCtx.Config.AdminPromotion.URLDomain, promoteKey)
-			promoteLink, err := l.svcCtx.AdminPromotionLinkModel.FindOneByUrl(l.ctx, url)
-			if err != nil && !errors.Is(err, model.ErrNotFound) {
-				return errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "生成订单, 查找推广链接失败: %+v", err)
-			}
-			if promoteLink != nil {
-				promoteOrder := &model.AdminPromotionOrder{
-					OrderId:     orderID,
-					LinkId:      promoteLink.Id,
-					UserId:      userID,
-					AdminUserId: promoteLink.AdminUserId,
-				}
-				_, insertPromoteOrderErr := l.svcCtx.AdminPromotionOrderModel.Insert(ctx, session, promoteOrder)
-				if insertPromoteOrderErr != nil {
-					return errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "生成订单, 保存推广订单失败: %+v", insertPromoteOrderErr)
-				}
-			}
-		}
-
-		return nil
-	})
-	if transErr != nil {
-		return nil, transErr
-	}
-	switch v := prepayData.(type) {
-	case string:
-		// 如果 prepayData 是字符串类型，直接返回
-		return &types.PaymentResp{PrepayId: v, OrderID: orderID}, nil
+	var payMethod service.PayMethod
+	switch req.PayMethod {
+	case "alipay":
+		payMethod = service.PayMethodAlipay
+	case "wechat":
+		payMethod = service.PayMethodWechat
+	// case "apple":
+	// 	payMethod = service.PayMethodApple
 	default:
-		return &types.PaymentResp{PrepayData: prepayData, OrderID: orderID}, nil
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "生成订单, 不支持的支付方式: %+v", req.PayMethod)
 	}
+
+	// 创建支付订单
+	orderReq := &service.CreateOrderRequest{
+		PayMethod: payMethod,
+		ProductEn: data.Product,
+	}
+
+	orderResp, err := l.svcCtx.PayService.CreateOrder(l.ctx, orderReq)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "生成订单失败: %+v", err)
+	}
+
+	return &types.PaymentResp{
+		PrepayData: orderResp.PayData,
+		PrepayId:   orderResp.OrderNo,
+		OrderID:    orderResp.OrderID,
+	}, nil
 }

app/main/api/internal/logic/pay/wechatpaycallbacklogic.go

@@ -3,9 +3,6 @@ package pay
 import (
 	"context"
 	"net/http"
-	"time"
-	"tyc-server/app/main/api/internal/service"
-	"tyc-server/pkg/lzkit/lzUtils"
 
 	"tyc-server/app/main/api/internal/svc"
 
@@ -27,50 +24,11 @@ func NewWechatPayCallbackLogic(ctx context.Context, svcCtx *svc.ServiceContext)
 }
 
 func (l *WechatPayCallbackLogic) WechatPayCallback(w http.ResponseWriter, r *http.Request) error {
-	notification, err := l.svcCtx.WechatPayService.HandleWechatPayNotification(l.ctx, r)
+	err := l.svcCtx.PayService.HandlePaymentCallback(l.ctx, "wechat", r)
 	if err != nil {
 		logx.Errorf("微信支付回调，%+v", err)
 		return nil
 	}
-	order, findOrderErr := l.svcCtx.OrderModel.FindOneByOrderNo(l.ctx, *notification.OutTradeNo)
-	if findOrderErr != nil {
-		logx.Errorf("微信支付回调，查找订单信息失败: %+v", findOrderErr)
-		return nil
-	}
-
-	amount := lzUtils.ToWechatAmount(order.Amount)
-	if amount != *notification.Amount.Total {
-		logx.Errorf("微信支付回调，金额不一致")
-		return nil
-	}
-	if order.Status != "pending" {
-		w.WriteHeader(http.StatusOK)
-		_, _ = w.Write([]byte("success")) // 确保只写入一次响应
-		return nil
-	}
-	switch *notification.TradeState {
-	case service.TradeStateSuccess:
-		order.Status = "paid"
-		order.PayTime = lzUtils.TimeToNullTime(time.Now())
-	case service.TradeStateClosed:
-		order.Status = "closed"
-		order.CloseTime = lzUtils.TimeToNullTime(time.Now())
-	case service.TradeStateRevoked:
-		order.Status = "failed"
-	default:
-		return nil
-	}
-	order.PlatformOrderId = lzUtils.StringToNullString(*notification.TransactionId)
-	if updateErr := l.svcCtx.OrderModel.UpdateWithVersion(l.ctx, nil, order); updateErr != nil {
-		logx.Errorf("微信支付回调，更新订单失败%+v", updateErr)
-		return nil
-	}
-	if order.Status == "paid" {
-		if asyncErr := l.svcCtx.AsynqService.SendQueryTask(order.Id); asyncErr != nil {
-			logx.Errorf("异步任务调度失败: %v", asyncErr)
-			return asyncErr
-		}
-	}
 
 	// 响应微信回调成功
 	w.WriteHeader(http.StatusOK)

app/main/api/internal/logic/pay/wechatpayrefundcallbacklogic.go

@@ -5,7 +5,6 @@ import (
 	"net/http"
 	"tyc-server/app/main/api/internal/svc"
 
-	"github.com/wechatpay-apiv3/wechatpay-go/services/refunddomestic"
 	"github.com/zeromicro/go-zero/core/logx"
 )
 
@@ -24,32 +23,36 @@ func NewWechatPayRefundCallbackLogic(ctx context.Context, svcCtx *svc.ServiceCon
 }
 
 func (l *WechatPayRefundCallbackLogic) WechatPayRefundCallback(w http.ResponseWriter, r *http.Request) error {
-	notification, err := l.svcCtx.WechatPayService.HandleRefundNotification(l.ctx, r)
-	if err != nil {
-		logx.Errorf("微信退款回调，%+v", err)
-		return nil
-	}
-	order, findOrderErr := l.svcCtx.OrderModel.FindOneByOrderNo(l.ctx, *notification.OutTradeNo)
-	if findOrderErr != nil {
-		logx.Errorf("微信退款回调，查找订单信息失败: %+v", findOrderErr)
-		return nil
-	}
+	// notification, err := l.svcCtx.PayService.re(l.ctx, r)
+	// if err != nil {
+	// 	logx.Errorf("微信退款回调，%+v", err)
+	// 	return nil
+	// }
+	// order, findOrderErr := l.svcCtx.OrderModel.FindOneByOrderNo(l.ctx, *notification.OutTradeNo)
+	// if findOrderErr != nil {
+	// 	logx.Errorf("微信退款回调，查找订单信息失败: %+v", findOrderErr)
+	// 	return nil
+	// }
 
-	switch *notification.Status {
-	case refunddomestic.STATUS_SUCCESS:
-		order.Status = "refunded"
-	case refunddomestic.STATUS_ABNORMAL:
-		// 异常
-		return nil
-	default:
-		return nil
-	}
-	if updateErr := l.svcCtx.OrderModel.UpdateWithVersion(l.ctx, nil, order); updateErr != nil {
-		logx.Errorf("微信退款回调，更新订单失败%+v", updateErr)
-		return nil
-	}
-	// 响应微信回调成功
-	w.WriteHeader(http.StatusOK)
-	_, _ = w.Write([]byte("success")) // 确保只写入一次响应
+	// switch *notification.Status {
+	// case refunddomestic.STATUS_SUCCESS:
+	// 	order.Status = "refunded"
+	// 	order.RefundTime = sql.NullTime{
+	// 		Time:  time.Now(),
+	// 		Valid: true,
+	// 	}
+	// case refunddomestic.STATUS_ABNORMAL:
+	// 	// 异常
+	// 	return nil
+	// default:
+	// 	return nil
+	// }
+	// if updateErr := l.svcCtx.OrderModel.UpdateWithVersion(l.ctx, nil, order); updateErr != nil {
+	// 	logx.Errorf("微信退款回调，更新订单失败%+v", updateErr)
+	// 	return nil
+	// }
+	// // 响应微信回调成功
+	// w.WriteHeader(http.StatusOK)
+	// _, _ = w.Write([]byte("success")) // 确保只写入一次响应
 	return nil
 }

app/main/api/internal/logic/query/queryservicelogic.go

@@ -2,9 +2,12 @@ package query
 
 import (
 	"context"
+	"crypto/rand"
 	"encoding/hex"
 	"encoding/json"
 	"fmt"
+	"strconv"
+	"sync/atomic"
 	"time"
 	"tyc-server/app/main/api/internal/service"
 	"tyc-server/common/ctxdata"
@@ -140,13 +143,13 @@ func (l *QueryServiceLogic) CacheData(params map[string]interface{}, Product str
 	if marshalErr != nil {
 		return "", errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "查询服务, 序列化参数失败: %+v", marshalErr)
 	}
-	outTradeNo := l.svcCtx.AlipayService.GenerateOutTradeNo()
-	redisKey := fmt.Sprintf("%d:%s", userID, outTradeNo)
+	cacheNo := l.GenerateCacheNo()
+	redisKey := fmt.Sprintf("%d:%s", userID, cacheNo)
 	cacheErr := l.svcCtx.Redis.SetexCtx(l.ctx, redisKey, string(jsonData), int(2*time.Hour))
 	if cacheErr != nil {
 		return "", cacheErr
 	}
-	return outTradeNo, nil
+	return cacheNo, nil
 }
 
 var productProcessors = map[string]func(*QueryServiceLogic, *types.QueryServiceReq) (*types.QueryServiceResp, error){
@@ -2067,3 +2070,27 @@ func (l *QueryServiceLogic) ProcessTocPersonEnterpriseProLogic(req *types.QueryS
 	return &types.QueryServiceResp{Id: cacheNo}, nil
 
 }
+
+// 全局原子计数器
+var CacheNoCounter uint32 = 0
+
+func (l *QueryServiceLogic) GenerateCacheNo() string {
+	// 获取当前时间戳（秒级）
+	timestamp := time.Now().Unix()
+	timeStr := strconv.FormatInt(timestamp, 10)
+
+	// 原子递增计数器
+	counter := atomic.AddUint32(&CacheNoCounter, 1)
+
+	// 生成4字节真随机数
+	randomBytes := make([]byte, 4)
+	_, err := rand.Read(randomBytes)
+	if err != nil {
+		// 如果随机数生成失败，回退到使用时间纳秒数据
+		randomBytes = []byte(strconv.FormatInt(time.Now().UnixNano()%1000000, 16))
+	}
+	randomHex := hex.EncodeToString(randomBytes)
+
+	// 组合所有部分: 前缀 + 时间戳 + 计数器 + 随机数
+	return fmt.Sprintf("query_%s%06x%s", timeStr, counter%0xFFFFFF, randomHex[:6])
+}

app/main/api/internal/logic/user/mobilecodeloginlogic.go

@@ -79,7 +79,7 @@ func (l *MobileCodeLoginLogic) MobileCodeLogin(req *types.MobileCodeLoginReq) (r
 			userAuth := new(model.UserAuth)
 			userAuth.UserId = lastId
 			userAuth.AuthKey = encryptedMobile
-			userAuth.AuthType = model.UserAuthTypeAppMobile
+			userAuth.AuthType = model.UserAuthTypeMobile
 			if _, userAuthInsertErr := l.svcCtx.UserAuthModel.Insert(ctx, session, userAuth); userAuthInsertErr != nil {
 				return errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "手机注册, 数据库插入用户认证失败, err:%+v", userAuthInsertErr)
 			}

app/main/api/internal/logic/user/registerlogic.go

@@ -86,7 +86,7 @@ func (l *RegisterLogic) Register(req *types.RegisterReq) (resp *types.RegisterRe
 		userAuth := new(model.UserAuth)
 		userAuth.UserId = lastId
 		userAuth.AuthKey = encryptedMobile
-		userAuth.AuthType = model.UserAuthTypeAppMobile
+		userAuth.AuthType = model.UserAuthTypeMobile
 		if _, userAuthInsertErr := l.svcCtx.UserAuthModel.Insert(ctx, session, userAuth); userAuthInsertErr != nil {
 			return errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "手机注册, 数据库插入用户认证失败, err:%+v", userAuthInsertErr)
 		}

app/main/api/internal/logic/user/wxminiauthlogic.go

@@ -42,7 +42,7 @@ func (l *WxMiniAuthLogic) WxMiniAuth(req *types.WXMiniAuthReq) (resp *types.WXMi
 	}
 
 	// 2. 根据 openid 查找用户
-	userAuth, findErr := l.svcCtx.UserAuthModel.FindOneByAuthTypeAuthKey(l.ctx, model.UserAuthTypeWxMini, weChatResponse.OpenId)
+	userAuth, findErr := l.svcCtx.UserAuthModel.FindOneByAuthTypeAuthKey(l.ctx, model.UserAuthTypeWechatMiniOpenID, weChatResponse.OpenId)
 	if findErr != nil && findErr != model.ErrNotFound {
 		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "微信登录, 读取用户认证信息失败, openid: %s, err: %+v", weChatResponse.OpenId, findErr)
 	}
@@ -70,7 +70,7 @@ func (l *WxMiniAuthLogic) WxMiniAuth(req *types.WXMiniAuthReq) (resp *types.WXMi
 			newUserAuth := &model.UserAuth{
 				UserId:   lastId,
 				AuthKey:  weChatResponse.OpenId,
-				AuthType: model.UserAuthTypeWxMini,
+				AuthType: model.UserAuthTypeWechatMiniOpenID,
 			}
 			if _, userAuthInsertErr := l.svcCtx.UserAuthModel.Insert(ctx, session, newUserAuth); userAuthInsertErr != nil {
 				return errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "微信登录, 数据库插入用户认证信息失败, err:%+v", userAuthInsertErr)

app/main/api/internal/queue/cleanQueryData.go

@@ -3,20 +3,21 @@ package queue
 import (
 	"context"
 	"time"
+	"tyc-server/app/main/api/internal/config"
 	"tyc-server/app/main/api/internal/svc"
 
 	"github.com/hibiken/asynq"
 	"github.com/zeromicro/go-zero/core/logx"
 )
 
-const TASKTIME = "0 3 * * *"
-
 type CleanQueryDataHandler struct {
+	config *config.Config
 	svcCtx *svc.ServiceContext
 }
 
-func NewCleanQueryDataHandler(svcCtx *svc.ServiceContext) *CleanQueryDataHandler {
+func NewCleanQueryDataHandler(config *config.Config, svcCtx *svc.ServiceContext) *CleanQueryDataHandler {
 	return &CleanQueryDataHandler{
+		config: config,
 		svcCtx: svcCtx,
 	}
 }
@@ -25,14 +26,10 @@ func (l *CleanQueryDataHandler) ProcessTask(ctx context.Context, t *asynq.Task)
 	now := time.Now().Format("2006-01-02 15:04:05")
 	logx.Infof("%s - 开始执行查询数据清理任务", now)
 
-	// 计算7天前的时间
-	sevenDaysAgo := time.Now().AddDate(0, 0, -7)
+	// 计算15天前的时间
+	sevenDaysAgo := time.Now().AddDate(0, 0, -l.config.CleanTask.Days)
 
-	// 创建查询条件，排除product_id为4的记录
-	conditions := l.svcCtx.QueryModel.SelectBuilder().Where("product_id != ?", 4)
-
-	// 调用QueryModel删除7天前的数据，排除product_id为4的记录
-	result, err := l.svcCtx.QueryModel.DeleteBefore(ctx, sevenDaysAgo, conditions)
+	result, err := l.svcCtx.QueryModel.DeleteBefore(ctx, sevenDaysAgo)
 	if err != nil {
 		logx.Errorf("%s - 清理查询数据失败: %v", time.Now().Format("2006-01-02 15:04:05"), err)
 		return err

app/main/api/internal/queue/paySuccessNotify.go

@@ -7,6 +7,7 @@ import (
 	"errors"
 	"fmt"
 	"strings"
+	"tyc-server/app/main/api/internal/service"
 	"tyc-server/app/main/api/internal/svc"
 	"tyc-server/app/main/api/internal/types"
 	"tyc-server/app/main/model"
@@ -159,33 +160,29 @@ func (l *PaySuccessNotifyUserHandler) handleError(ctx context.Context, err error
 			return asynq.SkipRetry
 		}
 
+		payRefundRequest := &service.RefundRequest{
+			OrderId:      order.Id,
+			RefundAmount: order.Amount,
+			Reason:       "查询失败退款",
+		}
 		// 退款
 		if order.PaymentPlatform == "wechat" {
-			refundErr := l.svcCtx.WechatPayService.WeChatRefund(ctx, order.OrderNo, order.Amount, order.Amount)
+			refundResp, refundErr := l.svcCtx.PayService.Refund(ctx, payRefundRequest)
 			if refundErr != nil {
 				logx.Error(refundErr)
 				return asynq.SkipRetry
 			}
+			if refundResp.Status == "success" {
+				// 直接成功
+			} else {
+				return asynq.SkipRetry
+			}
 		} else {
-			refund, refundErr := l.svcCtx.AlipayService.AliRefund(ctx, order.OrderNo, order.Amount)
+			_, refundErr := l.svcCtx.PayService.Refund(ctx, payRefundRequest)
 			if refundErr != nil {
 				logx.Error(refundErr)
 				return asynq.SkipRetry
 			}
-			if refund.IsSuccess() {
-				logx.Errorf("支付宝退款成功, orderID: %d", order.Id)
-				// 更新订单状态为退款
-				order.Status = "refunded"
-				updateOrderErr := l.svcCtx.OrderModel.UpdateWithVersion(ctx, nil, order)
-				if updateOrderErr != nil {
-					logx.Errorf("更新订单状态失败，订单ID: %d, 错误: %v", order.Id, updateOrderErr)
-					return fmt.Errorf("更新订单状态失败: %v", updateOrderErr)
-				}
-				return asynq.SkipRetry
-			} else {
-				logx.Errorf("支付宝退款失败:%v", refundErr)
-				return asynq.SkipRetry
-			}
 			// 直接成功
 		}
 

app/main/api/internal/queue/routes.go

@@ -3,19 +3,23 @@ package queue
 import (
 	"context"
 	"fmt"
+	"tyc-server/app/main/api/internal/config"
 	"tyc-server/app/main/api/internal/svc"
 	"tyc-server/app/main/api/internal/types"
 
 	"github.com/hibiken/asynq"
+	"github.com/zeromicro/go-zero/core/logx"
 )
 
 type CronJob struct {
+	config *config.Config
 	ctx    context.Context
 	svcCtx *svc.ServiceContext
 }
 
-func NewCronJob(ctx context.Context, svcCtx *svc.ServiceContext) *CronJob {
+func NewCronJob(config *config.Config, ctx context.Context, svcCtx *svc.ServiceContext) *CronJob {
 	return &CronJob{
+		config: config,
 		ctx:    ctx,
 		svcCtx: svcCtx,
 	}
@@ -24,17 +28,21 @@ func NewCronJob(ctx context.Context, svcCtx *svc.ServiceContext) *CronJob {
 func (l *CronJob) Register() *asynq.ServeMux {
 	redisClientOpt := asynq.RedisClientOpt{Addr: l.svcCtx.Config.CacheRedis[0].Host, Password: l.svcCtx.Config.CacheRedis[0].Pass}
 	scheduler := asynq.NewScheduler(redisClientOpt, nil)
-	task := asynq.NewTask(types.MsgCleanQueryData, nil, nil)
-	_, err := scheduler.Register(TASKTIME, task)
-	if err != nil {
-		panic(fmt.Sprintf("定时任务注册失败:%v", err))
+
+	// 根据配置决定是否启动清理任务
+	if l.config.CleanTask.Enabled {
+		task := asynq.NewTask(types.MsgCleanQueryData, nil, nil)
+		_, err := scheduler.Register(l.config.CleanTask.Time, task)
+		if err != nil {
+			panic(fmt.Sprintf("定时任务注册失败:%v", err))
+		}
+		scheduler.Start()
+		logx.Infof("清理数据定时任务已启动")
 	}
-	scheduler.Start()
-	fmt.Println("定时任务启动！！！")
 
 	mux := asynq.NewServeMux()
 	mux.Handle(types.MsgPaySuccessQuery, NewPaySuccessNotifyUserHandler(l.svcCtx))
-	mux.Handle(types.MsgCleanQueryData, NewCleanQueryDataHandler(l.svcCtx))
+	mux.Handle(types.MsgCleanQueryData, NewCleanQueryDataHandler(l.config, l.svcCtx))
 	mux.Handle(types.MsgCarMaintenanceQuery, NewCarMaintenanceQueryHandler(l.svcCtx))
 
 	return mux

app/main/api/internal/service/alipayService.go

@@ -1,196 +0,0 @@
-package service
-
-import (
-	"context"
-	"crypto/rand"
-	"encoding/hex"
-	"fmt"
-	"net/http"
-	"strconv"
-	"sync/atomic"
-	"time"
-	"tyc-server/app/main/api/internal/config"
-	"tyc-server/pkg/lzkit/lzUtils"
-
-	"github.com/smartwalle/alipay/v3"
-)
-
-type AliPayService struct {
-	config       config.AlipayConfig
-	AlipayClient *alipay.Client
-}
-
-// NewAliPayService 是一个构造函数，用于初始化 AliPayService
-func NewAliPayService(c config.Config) *AliPayService {
-	client, err := alipay.New(c.Alipay.AppID, c.Alipay.PrivateKey, c.Alipay.IsProduction)
-	if err != nil {
-		panic(fmt.Sprintf("创建支付宝客户端失败: %v", err))
-	}
-
-	// 加载支付宝公钥
-	err = client.LoadAliPayPublicKey(c.Alipay.AlipayPublicKey)
-	if err != nil {
-		panic(fmt.Sprintf("加载支付宝公钥失败: %v", err))
-	}
-	return &AliPayService{
-		config:       c.Alipay,
-		AlipayClient: client,
-	}
-}
-
-func (a *AliPayService) CreateAlipayAppOrder(amount float64, subject string, outTradeNo string) (string, error) {
-	client := a.AlipayClient
-	totalAmount := lzUtils.ToAlipayAmount(amount)
-	// 构造移动支付请求
-	p := alipay.TradeAppPay{
-		Trade: alipay.Trade{
-			Subject:     subject,
-			OutTradeNo:  outTradeNo,
-			TotalAmount: totalAmount,
-			ProductCode: "QUICK_MSECURITY_PAY", // 移动端支付专用代码
-			NotifyURL:   a.config.NotifyUrl,    // 异步回调通知地址
-		},
-	}
-
-	// 获取APP支付字符串，这里会签名
-	payStr, err := client.TradeAppPay(p)
-	if err != nil {
-		return "", fmt.Errorf("创建支付宝订单失败: %v", err)
-	}
-
-	return payStr, nil
-}
-
-// CreateAlipayH5Order 创建支付宝H5支付订单
-func (a *AliPayService) CreateAlipayH5Order(amount float64, subject string, outTradeNo string, brand string) (string, error) {
-	var returnURL string
-	var notifyURL string
-	if brand == "tyc" {
-		returnURL = "https://www.tianyuancha.cn/report"
-		notifyURL = "https://www.tianyuancha.cn/api/v1/pay/alipay/callback"
-	} else {
-		returnURL = a.config.ReturnURL
-		notifyURL = a.config.NotifyUrl
-	}
-	client := a.AlipayClient
-	totalAmount := lzUtils.ToAlipayAmount(amount)
-	// 构造H5支付请求
-	p := alipay.TradeWapPay{
-		Trade: alipay.Trade{
-			Subject:     subject,
-			OutTradeNo:  outTradeNo,
-			TotalAmount: totalAmount,
-			ProductCode: "QUICK_WAP_PAY", // H5支付专用产品码
-			NotifyURL:   notifyURL,       // 异步回调通知地址
-			ReturnURL:   returnURL,
-		},
-	}
-	// 获取H5支付请求字符串，这里会签名
-	payUrl, err := client.TradeWapPay(p)
-	if err != nil {
-		return "", fmt.Errorf("创建支付宝H5订单失败: %v", err)
-	}
-
-	return payUrl.String(), nil
-}
-
-// CreateAlipayOrder 根据平台类型创建支付宝支付订单
-func (a *AliPayService) CreateAlipayOrder(ctx context.Context, amount float64, subject string, outTradeNo string, brand string) (string, error) {
-	// 根据 ctx 中的 platform 判断平台
-	platform, platformOk := ctx.Value("platform").(string)
-	if !platformOk {
-		return "", fmt.Errorf("无的支付平台: %s", platform)
-	}
-	switch platform {
-	case "app":
-		// 调用App支付的创建方法
-		return a.CreateAlipayAppOrder(amount, subject, outTradeNo)
-	case "h5":
-		// 调用H5支付的创建方法，并传入 returnUrl
-		return a.CreateAlipayH5Order(amount, subject, outTradeNo, brand)
-	default:
-		return "", fmt.Errorf("不支持的支付平台: %s", platform)
-	}
-}
-
-// AliRefund 发起支付宝退款
-func (a *AliPayService) AliRefund(ctx context.Context, outTradeNo string, refundAmount float64) (*alipay.TradeRefundRsp, error) {
-	refund := alipay.TradeRefund{
-		OutTradeNo:   outTradeNo,
-		RefundAmount: lzUtils.ToAlipayAmount(refundAmount),
-		OutRequestNo: fmt.Sprintf("%s-refund", outTradeNo),
-	}
-
-	// 发起退款请求
-	refundResp, err := a.AlipayClient.TradeRefund(ctx, refund)
-	if err != nil {
-		return nil, fmt.Errorf("支付宝退款请求错误：%v", err)
-	}
-	return refundResp, nil
-}
-
-// HandleAliPaymentNotification 支付宝支付回调
-func (a *AliPayService) HandleAliPaymentNotification(r *http.Request) (*alipay.Notification, error) {
-	// 解析表单
-	err := r.ParseForm()
-	if err != nil {
-		return nil, fmt.Errorf("解析请求表单失败：%v", err)
-	}
-	// 解析并验证通知，DecodeNotification 会自动验证签名
-	notification, err := a.AlipayClient.DecodeNotification(r.Form)
-	if err != nil {
-		return nil, fmt.Errorf("验证签名失败: %v", err)
-	}
-	return notification, nil
-}
-func (a *AliPayService) QueryOrderStatus(ctx context.Context, outTradeNo string) (*alipay.TradeQueryRsp, error) {
-	queryRequest := alipay.TradeQuery{
-		OutTradeNo: outTradeNo,
-	}
-
-	// 发起查询请求
-	resp, err := a.AlipayClient.TradeQuery(ctx, queryRequest)
-	if err != nil {
-		return nil, fmt.Errorf("查询支付宝订单失败: %v", err)
-	}
-
-	// 返回交易状态
-	if resp.IsSuccess() {
-		return resp, nil
-	}
-
-	return nil, fmt.Errorf("查询支付宝订单失败: %v", resp.SubMsg)
-}
-
-// 添加全局原子计数器
-var alipayOrderCounter uint32 = 0
-
-// GenerateOutTradeNo 生成唯一订单号的函数 - 优化版本
-func (a *AliPayService) GenerateOutTradeNo() string {
-
-	// 获取当前时间戳（毫秒级）
-	timestamp := time.Now().UnixMilli()
-	timeStr := strconv.FormatInt(timestamp, 10)
-
-	// 原子递增计数器
-	counter := atomic.AddUint32(&alipayOrderCounter, 1)
-
-	// 生成4字节真随机数
-	randomBytes := make([]byte, 4)
-	_, err := rand.Read(randomBytes)
-	if err != nil {
-		// 如果随机数生成失败，回退到使用时间纳秒数据
-		randomBytes = []byte(strconv.FormatInt(time.Now().UnixNano()%1000000, 16))
-	}
-	randomHex := hex.EncodeToString(randomBytes)
-
-	// 组合所有部分: 前缀 + 时间戳 + 计数器 + 随机数
-	orderNo := fmt.Sprintf("%s%06x%s", timeStr[:10], counter%0xFFFFFF, randomHex[:6])
-
-	// 确保长度不超过32字符（大多数支付平台的限制）
-	if len(orderNo) > 32 {
-		orderNo = orderNo[:32]
-	}
-
-	return orderNo
-}

app/main/api/internal/service/applepayService.go

@@ -1,169 +0,0 @@
-package service
-
-import (
-	"context"
-	"crypto/ecdsa"
-	"crypto/x509"
-	"encoding/json"
-	"encoding/pem"
-	"fmt"
-	"io/ioutil"
-	"net/http"
-	"strconv"
-	"time"
-	"tyc-server/app/main/api/internal/config"
-
-	"github.com/golang-jwt/jwt/v4"
-)
-
-// ApplePayService 是 Apple IAP 支付服务的结构体
-type ApplePayService struct {
-	config config.ApplepayConfig // 配置项
-}
-
-// NewApplePayService 是一个构造函数，用于初始化 ApplePayService
-func NewApplePayService(c config.Config) *ApplePayService {
-	return &ApplePayService{
-		config: c.Applepay,
-	}
-}
-func (a *ApplePayService) GetIappayAppID(productName string) string {
-	return fmt.Sprintf("%s.%s", a.config.BundleID, productName)
-}
-
-// VerifyReceipt 验证苹果支付凭证
-func (a *ApplePayService) VerifyReceipt(ctx context.Context, receipt string) (*AppleVerifyResponse, error) {
-	var reqUrl string
-	if a.config.Sandbox {
-		reqUrl = a.config.SandboxVerifyURL
-	} else {
-		reqUrl = a.config.ProductionVerifyURL
-	}
-
-	// 读取私钥
-	privateKey, err := loadPrivateKey(a.config.LoadPrivateKeyPath)
-	if err != nil {
-		return nil, fmt.Errorf("加载私钥失败：%v", err)
-	}
-
-	// 生成 JWT
-	token, err := generateJWT(privateKey, a.config.KeyID, a.config.IssuerID)
-	if err != nil {
-		return nil, fmt.Errorf("生成JWT失败：%v", err)
-	}
-
-	// 构造查询参数
-	queryParams := fmt.Sprintf("?receipt-data=%s", receipt)
-	fullUrl := reqUrl + queryParams
-
-	// 构建 HTTP GET 请求
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, fullUrl, nil)
-	if err != nil {
-		return nil, fmt.Errorf("创建 HTTP 请求失败：%v", err)
-	}
-	req.Header.Set("Content-Type", "application/json")
-	req.Header.Set("Authorization", "Bearer "+token)
-
-	// 发送请求
-	client := &http.Client{Timeout: 10 * time.Second}
-	resp, err := client.Do(req)
-	if err != nil {
-		return nil, fmt.Errorf("请求苹果验证接口失败：%v", err)
-	}
-	defer resp.Body.Close()
-
-	// 解析响应
-	body, err := ioutil.ReadAll(resp.Body)
-	if err != nil {
-		return nil, fmt.Errorf("读取响应体失败：%v", err)
-	}
-
-	var verifyResponse AppleVerifyResponse
-	err = json.Unmarshal(body, &verifyResponse)
-	if err != nil {
-		return nil, fmt.Errorf("解析响应体失败：%v", err)
-	}
-
-	// 根据实际响应处理逻辑
-	if verifyResponse.Status != 0 {
-		return nil, fmt.Errorf("验证失败，状态码：%d", verifyResponse.Status)
-	}
-
-	return &verifyResponse, nil
-}
-
-func loadPrivateKey(path string) (*ecdsa.PrivateKey, error) {
-	data, err := ioutil.ReadFile(path)
-	if err != nil {
-		return nil, err
-	}
-	block, _ := pem.Decode(data)
-	if block == nil || block.Type != "PRIVATE KEY" {
-		return nil, fmt.Errorf("无效的私钥数据")
-	}
-	key, err := x509.ParsePKCS8PrivateKey(block.Bytes)
-	if err != nil {
-		return nil, err
-	}
-	ecdsaKey, ok := key.(*ecdsa.PrivateKey)
-	if !ok {
-		return nil, fmt.Errorf("私钥类型错误")
-	}
-	return ecdsaKey, nil
-}
-
-func generateJWT(privateKey *ecdsa.PrivateKey, keyID, issuerID string) (string, error) {
-	now := time.Now()
-	claims := jwt.RegisteredClaims{
-		Issuer:    issuerID,
-		IssuedAt:  jwt.NewNumericDate(now),
-		ExpiresAt: jwt.NewNumericDate(now.Add(1 * time.Hour)),
-		Audience:  jwt.ClaimStrings{"appstoreconnect-v1"},
-	}
-	token := jwt.NewWithClaims(jwt.SigningMethodES256, claims)
-	token.Header["kid"] = keyID
-	tokenString, err := token.SignedString(privateKey)
-	if err != nil {
-		return "", err
-	}
-	return tokenString, nil
-}
-
-// GenerateOutTradeNo 生成唯一订单号
-func (a *ApplePayService) GenerateOutTradeNo() string {
-	length := 16
-	timestamp := time.Now().UnixNano()
-	timeStr := strconv.FormatInt(timestamp, 10)
-	randomPart := strconv.Itoa(int(timestamp % 1e6))
-	combined := timeStr + randomPart
-
-	if len(combined) >= length {
-		return combined[:length]
-	}
-
-	for len(combined) < length {
-		combined += strconv.Itoa(int(timestamp % 10))
-	}
-
-	return combined
-}
-
-// AppleVerifyResponse 定义苹果验证接口的响应结构
-type AppleVerifyResponse struct {
-	Status  int      `json:"status"`  // 验证状态码：0 表示收据有效
-	Receipt *Receipt `json:"receipt"` // 收据信息
-}
-
-// Receipt 定义收据的精简结构
-type Receipt struct {
-	BundleID string      `json:"bundle_id"` // 应用的 Bundle ID
-	InApp    []InAppItem `json:"in_app"`    // 应用内购买记录
-}
-
-// InAppItem 定义单条交易记录
-type InAppItem struct {
-	ProductID       string `json:"product_id"`              // 商品 ID
-	TransactionID   string `json:"transaction_id"`          // 交易 ID
-	PurchaseDate    string `json:"purchase_date"`           // 购买日期 (ISO 8601)
-	OriginalTransID string `json:"original_transaction_id"` // 原始交易 ID
-}

app/main/api/internal/service/payService.go

@@ -0,0 +1,495 @@
+package service
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"net/http"
+	"time"
+	"tyc-server/app/main/api/internal/config"
+	"tyc-server/app/main/model"
+	"tyc-server/common/ctxdata"
+	"tyc-server/pkg/core/payment"
+
+	"github.com/zeromicro/go-zero/core/stores/sqlx"
+)
+
+// PayService 支付服务
+type PayService struct {
+	config           config.Config
+	orderModel       model.OrderModel
+	orderRefundModel model.OrderRefundModel
+	productModel     model.ProductModel
+	userAuthModel    model.UserAuthModel
+	userModel        model.UserModel
+	alipayService    *payment.AliPayService
+	wechatService    *payment.WechatPayService
+	appleService     *payment.ApplePayService
+}
+
+// NewPayService 创建支付服务
+func NewPayService(c config.Config, orderModel model.OrderModel, orderRefundModel model.OrderRefundModel, productModel model.ProductModel, userAuthModel model.UserAuthModel) *PayService {
+	ps := &PayService{
+		config:           c,
+		orderModel:       orderModel,
+		orderRefundModel: orderRefundModel,
+		productModel:     productModel,
+		userAuthModel:    userAuthModel,
+	}
+
+	// 根据配置选择性初始化支付服务
+	if c.Alipay.Enabled {
+		// 初始化支付宝服务
+		alipayConfig := payment.AlipayConfig{
+			AppID:           c.Alipay.AppID,
+			PrivateKey:      c.Alipay.PrivateKey,
+			AlipayPublicKey: c.Alipay.AlipayPublicKey,
+			IsProduction:    c.Alipay.IsProduction,
+			NotifyURL:       c.Alipay.NotifyUrl,
+			ReturnURL:       c.Alipay.ReturnURL,
+		}
+		alipayService, err := payment.NewAliPayService(alipayConfig)
+		if err != nil {
+			panic(fmt.Sprintf("初始化支付宝服务失败: %v", err))
+		}
+		ps.alipayService = alipayService
+	}
+
+	if c.Wxpay.Enabled {
+		// 初始化微信支付服务
+		wechatConfig := &payment.WechatPayConfig{
+			AppID:       c.Wxpay.AppID,
+			MchID:       c.Wxpay.MchID,
+			SerialNo:    c.Wxpay.MchCertificateSerialNumber,
+			MchAPIv3Key: c.Wxpay.MchApiv3Key,
+			PrivateKey:  c.Wxpay.MchPrivateKeyPath,
+			NotifyURL:   c.Wxpay.NotifyUrl,
+			RefundURL:   c.Wxpay.RefundNotifyUrl,
+		}
+		wechatService, err := payment.NewWechatPayService(wechatConfig)
+		if err != nil {
+			panic(fmt.Sprintf("初始化微信支付服务失败: %v", err))
+		}
+		ps.wechatService = wechatService
+	}
+
+	if c.Applepay.Enabled {
+		// 初始化苹果支付服务
+		appleConfig := payment.ApplePayConfig{
+			BundleID:        c.Applepay.BundleID,
+			KeyID:           c.Applepay.KeyID,
+			TeamID:          c.Applepay.IssuerID,
+			PrivateKey:      c.Applepay.LoadPrivateKeyPath,
+			IsProduction:    !c.Applepay.Sandbox,
+			NotifyURL:       c.Applepay.ProductionVerifyURL,
+			RefundNotifyURL: c.Applepay.SandboxVerifyURL,
+		}
+		appleService, err := payment.NewApplePayService(appleConfig)
+		if err != nil {
+			panic(fmt.Sprintf("初始化苹果支付服务失败: %v", err))
+		}
+		ps.appleService = appleService
+	}
+
+	return ps
+}
+
+// CreateOrder 创建支付订单
+func (p *PayService) CreateOrder(ctx context.Context, req *CreateOrderRequest) (*CreateOrderResponse, error) {
+	platform, ok := ctx.Value("platform").(string)
+	if !ok {
+		return nil, fmt.Errorf("获取平台失败")
+	}
+	userID, err := ctxdata.GetUidFromCtx(ctx)
+	if err != nil {
+		return nil, fmt.Errorf("获取用户信息失败: %v", err)
+	}
+	product, err := p.productModel.FindOneByProductEn(ctx, req.ProductEn)
+	if err != nil {
+		return nil, fmt.Errorf("获取商品失败: %v", err)
+	}
+	user, err := p.userModel.FindOne(ctx, userID)
+	if err != nil {
+		return nil, fmt.Errorf("获取用户失败: %v", err)
+	}
+	var outTradeNo string
+	var orderID int64
+	amount := product.SellPrice
+	if user.Inside == 1 {
+		amount = 0.01
+	}
+	// 使用事务创建订单
+	var payData interface{}
+	err = p.orderModel.Trans(ctx, func(ctx context.Context, session sqlx.Session) error {
+		// 根据支付方式创建支付订单
+		switch req.PayMethod {
+		case "alipay":
+			orderReq := &payment.AlipayCreateOrderRequest{
+				Amount:   amount,
+				Subject:  product.ProductName,
+				Platform: payment.PlatformApp,
+			}
+			resp, err := p.alipayService.CreateOrder(ctx, orderReq)
+			if err != nil {
+				return fmt.Errorf("创建支付宝订单失败: %v", err)
+			}
+			payData = resp.PayParams
+		case "wechat":
+			orderReq := &payment.Order{
+				OutTradeNo: outTradeNo,
+				Subject:    product.ProductName,
+				Amount:     amount,
+				Platform:   payment.PlatformApp,
+				NotifyURL:  p.config.Wxpay.NotifyUrl,
+			}
+
+			// 如果是小程序支付，需要获取用户的 OpenID
+			if platform == "mp-weixin" {
+				userAuth, err := p.userAuthModel.FindOneByUserIdAuthType(ctx, userID, model.UserAuthTypeWechatMiniOpenID)
+				if err != nil {
+					return fmt.Errorf("获取用户认证信息失败: %v", err)
+				}
+
+				orderReq.OpenID = userAuth.AuthKey
+			}
+
+			resp, err := p.wechatService.CreateOrder(orderReq)
+			if err != nil {
+				return fmt.Errorf("创建微信支付订单失败: %v", err)
+			}
+			payData = resp.PayParams
+			outTradeNo = resp.OrderNo
+		// case "apple":
+		// 	orderReq := &payment.AppleCreateOrderRequest{
+		// 		Amount:     amount,
+		// 		Subject:    product.ProductName,
+		// 		OutTradeNo: outTradeNo,
+		// 		Platform:   payment.PlatformApp,
+		// 		NotifyURL:  p.config.Applepay.ProductionVerifyURL,
+		// 	}
+		// 	resp, err := p.appleService.CreateOrder(ctx, orderReq)
+		// 	if err != nil {
+		// 		return fmt.Errorf("创建苹果支付订单失败: %v", err)
+		// 	}
+		// 	payData = resp.PayParams
+		default:
+			return fmt.Errorf("不支持的支付方式: %s", req.PayMethod)
+		}
+		// 创建订单记录
+		order := &model.Order{
+			OrderNo:         outTradeNo,
+			UserId:          userID,
+			ProductId:       product.Id,
+			PaymentPlatform: string(req.PayMethod),
+			PaymentScene:    platform,
+			Amount:          amount,
+			Status:          model.OrderStatusPending,
+		}
+		result, err := p.orderModel.Insert(ctx, session, order)
+		if err != nil {
+			return fmt.Errorf("创建订单记录失败: %v", err)
+		}
+		orderID, err = result.LastInsertId()
+		if err != nil {
+			return fmt.Errorf("获取订单ID失败: %v", err)
+		}
+		return nil
+	})
+
+	if err != nil {
+		return nil, err
+	}
+
+	return &CreateOrderResponse{
+		OrderNo:   outTradeNo,
+		PayData:   payData,
+		PayMethod: req.PayMethod,
+		OrderID:   orderID,
+	}, nil
+}
+
+// HandlePaymentCallback 处理支付回调
+func (p *PayService) HandlePaymentCallback(ctx context.Context, payType string, req *http.Request) error {
+	return p.orderModel.Trans(ctx, func(ctx context.Context, session sqlx.Session) error {
+		var payOrder *payment.QueryOrderResponse
+		var err error
+		switch payType {
+		case "alipay":
+			payOrder, err = p.handleAlipayCallback(ctx, req, session)
+		case "wechat":
+			payOrder, err = p.handleWechatCallback(ctx, req, session)
+		case "apple":
+			payOrder, err = p.handleAppleCallback(ctx, req, session)
+		default:
+			return fmt.Errorf("不支持的支付类型: %s", payType)
+		}
+
+		if err != nil {
+			return err
+		}
+
+		if payOrder == nil {
+			return fmt.Errorf("支付订单信息为空")
+		}
+
+		// 查询订单
+		order, err := p.orderModel.FindOneByOrderNo(ctx, payOrder.OrderNo)
+		if err != nil {
+			return fmt.Errorf("查询订单失败: %v", err)
+		}
+
+		// 验证订单金额
+		if payOrder.Amount != order.Amount {
+			return fmt.Errorf("订单金额不匹配")
+		}
+
+		// 根据支付状态更新订单状态
+		switch payOrder.Status {
+		case payment.StatusSuccess:
+			order.Status = model.OrderStatusPaid
+		case payment.StatusFailed:
+			order.Status = model.OrderStatusFailed
+		case payment.StatusClosed:
+			order.Status = model.OrderStatusClosed
+		case payment.StatusRefunded:
+			order.Status = model.OrderStatusRefunding
+		default:
+			return fmt.Errorf("不支持的支付状态: %s", payOrder.Status)
+		}
+
+		// 更新订单状态
+		order.PlatformOrderId = sql.NullString{String: payOrder.TransactionID, Valid: true}
+		_, err = p.orderModel.Update(ctx, session, order)
+		if err != nil {
+			return fmt.Errorf("更新订单状态失败: %v", err)
+		}
+		return nil
+	})
+}
+
+// handleAlipayCallback 处理支付宝回调
+func (p *PayService) handleAlipayCallback(ctx context.Context, req *http.Request, session sqlx.Session) (*payment.QueryOrderResponse, error) {
+	return p.alipayService.HandlePaymentNotification(req)
+}
+
+// handleWechatCallback 处理微信支付回调
+func (p *PayService) handleWechatCallback(ctx context.Context, req *http.Request, session sqlx.Session) (*payment.QueryOrderResponse, error) {
+	notification, err := p.wechatService.HandlePaymentNotification(req)
+	if err != nil {
+		return nil, fmt.Errorf("处理微信支付回调失败: %v", err)
+	}
+
+	// 将微信支付通知转换为统一的查询订单响应格式
+	return &payment.QueryOrderResponse{
+		OrderNo:       notification.OrderNo,
+		TransactionID: notification.TransactionID,
+		Status:        notification.Status,
+		Amount:        notification.Amount,
+		PayTime:       notification.PayTime,
+		PayMethod:     payment.MethodWechat,
+	}, nil
+}
+
+// handleAppleCallback 处理苹果支付回调
+func (p *PayService) handleAppleCallback(ctx context.Context, req *http.Request, session sqlx.Session) (*payment.QueryOrderResponse, error) {
+	receipt := req.FormValue("receipt-data")
+	if receipt == "" {
+		return nil, fmt.Errorf("无效的苹果支付收据")
+	}
+
+	verifyResp, err := p.appleService.VerifyReceipt(ctx, receipt)
+	if err != nil {
+		return nil, fmt.Errorf("验证苹果支付收据失败: %v", err)
+	}
+
+	if verifyResp.Status != payment.StatusSuccess {
+		return nil, fmt.Errorf("苹果支付验证失败，状态码: %s", verifyResp.Status)
+	}
+
+	// 将苹果支付验证响应转换为统一的查询订单响应格式
+	return &payment.QueryOrderResponse{
+		OrderNo:       verifyResp.OrderNo,
+		TransactionID: verifyResp.TransactionID,
+		Status:        verifyResp.Status,
+		Amount:        verifyResp.Amount,
+		PayTime:       time.Now(),
+		PayMethod:     payment.MethodApple,
+	}, nil
+}
+
+// Refund 申请退款
+func (p *PayService) Refund(ctx context.Context, req *RefundRequest) (*RefundResponse, error) {
+
+	// 查询订单信息
+	order, err := p.orderModel.FindOne(ctx, req.OrderId)
+	if err != nil {
+		return nil, fmt.Errorf("查询订单失败: %v", err)
+	}
+
+	// 验证订单状态
+	if order.Status != model.OrderStatusPaid {
+		return nil, fmt.Errorf("订单状态为 %s，无法退款", order.Status)
+	}
+	if req.RefundAmount > order.Amount {
+		return nil, fmt.Errorf("退款金额 %.2f 不能大于订单金额 %.2f", req.RefundAmount, order.Amount)
+	}
+
+	var result refundResult
+	result.status = model.OrderRefundStatusPending
+	order.Status = model.OrderStatusRefunding
+	// 使用事务处理退款流程
+	err = p.orderModel.Trans(ctx, func(ctx context.Context, session sqlx.Session) error {
+		// 根据支付方式申请退款
+		switch order.PaymentPlatform {
+		case string(PayMethodAlipay):
+			refundReq := &payment.AlipayRefundRequest{
+				OrderNo:      order.OrderNo,
+				RefundAmount: req.RefundAmount,
+			}
+			resp, err := p.alipayService.Refund(ctx, refundReq)
+			if err != nil {
+				return fmt.Errorf("支付宝退款申请失败: %v", err)
+			}
+			result = refundResult{
+				refundNo:         resp.RefundNo,
+				status:           model.OrderRefundStatusSuccess,
+				refundTime:       resp.RefundTime,
+				refundAmount:     resp.RefundAmount,
+				platformRefundId: sql.NullString{String: resp.RefundID, Valid: true},
+			}
+			order.Status = model.OrderRefundStatusSuccess
+		default:
+			return fmt.Errorf("不支持的支付平台退款: %s", order.PaymentPlatform)
+		}
+
+		// 创建退款记录
+		refund := &model.OrderRefund{
+			RefundNo:         result.refundNo,
+			PlatformRefundId: result.platformRefundId,
+			OrderId:          order.Id,
+			UserId:           order.UserId,
+			ProductId:        order.ProductId,
+			RefundAmount:     result.refundAmount,
+			RefundReason:     sql.NullString{String: req.Reason, Valid: true},
+			Status:           result.status,
+			RefundTime:       sql.NullTime{Time: result.refundTime, Valid: !result.refundTime.IsZero()},
+		}
+
+		if _, err := p.orderRefundModel.Insert(ctx, session, refund); err != nil {
+			return fmt.Errorf("创建退款记录失败: %v", err)
+		}
+
+		// 更新订单状态
+		order.Status = model.OrderStatusRefunding
+		order.RefundTime = sql.NullTime{Time: result.refundTime, Valid: !result.refundTime.IsZero()}
+		if _, err := p.orderModel.Update(ctx, session, order); err != nil {
+			return fmt.Errorf("更新订单状态失败: %v", err)
+		}
+
+		return nil
+	})
+
+	if err != nil {
+		return nil, err
+	}
+
+	return &RefundResponse{
+		RefundNo: result.refundNo,
+		Amount:   result.refundAmount,
+		Status:   result.status,
+	}, nil
+}
+
+// QueryOrderStatus 查询订单状态
+func (p *PayService) QueryOrderStatus(ctx context.Context, orderNo string) (*OrderStatusResponse, error) {
+	// 查询订单信息
+	order, err := p.orderModel.FindOneByOrderNo(ctx, orderNo)
+	if err != nil {
+		return nil, fmt.Errorf("查询订单失败: %v", err)
+	}
+
+	// 根据支付方式查询支付状态
+	var payStatus payment.PaymentStatus
+	switch order.PaymentPlatform {
+	case "alipay":
+		queryReq := &payment.QueryOrderRequest{
+			OrderNo: orderNo,
+		}
+		resp, err := p.alipayService.QueryOrder(ctx, queryReq)
+		if err != nil {
+			return nil, fmt.Errorf("查询支付宝订单状态失败: %v", err)
+		}
+		payStatus = resp.Status
+	// case "wechat":
+	// 	queryReq := &payment.OrderQuery{
+	// 		OrderNo: orderNo,
+	// 	}
+	// 	resp, err := p.wechatService.QueryOrder(queryReq)
+	// 	if err != nil {
+	// 		return nil, fmt.Errorf("查询微信支付订单状态失败: %v", err)
+	// 	}
+	// 	payStatus = resp.Status
+	// case "apple":
+	// 	return nil, fmt.Errorf("苹果支付暂不支持主动查询订单状态")
+	default:
+		return nil, fmt.Errorf("不支持的支付方式: %s", order.PaymentPlatform)
+	}
+
+	return &OrderStatusResponse{
+		OrderNo:     orderNo,
+		PayMethod:   PayMethod(order.PaymentPlatform),
+		PayStatus:   string(payStatus),
+		OrderStatus: order.Status,
+		Amount:      order.Amount,
+	}, nil
+}
+
+type PayMethod string
+
+const (
+	PayMethodAlipay PayMethod = "alipay"
+	PayMethodWechat PayMethod = "wechat"
+	PayMethodApple  PayMethod = "apple"
+)
+
+// 请求和响应结构体定义
+type CreateOrderRequest struct {
+	PayMethod PayMethod `json:"pay_method"` // 支付方式：alipay, wechat, apple
+	ProductEn string    `json:"product_en"` // 商品英文名
+}
+
+type CreateOrderResponse struct {
+	OrderNo   string      `json:"order_no"` // 订单号
+	PayData   interface{} `json:"pay_data"` // 支付数据
+	PayMethod PayMethod   `json:"pay_type"` // 支付方式
+	OrderID   int64       `json:"order_id"` // 订单ID
+}
+
+type RefundRequest struct {
+	OrderId      int64   `json:"order_id"`      // 订单ID
+	RefundAmount float64 `json:"refund_amount"` // 退款金额
+	Reason       string  `json:"reason"`        // 退款原因
+}
+
+// 定义退款结果结构
+type refundResult struct {
+	refundNo         string
+	status           string
+	refundTime       time.Time
+	refundAmount     float64
+	platformRefundId sql.NullString
+}
+
+type RefundResponse struct {
+	RefundNo string  `json:"refund_no"` // 退款单号
+	Amount   float64 `json:"amount"`    // 退款金额
+	Status   string  `json:"status"`    // 退款状态
+}
+
+type OrderStatusResponse struct {
+	OrderNo     string    `json:"order_no"`     // 订单号
+	PayMethod   PayMethod `json:"pay_type"`     // 支付方式
+	PayStatus   string    `json:"pay_status"`   // 支付状态
+	OrderStatus string    `json:"order_status"` // 订单状态
+	Amount      float64   `json:"amount"`       // 订单金额
+}

app/main/api/internal/service/wechatpayService.go

@@ -1,260 +0,0 @@
-package service
-
-import (
-	"context"
-	"fmt"
-	"net/http"
-	"strconv"
-	"time"
-	"tyc-server/app/main/api/internal/config"
-	"tyc-server/app/main/model"
-	"tyc-server/common/ctxdata"
-	"tyc-server/pkg/lzkit/lzUtils"
-
-	"github.com/wechatpay-apiv3/wechatpay-go/core"
-	"github.com/wechatpay-apiv3/wechatpay-go/core/auth/verifiers"
-	"github.com/wechatpay-apiv3/wechatpay-go/core/downloader"
-	"github.com/wechatpay-apiv3/wechatpay-go/core/notify"
-	"github.com/wechatpay-apiv3/wechatpay-go/core/option"
-	"github.com/wechatpay-apiv3/wechatpay-go/services/payments"
-	"github.com/wechatpay-apiv3/wechatpay-go/services/payments/app"
-	"github.com/wechatpay-apiv3/wechatpay-go/services/payments/jsapi"
-	"github.com/wechatpay-apiv3/wechatpay-go/services/refunddomestic"
-	"github.com/wechatpay-apiv3/wechatpay-go/utils"
-	"github.com/zeromicro/go-zero/core/logx"
-)
-
-const (
-	TradeStateSuccess    = "SUCCESS"    // 支付成功
-	TradeStateRefund     = "REFUND"     // 转入退款
-	TradeStateNotPay     = "NOTPAY"     // 未支付
-	TradeStateClosed     = "CLOSED"     // 已关闭
-	TradeStateRevoked    = "REVOKED"    // 已撤销（付款码支付）
-	TradeStateUserPaying = "USERPAYING" // 用户支付中（付款码支付）
-	TradeStatePayError   = "PAYERROR"   // 支付失败（其他原因，如银行返回失败）
-)
-
-type WechatPayService struct {
-	config        config.WxpayConfig
-	wechatClient  *core.Client
-	notifyHandler *notify.Handler
-	userAuthModel model.UserAuthModel
-}
-
-// NewWechatPayService 初始化微信支付服务
-func NewWechatPayService(c config.Config, userAuthModel model.UserAuthModel) *WechatPayService {
-	// 从配置中加载商户信息
-	mchID := c.Wxpay.MchID
-	mchCertificateSerialNumber := c.Wxpay.MchCertificateSerialNumber
-	mchAPIv3Key := c.Wxpay.MchApiv3Key
-
-	// 从文件中加载商户私钥
-	mchPrivateKey, err := utils.LoadPrivateKeyWithPath(c.Wxpay.MchPrivateKeyPath)
-	if err != nil {
-		logx.Errorf("加载商户私钥失败: %v", err)
-		panic(fmt.Sprintf("初始化失败，服务停止: %v", err)) // 记录错误并停止程序
-	}
-
-	// 使用商户私钥和其他参数初始化微信支付客户端
-	opts := []core.ClientOption{
-		option.WithWechatPayAutoAuthCipher(mchID, mchCertificateSerialNumber, mchPrivateKey, mchAPIv3Key),
-	}
-	client, err := core.NewClient(context.Background(), opts...)
-	if err != nil {
-		logx.Errorf("创建微信支付客户端失败: %v", err)
-		panic(fmt.Sprintf("初始化失败，服务停止: %v", err)) // 记录错误并停止程序
-	}
-	// 在初始化时获取证书访问器并创建 notifyHandler
-	certificateVisitor := downloader.MgrInstance().GetCertificateVisitor(mchID)
-	notifyHandler, err := notify.NewRSANotifyHandler(mchAPIv3Key, verifiers.NewSHA256WithRSAVerifier(certificateVisitor))
-	if err != nil {
-		logx.Errorf("获取证书访问器失败: %v", err)
-		panic(fmt.Sprintf("初始化失败，服务停止: %v", err)) // 记录错误并停止程序
-	}
-	return &WechatPayService{
-		config:        c.Wxpay,
-		wechatClient:  client,
-		notifyHandler: notifyHandler,
-		userAuthModel: userAuthModel,
-	}
-}
-
-// CreateWechatAppOrder 创建微信APP支付订单
-func (w *WechatPayService) CreateWechatAppOrder(ctx context.Context, amount float64, description string, outTradeNo string) (string, error) {
-	totalAmount := lzUtils.ToWechatAmount(amount)
-
-	// 构建支付请求参数
-	payRequest := app.PrepayRequest{
-		Appid:       core.String(w.config.AppID),
-		Mchid:       core.String(w.config.MchID),
-		Description: core.String(description),
-		OutTradeNo:  core.String(outTradeNo),
-		NotifyUrl:   core.String(w.config.NotifyUrl),
-		Amount: &app.Amount{
-			Total: core.Int64(totalAmount),
-		},
-	}
-
-	// 初始化 AppApiService
-	svc := app.AppApiService{Client: w.wechatClient}
-
-	// 发起预支付请求
-	resp, result, err := svc.Prepay(ctx, payRequest)
-	if err != nil {
-		return "", fmt.Errorf("微信支付订单创建失败: %v, 状态码: %d", err, result.Response.StatusCode)
-	}
-
-	// 返回预支付交易会话标识
-	return *resp.PrepayId, nil
-}
-
-// CreateWechatMiniProgramOrder 创建微信小程序支付订单
-func (w *WechatPayService) CreateWechatMiniProgramOrder(ctx context.Context, amount float64, description string, outTradeNo string, openid string) (interface{}, error) {
-	totalAmount := lzUtils.ToWechatAmount(amount)
-
-	// 构建支付请求参数
-	payRequest := jsapi.PrepayRequest{
-		Appid:       core.String(w.config.AppID),
-		Mchid:       core.String(w.config.MchID),
-		Description: core.String(description),
-		OutTradeNo:  core.String(outTradeNo),
-		NotifyUrl:   core.String(w.config.NotifyUrl),
-		Amount: &jsapi.Amount{
-			Total: core.Int64(totalAmount),
-		},
-		Payer: &jsapi.Payer{
-			Openid: core.String(openid), // 用户的 OpenID，通过前端传入
-		}}
-
-	// 初始化 AppApiService
-	svc := jsapi.JsapiApiService{Client: w.wechatClient}
-
-	// 发起预支付请求
-	resp, result, err := svc.PrepayWithRequestPayment(ctx, payRequest)
-	if err != nil {
-		return "", fmt.Errorf("微信支付订单创建失败: %v, 状态码: %d", err, result.Response.StatusCode)
-	}
-
-	// 返回预支付交易会话标识
-	return resp, nil
-}
-
-// CreateWechatOrder 创建微信支付订单（集成 APP、H5、小程序）
-func (w *WechatPayService) CreateWechatOrder(ctx context.Context, amount float64, description string, outTradeNo string) (interface{}, error) {
-	// 根据 ctx 中的 platform 判断平台
-	platform := ctx.Value("platform").(string)
-
-	var prepayData interface{}
-	var err error
-
-	switch platform {
-	case "mp-weixin":
-		userID, getUidErr := ctxdata.GetUidFromCtx(ctx)
-		if getUidErr != nil {
-			return "", fmt.Errorf("获取用户信息失败: %s", getUidErr)
-		}
-		userAuthModel, findUserAuthErr := w.userAuthModel.FindOneByUserIdAuthType(ctx, userID, "wx_mini")
-		if findUserAuthErr != nil {
-			return "", fmt.Errorf("获取用户认证信息失败: %s", findUserAuthErr)
-		}
-		// 如果是小程序平台，调用小程序支付订单创建
-		prepayData, err = w.CreateWechatMiniProgramOrder(ctx, amount, description, outTradeNo, userAuthModel.AuthKey)
-	case "app":
-		// 如果是 APP 平台，调用 APP 支付订单创建
-		prepayData, err = w.CreateWechatAppOrder(ctx, amount, description, outTradeNo)
-	default:
-		return "", fmt.Errorf("不支持的支付平台: %s", platform)
-	}
-
-	// 如果创建支付订单失败，返回错误
-	if err != nil {
-		return "", fmt.Errorf("支付订单创建失败: %v", err)
-	}
-
-	// 返回预支付ID
-	return prepayData, nil
-}
-
-// HandleWechatPayNotification 处理微信支付回调
-func (w *WechatPayService) HandleWechatPayNotification(ctx context.Context, req *http.Request) (*payments.Transaction, error) {
-	transaction := new(payments.Transaction)
-	_, err := w.notifyHandler.ParseNotifyRequest(ctx, req, transaction)
-	if err != nil {
-		return nil, fmt.Errorf("微信支付通知处理失败: %v", err)
-	}
-	// 返回交易信息
-	return transaction, nil
-}
-
-// HandleRefundNotification 处理微信退款回调
-func (w *WechatPayService) HandleRefundNotification(ctx context.Context, req *http.Request) (*refunddomestic.Refund, error) {
-	refund := new(refunddomestic.Refund)
-	_, err := w.notifyHandler.ParseNotifyRequest(ctx, req, refund)
-	if err != nil {
-		return nil, fmt.Errorf("微信退款回调通知处理失败: %v", err)
-	}
-	return refund, nil
-}
-
-// QueryOrderStatus 主动查询订单状态
-func (w *WechatPayService) QueryOrderStatus(ctx context.Context, transactionID string) (*payments.Transaction, error) {
-	svc := jsapi.JsapiApiService{Client: w.wechatClient}
-
-	// 调用 QueryOrderById 方法查询订单状态
-	resp, result, err := svc.QueryOrderById(ctx, jsapi.QueryOrderByIdRequest{
-		TransactionId: core.String(transactionID),
-		Mchid:         core.String(w.config.MchID),
-	})
-	if err != nil {
-		return nil, fmt.Errorf("订单查询失败: %v, 状态码: %d", err, result.Response.StatusCode)
-	}
-	return resp, nil
-
-}
-
-// WeChatRefund 申请微信退款
-func (w *WechatPayService) WeChatRefund(ctx context.Context, outTradeNo string, refundAmount float64, totalAmount float64) error {
-
-	// 生成唯一的退款单号
-	outRefundNo := fmt.Sprintf("%s-refund", outTradeNo)
-
-	// 初始化退款服务
-	svc := refunddomestic.RefundsApiService{Client: w.wechatClient}
-
-	// 创建退款请求
-	resp, result, err := svc.Create(ctx, refunddomestic.CreateRequest{
-		OutTradeNo:  core.String(outTradeNo),
-		OutRefundNo: core.String(outRefundNo),
-		NotifyUrl:   core.String(w.config.RefundNotifyUrl),
-		Amount: &refunddomestic.AmountReq{
-			Currency: core.String("CNY"),
-			Refund:   core.Int64(lzUtils.ToWechatAmount(refundAmount)),
-			Total:    core.Int64(lzUtils.ToWechatAmount(totalAmount)),
-		},
-	})
-	if err != nil {
-		return fmt.Errorf("微信订单申请退款错误: %v", err)
-	}
-	// 打印退款结果
-	logx.Infof("退款申请成功，状态码=%d，退款单号=%s，微信退款单号=%s", result.Response.StatusCode, *resp.OutRefundNo, *resp.RefundId)
-	return nil
-}
-
-// GenerateOutTradeNo 生成唯一订单号
-func (w *WechatPayService) GenerateOutTradeNo() string {
-	length := 16
-	timestamp := time.Now().UnixNano()
-	timeStr := strconv.FormatInt(timestamp, 10)
-	randomPart := strconv.Itoa(int(timestamp % 1e6))
-	combined := timeStr + randomPart
-
-	if len(combined) >= length {
-		return combined[:length]
-	}
-
-	for len(combined) < length {
-		combined += strconv.Itoa(int(timestamp % 10))
-	}
-
-	return combined
-}

app/main/api/internal/svc/servicecontext.go

@@ -21,7 +21,19 @@ type ServiceContext struct {
 	SourceInterceptor rest.Middleware
 	AuthInterceptor   rest.Middleware
 
-	// 模型
+	// 服务
+	PayService                     *service.PayService
+	WestDexService                 *service.WestDexService
+	YushanService                  *service.YushanService
+	TianjuService                  *service.TianjuService
+	ApiRequestService              *service.ApiRequestService
+	AsynqServer                    *asynq.Server
+	AsynqService                   *service.AsynqService
+	VerificationService            *service.VerificationService
+	DictService                    *service.DictService
+	AdminPromotionLinkStatsService *service.AdminPromotionLinkStatsService
+
+	// 基础模型
 	UserModel                model.UserModel
 	UserAuthModel            model.UserAuthModel
 	ProductModel             model.ProductModel
@@ -29,26 +41,13 @@ type ServiceContext struct {
 	ProductFeatureModel      model.ProductFeatureModel
 	ProductRenderModel       model.ProductRenderModel
 	OrderModel               model.OrderModel
+	OrderRefundModel         model.OrderRefundModel
 	QueryModel               model.QueryModel
 	GlobalNotificationsModel model.GlobalNotificationsModel
 	ExampleModel             model.ExampleModel
 	ExampleParamsModel       model.ExampleParamsModel
 
-	// 服务
-	AlipayService                  *service.AliPayService
-	WechatPayService               *service.WechatPayService
-	ApplePayService                *service.ApplePayService
-	WestDexService                 *service.WestDexService
-	YushanService                  *service.YushanService
-	TianjuService                  *service.TianjuService
-	ApiRequestService              *service.ApiRequestService
-	AsynqServer                    *asynq.Server         // 服务端
-	AsynqService                   *service.AsynqService // 客户端
-	VerificationService            *service.VerificationService
-	DictService                    *service.DictService
-	AdminPromotionLinkStatsService *service.AdminPromotionLinkStatsService
-
-	// admin
+	// 管理后台模型
 	AdminApiModel      model.AdminApiModel
 	AdminMenuModel     model.AdminMenuModel
 	AdminRoleModel     model.AdminRoleModel
@@ -59,20 +58,24 @@ type ServiceContext struct {
 	AdminDictDataModel model.AdminDictDataModel
 	AdminDictTypeModel model.AdminDictTypeModel
 
-	// admin promotion
+	// 推广相关模型
 	AdminPromotionLinkModel             model.AdminPromotionLinkModel
 	AdminPromotionLinkStatsTotalModel   model.AdminPromotionLinkStatsTotalModel
 	AdminPromotionLinkStatsHistoryModel model.AdminPromotionLinkStatsHistoryModel
 	AdminPromotionOrderModel            model.AdminPromotionOrderModel
 }
 
-func NewServiceContext(c config.Config) *ServiceContext {
-	db := sqlx.NewMysql(c.DataSource)
+// 初始化基础服务
+func initBaseServices(c config.Config) (*redis.Redis, *asynq.Server) {
+	// 初始化Redis
 	redisConf := redis.RedisConf{
 		Host: c.CacheRedis[0].Host,
 		Pass: c.CacheRedis[0].Pass,
 		Type: c.CacheRedis[0].Type,
 	}
+	r := redis.MustNewRedis(redisConf)
+
+	// 初始化Asynq服务
 	asynqServer := asynq.NewServer(
 		asynq.RedisClientOpt{Addr: c.CacheRedis[0].Host, Password: c.CacheRedis[0].Pass},
 		asynq.Config{
@@ -83,80 +86,203 @@ func NewServiceContext(c config.Config) *ServiceContext {
 			Concurrency: 10,
 		},
 	)
-	adminApiModel := model.NewAdminApiModel(db, c.CacheRedis)
-	adminMenuModel := model.NewAdminMenuModel(db, c.CacheRedis)
-	adminRoleModel := model.NewAdminRoleModel(db, c.CacheRedis)
-	adminRoleApiModel := model.NewAdminRoleApiModel(db, c.CacheRedis)
-	adminRoleMenuModel := model.NewAdminRoleMenuModel(db, c.CacheRedis)
-	adminUserModel := model.NewAdminUserModel(db, c.CacheRedis)
-	adminUserRoleModel := model.NewAdminUserRoleModel(db, c.CacheRedis)
-	adminDictDataModel := model.NewAdminDictDataModel(db, c.CacheRedis)
-	adminDictTypeModel := model.NewAdminDictTypeModel(db, c.CacheRedis)
 
-	// admin promotion
-	adminPromotionLinkModel := model.NewAdminPromotionLinkModel(db, c.CacheRedis)
-	adminPromotionLinkStatsTotalModel := model.NewAdminPromotionLinkStatsTotalModel(db, c.CacheRedis)
-	adminPromotionLinkStatsHistoryModel := model.NewAdminPromotionLinkStatsHistoryModel(db, c.CacheRedis)
-	adminPromotionOrderModel := model.NewAdminPromotionOrderModel(db, c.CacheRedis)
+	return r, asynqServer
+}
 
+// 初始化基础模型
+func initBaseModels(db sqlx.SqlConn, c config.Config) *BaseModels {
+	return &BaseModels{
+		UserModel:                model.NewUserModel(db, c.CacheRedis),
+		UserAuthModel:            model.NewUserAuthModel(db, c.CacheRedis),
+		ProductModel:             model.NewProductModel(db, c.CacheRedis),
+		FeatureModel:             model.NewFeatureModel(db, c.CacheRedis),
+		ProductFeatureModel:      model.NewProductFeatureModel(db, c.CacheRedis),
+		ProductRenderModel:       model.NewProductRenderModel(db, c.CacheRedis),
+		OrderModel:               model.NewOrderModel(db, c.CacheRedis),
+		OrderRefundModel:         model.NewOrderRefundModel(db, c.CacheRedis),
+		QueryModel:               model.NewQueryModel(db, c.CacheRedis),
+		GlobalNotificationsModel: model.NewGlobalNotificationsModel(db, c.CacheRedis),
+		ExampleModel:             model.NewExampleModel(db, c.CacheRedis),
+		ExampleParamsModel:       model.NewExampleParamsModel(db, c.CacheRedis),
+	}
+}
+
+// 初始化管理后台模型
+func initAdminModels(db sqlx.SqlConn, c config.Config) *AdminModels {
+	return &AdminModels{
+		AdminApiModel:      model.NewAdminApiModel(db, c.CacheRedis),
+		AdminMenuModel:     model.NewAdminMenuModel(db, c.CacheRedis),
+		AdminRoleModel:     model.NewAdminRoleModel(db, c.CacheRedis),
+		AdminRoleApiModel:  model.NewAdminRoleApiModel(db, c.CacheRedis),
+		AdminRoleMenuModel: model.NewAdminRoleMenuModel(db, c.CacheRedis),
+		AdminUserModel:     model.NewAdminUserModel(db, c.CacheRedis),
+		AdminUserRoleModel: model.NewAdminUserRoleModel(db, c.CacheRedis),
+		AdminDictDataModel: model.NewAdminDictDataModel(db, c.CacheRedis),
+		AdminDictTypeModel: model.NewAdminDictTypeModel(db, c.CacheRedis),
+	}
+}
+
+// 初始化推广相关模型
+func initPromotionModels(db sqlx.SqlConn, c config.Config) *PromotionModels {
+	return &PromotionModels{
+		AdminPromotionLinkModel:             model.NewAdminPromotionLinkModel(db, c.CacheRedis),
+		AdminPromotionLinkStatsTotalModel:   model.NewAdminPromotionLinkStatsTotalModel(db, c.CacheRedis),
+		AdminPromotionLinkStatsHistoryModel: model.NewAdminPromotionLinkStatsHistoryModel(db, c.CacheRedis),
+		AdminPromotionOrderModel:            model.NewAdminPromotionOrderModel(db, c.CacheRedis),
+	}
+}
+
+// 初始化业务服务
+func initBusinessServices(c config.Config, models *BaseModels, adminModels *AdminModels, promotionModels *PromotionModels) *BusinessServices {
+	// 初始化基础服务
 	westDexService := service.NewWestDexService(c)
 	yushanService := service.NewYushanService(c)
 	tianjuService := service.NewTianjuService(c)
-	productFeatureModel := model.NewProductFeatureModel(db, c.CacheRedis)
-	featureModel := model.NewFeatureModel(db, c.CacheRedis)
-	userAuthModel := model.NewUserAuthModel(db, c.CacheRedis)
-	apiRequestService := service.NewApiRequestService(c, westDexService, yushanService, tianjuService, featureModel, productFeatureModel)
+
+	// 初始化API请求服务
+	apiRequestService := service.NewApiRequestService(
+		c,
+		westDexService,
+		yushanService,
+		tianjuService,
+		models.FeatureModel,
+		models.ProductFeatureModel,
+	)
+
+	// 初始化推广统计服务
 	adminPromotionLinkStatsService := service.NewAdminPromotionLinkStatsService(&service.ServiceContext{
-		AdminPromotionLinkModel:             adminPromotionLinkModel,
-		AdminPromotionLinkStatsTotalModel:   adminPromotionLinkStatsTotalModel,
-		AdminPromotionLinkStatsHistoryModel: adminPromotionLinkStatsHistoryModel,
+		AdminPromotionLinkModel:             promotionModels.AdminPromotionLinkModel,
+		AdminPromotionLinkStatsTotalModel:   promotionModels.AdminPromotionLinkStatsTotalModel,
+		AdminPromotionLinkStatsHistoryModel: promotionModels.AdminPromotionLinkStatsHistoryModel,
 	})
-	dictService := service.NewDictService(adminDictTypeModel, adminDictDataModel)
-	return &ServiceContext{
-		Config:                         c,
-		Redis:                          redis.MustNewRedis(redisConf),
-		SourceInterceptor:              middleware.NewSourceInterceptorMiddleware().Handle,
-		AuthInterceptor:                middleware.NewAuthInterceptorMiddleware(c).Handle,
-		AlipayService:                  service.NewAliPayService(c),
-		WechatPayService:               service.NewWechatPayService(c, userAuthModel),
-		ApplePayService:                service.NewApplePayService(c),
+
+	return &BusinessServices{
+		PayService:                     service.NewPayService(c, models.OrderModel, models.OrderRefundModel, models.ProductModel, models.UserAuthModel),
 		WestDexService:                 westDexService,
 		YushanService:                  yushanService,
 		TianjuService:                  tianjuService,
-		AdminPromotionLinkStatsService: adminPromotionLinkStatsService,
-		VerificationService:            service.NewVerificationService(c, westDexService, apiRequestService),
-		AsynqServer:                    asynqServer,
 		ApiRequestService:              apiRequestService,
 		AsynqService:                   service.NewAsynqService(c),
-		DictService:                    dictService,
-		UserModel:                      model.NewUserModel(db, c.CacheRedis),
-		UserAuthModel:                  userAuthModel,
-		ProductModel:                   model.NewProductModel(db, c.CacheRedis),
-		ProductRenderModel:             model.NewProductRenderModel(db, c.CacheRedis),
-		OrderModel:                     model.NewOrderModel(db, c.CacheRedis),
-		QueryModel:                     model.NewQueryModel(db, c.CacheRedis),
-		ExampleModel:                   model.NewExampleModel(db, c.CacheRedis),
-		ExampleParamsModel:             model.NewExampleParamsModel(db, c.CacheRedis),
-		GlobalNotificationsModel:       model.NewGlobalNotificationsModel(db, c.CacheRedis),
-		FeatureModel:                   featureModel,
-		ProductFeatureModel:            productFeatureModel,
-
-		AdminApiModel:      adminApiModel,
-		AdminMenuModel:     adminMenuModel,
-		AdminRoleModel:     adminRoleModel,
-		AdminRoleApiModel:  adminRoleApiModel,
-		AdminRoleMenuModel: adminRoleMenuModel,
-		AdminUserModel:     adminUserModel,
-		AdminUserRoleModel: adminUserRoleModel,
-		AdminDictDataModel: adminDictDataModel,
-		AdminDictTypeModel: adminDictTypeModel,
-
-		AdminPromotionLinkModel:             adminPromotionLinkModel,
-		AdminPromotionLinkStatsTotalModel:   adminPromotionLinkStatsTotalModel,
-		AdminPromotionLinkStatsHistoryModel: adminPromotionLinkStatsHistoryModel,
-		AdminPromotionOrderModel:            adminPromotionOrderModel,
+		VerificationService:            service.NewVerificationService(c, westDexService, apiRequestService),
+		DictService:                    service.NewDictService(adminModels.AdminDictTypeModel, adminModels.AdminDictDataModel),
+		AdminPromotionLinkStatsService: adminPromotionLinkStatsService,
 	}
 }
+
+func NewServiceContext(c config.Config) *ServiceContext {
+	// 初始化数据库连接
+	db := sqlx.NewMysql(c.DataSource)
+
+	// 初始化基础服务
+	redis, asynqServer := initBaseServices(c)
+
+	// 初始化各种模型
+	baseModels := initBaseModels(db, c)
+	adminModels := initAdminModels(db, c)
+	promotionModels := initPromotionModels(db, c)
+
+	// 初始化业务服务
+	businessServices := initBusinessServices(c, baseModels, adminModels, promotionModels)
+
+	return &ServiceContext{
+		Config:            c,
+		Redis:             redis,
+		AsynqServer:       asynqServer,
+		SourceInterceptor: middleware.NewSourceInterceptorMiddleware().Handle,
+		AuthInterceptor:   middleware.NewAuthInterceptorMiddleware(c).Handle,
+
+		// 注入业务服务
+		PayService:                     businessServices.PayService,
+		WestDexService:                 businessServices.WestDexService,
+		YushanService:                  businessServices.YushanService,
+		TianjuService:                  businessServices.TianjuService,
+		ApiRequestService:              businessServices.ApiRequestService,
+		AsynqService:                   businessServices.AsynqService,
+		VerificationService:            businessServices.VerificationService,
+		DictService:                    businessServices.DictService,
+		AdminPromotionLinkStatsService: businessServices.AdminPromotionLinkStatsService,
+
+		// 注入基础模型
+		UserModel:                baseModels.UserModel,
+		UserAuthModel:            baseModels.UserAuthModel,
+		ProductModel:             baseModels.ProductModel,
+		FeatureModel:             baseModels.FeatureModel,
+		ProductFeatureModel:      baseModels.ProductFeatureModel,
+		ProductRenderModel:       baseModels.ProductRenderModel,
+		OrderModel:               baseModels.OrderModel,
+		OrderRefundModel:         baseModels.OrderRefundModel,
+		QueryModel:               baseModels.QueryModel,
+		GlobalNotificationsModel: baseModels.GlobalNotificationsModel,
+		ExampleModel:             baseModels.ExampleModel,
+		ExampleParamsModel:       baseModels.ExampleParamsModel,
+
+		// 注入管理后台模型
+		AdminApiModel:      adminModels.AdminApiModel,
+		AdminMenuModel:     adminModels.AdminMenuModel,
+		AdminRoleModel:     adminModels.AdminRoleModel,
+		AdminRoleApiModel:  adminModels.AdminRoleApiModel,
+		AdminRoleMenuModel: adminModels.AdminRoleMenuModel,
+		AdminUserModel:     adminModels.AdminUserModel,
+		AdminUserRoleModel: adminModels.AdminUserRoleModel,
+		AdminDictDataModel: adminModels.AdminDictDataModel,
+		AdminDictTypeModel: adminModels.AdminDictTypeModel,
+
+		// 注入推广相关模型
+		AdminPromotionLinkModel:             promotionModels.AdminPromotionLinkModel,
+		AdminPromotionLinkStatsTotalModel:   promotionModels.AdminPromotionLinkStatsTotalModel,
+		AdminPromotionLinkStatsHistoryModel: promotionModels.AdminPromotionLinkStatsHistoryModel,
+		AdminPromotionOrderModel:            promotionModels.AdminPromotionOrderModel,
+	}
+}
+
+// 辅助结构体，用于分组初始化
+type BaseModels struct {
+	UserModel                model.UserModel
+	UserAuthModel            model.UserAuthModel
+	ProductModel             model.ProductModel
+	FeatureModel             model.FeatureModel
+	ProductFeatureModel      model.ProductFeatureModel
+	ProductRenderModel       model.ProductRenderModel
+	OrderModel               model.OrderModel
+	OrderRefundModel         model.OrderRefundModel
+	QueryModel               model.QueryModel
+	GlobalNotificationsModel model.GlobalNotificationsModel
+	ExampleModel             model.ExampleModel
+	ExampleParamsModel       model.ExampleParamsModel
+}
+
+type AdminModels struct {
+	AdminApiModel      model.AdminApiModel
+	AdminMenuModel     model.AdminMenuModel
+	AdminRoleModel     model.AdminRoleModel
+	AdminRoleApiModel  model.AdminRoleApiModel
+	AdminRoleMenuModel model.AdminRoleMenuModel
+	AdminUserModel     model.AdminUserModel
+	AdminUserRoleModel model.AdminUserRoleModel
+	AdminDictDataModel model.AdminDictDataModel
+	AdminDictTypeModel model.AdminDictTypeModel
+}
+
+type PromotionModels struct {
+	AdminPromotionLinkModel             model.AdminPromotionLinkModel
+	AdminPromotionLinkStatsTotalModel   model.AdminPromotionLinkStatsTotalModel
+	AdminPromotionLinkStatsHistoryModel model.AdminPromotionLinkStatsHistoryModel
+	AdminPromotionOrderModel            model.AdminPromotionOrderModel
+}
+
+type BusinessServices struct {
+	PayService                     *service.PayService
+	WestDexService                 *service.WestDexService
+	YushanService                  *service.YushanService
+	TianjuService                  *service.TianjuService
+	ApiRequestService              *service.ApiRequestService
+	AsynqService                   *service.AsynqService
+	VerificationService            *service.VerificationService
+	DictService                    *service.DictService
+	AdminPromotionLinkStatsService *service.AdminPromotionLinkStatsService
+}
+
 func (s *ServiceContext) Close() {
 	if s.AsynqService != nil {
 		s.AsynqService.Close()

app/main/api/internal/types/types.go

@@ -1,6 +1,70 @@
 // Code generated by goctl. DO NOT EDIT.
 package types
 
+type AdminCreateFeatureReq struct {
+	ApiId string `json:"api_id"` // API标识
+	Name  string `json:"name"`   // 描述
+}
+
+type AdminCreateFeatureResp struct {
+	Id int64 `json:"id"` // 功能ID
+}
+
+type AdminCreateNotificationReq struct {
+	Title            string `json:"title"`             // 通知标题
+	NotificationPage string `json:"notification_page"` // 通知页面
+	Content          string `json:"content"`           // 通知内容
+	StartDate        string `json:"start_date"`        // 生效开始日期（yyyy-MM-dd）
+	StartTime        string `json:"start_time"`        // 生效开始时间（HH:mm:ss）
+	EndDate          string `json:"end_date"`          // 生效结束日期（yyyy-MM-dd）
+	EndTime          string `json:"end_time"`          // 生效结束时间（HH:mm:ss）
+	Status           int64  `json:"status"`            // 状态：1-启用，0-禁用
+}
+
+type AdminCreateNotificationResp struct {
+	Id int64 `json:"id"` // 通知ID
+}
+
+type AdminCreateOrderReq struct {
+	OrderNo         string  `json:"order_no"`               // 商户订单号
+	PlatformOrderId string  `json:"platform_order_id"`      // 支付订单号
+	ProductName     string  `json:"product_name"`           // 产品名称
+	PaymentPlatform string  `json:"payment_platform"`       // 支付方式
+	PaymentScene    string  `json:"payment_scene"`          // 支付平台
+	Amount          float64 `json:"amount"`                 // 金额
+	Status          string  `json:"status,default=pending"` // 支付状态：pending-待支付，paid-已支付，refunded-已退款，closed-已关闭，failed-支付失败
+	IsPromotion     int64   `json:"is_promotion,default=0"` // 是否推广订单：0-否，1-是
+}
+
+type AdminCreateOrderResp struct {
+	Id int64 `json:"id"` // 订单ID
+}
+
+type AdminCreatePlatformUserReq struct {
+	Mobile   string `json:"mobile"`   // 手机号
+	Password string `json:"password"` // 密码
+	Nickname string `json:"nickname"` // 昵称
+	Info     string `json:"info"`     // 备注信息
+	Inside   int64  `json:"inside"`   // 是否内部用户 1-是 0-否
+}
+
+type AdminCreatePlatformUserResp struct {
+	Id int64 `json:"id"` // 用户ID
+}
+
+type AdminCreateProductReq struct {
+	ProductName string  `json:"product_name"`   // 服务名
+	ProductEn   string  `json:"product_en"`     // 英文名
+	Description string  `json:"description"`    // 描述
+	Notes       string  `json:"notes,optional"` // 备注
+	CostPrice   float64 `json:"cost_price"`     // 成本
+	SellPrice   float64 `json:"sell_price"`     // 售价
+}
+
+type AdminCreateProductResp struct {
+	Id int64 `json:"id"` // 产品ID
+}
+
 type AdminCreateUserReq struct {
 	Username string  `json:"username"`         // 用户名
 	RealName string  `json:"real_name"`        // 真实姓名
@@ -12,6 +76,46 @@ type AdminCreateUserResp struct {
 	Id int64 `json:"id"` // 用户ID
 }
 
+type AdminDeleteFeatureReq struct {
+	Id int64 `path:"id"` // 功能ID
+}
+
+type AdminDeleteFeatureResp struct {
+	Success bool `json:"success"` // 是否成功
+}
+
+type AdminDeleteNotificationReq struct {
+	Id int64 `path:"id"` // 通知ID
+}
+
+type AdminDeleteNotificationResp struct {
+	Success bool `json:"success"` // 是否成功
+}
+
+type AdminDeleteOrderReq struct {
+	Id int64 `path:"id"` // 订单ID
+}
+
+type AdminDeleteOrderResp struct {
+	Success bool `json:"success"` // 是否成功
+}
+
+type AdminDeletePlatformUserReq struct {
+	Id int64 `path:"id"` // 用户ID
+}
+
+type AdminDeletePlatformUserResp struct {
+	Success bool `json:"success"` // 是否成功
+}
+
+type AdminDeleteProductReq struct {
+	Id int64 `path:"id"` // 产品ID
+}
+
+type AdminDeleteProductResp struct {
+	Success bool `json:"success"` // 是否成功
+}
+
 type AdminDeleteUserReq struct {
 	Id int64 `path:"id"` // 用户ID
 }
@@ -20,6 +124,183 @@ type AdminDeleteUserResp struct {
 	Success bool `json:"success"` // 是否成功
 }
 
+type AdminGetFeatureDetailReq struct {
+	Id int64 `path:"id"` // 功能ID
+}
+
+type AdminGetFeatureDetailResp struct {
+	Id         int64  `json:"id"`          // 功能ID
+	ApiId      string `json:"api_id"`      // API标识
+	Name       string `json:"name"`        // 描述
+	CreateTime string `json:"create_time"` // 创建时间
+	UpdateTime string `json:"update_time"` // 更新时间
+}
+
+type AdminGetFeatureListReq struct {
+	Page     int64   `form:"page"`            // 页码
+	PageSize int64   `form:"pageSize"`        // 每页数量
+	ApiId    *string `form:"api_id,optional"` // API标识
+	Name     *string `form:"name,optional"`   // 描述
+}
+
+type AdminGetFeatureListResp struct {
+	Total int64             `json:"total"` // 总数
+	Items []FeatureListItem `json:"items"` // 列表数据
+}
+
+type AdminGetNotificationDetailReq struct {
+	Id int64 `path:"id"` // 通知ID
+}
+
+type AdminGetNotificationDetailResp struct {
+	Id               int64  `json:"id"`                // 通知ID
+	Title            string `json:"title"`             // 通知标题
+	Content          string `json:"content"`           // 通知内容
+	NotificationPage string `json:"notification_page"` // 通知页面
+	StartDate        string `json:"start_date"`        // 生效开始日期
+	StartTime        string `json:"start_time"`        // 生效开始时间
+	EndDate          string `json:"end_date"`          // 生效结束日期
+	EndTime          string `json:"end_time"`          // 生效结束时间
+	Status           int64  `json:"status"`            // 状态
+	CreateTime       string `json:"create_time"`       // 创建时间
+	UpdateTime       string `json:"update_time"`       // 更新时间
+}
+
+type AdminGetNotificationListReq struct {
+	Page             int64   `form:"page"`                       // 页码
+	PageSize         int64   `form:"pageSize"`                   // 每页数量
+	Title            *string `form:"title,optional"`             // 通知标题（可选）
+	NotificationPage *string `form:"notification_page,optional"` // 通知页面（可选）
+	Status           *int64  `form:"status,optional"`            // 状态（可选）
+	StartDate        *string `form:"start_date,optional"`        // 开始日期范围（可选）
+	EndDate          *string `form:"end_date,optional"`          // 结束日期范围（可选）
+}
+
+type AdminGetNotificationListResp struct {
+	Total int64                  `json:"total"` // 总数
+	Items []NotificationListItem `json:"items"` // 列表数据
+}
+
+type AdminGetOrderDetailReq struct {
+	Id int64 `path:"id"` // 订单ID
+}
+
+type AdminGetOrderDetailResp struct {
+	Id              int64   `json:"id"`                // 订单ID
+	OrderNo         string  `json:"order_no"`          // 商户订单号
+	PlatformOrderId string  `json:"platform_order_id"` // 支付订单号
+	ProductName     string  `json:"product_name"`      // 产品名称
+	PaymentPlatform string  `json:"payment_platform"`  // 支付方式
+	PaymentScene    string  `json:"payment_scene"`     // 支付平台
+	Amount          float64 `json:"amount"`            // 金额
+	Status          string  `json:"status"`            // 支付状态：pending-待支付，paid-已支付，refunded-已退款，closed-已关闭，failed-支付失败
+	CreateTime      string  `json:"create_time"`       // 创建时间
+	PayTime         string  `json:"pay_time"`          // 支付时间
+	RefundTime      string  `json:"refund_time"`       // 退款时间
+	IsPromotion     int64   `json:"is_promotion"`      // 是否推广订单：0-否，1-是
+	UpdateTime      string  `json:"update_time"`       // 更新时间
+}
+
+type AdminGetOrderListReq struct {
+	Page            int64   `form:"page,default=1"`                   // 页码
+	PageSize        int64   `form:"pageSize,default=20"`              // 每页数量
+	OrderNo         string  `form:"order_no,optional"`                // 商户订单号
+	PlatformOrderId string  `form:"platform_order_id,optional"`       // 支付订单号
+	ProductName     string  `form:"product_name,optional"`            // 产品名称
+	PaymentPlatform string  `form:"payment_platform,optional"`        // 支付方式
+	PaymentScene    string  `form:"payment_scene,optional"`           // 支付平台
+	Amount          float64 `form:"amount,optional"`                  // 金额
+	Status          string  `form:"status,optional"`                  // 支付状态：pending-待支付，paid-已支付，refunded-已退款，closed-已关闭，failed-支付失败
+	IsPromotion     int64   `form:"is_promotion,optional,default=-1"` // 是否推广订单：0-否，1-是
+	CreateTimeStart string  `form:"create_time_start,optional"`       // 创建时间开始
+	CreateTimeEnd   string  `form:"create_time_end,optional"`         // 创建时间结束
+	PayTimeStart    string  `form:"pay_time_start,optional"`          // 支付时间开始
+	PayTimeEnd      string  `form:"pay_time_end,optional"`            // 支付时间结束
+	RefundTimeStart string  `form:"refund_time_start,optional"`       // 退款时间开始
+	RefundTimeEnd   string  `form:"refund_time_end,optional"`         // 退款时间结束
+}
+
+type AdminGetOrderListResp struct {
+	Total int64           `json:"total"` // 总数
+	Items []OrderListItem `json:"items"` // 列表
+}
+
+type AdminGetPlatformUserDetailReq struct {
+	Id int64 `path:"id"` // 用户ID
+}
+
+type AdminGetPlatformUserDetailResp struct {
+	Id         int64  `json:"id"`          // 用户ID
+	Mobile     string `json:"mobile"`      // 手机号
+	Nickname   string `json:"nickname"`    // 昵称
+	Info       string `json:"info"`        // 备注信息
+	Inside     int64  `json:"inside"`      // 是否内部用户 1-是 0-否
+	CreateTime string `json:"create_time"` // 创建时间
+	UpdateTime string `json:"update_time"` // 更新时间
+}
+
+type AdminGetPlatformUserListReq struct {
+	Page            int64  `form:"page,default=1"`             // 页码
+	PageSize        int64  `form:"pageSize,default=20"`        // 每页数量
+	Mobile          string `form:"mobile,optional"`            // 手机号
+	Nickname        string `form:"nickname,optional"`          // 昵称
+	Inside          int64  `form:"inside,optional"`            // 是否内部用户 1-是 0-否
+	CreateTimeStart string `form:"create_time_start,optional"` // 创建时间开始
+	CreateTimeEnd   string `form:"create_time_end,optional"`   // 创建时间结束
+	OrderBy         string `form:"order_by,optional"`          // 排序字段
+	OrderType       string `form:"order_type,optional"`        // 排序类型
+}
+
+type AdminGetPlatformUserListResp struct {
+	Total int64                  `json:"total"` // 总数
+	Items []PlatformUserListItem `json:"items"` // 列表
+}
+
+type AdminGetProductDetailReq struct {
+	Id int64 `path:"id"` // 产品ID
+}
+
+type AdminGetProductDetailResp struct {
+	Id          int64   `json:"id"`           // 产品ID
+	ProductName string  `json:"product_name"` // 服务名
+	ProductEn   string  `json:"product_en"`   // 英文名
+	Description string  `json:"description"`  // 描述
+	Notes       string  `json:"notes"`        // 备注
+	CostPrice   float64 `json:"cost_price"`   // 成本
+	SellPrice   float64 `json:"sell_price"`   // 售价
+	CreateTime  string  `json:"create_time"`  // 创建时间
+	UpdateTime  string  `json:"update_time"`  // 更新时间
+}
+
+type AdminGetProductFeatureListReq struct {
+	ProductId int64 `path:"product_id"` // 产品ID
+}
+
+type AdminGetProductFeatureListResp struct {
+	Id          int64  `json:"id"`           // 关联ID
+	ProductId   int64  `json:"product_id"`   // 产品ID
+	FeatureId   int64  `json:"feature_id"`   // 功能ID
+	ApiId       string `json:"api_id"`       // API标识
+	Name        string `json:"name"`         // 功能描述
+	Sort        int64  `json:"sort"`         // 排序
+	Enable      int64  `json:"enable"`       // 是否启用
+	IsImportant int64  `json:"is_important"` // 是否重要
+	CreateTime  string `json:"create_time"`  // 创建时间
+	UpdateTime  string `json:"update_time"`  // 更新时间
+}
+
+type AdminGetProductListReq struct {
+	Page        int64   `form:"page"`                  // 页码
+	PageSize    int64   `form:"pageSize"`              // 每页数量
+	ProductName *string `form:"product_name,optional"` // 服务名
+	ProductEn   *string `form:"product_en,optional"`   // 英文名
+}
+
+type AdminGetProductListResp struct {
+	Total int64             `json:"total"` // 总数
+	Items []ProductListItem `json:"items"` // 列表数据
+}
+
 type AdminGetUserDetailReq struct {
 	Id int64 `path:"id"` // 用户ID
 }
@@ -43,8 +324,8 @@ type AdminGetUserListReq struct {
 }
 
 type AdminGetUserListResp struct {
-	Total int64          `json:"total"` // 总数
-	Items []UserListItem `json:"items"` // 列表
+	Total int64               `json:"total"` // 总数
+	Items []AdminUserListItem `json:"items"` // 列表
 }
 
 type AdminLoginReq struct {
@@ -60,6 +341,98 @@ type AdminLoginResp struct {
 	Roles        []string `json:"roles"`
 }
 
+type AdminRefundOrderReq struct {
+	Id           int64   `path:"id"`            // 订单ID
+	RefundAmount float64 `json:"refund_amount"` // 退款金额
+	RefundReason string  `json:"refund_reason"` // 退款原因
+}
+
+type AdminRefundOrderResp struct {
+	Status   string  `json:"status"`    // 退款状态
+	RefundNo string  `json:"refund_no"` // 退款单号
+	Amount   float64 `json:"amount"`    // 退款金额
+}
+
+type AdminUpdateFeatureReq struct {
+	Id    int64   `path:"id"`              // 功能ID
+	ApiId *string `json:"api_id,optional"` // API标识
+	Name  *string `json:"name,optional"`   // 描述
+}
+
+type AdminUpdateFeatureResp struct {
+	Success bool `json:"success"` // 是否成功
+}
+
+type AdminUpdateNotificationReq struct {
+	Id               int64   `path:"id"`                         // 通知ID
+	Title            *string `json:"title,optional"`             // 通知标题
+	Content          *string `json:"content,optional"`           // 通知内容
+	NotificationPage *string `json:"notification_page,optional"` // 通知页面
+	StartDate        *string `json:"start_date,optional"`        // 生效开始日期
+	StartTime        *string `json:"start_time,optional"`        // 生效开始时间
+	EndDate          *string `json:"end_date,optional"`          // 生效结束日期
+	EndTime          *string `json:"end_time,optional"`          // 生效结束时间
+	Status           *int64  `json:"status,optional"`            // 状态
+}
+
+type AdminUpdateNotificationResp struct {
+	Success bool `json:"success"` // 是否成功
+}
+
+type AdminUpdateOrderReq struct {
+	Id              int64    `path:"id"`                         // 订单ID
+	OrderNo         *string  `json:"order_no,optional"`          // 商户订单号
+	PlatformOrderId *string  `json:"platform_order_id,optional"` // 支付订单号
+	ProductName     *string  `json:"product_name,optional"`      // 产品名称
+	PaymentPlatform *string  `json:"payment_platform,optional"`  // 支付方式
+	PaymentScene    *string  `json:"payment_scene,optional"`     // 支付平台
+	Amount          *float64 `json:"amount,optional"`            // 金额
+	Status          *string  `json:"status,optional"`            // 支付状态：pending-待支付，paid-已支付，refunded-已退款，closed-已关闭，failed-支付失败
+	PayTime         *string  `json:"pay_time,optional"`          // 支付时间
+	RefundTime      *string  `json:"refund_time,optional"`       // 退款时间
+	IsPromotion     *int64   `json:"is_promotion,optional"`      // 是否推广订单：0-否，1-是
+}
+
+type AdminUpdateOrderResp struct {
+	Success bool `json:"success"` // 是否成功
+}
+
+type AdminUpdatePlatformUserReq struct {
+	Id       int64   `path:"id"`                // 用户ID
+	Mobile   *string `json:"mobile,optional"`   // 手机号
+	Password *string `json:"password,optional"` // 密码
+	Nickname *string `json:"nickname,optional"` // 昵称
+	Info     *string `json:"info,optional"`     // 备注信息
+	Inside   *int64  `json:"inside,optional"`   // 是否内部用户 1-是 0-否
+}
+
+type AdminUpdatePlatformUserResp struct {
+	Success bool `json:"success"` // 是否成功
+}
+
+type AdminUpdateProductFeaturesReq struct {
+	ProductId int64                `path:"product_id"` // 产品ID
+	Features  []ProductFeatureItem `json:"features"`   // 功能列表
+}
+
+type AdminUpdateProductFeaturesResp struct {
+	Success bool `json:"success"` // 是否成功
+}
+
+type AdminUpdateProductReq struct {
+	Id          int64    `path:"id"`                    // 产品ID
+	ProductName *string  `json:"product_name,optional"` // 服务名
+	ProductEn   *string  `json:"product_en,optional"`   // 英文名
+	Description *string  `json:"description,optional"`  // 描述
+	Notes       *string  `json:"notes,optional"`        // 备注
+	CostPrice   *float64 `json:"cost_price,optional"`   // 成本
+	SellPrice   *float64 `json:"sell_price,optional"`   // 售价
+}
+
+type AdminUpdateProductResp struct {
+	Success bool `json:"success"` // 是否成功
+}
+
 type AdminUpdateUserReq struct {
 	Id       int64   `path:"id"`                 // 用户ID
 	Username *string `json:"username,optional"`  // 用户名
@@ -81,6 +454,15 @@ type AdminUserInfoResp struct {
 	Roles    []string `json:"roles"`     // 角色编码列表
 }
 
+type AdminUserListItem struct {
+	Id         int64   `json:"id"`          // 用户ID
+	Username   string  `json:"username"`    // 用户名
+	RealName   string  `json:"real_name"`   // 真实姓名
+	Status     int64   `json:"status"`      // 状态：0-禁用，1-启用
+	CreateTime string  `json:"create_time"` // 创建时间
+	RoleIds    []int64 `json:"role_ids"`    // 关联的角色ID列表
+}
+
 type CreateMenuReq struct {
 	Pid       int64                  `json:"pid,optional"`              // 父菜单ID
 	Name      string                 `json:"name"`                      // 路由名称
@@ -149,6 +531,14 @@ type Feature struct {
 	Name  string `json:"name"`   // 功能描述
 }
 
+type FeatureListItem struct {
+	Id         int64  `json:"id"`          // 功能ID
+	ApiId      string `json:"api_id"`      // API标识
+	Name       string `json:"name"`        // 描述
+	CreateTime string `json:"create_time"` // 创建时间
+	UpdateTime string `json:"update_time"` // 更新时间
+}
+
 type GetMenuAllReq struct {
 }
 
@@ -335,6 +725,35 @@ type Notification struct {
 	EndTime          string `json:"endTime"`          // 每天通知结束时间，格式 "HH:MM:SS"
 }
 
+type NotificationListItem struct {
+	Id               int64  `json:"id"`                // 通知ID
+	Title            string `json:"title"`             // 通知标题
+	NotificationPage string `json:"notification_page"` // 通知页面
+	Content          string `json:"content"`           // 通知内容
+	StartDate        string `json:"start_date"`        // 生效开始日期
+	StartTime        string `json:"start_time"`        // 生效开始时间
+	EndDate          string `json:"end_date"`          // 生效结束日期
+	EndTime          string `json:"end_time"`          // 生效结束时间
+	Status           int64  `json:"status"`            // 状态
+	CreateTime       string `json:"create_time"`       // 创建时间
+	UpdateTime       string `json:"update_time"`       // 更新时间
+}
+
+type OrderListItem struct {
+	Id              int64   `json:"id"`                // 订单ID
+	OrderNo         string  `json:"order_no"`          // 商户订单号
+	PlatformOrderId string  `json:"platform_order_id"` // 支付订单号
+	ProductName     string  `json:"product_name"`      // 产品名称
+	PaymentPlatform string  `json:"payment_platform"`  // 支付方式
+	PaymentScene    string  `json:"payment_scene"`     // 支付平台
+	Amount          float64 `json:"amount"`            // 金额
+	Status          string  `json:"status"`            // 支付状态：pending-待支付，paid-已支付，refunded-已退款，closed-已关闭，failed-支付失败
+	CreateTime      string  `json:"create_time"`       // 创建时间
+	PayTime         string  `json:"pay_time"`          // 支付时间
+	RefundTime      string  `json:"refund_time"`       // 退款时间
+	IsPromotion     int64   `json:"is_promotion"`      // 是否推广订单：0-否，1-是
+}
+
 type PaymentReq struct {
 	Id        string `json:"id"`
 	PayMethod string `json:"pay_method"`
@@ -346,6 +765,16 @@ type PaymentResp struct {
 	OrderID    int64       `json:"order_id"`
 }
 
+type PlatformUserListItem struct {
+	Id         int64  `json:"id"`          // 用户ID
+	Mobile     string `json:"mobile"`      // 手机号
+	Nickname   string `json:"nickname"`    // 昵称
+	Info       string `json:"info"`        // 备注信息
+	Inside     int64  `json:"inside"`      // 是否内部用户 1-是 0-否
+	CreateTime string `json:"create_time"` // 创建时间
+	UpdateTime string `json:"update_time"` // 更新时间
+}
+
 type Product struct {
 	ProductName string    `json:"product_name"`
 	ProductEn   string    `json:"product_en"`
@@ -355,6 +784,25 @@ type Product struct {
 	Features    []Feature `json:"features"` // 关联功能列表
 }
 
+type ProductFeatureItem struct {
+	FeatureId   int64 `json:"feature_id"`   // 功能ID
+	Sort        int64 `json:"sort"`         // 排序
+	Enable      int64 `json:"enable"`       // 是否启用
+	IsImportant int64 `json:"is_important"` // 是否重要
+}
+
+type ProductListItem struct {
+	Id          int64   `json:"id"`           // 产品ID
+	ProductName string  `json:"product_name"` // 服务名
+	ProductEn   string  `json:"product_en"`   // 英文名
+	Description string  `json:"description"`  // 描述
+	Notes       string  `json:"notes"`        // 备注
+	CostPrice   float64 `json:"cost_price"`   // 成本
+	SellPrice   float64 `json:"sell_price"`   // 售价
+	CreateTime  string  `json:"create_time"`  // 创建时间
+	UpdateTime  string  `json:"update_time"`  // 更新时间
+}
+
 type ProductResponse struct {
 	Product
 }
@@ -573,15 +1021,6 @@ type UserInfoResp struct {
 	UserInfo User `json:"userInfo"`
 }
 
-type UserListItem struct {
-	Id         int64   `json:"id"`          // 用户ID
-	Username   string  `json:"username"`    // 用户名
-	RealName   string  `json:"real_name"`   // 真实姓名
-	Status     int64   `json:"status"`      // 状态：0-禁用，1-启用
-	CreateTime string  `json:"create_time"` // 创建时间
-	RoleIds    []int64 `json:"role_ids"`    // 关联的角色ID列表
-}
-
 type WXH5AuthReq struct {
 	Code string `json:"code"`
 }