修正了取消订单等操作

api/amqp/consumer/CancelUnPayOrder.go

@@ -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)

api/controller/OrderSingle.go

@@ -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)

api/dao/OrderMemberCoupon.go

@@ -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

api/dao/OrderSingleCoupon.go

@@ -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

api/service/OrderMember.go

@@ -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{})
+	orderMemberData := make(map[string]interface{})
-	orderSingleData["order_status"] = 3
+	orderMemberData["order_status"] = 3
 	if cancelReason == 3 {
 		// 支付超时取消
-		orderSingleData["pay_status"] = 5
+		orderMemberData["pay_status"] = 5
 	}
-	orderSingleData["cancel_status"] = 1
+	orderMemberData["cancel_status"] = 1
-	orderSingleData["cancel_time"] = time.Now().Format("2006-01-02 15:04:05")
+	orderMemberData["cancel_time"] = time.Now().Format("2006-01-02 15:04:05")
-	orderSingleData["cancel_remarks"] = utils.OrderCancelReasonToString(cancelReason)
+	orderMemberData["cancel_remarks"] = utils.OrderCancelReasonToString(cancelReason)
-	orderSingleData["updated_at"] = time.Now().Format("2006-01-02 15:04:05")
+	orderMemberData["updated_at"] = time.Now().Format("2006-01-02 15:04:05")
-	err = orderSingleDao.EditOrderSingleById(tx, orderId, orderSingleData)
+
+	orderMemberDao := dao.OrderMemberDao{}
+	err = orderMemberDao.EditOrderMemberById(tx, orderMember.OrderId, orderMemberData)
 	if err != nil {
 		return false, errors.New("订单取消失败")
 	}
 
 	// 退还订单优惠卷
-	if orderSingle.CouponAmountTotal != 0 {
+	err = r.OrderCouponRefund(tx, orderMember)
-		// 获取订单优惠卷数据
-		orderSingleCouponDao := dao.OrderSingleCouponDao{}
-		orderSingleCoupon, err := orderSingleCouponDao.GetOrderSingleCouponByOrderId(orderId)
 	if err != nil {
 		tx.Rollback()
-			return false, errors.New("订单取消失败")
+		return false, err
-		}
-
-		userCouponService := &UserCouponService{}
-		userCouponService.ReturnUserCoupon(tx, orderSingleCoupon.UserCouponId)
 	}
 
 	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
+}

api/service/OrderSingle.go

@@ -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 {
+	err = r.OrderCouponRefund(tx, orderSingle)
-		// 获取订单优惠卷数据
-		orderSingleCouponDao := dao.OrderSingleCouponDao{}
-		orderSingleCoupon, err := orderSingleCouponDao.GetOrderSingleCouponByOrderId(orderId)
 	if err != nil {
 		tx.Rollback()
-			return false, errors.New("订单取消失败")
+		return false, err
-		}
-
-		userCouponService := &UserCouponService{}
-		userCouponService.ReturnUserCoupon(tx, orderSingleCoupon.UserCouponId)
 	}
 
 	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
+}