liucaijun
/
voucher
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

自定义错误

This commit is contained in:
李子铭 2025-03-15 13:52:48 +08:00
parent e5291d07f4
commit 82b3ae0731
12 changed files with 105 additions and 98 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
api/err/err.proto
View File

@ -13,8 +13,6 @@ enum Err {
// DB数据未找到
DB_NOT_FOUND = 1 [(errors.code) = 404];
ORDER_NOT_FOUND = 2 [(errors.code) = 404];
PRODUCT_NOT_FOUND = 3 [(errors.code) = 404];
}
enum NotifyConsumeErr{

40
api/err/wechat.proto
View File

@ -9,26 +9,30 @@ enum WechatErr{
WechatFAIL = 0 [(errors.code) = 500];
WechatUserIllegal = 1 [(errors.code) = 500];
WechatMismatch = 2 [(errors.code) = 500];
WechatAppIDMchIDMismatch = 2 [(errors.code) = 500];
WechatOpenIDAppIDMismatch = 3 [(errors.code) = 500];
WechatInvalidMerchantID = 4 [(errors.code) = 500];
WechatHighFrequency = 5 [(errors.code) = 500];
WechatActivityInactive = 6 [(errors.code) = 500];
WechatBatchInfoError = 7 [(errors.code) = 500];
WechatParamRequired = 8 [(errors.code) = 500];
WechatInvalidBatchStatus = 10 [(errors.code) = 500];
WechatMchNotExists = 11 [(errors.code) = 500];
WechatBatchBudgetInsufficient = 9 [(errors.code) = 500];
WechatDailyLimitExceeded = 12 [(errors.code) = 500];
WechatAccountBalanceInsufficient = 13 [(errors.code) = 500];
WechatBatchBudgetDepleted = 14 [(errors.code) = 500];
WechatMerchantNoPermission = 15 [(errors.code) = 500];
WechatCrossMerchantNotSupported = 16 [(errors.code) = 500];
WechatUserReceiveLimit = 17 [(errors.code) = 500];
WechatAPIChannelNotSupported = 18 [(errors.code) = 500];
WechatSpecifiedDenominationNotSupported = 19 [(errors.code) = 500];
WechatOnlyAdvertisingBatch = 20 [(errors.code) = 500];
WechatUserMaxCoupons = 21 [(errors.code) = 500];
WechatNaturalPersonRuleBlocked = 22 [(errors.code) = 500];
WechatResourceNotExists = 23 [(errors.code) = 500];
WechatFrequencyLimited = 24 [(errors.code) = 500];
WechatAppIDRequired = 8 [(errors.code) = 500];
WechatOpenIDRequired = 9 [(errors.code) = 500];
WechatBatchIDRequired = 10 [(errors.code) = 500];
WechatMerchantIDRequired = 11 [(errors.code) = 500];
WechatInvalidBatchStatus = 12 [(errors.code) = 500];
WechatMchNotExists = 13 [(errors.code) = 500];
WechatBatchBudgetInsufficient = 14 [(errors.code) = 500];
WechatDailyLimitExceeded = 15 [(errors.code) = 500];
WechatAccountBalanceInsufficient = 16 [(errors.code) = 500];
WechatBatchBudgetDepleted = 17 [(errors.code) = 500];
WechatMerchantNoPermission = 18 [(errors.code) = 500];
WechatCrossMerchantNotSupported = 19 [(errors.code) = 500];
WechatUserReceiveLimit = 20 [(errors.code) = 500];
WechatAPIChannelNotSupported = 21 [(errors.code) = 500];
WechatSpecifiedDenominationNotSupported = 22 [(errors.code) = 500];
WechatOnlyAdvertisingBatch = 23 [(errors.code) = 500];
WechatUserMaxCoupons = 24 [(errors.code) = 500];
WechatNaturalPersonRuleBlocked = 25 [(errors.code) = 500];
WechatResourceNotExists = 26 [(errors.code) = 500];
WechatFrequencyLimited = 27 [(errors.code) = 500];
}

7
internal/biz/cmb.go
View File

@ -11,7 +11,7 @@ import (
"voucher/internal/pkg/lock"
)
func (v *VoucherBiz) CmbOrder(ctx context.Context, req *bo.OrderCreateReqBo) (voucherNo string, err error) {
func (v *VoucherBiz) CmbOrder(ctx context.Context, req *bo.OrderCreateReqBo) (orderNo string, err error) {
c := vo.CmbOrderLockKey.BuildCache([]string{req.OutBizNo, req.Type.String()})
@ -26,12 +26,13 @@ func (v *VoucherBiz) CmbOrder(ctx context.Context, req *bo.OrderCreateReqBo) (vo
if order != nil {
if order.Status.IsFail() {
if err = v.orderRetry(ctx, order); err != nil {
return err
}
}
voucherNo = order.VoucherNo
orderNo = order.OrderNo
return nil
}
@ -49,7 +50,7 @@ func (v *VoucherBiz) CmbOrder(ctx context.Context, req *bo.OrderCreateReqBo) (vo
return err
}
voucherNo = order.VoucherNo
orderNo = order.OrderNo
return nil
})

7
internal/biz/order.go
View File

@ -52,11 +52,14 @@ func (v *VoucherBiz) order(ctx context.Context, req *bo.OrderCreateReqBo, produc
func (v *VoucherBiz) orderRetry(ctx context.Context, order *bo.OrderBo) error {
voucherNo, err := v.WechatCpnRepo.Order(ctx, order)
if err != nil {
return v.fail(ctx, order, err.Error())
if err2 := v.fail(ctx, order, err.Error()); err2 != nil {
return err2
}
return err
}
order.VoucherNo = voucherNo
return v.success(ctx, order, voucherNo)
}

8
internal/data/repoimpl/base.go
View File

@ -2,17 +2,9 @@ package repoimpl
import (
"time"
err2 "voucher/api/err"
"voucher/internal/pkg/mapstructure"
)
var (
ErrOrderRecordNotFound = err2.ErrorOrderNotFound("订单不存在")
ErrProductRecordNotFound = err2.ErrorProductNotFound("商品不存在")
ErrOrderNotifyRecordNotFound = err2.ErrorDbNotFound("订单通知数据不存在")
ErrWechatNotifyRegisterTagRecordNotFound = err2.ErrorDbNotFound("微信注册tag数据不存在")
)
type Base[D any, B any] struct{}
func (*Base[D, B]) ToBo(d *D) *B {

9
internal/data/repoimpl/order.go
View File

@ -5,6 +5,7 @@ import (
"gorm.io/gorm"
"time"
"unicode/utf8"
err2 "voucher/api/err"
"voucher/internal/biz/bo"
"voucher/internal/biz/repo"
"voucher/internal/biz/vo"
@ -91,7 +92,7 @@ func (p *OrderRepoImpl) GetByOutBizNo(ctx context.Context, t vo.OrderType, outBi
}
if tx.RowsAffected == 0 {
return nil, ErrOrderRecordNotFound
return nil, err2.ErrorDbNotFound("订单数据不存在")
}
return p.ToBo(info), nil
@ -107,7 +108,7 @@ func (p *OrderRepoImpl) GetByID(ctx context.Context, id uint64) (*bo.OrderBo, er
}
if tx.RowsAffected == 0 {
return nil, ErrOrderRecordNotFound
return nil, err2.ErrorDbNotFound("订单数据不存在")
}
return p.ToBo(info), nil
@ -123,7 +124,7 @@ func (p *OrderRepoImpl) GetByOrderNo(ctx context.Context, orderNo string) (*bo.O
}
if tx.RowsAffected == 0 {
return nil, ErrOrderRecordNotFound
return nil, err2.ErrorDbNotFound("订单数据不存在")
}
return p.ToBo(info), nil
@ -139,7 +140,7 @@ func (p *OrderRepoImpl) GetByMBV(ctx context.Context, merchantNo, batchNo, vouch
}
if tx.RowsAffected == 0 {
return nil, ErrOrderRecordNotFound
return nil, err2.ErrorDbNotFound("订单数据不存在")
}
return p.ToBo(info), nil

3
internal/data/repoimpl/order_notify.go
View File

@ -5,6 +5,7 @@ import (
"gorm.io/gorm"
"time"
"unicode/utf8"
err2 "voucher/api/err"
"voucher/internal/biz/bo"
"voucher/internal/biz/repo"
"voucher/internal/biz/vo"
@ -37,7 +38,7 @@ func (p *OrderNotifyRepoImpl) GetByID(ctx context.Context, id uint64) (*bo.Order
}
if tx.RowsAffected == 0 {
return nil, ErrOrderNotifyRecordNotFound
return nil, err2.ErrorDbNotFound("订单通知数据不存在")
}
return p.ToBo(info), nil

3
internal/data/repoimpl/product.go
View File

@ -3,6 +3,7 @@ package repoimpl
import (
"context"
"gorm.io/gorm"
err2 "voucher/api/err"
"voucher/internal/biz/bo"
"voucher/internal/biz/repo"
"voucher/internal/data"
@ -34,7 +35,7 @@ func (r *ProductRepoImpl) GetByPNO(ctx context.Context, PNO string) (*bo.Product
}
if tx.RowsAffected == 0 {
return nil, ErrProductRecordNotFound
return nil, err2.ErrorDbNotFound("商品数据不存在")
}
return r.ToBo(&item), nil

3
internal/data/repoimpl/wechat_notify_register_tag.go
View File

@ -5,6 +5,7 @@ import (
"gorm.io/gorm"
"time"
"unicode/utf8"
err2 "voucher/api/err"
"voucher/internal/biz/bo"
"voucher/internal/biz/repo"
"voucher/internal/biz/vo"
@ -37,7 +38,7 @@ func (p *WechatNotifyRegisterTagRepoImpl) GetByStockIdAndMchId(ctx context.Conte
}
if tx.RowsAffected == 0 {
return nil, ErrWechatNotifyRegisterTagRecordNotFound
return nil, err2.ErrorDbNotFound("微信回调注册tag数据不存在")
}
return p.ToBo(info), nil

108
internal/data/wechatrepoimpl/cpn_code.go
View File

@ -222,64 +222,64 @@ var _ = map[ErrCode][]APIError{
// 使用常量定义错误描述，减少硬编码
const (
ErrorUserIllegal = "用户非法"
ErrorAppIDMchIDMismatch = "商户号与AppID不匹配"
ErrorOpenIDAppIDMismatch = "OpenID与AppID不匹配"
ErrorInvalidMerchantID = "非法的商户号"
ErrorHighFrequency = "调用频率过高"
ErrorActivityInactive = "活动已结束或未激活"
ErrorBatchInfoError = "批次信息获取失败，请确认参数是否有误"
ErrorAppIDRequired = "AppID必填"
ErrorOpenIDRequired = "OpenID必填"
ErrorBatchIDRequired = "批次号必填"
ErrorMerchantIDRequired = "商户号必填"
ErrorInvalidBatchStatus = "非法的批次状态"
ErrorMchNotExists = "商户号不合法"
ErrorBatchBudgetInsufficient = "批次预算不足"
ErrorDailyLimitExceeded = "发券超过单天限额"
ErrorAccountBalanceInsufficient = "账户余额不足，请充值"
ErrorBatchBudgetDepleted = "批次预算耗尽"
ErrorMerchantNoPermission = "商户无权发券"
ErrorCrossMerchantNotSupported = "批次不支持跨商户发券"
ErrorUserReceiveLimit = "用户被限领拦截"
ErrorAPIChannelNotSupported = "不能在API渠道发放"
ErrorSpecifiedDenominationNotSupported = "不支持指定面额发券"
ErrorOnlyAdvertisingBatch = "仅在广告场景下发放批次"
ErrorUserMaxCoupons = "用户已达最大领券次数"
ErrorNaturalPersonRuleBlocked = "被自然人规则拦截"
ErrorResourceNotExists = "批次不存在"
ErrorFrequencyLimited = "当前请求人数过多，请稍后重试"
ErrorWechatUserIllegal = "用户非法"
ErrorWechatAppIDMchIDMismatch = "商户号与AppID不匹配"
ErrorWechatOpenIDAppIDMismatch = "OpenID与AppID不匹配"
ErrorWechatInvalidMerchantID = "非法的商户号"
ErrorWechatHighFrequency = "调用频率过高"
ErrorWechatActivityInactive = "活动已结束或未激活"
ErrorWechatBatchInfoError = "批次信息获取失败，请确认参数是否有误"
ErrorWechatAppIDRequired = "AppID必填"
ErrorWechatOpenIDRequired = "OpenID必填"
ErrorWechatBatchIDRequired = "批次号必填"
ErrorWechatMerchantIDRequired = "商户号必填"
ErrorWechatInvalidBatchStatus = "非法的批次状态"
ErrorWechatMchNotExists = "商户号不合法"
ErrorWechatBatchBudgetInsufficient = "批次预算不足"
ErrorWechatDailyLimitExceeded = "发券超过单天限额"
ErrorWechatAccountBalanceInsufficient = "账户余额不足，请充值"
ErrorWechatBatchBudgetDepleted = "批次预算耗尽"
ErrorWechatMerchantNoPermission = "商户无权发券"
ErrorWechatCrossMerchantNotSupported = "批次不支持跨商户发券"
ErrorWechatUserReceiveLimit = "用户被限领拦截"
ErrorWechatAPIChannelNotSupported = "不能在API渠道发放"
ErrorWechatSpecifiedDenominationNotSupported = "不支持指定面额发券"
ErrorWechatOnlyAdvertisingBatch = "仅在广告场景下发放批次"
ErrorWechatUserMaxCoupons = "用户已达最大领券次数"
ErrorWechatNaturalPersonRuleBlocked = "被自然人规则拦截"
ErrorWechatResourceNotExists = "批次不存在"
ErrorWechatFrequencyLimited = "当前请求人数过多，请稍后重试"
)
// WechatError 映射错误描述到具体的错误处理
var WechatError = map[string]*errors.Error{
ErrorUserIllegal: err2.ErrorWechatUserIllegal(ErrorUserIllegal),
ErrorAppIDMchIDMismatch: err2.ErrorWechatMismatch(ErrorAppIDMchIDMismatch),
ErrorOpenIDAppIDMismatch: err2.ErrorWechatMismatch(ErrorOpenIDAppIDMismatch),
ErrorInvalidMerchantID: err2.ErrorWechatInvalidMerchantID(ErrorInvalidMerchantID),
ErrorHighFrequency: err2.ErrorWechatHighFrequency(ErrorHighFrequency),
ErrorActivityInactive: err2.ErrorWechatActivityInactive(ErrorActivityInactive),
ErrorBatchInfoError: err2.ErrorWechatBatchInfoError(ErrorBatchInfoError),
ErrorAppIDRequired: err2.ErrorWechatParamRequired(ErrorAppIDRequired),
ErrorOpenIDRequired: err2.ErrorWechatParamRequired(ErrorOpenIDRequired),
ErrorBatchIDRequired: err2.ErrorWechatParamRequired(ErrorBatchIDRequired),
ErrorMerchantIDRequired: err2.ErrorWechatParamRequired(ErrorMerchantIDRequired),
ErrorInvalidBatchStatus: err2.ErrorWechatInvalidBatchStatus(ErrorInvalidBatchStatus),
ErrorMchNotExists: err2.ErrorWechatMchNotExists(ErrorMchNotExists),
ErrorBatchBudgetInsufficient: err2.ErrorWechatBatchBudgetInsufficient(ErrorBatchBudgetInsufficient),
ErrorDailyLimitExceeded: err2.ErrorWechatDailyLimitExceeded(ErrorDailyLimitExceeded),
ErrorAccountBalanceInsufficient: err2.ErrorWechatAccountBalanceInsufficient(ErrorAccountBalanceInsufficient),
ErrorBatchBudgetDepleted: err2.ErrorWechatBatchBudgetDepleted(ErrorBatchBudgetDepleted),
ErrorMerchantNoPermission: err2.ErrorWechatMerchantNoPermission(ErrorMerchantNoPermission),
ErrorCrossMerchantNotSupported: err2.ErrorWechatCrossMerchantNotSupported(ErrorCrossMerchantNotSupported),
ErrorUserReceiveLimit: err2.ErrorWechatUserReceiveLimit(ErrorUserReceiveLimit),
ErrorAPIChannelNotSupported: err2.ErrorWechatAPIChannelNotSupported(ErrorAPIChannelNotSupported),
ErrorSpecifiedDenominationNotSupported: err2.ErrorWechatSpecifiedDenominationNotSupported(ErrorSpecifiedDenominationNotSupported),
ErrorOnlyAdvertisingBatch: err2.ErrorWechatOnlyAdvertisingBatch(ErrorOnlyAdvertisingBatch),
ErrorUserMaxCoupons: err2.ErrorWechatUserMaxCoupons(ErrorUserMaxCoupons),
ErrorNaturalPersonRuleBlocked: err2.ErrorWechatNaturalPersonRuleBlocked(ErrorNaturalPersonRuleBlocked),
ErrorResourceNotExists: err2.ErrorWechatResourceNotExists(ErrorResourceNotExists),
ErrorFrequencyLimited: err2.ErrorWechatFrequencyLimited(ErrorFrequencyLimited),
ErrorWechatUserIllegal: err2.ErrorWechatUserIllegal(ErrorWechatUserIllegal),
ErrorWechatAppIDMchIDMismatch: err2.ErrorWechatAppIDMchIDMismatch(ErrorWechatAppIDMchIDMismatch),
ErrorWechatOpenIDAppIDMismatch: err2.ErrorWechatOpenIDAppIDMismatch(ErrorWechatOpenIDAppIDMismatch),
ErrorWechatInvalidMerchantID: err2.ErrorWechatInvalidMerchantID(ErrorWechatInvalidMerchantID),
ErrorWechatHighFrequency: err2.ErrorWechatHighFrequency(ErrorWechatHighFrequency),
ErrorWechatActivityInactive: err2.ErrorWechatActivityInactive(ErrorWechatActivityInactive),
ErrorWechatBatchInfoError: err2.ErrorWechatBatchInfoError(ErrorWechatBatchInfoError),
ErrorWechatAppIDRequired: err2.ErrorWechatAppIDRequired(ErrorWechatAppIDRequired),
ErrorWechatOpenIDRequired: err2.ErrorWechatOpenIDRequired(ErrorWechatOpenIDRequired),
ErrorWechatBatchIDRequired: err2.ErrorWechatBatchIDRequired(ErrorWechatBatchIDRequired),
ErrorWechatMerchantIDRequired: err2.ErrorWechatMerchantIDRequired(ErrorWechatMerchantIDRequired),
ErrorWechatInvalidBatchStatus: err2.ErrorWechatInvalidBatchStatus(ErrorWechatInvalidBatchStatus),
ErrorWechatMchNotExists: err2.ErrorWechatMchNotExists(ErrorWechatMchNotExists),
ErrorWechatBatchBudgetInsufficient: err2.ErrorWechatBatchBudgetInsufficient(ErrorWechatBatchBudgetInsufficient),
ErrorWechatDailyLimitExceeded: err2.ErrorWechatDailyLimitExceeded(ErrorWechatDailyLimitExceeded),
ErrorWechatAccountBalanceInsufficient: err2.ErrorWechatAccountBalanceInsufficient(ErrorWechatAccountBalanceInsufficient),
ErrorWechatBatchBudgetDepleted: err2.ErrorWechatBatchBudgetDepleted(ErrorWechatBatchBudgetDepleted),
ErrorWechatMerchantNoPermission: err2.ErrorWechatMerchantNoPermission(ErrorWechatMerchantNoPermission),
ErrorWechatCrossMerchantNotSupported: err2.ErrorWechatCrossMerchantNotSupported(ErrorWechatCrossMerchantNotSupported),
ErrorWechatUserReceiveLimit: err2.ErrorWechatUserReceiveLimit(ErrorWechatUserReceiveLimit),
ErrorWechatAPIChannelNotSupported: err2.ErrorWechatAPIChannelNotSupported(ErrorWechatAPIChannelNotSupported),
ErrorWechatSpecifiedDenominationNotSupported: err2.ErrorWechatSpecifiedDenominationNotSupported(ErrorWechatSpecifiedDenominationNotSupported),
ErrorWechatOnlyAdvertisingBatch: err2.ErrorWechatOnlyAdvertisingBatch(ErrorWechatOnlyAdvertisingBatch),
ErrorWechatUserMaxCoupons: err2.ErrorWechatUserMaxCoupons(ErrorWechatUserMaxCoupons),
ErrorWechatNaturalPersonRuleBlocked: err2.ErrorWechatNaturalPersonRuleBlocked(ErrorWechatNaturalPersonRuleBlocked),
ErrorWechatResourceNotExists: err2.ErrorWechatResourceNotExists(ErrorWechatResourceNotExists),
ErrorWechatFrequencyLimited: err2.ErrorWechatFrequencyLimited(ErrorWechatFrequencyLimited),
}
type ErrBody struct {

5
internal/data/wechatrepoimpl/cpn_code_test.go
View File

@ -3,6 +3,7 @@ package wechatrepoimpl
import (
"errors"
errors2 "github.com/go-kratos/kratos/v2/errors"
"gorm.io/gorm"
"testing"
)
@ -12,6 +13,10 @@ func TestGetErrorByDescription(t *testing.T) {
Message: "活动已结束或未激活",
}
t.Log(e.GetWechatError())
err := gorm.ErrRecordNotFound
t.Log(errors.Is(err, gorm.ErrRecordNotFound))
}
func TestErr(t *testing.T) {

8
internal/service/cmb.go
View File

@ -20,7 +20,7 @@ func (s *VoucherService) CmbOrder(ctx http.Context) error {
bizReply *v1.CmbOrderReply
)
voucherNo, err := s.cmbOrder(ctx)
orderNo, err := s.cmbOrder(ctx)
if err != nil {
se := errors.FromError(err)
@ -41,7 +41,7 @@ func (s *VoucherService) CmbOrder(ctx http.Context) error {
bizReply = &v1.CmbOrderReply{
RespCode: vo.CmbResponseStatusSuccess.GetValue(),
RespMsg: "成功",
CodeNo: voucherNo,
CodeNo: orderNo,
}
}
@ -97,12 +97,12 @@ func (s *VoucherService) cmbOrder(ctx http.Context) (string, error) {
Type: vo.OrderTypeCmb,
}
voucherNo, err := s.VoucherBiz.CmbOrder(ctx, boReq)
orderNo, err := s.VoucherBiz.CmbOrder(ctx, boReq)
if err != nil {
return "", err
}
return voucherNo, nil
return orderNo, nil
}
func (s *VoucherService) CmbQuery(ctx http.Context) error {