gdxz/hepa-calc-api
4
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

修正了取消订单等操作

Browse Source
This commit is contained in:
wucongxing8150 2024-08-09 14:31:02 +08:00
parent 9dc506b1c1
commit befca63e7c
6 changed files with 136 additions and 80 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
api/amqp/consumer/CancelUnPayOrder.go
View File

@ -3,6 +3,7 @@ package consumer
import (
"encoding/json"
"github.com/rabbitmq/amqp091-go"
"hepa-calc-api/api/dao"
"hepa-calc-api/api/service"
"hepa-calc-api/extend/weChat"
"hepa-calc-api/global"
@ -66,8 +67,21 @@ func CancelUnPayOrder(msg amqp091.Delivery) {
// 单项订单
if data.OrderType == 1 {
// 获取订单数据
orderSingleDao := dao.OrderSingleDao{}
maps := make(map[string]interface{})
maps["user_id"] = userId
maps["order_id"] = orderId
orderSingle, err := orderSingleDao.GetOrderSingle(maps)
if err != nil {
tx.Rollback()
utils.LogJsonErr("consumer.CouponExpire:", "订单异常")
_ = msg.Reject(true)
return
}
orderSingleService := service.OrderSingleService{}
res, err := orderSingleService.CancelOrderSingle(tx, userId, orderId, 3)
res, err := orderSingleService.CancelOrderSingle(tx, orderSingle, 3)
if err != nil {
tx.Rollback()
utils.LogJsonErr("consumer.CouponExpire:", err)

27
api/controller/OrderSingle.go
View File

@ -97,20 +97,6 @@ func (b *OrderSingle) AddOrderSingle(c *gin.Context) {
userCouponId = &id
}
// 获取用户数据
userDao := dao.UserDao{}
user, err := userDao.GetUserById(userId)
if err != nil || user == nil {
responses.FailWithMessage("用户错误", c)
return
}
// 检测是否会员
if req.PayChannel == 3 && user.IsMember == 0 {
responses.FailWithMessage("非法操作", c)
return
}
if req.OrderPrice < 0 {
responses.FailWithMessage("价格错误", c)
return
@ -158,6 +144,17 @@ func (b *OrderSingle) PutCancelOrderSingle(c *gin.Context) {
return
}
// 获取订单数据
orderSingleDao := dao.OrderSingleDao{}
maps := make(map[string]interface{})
maps["user_id"] = userId
maps["order_id"] = orderId
orderSingle, err := orderSingleDao.GetOrderSingle(maps)
if err != nil {
responses.FailWithMessage("订单异常", c)
return
}
// 开始事务
tx := global.Db.Begin()
defer func() {
@ -168,7 +165,7 @@ func (b *OrderSingle) PutCancelOrderSingle(c *gin.Context) {
// 取消单项订单
orderSingleService := service.OrderSingleService{}
res, err := orderSingleService.CancelOrderSingle(tx, userId, orderId, 1)
res, err := orderSingleService.CancelOrderSingle(tx, orderSingle, 1)
if err != nil {
tx.Rollback()
responses.FailWithMessage(err.Error(), c)

9
api/dao/OrderMemberCoupon.go
View File

@ -28,6 +28,15 @@ func (r *OrderMemberCouponDao) GetOrderMemberCouponPreloadById(OrderMemberCoupon
return m, nil
}
// GetOrderMemberCouponListByOrderId 获取列表-订单id
func (r *OrderMemberCouponDao) GetOrderMemberCouponListByOrderId(orderId int64) (m []*model.OrderMemberCoupon, err error) {
err = global.Db.Where("order_id = ?", orderId).Find(&m).Error
if err != nil {
return nil, err
}
return m, nil
}
// DeleteOrderMemberCoupon 删除
func (r *OrderMemberCouponDao) DeleteOrderMemberCoupon(tx *gorm.DB, maps interface{}) error {
err := tx.Where(maps).Delete(&model.OrderMemberCoupon{}).Error

9
api/dao/OrderSingleCoupon.go
View File

@ -37,6 +37,15 @@ func (r *OrderSingleCouponDao) GetOrderSingleCouponByOrderId(orderId int64) (m *
return m, nil
}
// GetOrderSingleCouponListByOrderId 获取列表-订单id
func (r *OrderSingleCouponDao) GetOrderSingleCouponListByOrderId(orderId int64) (m []*model.OrderSingleCoupon, err error) {
err = global.Db.Where("order_id = ?", orderId).Find(&m).Error
if err != nil {
return nil, err
}
return m, nil
}
// DeleteOrderSingleCoupon 删除
func (r *OrderSingleCouponDao) DeleteOrderSingleCoupon(tx *gorm.DB, maps interface{}) error {
err := tx.Where(maps).Delete(&model.OrderSingleCoupon{}).Error

87
api/service/OrderMember.go
View File

@ -184,11 +184,11 @@ func (r *OrderMemberService) AddOrderMember(tx *gorm.DB, UserId, SystemMemberId
return orderMember, nil
}
// PutCancelOrderMember 取消会员订单
// CancelOrderSingle 取消会员订单
// cancelReason:订单取消原因（1:主动取消 2:后台取消 3:支付超时取消）
func (r *OrderMemberService) PutCancelOrderMember(tx *gorm.DB, userId, orderId int64, cancelReason int) (bool, error) {
func (r *OrderMemberService) CancelOrderSingle(tx *gorm.DB, orderMember *model.OrderMember, cancelReason int) (bool, error) {
// 检测多次请求
redisKey := "CancelOrderSingle" + fmt.Sprintf("%d", userId) + fmt.Sprintf("%d", orderId)
redisKey := "CancelOrderMember" + fmt.Sprintf("%d", orderMember.UserId) + fmt.Sprintf("%d", orderMember.OrderId)
res, _ := global.Redis.Get(context.Background(), redisKey).Result()
if res != "" {
return false, errors.New("请勿重复操作")
@ -204,80 +204,65 @@ func (r *OrderMemberService) PutCancelOrderMember(tx *gorm.DB, userId, orderId i
return false, errors.New("取消订单失败")
}
// 获取订单数据
orderSingleDao := dao.OrderSingleDao{}
maps := make(map[string]interface{})
maps["user_id"] = userId
maps["order_id"] = orderId
orderSingle, err := orderSingleDao.GetOrderSingle(maps)
if err != nil {
return false, errors.New("订单异常")
}
// 订单状态（1:待支付 2:已完成 3:已取消）
if orderSingle.OrderStatus == 2 {
if orderMember.OrderStatus == 2 {
return false, errors.New("订单已完成,无法取消")
}
if orderSingle.OrderStatus == 3 {
if orderMember.OrderStatus == 3 {
return false, errors.New("订单已取消,请勿重复操作")
}
// 取消状态（0:否 1:是）
if orderSingle.CancelStatus == 1 {
if orderMember.CancelStatus == 1 {
return false, errors.New("订单已取消")
}
// 支付状态（1:未支付 2:已支付 3:支付中 4:支付失败 5:支付超时 6:支付关闭 7:已撤销 8:转入退款）
if orderSingle.PayStatus == 2 {
if orderMember.PayStatus == 2 {
return false, errors.New("订单已支付,无法取消")
}
// 订单退款状态（0:无退款 1:申请退款 2:退款中 3:退款成功 4:拒绝退款 5:退款关闭 6:退款异常 7:部分退款）
if orderSingle.RefundStatus == 1 {
if orderMember.RefundStatus == 1 {
return false, errors.New("订单已申请退款")
}
if orderSingle.RefundStatus == 2 {
if orderMember.RefundStatus == 2 {
return false, errors.New("订单退款中")
}
if orderSingle.RefundStatus == 3 {
if orderMember.RefundStatus == 3 {
return false, errors.New("订单已退款成功")
}
if orderSingle.RefundStatus == 6 {
if orderMember.RefundStatus == 6 {
return false, errors.New("订单退款异常")
}
// 修改订单为取消
orderSingleData := make(map[string]interface{})
orderSingleData["order_status"] = 3
orderMemberData := make(map[string]interface{})
orderMemberData["order_status"] = 3
if cancelReason == 3 {
// 支付超时取消
orderSingleData["pay_status"] = 5
orderMemberData["pay_status"] = 5
}
orderSingleData["cancel_status"] = 1
orderSingleData["cancel_time"] = time.Now().Format("2006-01-02 15:04:05")
orderSingleData["cancel_remarks"] = utils.OrderCancelReasonToString(cancelReason)
orderSingleData["updated_at"] = time.Now().Format("2006-01-02 15:04:05")
err = orderSingleDao.EditOrderSingleById(tx, orderId, orderSingleData)
orderMemberData["cancel_status"] = 1
orderMemberData["cancel_time"] = time.Now().Format("2006-01-02 15:04:05")
orderMemberData["cancel_remarks"] = utils.OrderCancelReasonToString(cancelReason)
orderMemberData["updated_at"] = time.Now().Format("2006-01-02 15:04:05")
orderMemberDao := dao.OrderMemberDao{}
err = orderMemberDao.EditOrderMemberById(tx, orderMember.OrderId, orderMemberData)
if err != nil {
return false, errors.New("订单取消失败")
}
// 退还订单优惠卷
if orderSingle.CouponAmountTotal != 0 {
// 获取订单优惠卷数据
orderSingleCouponDao := dao.OrderSingleCouponDao{}
orderSingleCoupon, err := orderSingleCouponDao.GetOrderSingleCouponByOrderId(orderId)
if err != nil {
tx.Rollback()
return false, errors.New("订单取消失败")
}
userCouponService := &UserCouponService{}
userCouponService.ReturnUserCoupon(tx, orderSingleCoupon.UserCouponId)
err = r.OrderCouponRefund(tx, orderMember)
if err != nil {
tx.Rollback()
return false, err
}
return true, nil
@ -349,3 +334,25 @@ func (r *OrderMemberService) GetAppPrepay(m *model.OrderMember) (prepay *app.Pre
return prepay, nil
}
// OrderCouponRefund 订单优惠卷退还
func (r *OrderMemberService) OrderCouponRefund(tx *gorm.DB, order *model.OrderMember) error {
// 订单优惠金额为0，无需退还优惠卷
if order.CouponAmountTotal == 0 {
return nil
}
// 获取订单优惠卷数据
orderMemberCouponDao := dao.OrderMemberCouponDao{}
orderMemberCoupons, err := orderMemberCouponDao.GetOrderMemberCouponListByOrderId(order.OrderId)
if err != nil {
return errors.New("优惠卷数据错误")
}
userCouponService := &UserCouponService{}
for _, coupon := range orderMemberCoupons {
_ = userCouponService.ReturnUserCoupon(tx, coupon.UserCouponId)
}
return nil
}

68
api/service/OrderSingle.go
View File

@ -54,6 +54,18 @@ func (r *OrderSingleService) AddOrderSingle(tx *gorm.DB, UserId, QuestionId int6
return nil, err
}
// 获取用户数据
userDao := dao.UserDao{}
user, err := userDao.GetUserById(UserId)
if err != nil || user == nil {
return nil, errors.New("用户错误")
}
// 检测是否会员
if payChannel == 3 && user.IsMember == 0 {
return nil, errors.New("用户非会员，不可使用会员支付")
}
var amountTotal *float64 // 总金额
var couponAmountTotal float64 // 优惠卷总金额
var paymentAmountTotal float64 // 实际付款金额
@ -82,6 +94,7 @@ func (r *OrderSingleService) AddOrderSingle(tx *gorm.DB, UserId, QuestionId int6
return nil, errors.New("优惠券异常")
}
// 检测用户优惠卷
userCouponService := &UserCouponService{}
isCanUse, err := userCouponService.CheckUserCoupon(userCoupon, QuestionId, 1, *amountTotal)
if err != nil || isCanUse == false {
@ -206,9 +219,9 @@ func (r *OrderSingleService) AddOrderSingle(tx *gorm.DB, UserId, QuestionId int6
// CancelOrderSingle 取消单项订单
// cancelReason:订单取消原因（1:主动取消 2:后台取消 3:支付超时取消）
func (r *OrderSingleService) CancelOrderSingle(tx *gorm.DB, userId, orderId int64, cancelReason int) (bool, error) {
func (r *OrderSingleService) CancelOrderSingle(tx *gorm.DB, orderSingle *model.OrderSingle, cancelReason int) (bool, error) {
// 检测多次请求
redisKey := "CancelOrderSingle" + fmt.Sprintf("%d", userId) + fmt.Sprintf("%d", orderId)
redisKey := "CancelOrderSingle" + fmt.Sprintf("%d", orderSingle.UserId) + fmt.Sprintf("%d", orderSingle.OrderId)
res, _ := global.Redis.Get(context.Background(), redisKey).Result()
if res != "" {
return false, errors.New("请勿重复操作")
@ -224,16 +237,6 @@ func (r *OrderSingleService) CancelOrderSingle(tx *gorm.DB, userId, orderId int6
return false, errors.New("取消订单失败")
}
// 获取订单数据
orderSingleDao := dao.OrderSingleDao{}
maps := make(map[string]interface{})
maps["user_id"] = userId
maps["order_id"] = orderId
orderSingle, err := orderSingleDao.GetOrderSingle(maps)
if err != nil {
return false, errors.New("订单异常")
}
// 订单状态（1:待支付 2:已完成 3:已取消）
if orderSingle.OrderStatus == 2 {
return false, errors.New("订单已完成,无法取消")
@ -281,23 +284,18 @@ func (r *OrderSingleService) CancelOrderSingle(tx *gorm.DB, userId, orderId int6
orderSingleData["cancel_time"] = time.Now().Format("2006-01-02 15:04:05")
orderSingleData["cancel_remarks"] = utils.OrderCancelReasonToString(cancelReason)
orderSingleData["updated_at"] = time.Now().Format("2006-01-02 15:04:05")
err = orderSingleDao.EditOrderSingleById(tx, orderId, orderSingleData)
orderSingleDao := dao.OrderSingleDao{}
err = orderSingleDao.EditOrderSingleById(tx, orderSingle.OrderId, orderSingleData)
if err != nil {
return false, errors.New("订单取消失败")
}
// 退还订单优惠卷
if orderSingle.CouponAmountTotal != 0 {
// 获取订单优惠卷数据
orderSingleCouponDao := dao.OrderSingleCouponDao{}
orderSingleCoupon, err := orderSingleCouponDao.GetOrderSingleCouponByOrderId(orderId)
if err != nil {
tx.Rollback()
return false, errors.New("订单取消失败")
}
userCouponService := &UserCouponService{}
userCouponService.ReturnUserCoupon(tx, orderSingleCoupon.UserCouponId)
err = r.OrderCouponRefund(tx, orderSingle)
if err != nil {
tx.Rollback()
return false, err
}
return true, nil
@ -417,3 +415,25 @@ func (r *OrderSingleService) CompleteUnPayOrderSingle(tx *gorm.DB, userId int64)
return true, nil
}
// OrderCouponRefund 订单优惠卷退还
func (r *OrderSingleService) OrderCouponRefund(tx *gorm.DB, order *model.OrderSingle) error {
// 订单优惠金额为0，无需退还优惠卷
if order.CouponAmountTotal == 0 {
return nil
}
// 获取订单优惠卷数据
orderSingleCouponDao := dao.OrderSingleCouponDao{}
orderSingleCoupons, err := orderSingleCouponDao.GetOrderSingleCouponListByOrderId(order.OrderId)
if err != nil {
return errors.New("优惠卷数据错误")
}
userCouponService := &UserCouponService{}
for _, coupon := range orderSingleCoupons {
_ = userCouponService.ReturnUserCoupon(tx, coupon.UserCouponId)
}
return nil
}