HI-VPN/hi-server
4
0
Fork 0
Code Issues Pull Requests 3 Actions Packages Projects Releases Wiki Activity

新功能(#79): 实现促销管理接口并支持数量配价

Browse Source 
Co-authored-by: multica-agent <github@multica.ai>
This commit is contained in:
shanshanzhong
2026-05-27 00:54:32 -07:00
parent 5ebfe0a981
commit e27b2320b4
28 changed files with 1462 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files
internal/logic/admin/promo/createRuleLogic.go
+58
View File
@@ -0,0 +1,58 @@
package promo
import (
"context"
promomodel "github.com/perfect-panel/server/internal/model/promo"
"github.com/perfect-panel/server/internal/svc"
"github.com/perfect-panel/server/internal/types"
"github.com/perfect-panel/server/pkg/logger"
"github.com/perfect-panel/server/pkg/xerr"
"github.com/pkg/errors"
)
type CreateRuleLogic struct {
logger.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
func NewCreateRuleLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CreateRuleLogic {
return &CreateRuleLogic{
Logger: logger.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *CreateRuleLogic) CreateRule(req *types.CreatePromoRuleRequest) (*types.PromoRule, error) {
if err := validateRuleInput(req.Type, req.Params, req.Priority, req.StartTime, req.EndTime); err != nil {
return nil, err
}
params, err := paramsToString(req.Params)
if err != nil {
return nil, err
}
enabled := true
if req.Enabled != nil {
enabled = *req.Enabled
}
rule := &promomodel.Rule{
Name: req.Name,
Type: req.Type,
Params: params,
Priority: req.Priority,
Enabled: &enabled,
StartTime: unixPtrToTimePtr(req.StartTime),
EndTime: unixPtrToTimePtr(req.EndTime),
}
if err := l.svcCtx.PromoModel.InsertRule(l.ctx, rule); err != nil {
l.Errorw("[CreatePromoRule] Database Error", logger.Field("error", err.Error()))
return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseInsertError), "create promo rule error: %v", err.Error())
}
if err := l.svcCtx.Redis.Del(l.ctx, ruleCacheKey).Err(); err != nil {
l.Errorw("[CreatePromoRule] Delete Cache Error", logger.Field("error", err.Error()))
}
resp := convertRule(rule)
return &resp, nil
}
internal/logic/admin/promo/deletePriceLogic.go
+41
View File
@@ -0,0 +1,41 @@
package promo
import (
"context"
"github.com/perfect-panel/server/internal/svc"
"github.com/perfect-panel/server/internal/types"
"github.com/perfect-panel/server/pkg/logger"
"github.com/perfect-panel/server/pkg/xerr"
"github.com/pkg/errors"
)
type DeletePriceLogic struct {
logger.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
func NewDeletePriceLogic(ctx context.Context, svcCtx *svc.ServiceContext) *DeletePriceLogic {
return &DeletePriceLogic{
Logger: logger.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *DeletePriceLogic) DeletePrice(req *types.DeletePromoPriceRequest) error {
price, err := l.svcCtx.PromoModel.FindPrice(l.ctx, req.Id)
if err != nil {
l.Errorw("[DeletePromoPrice] Find Price Error", logger.Field("error", err.Error()))
return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "find promo price error: %v", err.Error())
}
if err := l.svcCtx.PromoModel.DeletePrice(l.ctx, req.Id); err != nil {
l.Errorw("[DeletePromoPrice] Database Error", logger.Field("error", err.Error()))
return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseDeletedError), "delete promo price error: %v", err.Error())
}
if err := l.svcCtx.Redis.Del(l.ctx, subscribePromoCacheKey(price.SubscribeId)).Err(); err != nil {
l.Errorw("[DeletePromoPrice] Delete Cache Error", logger.Field("error", err.Error()))
}
return nil
}
internal/logic/admin/promo/deleteRuleLogic.go
+36
View File
@@ -0,0 +1,36 @@
package promo
import (
"context"
"github.com/perfect-panel/server/internal/svc"
"github.com/perfect-panel/server/internal/types"
"github.com/perfect-panel/server/pkg/logger"
"github.com/perfect-panel/server/pkg/xerr"
"github.com/pkg/errors"
)
type DeleteRuleLogic struct {
logger.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
func NewDeleteRuleLogic(ctx context.Context, svcCtx *svc.ServiceContext) *DeleteRuleLogic {
return &DeleteRuleLogic{
Logger: logger.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *DeleteRuleLogic) DeleteRule(req *types.DeletePromoRuleRequest) error {
if err := l.svcCtx.PromoModel.DeleteRule(l.ctx, req.Id); err != nil {
l.Errorw("[DeletePromoRule] Database Error", logger.Field("error", err.Error()))
return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseDeletedError), "delete promo rule error: %v", err.Error())
}
if err := l.svcCtx.Redis.Del(l.ctx, ruleCacheKey).Err(); err != nil {
l.Errorw("[DeletePromoRule] Delete Cache Error", logger.Field("error", err.Error()))
}
return nil
}
internal/logic/admin/promo/getPriceListLogic.go
+41
View File
@@ -0,0 +1,41 @@
package promo
import (
"context"
"github.com/perfect-panel/server/internal/svc"
"github.com/perfect-panel/server/internal/types"
"github.com/perfect-panel/server/pkg/logger"
"github.com/perfect-panel/server/pkg/xerr"
"github.com/pkg/errors"
)
type GetPriceListLogic struct {
logger.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
func NewGetPriceListLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetPriceListLogic {
return &GetPriceListLogic{
Logger: logger.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *GetPriceListLogic) GetPriceList(req *types.GetPromoPriceListRequest) (*types.GetPromoPriceListResponse, error) {
total, list, err := l.svcCtx.PromoModel.QueryPriceList(l.ctx, req.PromoRuleId, int(req.Page), int(req.Size))
if err != nil {
l.Errorw("[GetPromoPriceList] Database Error", logger.Field("error", err.Error()))
return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "get promo price list error: %v", err.Error())
}
resp := &types.GetPromoPriceListResponse{
Total: total,
List: make([]types.PromoPrice, 0, len(list)),
}
for _, item := range list {
resp.List = append(resp.List, convertPrice(item))
}
return resp, nil
}
internal/logic/admin/promo/getRuleDetailLogic.go
+35
View File
@@ -0,0 +1,35 @@
package promo
import (
"context"
"github.com/perfect-panel/server/internal/svc"
"github.com/perfect-panel/server/internal/types"
"github.com/perfect-panel/server/pkg/logger"
"github.com/perfect-panel/server/pkg/xerr"
"github.com/pkg/errors"
)
type GetRuleDetailLogic struct {
logger.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
func NewGetRuleDetailLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetRuleDetailLogic {
return &GetRuleDetailLogic{
Logger: logger.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *GetRuleDetailLogic) GetRuleDetail(req *types.GetPromoRuleDetailRequest) (*types.PromoRule, error) {
rule, err := l.svcCtx.PromoModel.FindRule(l.ctx, req.Id)
if err != nil {
l.Errorw("[GetPromoRuleDetail] Database Error", logger.Field("error", err.Error()))
return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "get promo rule detail error: %v", err.Error())
}
resp := convertRule(rule)
return &resp, nil
}
internal/logic/admin/promo/getRuleListLogic.go
+41
View File
@@ -0,0 +1,41 @@
package promo
import (
"context"
"github.com/perfect-panel/server/internal/svc"
"github.com/perfect-panel/server/internal/types"
"github.com/perfect-panel/server/pkg/logger"
"github.com/perfect-panel/server/pkg/xerr"
"github.com/pkg/errors"
)
type GetRuleListLogic struct {
logger.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
func NewGetRuleListLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetRuleListLogic {
return &GetRuleListLogic{
Logger: logger.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *GetRuleListLogic) GetRuleList(req *types.GetPromoRuleListRequest) (*types.GetPromoRuleListResponse, error) {
total, list, err := l.svcCtx.PromoModel.QueryRuleList(l.ctx, int(req.Page), int(req.Size), req.Type, req.Enabled, req.Search)
if err != nil {
l.Errorw("[GetPromoRuleList] Database Error", logger.Field("error", err.Error()))
return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "get promo rule list error: %v", err.Error())
}
resp := &types.GetPromoRuleListResponse{
Total: total,
List: make([]types.PromoRule, 0, len(list)),
}
for _, item := range list {
resp.List = append(resp.List, convertRule(item))
}
return resp, nil
}
internal/logic/admin/promo/getUsageListLogic.go
+49
View File
@@ -0,0 +1,49 @@
package promo
import (
"context"
promomodel "github.com/perfect-panel/server/internal/model/promo"
"github.com/perfect-panel/server/internal/svc"
"github.com/perfect-panel/server/internal/types"
"github.com/perfect-panel/server/pkg/logger"
"github.com/perfect-panel/server/pkg/xerr"
"github.com/pkg/errors"
)
type GetUsageListLogic struct {
logger.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
func NewGetUsageListLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetUsageListLogic {
return &GetUsageListLogic{
Logger: logger.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *GetUsageListLogic) GetUsageList(req *types.GetPromoUsageListRequest) (*types.GetPromoUsageListResponse, error) {
total, list, err := l.svcCtx.PromoModel.QueryUsageList(l.ctx, promomodel.UsageFilter{
Page: int(req.Page),
Size: int(req.Size),
RuleId: req.RuleId,
UserId: req.UserId,
SubscribeId: req.SubscribeId,
OrderNo: req.OrderNo,
})
if err != nil {
l.Errorw("[GetPromoUsageList] Database Error", logger.Field("error", err.Error()))
return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "get promo usage list error: %v", err.Error())
}
resp := &types.GetPromoUsageListResponse{
Total: total,
List: make([]types.PromoUsage, 0, len(list)),
}
for _, item := range list {
resp.List = append(resp.List, convertUsage(item))
}
return resp, nil
}
internal/logic/admin/promo/setPriceLogic.go
+67
View File
@@ -0,0 +1,67 @@
package promo
import (
"context"
promomodel "github.com/perfect-panel/server/internal/model/promo"
"github.com/perfect-panel/server/internal/svc"
"github.com/perfect-panel/server/internal/types"
"github.com/perfect-panel/server/pkg/logger"
"github.com/perfect-panel/server/pkg/xerr"
"github.com/pkg/errors"
"gorm.io/gorm"
)
type SetPriceLogic struct {
logger.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
func NewSetPriceLogic(ctx context.Context, svcCtx *svc.ServiceContext) *SetPriceLogic {
return &SetPriceLogic{
Logger: logger.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *SetPriceLogic) SetPrice(req *types.SetPromoPriceRequest) error {
if _, err := l.svcCtx.PromoModel.FindRule(l.ctx, req.PromoRuleId); err != nil {
l.Errorw("[SetPromoPrice] Find Rule Error", logger.Field("error", err.Error()))
return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "find promo rule error: %v", err.Error())
}
items := make([]*promomodel.SubscribePromo, 0, len(req.Items))
cacheKeys := make([]string, 0, len(req.Items))
for _, item := range req.Items {
sub, err := l.svcCtx.SubscribeModel.FindOne(l.ctx, item.SubscribeId)
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return errors.Wrapf(xerr.NewErrCode(xerr.InvalidParams), "subscribe plan not found")
}
l.Errorw("[SetPromoPrice] Find Subscribe Error", logger.Field("error", err.Error()))
return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "find subscribe error: %v", err.Error())
}
originPrice := sub.UnitPrice * item.Quantity
if item.PromoPrice >= originPrice {
return errors.Wrapf(xerr.NewErrCode(xerr.InvalidParams), "promo_price must be less than unit_price * quantity")
}
items = append(items, &promomodel.SubscribePromo{
SubscribeId: item.SubscribeId,
PromoRuleId: req.PromoRuleId,
Quantity: item.Quantity,
PromoPrice: item.PromoPrice,
})
cacheKeys = append(cacheKeys, subscribePromoCacheKey(item.SubscribeId))
}
if err := l.svcCtx.PromoModel.UpsertPrices(l.ctx, req.PromoRuleId, items); err != nil {
l.Errorw("[SetPromoPrice] Database Error", logger.Field("error", err.Error()))
return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), "set promo price error: %v", err.Error())
}
if len(cacheKeys) > 0 {
if err := l.svcCtx.Redis.Del(l.ctx, cacheKeys...).Err(); err != nil {
l.Errorw("[SetPromoPrice] Delete Cache Error", logger.Field("error", err.Error()))
}
}
return nil
}
internal/logic/admin/promo/tool.go
+166
View File
@@ -0,0 +1,166 @@
package promo
import (
"encoding/json"
"fmt"
"math"
"time"
promomodel "github.com/perfect-panel/server/internal/model/promo"
"github.com/perfect-panel/server/internal/types"
"github.com/perfect-panel/server/pkg/xerr"
"github.com/pkg/errors"
)
const (
ruleCacheKey = "promo:rules:enabled"
subscribeCachePref = "promo:subscribe:"
)
func validateRuleInput(ruleType string, params map[string]interface{}, priority int64, startTime, endTime *int64) error {
if priority < 0 {
return errors.Wrapf(xerr.NewErrCode(xerr.InvalidParams), "priority must be greater than or equal to 0")
}
if startTime != nil && endTime != nil && *startTime >= *endTime {
return errors.Wrapf(xerr.NewErrCode(xerr.InvalidParams), "start_time must be less than end_time")
}
switch ruleType {
case "new_user":
windowHours, ok := numberParam(params, "window_hours")
if !ok || windowHours <= 0 {
return errors.Wrapf(xerr.NewErrCode(xerr.InvalidParams), "params.window_hours must be greater than 0")
}
case "inactive_user":
inactiveMonths, ok := numberParam(params, "inactive_months")
if !ok || inactiveMonths <= 0 {
return errors.Wrapf(xerr.NewErrCode(xerr.InvalidParams), "params.inactive_months must be greater than 0")
}
case "campaign":
if params == nil {
return nil
}
default:
return errors.Wrapf(xerr.NewErrCode(xerr.InvalidParams), "unsupported promo rule type")
}
return nil
}
func numberParam(params map[string]interface{}, key string) (int64, bool) {
if params == nil {
return 0, false
}
value, ok := params[key]
if !ok {
return 0, false
}
switch v := value.(type) {
case float64:
if math.Trunc(v) != v {
return 0, false
}
return int64(v), true
case int64:
return v, true
case int:
return int64(v), true
case json.Number:
n, err := v.Int64()
return n, err == nil
default:
return 0, false
}
}
func paramsToString(params map[string]interface{}) (string, error) {
if params == nil {
params = map[string]interface{}{}
}
b, err := json.Marshal(params)
if err != nil {
return "", errors.Wrapf(xerr.NewErrCode(xerr.InvalidParams), "invalid params")
}
return string(b), nil
}
func parseParams(data string) map[string]interface{} {
if data == "" {
return map[string]interface{}{}
}
var params map[string]interface{}
if err := json.Unmarshal([]byte(data), &params); err != nil {
return map[string]interface{}{}
}
return params
}
func unixPtrToTimePtr(ts *int64) *time.Time {
if ts == nil || *ts == 0 {
return nil
}
t := time.Unix(*ts, 0)
return &t
}
func timePtrToUnixPtr(t *time.Time) *int64 {
if t == nil {
return nil
}
ts := t.Unix()
return &ts
}
func convertRule(item *promomodel.Rule) types.PromoRule {
if item == nil {
return types.PromoRule{}
}
enabled := false
if item.Enabled != nil {
enabled = *item.Enabled
}
return types.PromoRule{
Id: item.Id,
Name: item.Name,
Type: item.Type,
Params: parseParams(item.Params),
Priority: item.Priority,
Enabled: enabled,
StartTime: timePtrToUnixPtr(item.StartTime),
EndTime: timePtrToUnixPtr(item.EndTime),
CreatedAt: item.CreatedAt.Unix(),
UpdatedAt: item.UpdatedAt.Unix(),
}
}
func convertPrice(item *promomodel.SubscribePromo) types.PromoPrice {
if item == nil {
return types.PromoPrice{}
}
return types.PromoPrice{
Id: item.Id,
SubscribeId: item.SubscribeId,
PromoRuleId: item.PromoRuleId,
Quantity: item.Quantity,
PromoPrice: item.PromoPrice,
CreatedAt: item.CreatedAt.Unix(),
UpdatedAt: item.UpdatedAt.Unix(),
}
}
func convertUsage(item *promomodel.Usage) types.PromoUsage {
if item == nil {
return types.PromoUsage{}
}
return types.PromoUsage{
Id: item.Id,
UserId: item.UserId,
PromoRuleId: item.PromoRuleId,
SubscribeId: item.SubscribeId,
OrderNo: item.OrderNo,
PromoPrice: item.PromoPrice,
CreatedAt: item.CreatedAt.Unix(),
}
}
func subscribePromoCacheKey(subscribeId int64) string {
return fmt.Sprintf("%s%d", subscribeCachePref, subscribeId)
}
internal/logic/admin/promo/updateRuleLogic.go
+63
View File
@@ -0,0 +1,63 @@
package promo
import (
"context"
"github.com/perfect-panel/server/internal/svc"
"github.com/perfect-panel/server/internal/types"
"github.com/perfect-panel/server/pkg/logger"
"github.com/perfect-panel/server/pkg/xerr"
"github.com/pkg/errors"
)
type UpdateRuleLogic struct {
logger.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
func NewUpdateRuleLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UpdateRuleLogic {
return &UpdateRuleLogic{
Logger: logger.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *UpdateRuleLogic) UpdateRule(req *types.UpdatePromoRuleRequest) (*types.PromoRule, error) {
if err := validateRuleInput(req.Type, req.Params, req.Priority, req.StartTime, req.EndTime); err != nil {
return nil, err
}
rule, err := l.svcCtx.PromoModel.FindRule(l.ctx, req.Id)
if err != nil {
l.Errorw("[UpdatePromoRule] Find Rule Error", logger.Field("error", err.Error()))
return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "find promo rule error: %v", err.Error())
}
params, err := paramsToString(req.Params)
if err != nil {
return nil, err
}
enabled := true
if rule.Enabled != nil {
enabled = *rule.Enabled
}
if req.Enabled != nil {
enabled = *req.Enabled
}
rule.Name = req.Name
rule.Type = req.Type
rule.Params = params
rule.Priority = req.Priority
rule.Enabled = &enabled
rule.StartTime = unixPtrToTimePtr(req.StartTime)
rule.EndTime = unixPtrToTimePtr(req.EndTime)
if err := l.svcCtx.PromoModel.UpdateRule(l.ctx, rule); err != nil {
l.Errorw("[UpdatePromoRule] Database Error", logger.Field("error", err.Error()))
return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), "update promo rule error: %v", err.Error())
}
if err := l.svcCtx.Redis.Del(l.ctx, ruleCacheKey).Err(); err != nil {
l.Errorw("[UpdatePromoRule] Delete Cache Error", logger.Field("error", err.Error()))
}
resp := convertRule(rule)
return &resp, nil
}