From 84046e51e72fc54b1d70428b6ebc7e04cdd6d734 Mon Sep 17 00:00:00 2001 From: liangzai <2440983361@qq.com> Date: Tue, 21 Oct 2025 18:41:08 +0800 Subject: [PATCH] fix --- .../logic/pay/wechatpayrefundcallbacklogic.go | 27 +- app/main/model/orderRefundModel_gen.go | 81 ++-- deploy/script/gen_models.ps1 | 8 +- deploy/script/model/orderRefundModel.go | 27 ++ deploy/script/model/orderRefundModel_gen.go | 441 ++++++++++++++++++ 5 files changed, 523 insertions(+), 61 deletions(-) create mode 100644 deploy/script/model/orderRefundModel.go create mode 100644 deploy/script/model/orderRefundModel_gen.go diff --git a/app/main/api/internal/logic/pay/wechatpayrefundcallbacklogic.go b/app/main/api/internal/logic/pay/wechatpayrefundcallbacklogic.go index df1876b..9fa224d 100644 --- a/app/main/api/internal/logic/pay/wechatpayrefundcallbacklogic.go +++ b/app/main/api/internal/logic/pay/wechatpayrefundcallbacklogic.go @@ -5,6 +5,7 @@ import ( "database/sql" "hm-server/app/main/api/internal/svc" "hm-server/app/main/model" + "hm-server/common/globalkey" "net/http" "strings" "time" @@ -73,11 +74,11 @@ func (l *WechatPayRefundCallbackLogic) handleQueryOrderRefund(orderNo string, st } } - // 更新退款记录状态 - refund, err := l.svcCtx.OrderRefundModel.FindOneByOrderId(ctx, order.Id) + // 查找最新的pending状态的退款记录 + refund, err := l.findLatestPendingRefund(ctx, order.Id) if err != nil { if err == model.ErrNotFound { - logx.Errorf("未找到订单对应的退款记录: orderNo=%s, orderId=%d", orderNo, order.Id) + logx.Errorf("未找到订单对应的待处理退款记录: orderNo=%s, orderId=%d", orderNo, order.Id) return nil // 没有退款记录时不报错，只记录警告 } return errors.Wrapf(err, "查找退款记录失败: orderNo=%s", orderNo) @@ -213,3 +214,23 @@ func (l *WechatPayRefundCallbackLogic) WechatPayRefundCallback(w http.ResponseWr l.sendSuccessResponse(w) return nil } + +// findLatestPendingRefund 查找订单最新的pending状态退款记录 +func (l *WechatPayRefundCallbackLogic) findLatestPendingRefund(ctx context.Context, orderId int64) (*model.OrderRefund, error) { + // 使用SelectBuilder查询最新的pending状态退款记录 + builder := l.svcCtx.OrderRefundModel.SelectBuilder(). + Where("order_id = ? AND status = ? AND del_state = ?", orderId, model.OrderRefundStatusPending, globalkey.DelStateNo). + OrderBy("id DESC"). + Limit(1) + + refunds, err := l.svcCtx.OrderRefundModel.FindAll(ctx, builder, "") + if err != nil { + return nil, err + } + + if len(refunds) == 0 { + return nil, model.ErrNotFound + } + + return refunds[0], nil +} diff --git a/app/main/model/orderRefundModel_gen.go b/app/main/model/orderRefundModel_gen.go index 5e801b2..bf40094 100644 --- a/app/main/model/orderRefundModel_gen.go +++ b/app/main/model/orderRefundModel_gen.go @@ -10,8 +10,6 @@ import ( "time" - "hm-server/common/globalkey" - "github.com/Masterminds/squirrel" "github.com/pkg/errors" "github.com/zeromicro/go-zero/core/stores/builder" @@ -19,6 +17,7 @@ import ( "github.com/zeromicro/go-zero/core/stores/sqlc" "github.com/zeromicro/go-zero/core/stores/sqlx" "github.com/zeromicro/go-zero/core/stringx" + "hm-server/common/globalkey" ) var ( @@ -27,17 +26,15 @@ var ( orderRefundRowsExpectAutoSet = strings.Join(stringx.Remove(orderRefundFieldNames, "`id`", "`create_time`", "`update_time`"), ",") orderRefundRowsWithPlaceHolder = strings.Join(stringx.Remove(orderRefundFieldNames, "`id`", "`create_time`", "`update_time`"), "=?,") + "=?" - cacheHmOrderRefundIdPrefix = "cache:hm:orderRefund:id:" - cacheHmOrderRefundOrderIdPrefix = "cache:hm:orderRefund:orderId:" - cacheHmOrderRefundPlatformRefundIdPrefix = "cache:hm:orderRefund:platformRefundId:" - cacheHmOrderRefundRefundNoPrefix = "cache:hm:orderRefund:refundNo:" + cacheTydataOrderRefundIdPrefix = "cache:tydata:orderRefund:id:" + cacheTydataOrderRefundPlatformRefundIdPrefix = "cache:tydata:orderRefund:platformRefundId:" + cacheTydataOrderRefundRefundNoPrefix = "cache:tydata:orderRefund:refundNo:" ) type ( orderRefundModel interface { Insert(ctx context.Context, session sqlx.Session, data *OrderRefund) (sql.Result, error) FindOne(ctx context.Context, id int64) (*OrderRefund, error) - FindOneByOrderId(ctx context.Context, orderId int64) (*OrderRefund, error) FindOneByPlatformRefundId(ctx context.Context, platformRefundId sql.NullString) (*OrderRefund, error) FindOneByRefundNo(ctx context.Context, refundNo string) (*OrderRefund, error) Update(ctx context.Context, session sqlx.Session, data *OrderRefund) (sql.Result, error) @@ -89,23 +86,22 @@ func newOrderRefundModel(conn sqlx.SqlConn, c cache.CacheConf) *defaultOrderRefu func (m *defaultOrderRefundModel) Insert(ctx context.Context, session sqlx.Session, data *OrderRefund) (sql.Result, error) { data.DelState = globalkey.DelStateNo - hmOrderRefundIdKey := fmt.Sprintf("%s%v", cacheHmOrderRefundIdPrefix, data.Id) - hmOrderRefundOrderIdKey := fmt.Sprintf("%s%v", cacheHmOrderRefundOrderIdPrefix, data.OrderId) - hmOrderRefundPlatformRefundIdKey := fmt.Sprintf("%s%v", cacheHmOrderRefundPlatformRefundIdPrefix, data.PlatformRefundId) - hmOrderRefundRefundNoKey := fmt.Sprintf("%s%v", cacheHmOrderRefundRefundNoPrefix, data.RefundNo) + tydataOrderRefundIdKey := fmt.Sprintf("%s%v", cacheTydataOrderRefundIdPrefix, data.Id) + tydataOrderRefundPlatformRefundIdKey := fmt.Sprintf("%s%v", cacheTydataOrderRefundPlatformRefundIdPrefix, data.PlatformRefundId) + tydataOrderRefundRefundNoKey := fmt.Sprintf("%s%v", cacheTydataOrderRefundRefundNoPrefix, data.RefundNo) return m.ExecCtx(ctx, func(ctx context.Context, conn sqlx.SqlConn) (result sql.Result, err error) { query := fmt.Sprintf("insert into %s (%s) values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", m.table, orderRefundRowsExpectAutoSet) if session != nil { return session.ExecCtx(ctx, query, data.RefundNo, data.OrderId, data.UserId, data.ProductId, data.PlatformRefundId, data.RefundAmount, data.RefundReason, data.Status, data.DelState, data.Version, data.RefundTime, data.CloseTime, data.DeleteTime) } return conn.ExecCtx(ctx, query, data.RefundNo, data.OrderId, data.UserId, data.ProductId, data.PlatformRefundId, data.RefundAmount, data.RefundReason, data.Status, data.DelState, data.Version, data.RefundTime, data.CloseTime, data.DeleteTime) - }, hmOrderRefundIdKey, hmOrderRefundOrderIdKey, hmOrderRefundPlatformRefundIdKey, hmOrderRefundRefundNoKey) + }, tydataOrderRefundIdKey, tydataOrderRefundPlatformRefundIdKey, tydataOrderRefundRefundNoKey) } func (m *defaultOrderRefundModel) FindOne(ctx context.Context, id int64) (*OrderRefund, error) { - hmOrderRefundIdKey := fmt.Sprintf("%s%v", cacheHmOrderRefundIdPrefix, id) + tydataOrderRefundIdKey := fmt.Sprintf("%s%v", cacheTydataOrderRefundIdPrefix, id) var resp OrderRefund - err := m.QueryRowCtx(ctx, &resp, hmOrderRefundIdKey, func(ctx context.Context, conn sqlx.SqlConn, v interface{}) error { + err := m.QueryRowCtx(ctx, &resp, tydataOrderRefundIdKey, func(ctx context.Context, conn sqlx.SqlConn, v interface{}) error { query := fmt.Sprintf("select %s from %s where `id` = ? and del_state = ? limit 1", orderRefundRows, m.table) return conn.QueryRowCtx(ctx, v, query, id, globalkey.DelStateNo) }) @@ -119,30 +115,10 @@ func (m *defaultOrderRefundModel) FindOne(ctx context.Context, id int64) (*Order } } -func (m *defaultOrderRefundModel) FindOneByOrderId(ctx context.Context, orderId int64) (*OrderRefund, error) { - hmOrderRefundOrderIdKey := fmt.Sprintf("%s%v", cacheHmOrderRefundOrderIdPrefix, orderId) - var resp OrderRefund - err := m.QueryRowIndexCtx(ctx, &resp, hmOrderRefundOrderIdKey, m.formatPrimary, func(ctx context.Context, conn sqlx.SqlConn, v interface{}) (i interface{}, e error) { - query := fmt.Sprintf("select %s from %s where `order_id` = ? and del_state = ? limit 1", orderRefundRows, m.table) - if err := conn.QueryRowCtx(ctx, &resp, query, orderId, globalkey.DelStateNo); err != nil { - return nil, err - } - return resp.Id, nil - }, m.queryPrimary) - switch err { - case nil: - return &resp, nil - case sqlc.ErrNotFound: - return nil, ErrNotFound - default: - return nil, err - } -} - func (m *defaultOrderRefundModel) FindOneByPlatformRefundId(ctx context.Context, platformRefundId sql.NullString) (*OrderRefund, error) { - hmOrderRefundPlatformRefundIdKey := fmt.Sprintf("%s%v", cacheHmOrderRefundPlatformRefundIdPrefix, platformRefundId) + tydataOrderRefundPlatformRefundIdKey := fmt.Sprintf("%s%v", cacheTydataOrderRefundPlatformRefundIdPrefix, platformRefundId) var resp OrderRefund - err := m.QueryRowIndexCtx(ctx, &resp, hmOrderRefundPlatformRefundIdKey, m.formatPrimary, func(ctx context.Context, conn sqlx.SqlConn, v interface{}) (i interface{}, e error) { + err := m.QueryRowIndexCtx(ctx, &resp, tydataOrderRefundPlatformRefundIdKey, m.formatPrimary, func(ctx context.Context, conn sqlx.SqlConn, v interface{}) (i interface{}, e error) { query := fmt.Sprintf("select %s from %s where `platform_refund_id` = ? and del_state = ? limit 1", orderRefundRows, m.table) if err := conn.QueryRowCtx(ctx, &resp, query, platformRefundId, globalkey.DelStateNo); err != nil { return nil, err @@ -160,9 +136,9 @@ func (m *defaultOrderRefundModel) FindOneByPlatformRefundId(ctx context.Context, } func (m *defaultOrderRefundModel) FindOneByRefundNo(ctx context.Context, refundNo string) (*OrderRefund, error) { - hmOrderRefundRefundNoKey := fmt.Sprintf("%s%v", cacheHmOrderRefundRefundNoPrefix, refundNo) + tydataOrderRefundRefundNoKey := fmt.Sprintf("%s%v", cacheTydataOrderRefundRefundNoPrefix, refundNo) var resp OrderRefund - err := m.QueryRowIndexCtx(ctx, &resp, hmOrderRefundRefundNoKey, m.formatPrimary, func(ctx context.Context, conn sqlx.SqlConn, v interface{}) (i interface{}, e error) { + err := m.QueryRowIndexCtx(ctx, &resp, tydataOrderRefundRefundNoKey, m.formatPrimary, func(ctx context.Context, conn sqlx.SqlConn, v interface{}) (i interface{}, e error) { query := fmt.Sprintf("select %s from %s where `refund_no` = ? and del_state = ? limit 1", orderRefundRows, m.table) if err := conn.QueryRowCtx(ctx, &resp, query, refundNo, globalkey.DelStateNo); err != nil { return nil, err @@ -184,17 +160,16 @@ func (m *defaultOrderRefundModel) Update(ctx context.Context, session sqlx.Sessi if err != nil { return nil, err } - hmOrderRefundIdKey := fmt.Sprintf("%s%v", cacheHmOrderRefundIdPrefix, data.Id) - hmOrderRefundOrderIdKey := fmt.Sprintf("%s%v", cacheHmOrderRefundOrderIdPrefix, data.OrderId) - hmOrderRefundPlatformRefundIdKey := fmt.Sprintf("%s%v", cacheHmOrderRefundPlatformRefundIdPrefix, data.PlatformRefundId) - hmOrderRefundRefundNoKey := fmt.Sprintf("%s%v", cacheHmOrderRefundRefundNoPrefix, data.RefundNo) + tydataOrderRefundIdKey := fmt.Sprintf("%s%v", cacheTydataOrderRefundIdPrefix, data.Id) + tydataOrderRefundPlatformRefundIdKey := fmt.Sprintf("%s%v", cacheTydataOrderRefundPlatformRefundIdPrefix, data.PlatformRefundId) + tydataOrderRefundRefundNoKey := fmt.Sprintf("%s%v", cacheTydataOrderRefundRefundNoPrefix, data.RefundNo) return m.ExecCtx(ctx, func(ctx context.Context, conn sqlx.SqlConn) (result sql.Result, err error) { query := fmt.Sprintf("update %s set %s where `id` = ?", m.table, orderRefundRowsWithPlaceHolder) if session != nil { return session.ExecCtx(ctx, query, newData.RefundNo, newData.OrderId, newData.UserId, newData.ProductId, newData.PlatformRefundId, newData.RefundAmount, newData.RefundReason, newData.Status, newData.DelState, newData.Version, newData.RefundTime, newData.CloseTime, newData.DeleteTime, newData.Id) } return conn.ExecCtx(ctx, query, newData.RefundNo, newData.OrderId, newData.UserId, newData.ProductId, newData.PlatformRefundId, newData.RefundAmount, newData.RefundReason, newData.Status, newData.DelState, newData.Version, newData.RefundTime, newData.CloseTime, newData.DeleteTime, newData.Id) - }, hmOrderRefundIdKey, hmOrderRefundOrderIdKey, hmOrderRefundPlatformRefundIdKey, hmOrderRefundRefundNoKey) + }, tydataOrderRefundIdKey, tydataOrderRefundPlatformRefundIdKey, tydataOrderRefundRefundNoKey) } func (m *defaultOrderRefundModel) UpdateWithVersion(ctx context.Context, session sqlx.Session, newData *OrderRefund) error { @@ -209,17 +184,16 @@ func (m *defaultOrderRefundModel) UpdateWithVersion(ctx context.Context, session if err != nil { return err } - hmOrderRefundIdKey := fmt.Sprintf("%s%v", cacheHmOrderRefundIdPrefix, data.Id) - hmOrderRefundOrderIdKey := fmt.Sprintf("%s%v", cacheHmOrderRefundOrderIdPrefix, data.OrderId) - hmOrderRefundPlatformRefundIdKey := fmt.Sprintf("%s%v", cacheHmOrderRefundPlatformRefundIdPrefix, data.PlatformRefundId) - hmOrderRefundRefundNoKey := fmt.Sprintf("%s%v", cacheHmOrderRefundRefundNoPrefix, data.RefundNo) + tydataOrderRefundIdKey := fmt.Sprintf("%s%v", cacheTydataOrderRefundIdPrefix, data.Id) + tydataOrderRefundPlatformRefundIdKey := fmt.Sprintf("%s%v", cacheTydataOrderRefundPlatformRefundIdPrefix, data.PlatformRefundId) + tydataOrderRefundRefundNoKey := fmt.Sprintf("%s%v", cacheTydataOrderRefundRefundNoPrefix, data.RefundNo) sqlResult, err = m.ExecCtx(ctx, func(ctx context.Context, conn sqlx.SqlConn) (result sql.Result, err error) { query := fmt.Sprintf("update %s set %s where `id` = ? and version = ? ", m.table, orderRefundRowsWithPlaceHolder) if session != nil { return session.ExecCtx(ctx, query, newData.RefundNo, newData.OrderId, newData.UserId, newData.ProductId, newData.PlatformRefundId, newData.RefundAmount, newData.RefundReason, newData.Status, newData.DelState, newData.Version, newData.RefundTime, newData.CloseTime, newData.DeleteTime, newData.Id, oldVersion) } return conn.ExecCtx(ctx, query, newData.RefundNo, newData.OrderId, newData.UserId, newData.ProductId, newData.PlatformRefundId, newData.RefundAmount, newData.RefundReason, newData.Status, newData.DelState, newData.Version, newData.RefundTime, newData.CloseTime, newData.DeleteTime, newData.Id, oldVersion) - }, hmOrderRefundIdKey, hmOrderRefundOrderIdKey, hmOrderRefundPlatformRefundIdKey, hmOrderRefundRefundNoKey) + }, tydataOrderRefundIdKey, tydataOrderRefundPlatformRefundIdKey, tydataOrderRefundRefundNoKey) if err != nil { return err } @@ -442,21 +416,20 @@ func (m *defaultOrderRefundModel) Delete(ctx context.Context, session sqlx.Sessi return err } - hmOrderRefundIdKey := fmt.Sprintf("%s%v", cacheHmOrderRefundIdPrefix, id) - hmOrderRefundOrderIdKey := fmt.Sprintf("%s%v", cacheHmOrderRefundOrderIdPrefix, data.OrderId) - hmOrderRefundPlatformRefundIdKey := fmt.Sprintf("%s%v", cacheHmOrderRefundPlatformRefundIdPrefix, data.PlatformRefundId) - hmOrderRefundRefundNoKey := fmt.Sprintf("%s%v", cacheHmOrderRefundRefundNoPrefix, data.RefundNo) + tydataOrderRefundIdKey := fmt.Sprintf("%s%v", cacheTydataOrderRefundIdPrefix, id) + tydataOrderRefundPlatformRefundIdKey := fmt.Sprintf("%s%v", cacheTydataOrderRefundPlatformRefundIdPrefix, data.PlatformRefundId) + tydataOrderRefundRefundNoKey := fmt.Sprintf("%s%v", cacheTydataOrderRefundRefundNoPrefix, data.RefundNo) _, err = m.ExecCtx(ctx, func(ctx context.Context, conn sqlx.SqlConn) (result sql.Result, err error) { query := fmt.Sprintf("delete from %s where `id` = ?", m.table) if session != nil { return session.ExecCtx(ctx, query, id) } return conn.ExecCtx(ctx, query, id) - }, hmOrderRefundIdKey, hmOrderRefundOrderIdKey, hmOrderRefundPlatformRefundIdKey, hmOrderRefundRefundNoKey) + }, tydataOrderRefundIdKey, tydataOrderRefundPlatformRefundIdKey, tydataOrderRefundRefundNoKey) return err } func (m *defaultOrderRefundModel) formatPrimary(primary interface{}) string { - return fmt.Sprintf("%s%v", cacheHmOrderRefundIdPrefix, primary) + return fmt.Sprintf("%s%v", cacheTydataOrderRefundIdPrefix, primary) } func (m *defaultOrderRefundModel) queryPrimary(ctx context.Context, conn sqlx.SqlConn, v, primary interface{}) error { query := fmt.Sprintf("select %s from %s where `id` = ? and del_state = ? limit 1", orderRefundRows, m.table) diff --git a/deploy/script/gen_models.ps1 b/deploy/script/gen_models.ps1 index 852b980..3e6c3b6 100644 --- a/deploy/script/gen_models.ps1 +++ b/deploy/script/gen_models.ps1 @@ -1,7 +1,7 @@ # 设置输出编码为UTF-8 [Console]::OutputEncoding = [System.Text.Encoding]::UTF8 # 数据库连接信息 - 修改了URL格式 -$DB_URL = "hm:5vg67b3UNHu8@(127.0.0.1:21001)/hm" +$DB_URL = "tydata:5vg67b3UNHu8@(127.0.0.1:21001)/tydata" $OUTPUT_DIR = "./model" $TEMPLATE_DIR = "../template" @@ -24,12 +24,12 @@ $tables = @( # "agent_wallet", # "agent_real_name" # "agent_withdrawal" - "agent_withdrawal_tax" + # "agent_withdrawal_tax" # "agent_withdrawal_tax_exemption" # "feature", # "global_notifications" # "order", - # "order_refund" + "order_refund" # "product", # "product_feature", # "query", @@ -58,5 +58,5 @@ $tables = @( # 为每个表生成模型 foreach ($table in $tables) { - goctl model mysql datasource -url="hm:5vg67b3UNHu8@tcp(127.0.0.1:21001)/hm" -table="$table" -dir="./model" --home="../template" -cache=true --style=goZero + goctl model mysql datasource -url="tydata:5vg67b3UNHu8@tcp(127.0.0.1:21001)/tydata" -table="$table" -dir="./model" --home="../template" -cache=true --style=goZero } diff --git a/deploy/script/model/orderRefundModel.go b/deploy/script/model/orderRefundModel.go new file mode 100644 index 0000000..92c3174 --- /dev/null +++ b/deploy/script/model/orderRefundModel.go @@ -0,0 +1,27 @@ +package model + +import ( + "github.com/zeromicro/go-zero/core/stores/cache" + "github.com/zeromicro/go-zero/core/stores/sqlx" +) + +var _ OrderRefundModel = (*customOrderRefundModel)(nil) + +type ( + // OrderRefundModel is an interface to be customized, add more methods here, + // and implement the added methods in customOrderRefundModel. + OrderRefundModel interface { + orderRefundModel + } + + customOrderRefundModel struct { + *defaultOrderRefundModel + } +) + +// NewOrderRefundModel returns a model for the database table. +func NewOrderRefundModel(conn sqlx.SqlConn, c cache.CacheConf) OrderRefundModel { + return &customOrderRefundModel{ + defaultOrderRefundModel: newOrderRefundModel(conn, c), + } +} diff --git a/deploy/script/model/orderRefundModel_gen.go b/deploy/script/model/orderRefundModel_gen.go new file mode 100644 index 0000000..bf40094 --- /dev/null +++ b/deploy/script/model/orderRefundModel_gen.go @@ -0,0 +1,441 @@ +// Code generated by goctl. DO NOT EDIT! + +package model + +import ( + "context" + "database/sql" + "fmt" + "strings" + + "time" + + "github.com/Masterminds/squirrel" + "github.com/pkg/errors" + "github.com/zeromicro/go-zero/core/stores/builder" + "github.com/zeromicro/go-zero/core/stores/cache" + "github.com/zeromicro/go-zero/core/stores/sqlc" + "github.com/zeromicro/go-zero/core/stores/sqlx" + "github.com/zeromicro/go-zero/core/stringx" + "hm-server/common/globalkey" +) + +var ( + orderRefundFieldNames = builder.RawFieldNames(&OrderRefund{}) + orderRefundRows = strings.Join(orderRefundFieldNames, ",") + orderRefundRowsExpectAutoSet = strings.Join(stringx.Remove(orderRefundFieldNames, "`id`", "`create_time`", "`update_time`"), ",") + orderRefundRowsWithPlaceHolder = strings.Join(stringx.Remove(orderRefundFieldNames, "`id`", "`create_time`", "`update_time`"), "=?,") + "=?" + + cacheTydataOrderRefundIdPrefix = "cache:tydata:orderRefund:id:" + cacheTydataOrderRefundPlatformRefundIdPrefix = "cache:tydata:orderRefund:platformRefundId:" + cacheTydataOrderRefundRefundNoPrefix = "cache:tydata:orderRefund:refundNo:" +) + +type ( + orderRefundModel interface { + Insert(ctx context.Context, session sqlx.Session, data *OrderRefund) (sql.Result, error) + FindOne(ctx context.Context, id int64) (*OrderRefund, error) + FindOneByPlatformRefundId(ctx context.Context, platformRefundId sql.NullString) (*OrderRefund, error) + FindOneByRefundNo(ctx context.Context, refundNo string) (*OrderRefund, error) + Update(ctx context.Context, session sqlx.Session, data *OrderRefund) (sql.Result, error) + UpdateWithVersion(ctx context.Context, session sqlx.Session, data *OrderRefund) error + Trans(ctx context.Context, fn func(context context.Context, session sqlx.Session) error) error + SelectBuilder() squirrel.SelectBuilder + DeleteSoft(ctx context.Context, session sqlx.Session, data *OrderRefund) error + FindSum(ctx context.Context, sumBuilder squirrel.SelectBuilder, field string) (float64, error) + FindCount(ctx context.Context, countBuilder squirrel.SelectBuilder, field string) (int64, error) + FindAll(ctx context.Context, rowBuilder squirrel.SelectBuilder, orderBy string) ([]*OrderRefund, error) + FindPageListByPage(ctx context.Context, rowBuilder squirrel.SelectBuilder, page, pageSize int64, orderBy string) ([]*OrderRefund, error) + FindPageListByPageWithTotal(ctx context.Context, rowBuilder squirrel.SelectBuilder, page, pageSize int64, orderBy string) ([]*OrderRefund, int64, error) + FindPageListByIdDESC(ctx context.Context, rowBuilder squirrel.SelectBuilder, preMinId, pageSize int64) ([]*OrderRefund, error) + FindPageListByIdASC(ctx context.Context, rowBuilder squirrel.SelectBuilder, preMaxId, pageSize int64) ([]*OrderRefund, error) + Delete(ctx context.Context, session sqlx.Session, id int64) error + } + + defaultOrderRefundModel struct { + sqlc.CachedConn + table string + } + + OrderRefund struct { + Id int64 `db:"id"` // 主键ID + RefundNo string `db:"refund_no"` // 退款单号 + OrderId int64 `db:"order_id"` // 关联的订单ID + UserId int64 `db:"user_id"` // 用户ID + ProductId int64 `db:"product_id"` // 产品ID + PlatformRefundId sql.NullString `db:"platform_refund_id"` // 支付平台退款单号 + RefundAmount float64 `db:"refund_amount"` // 退款金额 + RefundReason sql.NullString `db:"refund_reason"` // 退款原因 + Status string `db:"status"` // 退款状态 + DelState int64 `db:"del_state"` // 删除状态 + Version int64 `db:"version"` // 版本号 + CreateTime time.Time `db:"create_time"` // 创建时间 + UpdateTime time.Time `db:"update_time"` // 更新时间 + RefundTime sql.NullTime `db:"refund_time"` // 退款成功时间 + CloseTime sql.NullTime `db:"close_time"` // 退款关闭时间 + DeleteTime sql.NullTime `db:"delete_time"` // 删除时间 + } +) + +func newOrderRefundModel(conn sqlx.SqlConn, c cache.CacheConf) *defaultOrderRefundModel { + return &defaultOrderRefundModel{ + CachedConn: sqlc.NewConn(conn, c), + table: "`order_refund`", + } +} + +func (m *defaultOrderRefundModel) Insert(ctx context.Context, session sqlx.Session, data *OrderRefund) (sql.Result, error) { + data.DelState = globalkey.DelStateNo + tydataOrderRefundIdKey := fmt.Sprintf("%s%v", cacheTydataOrderRefundIdPrefix, data.Id) + tydataOrderRefundPlatformRefundIdKey := fmt.Sprintf("%s%v", cacheTydataOrderRefundPlatformRefundIdPrefix, data.PlatformRefundId) + tydataOrderRefundRefundNoKey := fmt.Sprintf("%s%v", cacheTydataOrderRefundRefundNoPrefix, data.RefundNo) + return m.ExecCtx(ctx, func(ctx context.Context, conn sqlx.SqlConn) (result sql.Result, err error) { + query := fmt.Sprintf("insert into %s (%s) values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", m.table, orderRefundRowsExpectAutoSet) + if session != nil { + return session.ExecCtx(ctx, query, data.RefundNo, data.OrderId, data.UserId, data.ProductId, data.PlatformRefundId, data.RefundAmount, data.RefundReason, data.Status, data.DelState, data.Version, data.RefundTime, data.CloseTime, data.DeleteTime) + } + return conn.ExecCtx(ctx, query, data.RefundNo, data.OrderId, data.UserId, data.ProductId, data.PlatformRefundId, data.RefundAmount, data.RefundReason, data.Status, data.DelState, data.Version, data.RefundTime, data.CloseTime, data.DeleteTime) + }, tydataOrderRefundIdKey, tydataOrderRefundPlatformRefundIdKey, tydataOrderRefundRefundNoKey) +} + +func (m *defaultOrderRefundModel) FindOne(ctx context.Context, id int64) (*OrderRefund, error) { + tydataOrderRefundIdKey := fmt.Sprintf("%s%v", cacheTydataOrderRefundIdPrefix, id) + var resp OrderRefund + err := m.QueryRowCtx(ctx, &resp, tydataOrderRefundIdKey, func(ctx context.Context, conn sqlx.SqlConn, v interface{}) error { + query := fmt.Sprintf("select %s from %s where `id` = ? and del_state = ? limit 1", orderRefundRows, m.table) + return conn.QueryRowCtx(ctx, v, query, id, globalkey.DelStateNo) + }) + switch err { + case nil: + return &resp, nil + case sqlc.ErrNotFound: + return nil, ErrNotFound + default: + return nil, err + } +} + +func (m *defaultOrderRefundModel) FindOneByPlatformRefundId(ctx context.Context, platformRefundId sql.NullString) (*OrderRefund, error) { + tydataOrderRefundPlatformRefundIdKey := fmt.Sprintf("%s%v", cacheTydataOrderRefundPlatformRefundIdPrefix, platformRefundId) + var resp OrderRefund + err := m.QueryRowIndexCtx(ctx, &resp, tydataOrderRefundPlatformRefundIdKey, m.formatPrimary, func(ctx context.Context, conn sqlx.SqlConn, v interface{}) (i interface{}, e error) { + query := fmt.Sprintf("select %s from %s where `platform_refund_id` = ? and del_state = ? limit 1", orderRefundRows, m.table) + if err := conn.QueryRowCtx(ctx, &resp, query, platformRefundId, globalkey.DelStateNo); err != nil { + return nil, err + } + return resp.Id, nil + }, m.queryPrimary) + switch err { + case nil: + return &resp, nil + case sqlc.ErrNotFound: + return nil, ErrNotFound + default: + return nil, err + } +} + +func (m *defaultOrderRefundModel) FindOneByRefundNo(ctx context.Context, refundNo string) (*OrderRefund, error) { + tydataOrderRefundRefundNoKey := fmt.Sprintf("%s%v", cacheTydataOrderRefundRefundNoPrefix, refundNo) + var resp OrderRefund + err := m.QueryRowIndexCtx(ctx, &resp, tydataOrderRefundRefundNoKey, m.formatPrimary, func(ctx context.Context, conn sqlx.SqlConn, v interface{}) (i interface{}, e error) { + query := fmt.Sprintf("select %s from %s where `refund_no` = ? and del_state = ? limit 1", orderRefundRows, m.table) + if err := conn.QueryRowCtx(ctx, &resp, query, refundNo, globalkey.DelStateNo); err != nil { + return nil, err + } + return resp.Id, nil + }, m.queryPrimary) + switch err { + case nil: + return &resp, nil + case sqlc.ErrNotFound: + return nil, ErrNotFound + default: + return nil, err + } +} + +func (m *defaultOrderRefundModel) Update(ctx context.Context, session sqlx.Session, newData *OrderRefund) (sql.Result, error) { + data, err := m.FindOne(ctx, newData.Id) + if err != nil { + return nil, err + } + tydataOrderRefundIdKey := fmt.Sprintf("%s%v", cacheTydataOrderRefundIdPrefix, data.Id) + tydataOrderRefundPlatformRefundIdKey := fmt.Sprintf("%s%v", cacheTydataOrderRefundPlatformRefundIdPrefix, data.PlatformRefundId) + tydataOrderRefundRefundNoKey := fmt.Sprintf("%s%v", cacheTydataOrderRefundRefundNoPrefix, data.RefundNo) + return m.ExecCtx(ctx, func(ctx context.Context, conn sqlx.SqlConn) (result sql.Result, err error) { + query := fmt.Sprintf("update %s set %s where `id` = ?", m.table, orderRefundRowsWithPlaceHolder) + if session != nil { + return session.ExecCtx(ctx, query, newData.RefundNo, newData.OrderId, newData.UserId, newData.ProductId, newData.PlatformRefundId, newData.RefundAmount, newData.RefundReason, newData.Status, newData.DelState, newData.Version, newData.RefundTime, newData.CloseTime, newData.DeleteTime, newData.Id) + } + return conn.ExecCtx(ctx, query, newData.RefundNo, newData.OrderId, newData.UserId, newData.ProductId, newData.PlatformRefundId, newData.RefundAmount, newData.RefundReason, newData.Status, newData.DelState, newData.Version, newData.RefundTime, newData.CloseTime, newData.DeleteTime, newData.Id) + }, tydataOrderRefundIdKey, tydataOrderRefundPlatformRefundIdKey, tydataOrderRefundRefundNoKey) +} + +func (m *defaultOrderRefundModel) UpdateWithVersion(ctx context.Context, session sqlx.Session, newData *OrderRefund) error { + + oldVersion := newData.Version + newData.Version += 1 + + var sqlResult sql.Result + var err error + + data, err := m.FindOne(ctx, newData.Id) + if err != nil { + return err + } + tydataOrderRefundIdKey := fmt.Sprintf("%s%v", cacheTydataOrderRefundIdPrefix, data.Id) + tydataOrderRefundPlatformRefundIdKey := fmt.Sprintf("%s%v", cacheTydataOrderRefundPlatformRefundIdPrefix, data.PlatformRefundId) + tydataOrderRefundRefundNoKey := fmt.Sprintf("%s%v", cacheTydataOrderRefundRefundNoPrefix, data.RefundNo) + sqlResult, err = m.ExecCtx(ctx, func(ctx context.Context, conn sqlx.SqlConn) (result sql.Result, err error) { + query := fmt.Sprintf("update %s set %s where `id` = ? and version = ? ", m.table, orderRefundRowsWithPlaceHolder) + if session != nil { + return session.ExecCtx(ctx, query, newData.RefundNo, newData.OrderId, newData.UserId, newData.ProductId, newData.PlatformRefundId, newData.RefundAmount, newData.RefundReason, newData.Status, newData.DelState, newData.Version, newData.RefundTime, newData.CloseTime, newData.DeleteTime, newData.Id, oldVersion) + } + return conn.ExecCtx(ctx, query, newData.RefundNo, newData.OrderId, newData.UserId, newData.ProductId, newData.PlatformRefundId, newData.RefundAmount, newData.RefundReason, newData.Status, newData.DelState, newData.Version, newData.RefundTime, newData.CloseTime, newData.DeleteTime, newData.Id, oldVersion) + }, tydataOrderRefundIdKey, tydataOrderRefundPlatformRefundIdKey, tydataOrderRefundRefundNoKey) + if err != nil { + return err + } + updateCount, err := sqlResult.RowsAffected() + if err != nil { + return err + } + if updateCount == 0 { + return ErrNoRowsUpdate + } + + return nil +} + +func (m *defaultOrderRefundModel) DeleteSoft(ctx context.Context, session sqlx.Session, data *OrderRefund) error { + data.DelState = globalkey.DelStateYes + data.DeleteTime = sql.NullTime{Time: time.Now(), Valid: true} + if err := m.UpdateWithVersion(ctx, session, data); err != nil { + return errors.Wrapf(errors.New("delete soft failed "), "OrderRefundModel delete err : %+v", err) + } + return nil +} + +func (m *defaultOrderRefundModel) FindSum(ctx context.Context, builder squirrel.SelectBuilder, field string) (float64, error) { + + if len(field) == 0 { + return 0, errors.Wrapf(errors.New("FindSum Least One Field"), "FindSum Least One Field") + } + + builder = builder.Columns("IFNULL(SUM(" + field + "),0)") + + query, values, err := builder.Where("del_state = ?", globalkey.DelStateNo).ToSql() + if err != nil { + return 0, err + } + + var resp float64 + err = m.QueryRowNoCacheCtx(ctx, &resp, query, values...) + switch err { + case nil: + return resp, nil + default: + return 0, err + } +} + +func (m *defaultOrderRefundModel) FindCount(ctx context.Context, builder squirrel.SelectBuilder, field string) (int64, error) { + + if len(field) == 0 { + return 0, errors.Wrapf(errors.New("FindCount Least One Field"), "FindCount Least One Field") + } + + builder = builder.Columns("COUNT(" + field + ")") + + query, values, err := builder.Where("del_state = ?", globalkey.DelStateNo).ToSql() + if err != nil { + return 0, err + } + + var resp int64 + err = m.QueryRowNoCacheCtx(ctx, &resp, query, values...) + switch err { + case nil: + return resp, nil + default: + return 0, err + } +} + +func (m *defaultOrderRefundModel) FindAll(ctx context.Context, builder squirrel.SelectBuilder, orderBy string) ([]*OrderRefund, error) { + + builder = builder.Columns(orderRefundRows) + + if orderBy == "" { + builder = builder.OrderBy("id DESC") + } else { + builder = builder.OrderBy(orderBy) + } + + query, values, err := builder.Where("del_state = ?", globalkey.DelStateNo).ToSql() + if err != nil { + return nil, err + } + + var resp []*OrderRefund + err = m.QueryRowsNoCacheCtx(ctx, &resp, query, values...) + switch err { + case nil: + return resp, nil + default: + return nil, err + } +} + +func (m *defaultOrderRefundModel) FindPageListByPage(ctx context.Context, builder squirrel.SelectBuilder, page, pageSize int64, orderBy string) ([]*OrderRefund, error) { + + builder = builder.Columns(orderRefundRows) + + if orderBy == "" { + builder = builder.OrderBy("id DESC") + } else { + builder = builder.OrderBy(orderBy) + } + + if page < 1 { + page = 1 + } + offset := (page - 1) * pageSize + + query, values, err := builder.Where("del_state = ?", globalkey.DelStateNo).Offset(uint64(offset)).Limit(uint64(pageSize)).ToSql() + if err != nil { + return nil, err + } + + var resp []*OrderRefund + err = m.QueryRowsNoCacheCtx(ctx, &resp, query, values...) + switch err { + case nil: + return resp, nil + default: + return nil, err + } +} + +func (m *defaultOrderRefundModel) FindPageListByPageWithTotal(ctx context.Context, builder squirrel.SelectBuilder, page, pageSize int64, orderBy string) ([]*OrderRefund, int64, error) { + + total, err := m.FindCount(ctx, builder, "id") + if err != nil { + return nil, 0, err + } + + builder = builder.Columns(orderRefundRows) + + if orderBy == "" { + builder = builder.OrderBy("id DESC") + } else { + builder = builder.OrderBy(orderBy) + } + + if page < 1 { + page = 1 + } + offset := (page - 1) * pageSize + + query, values, err := builder.Where("del_state = ?", globalkey.DelStateNo).Offset(uint64(offset)).Limit(uint64(pageSize)).ToSql() + if err != nil { + return nil, total, err + } + + var resp []*OrderRefund + err = m.QueryRowsNoCacheCtx(ctx, &resp, query, values...) + switch err { + case nil: + return resp, total, nil + default: + return nil, total, err + } +} + +func (m *defaultOrderRefundModel) FindPageListByIdDESC(ctx context.Context, builder squirrel.SelectBuilder, preMinId, pageSize int64) ([]*OrderRefund, error) { + + builder = builder.Columns(orderRefundRows) + + if preMinId > 0 { + builder = builder.Where(" id < ? ", preMinId) + } + + query, values, err := builder.Where("del_state = ?", globalkey.DelStateNo).OrderBy("id DESC").Limit(uint64(pageSize)).ToSql() + if err != nil { + return nil, err + } + + var resp []*OrderRefund + err = m.QueryRowsNoCacheCtx(ctx, &resp, query, values...) + switch err { + case nil: + return resp, nil + default: + return nil, err + } +} + +func (m *defaultOrderRefundModel) FindPageListByIdASC(ctx context.Context, builder squirrel.SelectBuilder, preMaxId, pageSize int64) ([]*OrderRefund, error) { + + builder = builder.Columns(orderRefundRows) + + if preMaxId > 0 { + builder = builder.Where(" id > ? ", preMaxId) + } + + query, values, err := builder.Where("del_state = ?", globalkey.DelStateNo).OrderBy("id ASC").Limit(uint64(pageSize)).ToSql() + if err != nil { + return nil, err + } + + var resp []*OrderRefund + err = m.QueryRowsNoCacheCtx(ctx, &resp, query, values...) + switch err { + case nil: + return resp, nil + default: + return nil, err + } +} + +func (m *defaultOrderRefundModel) Trans(ctx context.Context, fn func(ctx context.Context, session sqlx.Session) error) error { + + return m.TransactCtx(ctx, func(ctx context.Context, session sqlx.Session) error { + return fn(ctx, session) + }) + +} + +func (m *defaultOrderRefundModel) SelectBuilder() squirrel.SelectBuilder { + return squirrel.Select().From(m.table) +} +func (m *defaultOrderRefundModel) Delete(ctx context.Context, session sqlx.Session, id int64) error { + data, err := m.FindOne(ctx, id) + if err != nil { + return err + } + + tydataOrderRefundIdKey := fmt.Sprintf("%s%v", cacheTydataOrderRefundIdPrefix, id) + tydataOrderRefundPlatformRefundIdKey := fmt.Sprintf("%s%v", cacheTydataOrderRefundPlatformRefundIdPrefix, data.PlatformRefundId) + tydataOrderRefundRefundNoKey := fmt.Sprintf("%s%v", cacheTydataOrderRefundRefundNoPrefix, data.RefundNo) + _, err = m.ExecCtx(ctx, func(ctx context.Context, conn sqlx.SqlConn) (result sql.Result, err error) { + query := fmt.Sprintf("delete from %s where `id` = ?", m.table) + if session != nil { + return session.ExecCtx(ctx, query, id) + } + return conn.ExecCtx(ctx, query, id) + }, tydataOrderRefundIdKey, tydataOrderRefundPlatformRefundIdKey, tydataOrderRefundRefundNoKey) + return err +} +func (m *defaultOrderRefundModel) formatPrimary(primary interface{}) string { + return fmt.Sprintf("%s%v", cacheTydataOrderRefundIdPrefix, primary) +} +func (m *defaultOrderRefundModel) queryPrimary(ctx context.Context, conn sqlx.SqlConn, v, primary interface{}) error { + query := fmt.Sprintf("select %s from %s where `id` = ? and del_state = ? limit 1", orderRefundRows, m.table) + return conn.QueryRowCtx(ctx, v, query, primary, globalkey.DelStateNo) +} + +func (m *defaultOrderRefundModel) tableName() string { + return m.table +}