修改了退款相关接口，新增了退款回调

api/controller/CallBack.go

@@ -17,7 +17,7 @@ type CallBack struct{}
 
 // WxPaySingle 微信支付回调-单项
 func (r *CallBack) WxPaySingle(c *gin.Context) {
-	notifyReq, transaction, err := weChat.ParseNotify(c)
+	notifyReq, transaction, err := weChat.PayParseNotify(c)
 	if err != nil {
 		responses.FailWithMessage(err.Error(), c)
 		return
@@ -60,8 +60,8 @@ func (r *CallBack) WxPaySingle(c *gin.Context) {
 		return
 	}
 
-	// 处理支付状态
-	wxPayResult, err := weChat.HandlePayStatus(transaction)
+	// 处理回调支付状态
+	wxResult, err := weChat.HandlePayStatus(transaction)
 	if err != nil {
 		c.JSON(http.StatusBadRequest, gin.H{"code": "ERROR", "message": err})
 		return
@@ -77,18 +77,15 @@ func (r *CallBack) WxPaySingle(c *gin.Context) {
 
 	// 修改订单
 	orderSingleData := make(map[string]interface{})
-	if wxPayResult.OrderStatus != nil {
-		orderSingleData["order_status"] = &wxPayResult.OrderStatus
-	}
-	orderSingleData["pay_status"] = &wxPayResult.PayStatus
-	if wxPayResult.PayTime != nil {
-		orderSingleData["pay_time"] = &wxPayResult.PayTime
+	orderSingleData["order_status"] = wxResult.OrderStatus
+	orderSingleData["pay_status"] = wxResult.PayStatus
+	if wxResult.PayTime != nil {
+		orderSingleData["pay_time"] = *wxResult.PayTime
 	}
 	orderSingleData["escrow_trade_no"] = transaction.TransactionId
-	orderSingleData["updated_at"] = time.Now().Format("2006-01-02 15:04:05")
 
 	// 处理单项有效时间
-	if *wxPayResult.PayStatus == 2 {
+	if wxResult.PayStatus == 2 {
 		systemSingleDao := dao.SystemSingleDao{}
 
 		maps := make(map[string]interface{})
@@ -109,22 +106,24 @@ func (r *CallBack) WxPaySingle(c *gin.Context) {
 		return
 	}
 
-	// 增加单项支付次数
-	questionService := service.QuestionService{}
-	res, err := questionService.AddQuestionPayCount(tx, orderSingle.QuestionId)
-	if err != nil || res == false {
-		tx.Rollback()
-		responses.FailWithMessage("内部错误", c)
-		return
-	}
+	if wxResult.PayStatus == 2 {
+		// 增加单项支付次数
+		questionService := service.QuestionService{}
+		res, err := questionService.AddQuestionPayCount(tx, orderSingle.QuestionId)
+		if err != nil || res == false {
+			tx.Rollback()
+			responses.FailWithMessage("内部错误", c)
+			return
+		}
 
-	// 增加用户单项支付次数
-	userService := service.UserService{}
-	res, err = userService.AddUserSingleSubmitCount(tx, orderSingle.UserId)
-	if err != nil || res == false {
-		tx.Rollback()
-		responses.FailWithMessage("内部错误", c)
-		return
+		// 增加用户单项支付次数
+		userService := service.UserService{}
+		res, err = userService.AddUserSingleSubmitCount(tx, orderSingle.UserId)
+		if err != nil || res == false {
+			tx.Rollback()
+			responses.FailWithMessage("内部错误", c)
+			return
+		}
 	}
 
 	tx.Commit()
@@ -133,7 +132,7 @@ func (r *CallBack) WxPaySingle(c *gin.Context) {
 
 // WxPayMember 微信支付回调-会员
 func (r *CallBack) WxPayMember(c *gin.Context) {
-	notifyReq, transaction, err := weChat.ParseNotify(c)
+	notifyReq, transaction, err := weChat.PayParseNotify(c)
 	if err != nil {
 		responses.FailWithMessage(err.Error(), c)
 		return
@@ -176,8 +175,8 @@ func (r *CallBack) WxPayMember(c *gin.Context) {
 		return
 	}
 
-	// 处理支付状态
-	wxPayResult, err := weChat.HandlePayStatus(transaction)
+	// 处理回调支付状态
+	wxResult, err := weChat.HandlePayStatus(transaction)
 	if err != nil {
 		c.JSON(http.StatusBadRequest, gin.H{"code": "ERROR", "message": err})
 		return
@@ -201,15 +200,12 @@ func (r *CallBack) WxPayMember(c *gin.Context) {
 
 	// 修改订单
 	orderSingleData := make(map[string]interface{})
-	if wxPayResult.OrderStatus != nil {
-		orderSingleData["order_status"] = &wxPayResult.OrderStatus
-	}
-	orderSingleData["pay_status"] = &wxPayResult.PayStatus
-	if wxPayResult.PayTime != nil {
-		orderSingleData["pay_time"] = &wxPayResult.PayTime
+	orderSingleData["order_status"] = wxResult.OrderStatus
+	orderSingleData["pay_status"] = wxResult.PayStatus
+	if wxResult.PayTime != nil {
+		orderSingleData["pay_time"] = *wxResult.PayTime
 	}
 	orderSingleData["escrow_trade_no"] = transaction.TransactionId
-	orderSingleData["updated_at"] = time.Now().Format("2006-01-02 15:04:05")
 	err = orderMemberDao.EditOrderMemberById(tx, orderMember.OrderId, orderSingleData)
 	if err != nil {
 		tx.Rollback()
@@ -217,8 +213,9 @@ func (r *CallBack) WxPayMember(c *gin.Context) {
 		return
 	}
 
-	// 处理未支付单项订单
-	if *wxPayResult.OrderStatus == 2 {
+	// 处理支付成功情况
+	if wxResult.OrderStatus == 2 {
+		// 完成未支付单项订单
 		orderSingleService := service.OrderSingleService{}
 		res, err := orderSingleService.CompleteUnPayOrderSingle(tx, orderMember.UserId)
 		if err != nil || res == false {
@@ -226,10 +223,8 @@ func (r *CallBack) WxPayMember(c *gin.Context) {
 			c.JSON(http.StatusInternalServerError, gin.H{"code": "ERROR", "message": err})
 			return
 		}
-	}
 
-	// 处理用户会员过期时间
-	if *wxPayResult.OrderStatus == 2 {
+		// 处理用户会员过期时间
 		// 获取订单配置
 		systemMemberDao := dao.SystemMemberDao{}
 		systemMember, err := systemMemberDao.GetSystemMemberById(orderMember.SystemMemberId)
@@ -240,23 +235,240 @@ func (r *CallBack) WxPayMember(c *gin.Context) {
 		}
 
 		userService := service.UserService{}
-		res := userService.AddUserMemberValidDate(tx, user, int(systemMember.MemberDays))
+		res = userService.AddUserMemberValidDate(tx, user, int(systemMember.MemberDays))
 		if res == false {
 			tx.Rollback()
 			c.JSON(http.StatusInternalServerError, gin.H{"code": "ERROR", "message": "增加用户会员到期时间失败"})
 			return
 		}
+
+		// 增加用户会员购买次数
+		res, err = userService.AddUserMemberBuyCount(tx, user.UserId)
+		if err != nil || res == false {
+			tx.Rollback()
+			c.JSON(http.StatusInternalServerError, gin.H{"code": "ERROR", "message": "增加用户会员到期时间失败"})
+			return
+		}
 	}
 
-	// 增加用户单项提交次数
-	userService := service.UserService{}
-	res, err := userService.AddUserMemberBuyCount(tx, user.UserId)
-	if err != nil || res == false {
-		tx.Rollback()
-		c.JSON(http.StatusInternalServerError, gin.H{"code": "ERROR", "message": "增加用户会员到期时间失败"})
+	tx.Commit()
+	c.JSON(http.StatusOK, gin.H{"code": "SUCCESS", "message": "OK"})
+}
+
+// WxPaySingleRefund 微信退款回调-单项
+func (r *CallBack) WxPaySingleRefund(c *gin.Context) {
+	notifyReq, refund, err := weChat.RefundParseNotify(c)
+	if err != nil {
+		responses.FailWithMessage(err.Error(), c)
 		return
 	}
 
+	// 记录日志
+	utils.LogJsonErr("微信退款回调-单项", notifyReq)
+	utils.LogJsonErr("微信退款回调-单项", refund)
+
+	if refund == nil {
+		c.JSON(http.StatusBadRequest, gin.H{"code": "ERROR", "message": "缺少订单数据"})
+		return
+	}
+
+	if refund.OutTradeNo == nil {
+		c.JSON(http.StatusBadRequest, gin.H{"code": "ERROR", "message": "缺少外部订单号"})
+		return
+	}
+
+	// 查询订单
+	orderSingleDao := dao.OrderSingleDao{}
+	maps := make(map[string]interface{})
+	maps["order_no"] = refund.OutTradeNo
+	orderSingle, err := orderSingleDao.GetOrderSingle(maps)
+	if err != nil || orderSingle == nil {
+		c.JSON(http.StatusBadRequest, gin.H{"code": "ERROR", "message": "无订单数据"})
+		return
+	}
+
+	// 验证订单状态-订单状态（1:待支付 2:已完成 3:已取消）
+	if orderSingle.OrderStatus == 1 {
+		message := "订单状态:" + utils.OrderSingleStatusToString(orderSingle.OrderStatus) + " 无需处理"
+		c.JSON(http.StatusOK, gin.H{"code": "SUCCESS", "message": message})
+		return
+	}
+
+	// 验证订单退款状态（0:无退款 1:申请退款 2:退款中 3:退款成功 4:拒绝退款 5:退款关闭 6:退款异常 7:部分退款）
+	if orderSingle.RefundStatus == 3 {
+		message := "订单状态:" + utils.OrderSingleRefundStatusToString(orderSingle.RefundStatus) + " 无需处理"
+		c.JSON(http.StatusOK, gin.H{"code": "SUCCESS", "message": message})
+		return
+	}
+
+	// 验证订单支付状态（1:未支付 2:已支付 3:支付中 4:支付失败 5:支付超时 6:支付关闭 7:已撤销 8:转入退款）
+	if orderSingle.PayStatus != 2 && orderSingle.PayStatus != 8 {
+		message := "订单状态:" + utils.OrderSinglePayStatusToString(orderSingle.RefundStatus) + " 无需处理"
+		c.JSON(http.StatusOK, gin.H{"code": "SUCCESS", "message": message})
+		return
+	}
+
+	// 处理回调支付状态
+	wxResult, err := weChat.HandlePayRefundStatus(refund)
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"code": "ERROR", "message": err})
+		return
+	}
+
+	// 开始事务
+	tx := global.Db.Begin()
+	defer func() {
+		if r := recover(); r != nil {
+			tx.Rollback()
+		}
+	}()
+
+	// 修改订单
+	orderSingleData := make(map[string]interface{})
+	orderSingleData["refund_status"] = wxResult.RefundStatus
+	err = orderSingleDao.EditOrderSingleById(tx, orderSingle.OrderId, orderSingleData)
+	if err != nil {
+		tx.Rollback()
+		c.JSON(http.StatusBadRequest, gin.H{"code": "ERROR", "message": err})
+		return
+	}
+
+	// 修改订单退款
+	orderSingleRefundDao := dao.OrderSingleRefundDao{}
+
+	orderSingleRefundData := make(map[string]interface{})
+	orderSingleRefundData["refund_status"] = wxResult.RefundStatus
+	if wxResult.SuccessTime != nil {
+		orderSingleRefundData["success_time"] = *wxResult.SuccessTime
+	}
+	err = orderSingleRefundDao.EditOrderSingleRefundById(tx, orderSingle.OrderId, orderSingleRefundData)
+	if err != nil {
+		tx.Rollback()
+		c.JSON(http.StatusBadRequest, gin.H{"code": "ERROR", "message": err})
+		return
+	}
+
+	// 处理退款成功情况
+	if wxResult.RefundStatus == 3 {
+		// 退还订单优惠卷
+		orderSingleService := service.OrderSingleService{}
+		err = orderSingleService.OrderCouponRefund(tx, orderSingle)
+		if err != nil {
+			tx.Rollback()
+			c.JSON(http.StatusBadRequest, gin.H{"code": "ERROR", "message": err})
+			return
+		}
+	}
+
+	tx.Commit()
+	c.JSON(http.StatusOK, gin.H{"code": "SUCCESS", "message": "OK"})
+}
+
+// WxPayMemberRefund 微信退款回调-会员
+func (r *CallBack) WxPayMemberRefund(c *gin.Context) {
+	notifyReq, refund, err := weChat.RefundParseNotify(c)
+	if err != nil {
+		responses.FailWithMessage(err.Error(), c)
+		return
+	}
+
+	// 记录日志
+	utils.LogJsonErr("微信退款回调-会员", notifyReq)
+	utils.LogJsonErr("微信退款回调-会员", refund)
+
+	if refund == nil {
+		c.JSON(http.StatusBadRequest, gin.H{"code": "ERROR", "message": "缺少订单数据"})
+		return
+	}
+
+	if refund.OutTradeNo == nil {
+		c.JSON(http.StatusBadRequest, gin.H{"code": "ERROR", "message": "缺少外部订单号"})
+		return
+	}
+
+	// 查询订单
+	orderMemberDao := dao.OrderMemberDao{}
+	maps := make(map[string]interface{})
+	maps["order_no"] = refund.OutTradeNo
+	orderMember, err := orderMemberDao.GetOrderMember(maps)
+	if err != nil || orderMember == nil {
+		c.JSON(http.StatusBadRequest, gin.H{"code": "ERROR", "message": "无订单数据"})
+		return
+	}
+
+	// 验证订单状态-订单状态（1:待支付 2:已完成 3:已取消）
+	if orderMember.OrderStatus == 1 {
+		message := "订单状态:" + utils.OrderSingleStatusToString(orderMember.OrderStatus) + " 无需处理"
+		c.JSON(http.StatusOK, gin.H{"code": "SUCCESS", "message": message})
+		return
+	}
+
+	// 验证订单退款状态（0:无退款 1:申请退款 2:退款中 3:退款成功 4:拒绝退款 5:退款关闭 6:退款异常 7:部分退款）
+	if orderMember.RefundStatus == 3 {
+		message := "订单状态:" + utils.OrderSingleRefundStatusToString(orderMember.RefundStatus) + " 无需处理"
+		c.JSON(http.StatusOK, gin.H{"code": "SUCCESS", "message": message})
+		return
+	}
+
+	// 验证订单支付状态（1:未支付 2:已支付 3:支付中 4:支付失败 5:支付超时 6:支付关闭 7:已撤销 8:转入退款）
+	if orderMember.PayStatus != 2 && orderMember.PayStatus != 8 {
+		message := "订单状态:" + utils.OrderSinglePayStatusToString(orderMember.RefundStatus) + " 无需处理"
+		c.JSON(http.StatusOK, gin.H{"code": "SUCCESS", "message": message})
+		return
+	}
+
+	// 处理回调支付状态
+	wxResult, err := weChat.HandlePayRefundStatus(refund)
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"code": "ERROR", "message": err})
+		return
+	}
+
+	// 开始事务
+	tx := global.Db.Begin()
+	defer func() {
+		if r := recover(); r != nil {
+			tx.Rollback()
+		}
+	}()
+
+	// 修改订单
+	orderMemberData := make(map[string]interface{})
+	orderMemberData["refund_status"] = wxResult.RefundStatus
+	err = orderMemberDao.EditOrderMemberById(tx, orderMember.OrderId, orderMemberData)
+	if err != nil {
+		tx.Rollback()
+		c.JSON(http.StatusBadRequest, gin.H{"code": "ERROR", "message": err})
+		return
+	}
+
+	// 修改订单退款
+	orderMemberRefundDao := dao.OrderMemberRefundDao{}
+
+	orderMemberRefundData := make(map[string]interface{})
+	orderMemberRefundData["refund_status"] = wxResult.RefundStatus
+	if wxResult.SuccessTime != nil {
+		orderMemberRefundData["success_time"] = *wxResult.SuccessTime
+	}
+	err = orderMemberRefundDao.EditOrderMemberRefundById(tx, orderMember.OrderId, orderMemberRefundData)
+	if err != nil {
+		tx.Rollback()
+		c.JSON(http.StatusBadRequest, gin.H{"code": "ERROR", "message": err})
+		return
+	}
+
+	// 处理退款成功情况
+	if wxResult.RefundStatus == 3 {
+		// 退还订单优惠卷
+		orderMemberService := service.OrderMemberService{}
+		err = orderMemberService.OrderCouponRefund(tx, orderMember)
+		if err != nil {
+			tx.Rollback()
+			c.JSON(http.StatusBadRequest, gin.H{"code": "ERROR", "message": err})
+			return
+		}
+	}
+
 	tx.Commit()
 	c.JSON(http.StatusOK, gin.H{"code": "SUCCESS", "message": "OK"})
 }

api/router/router.go

@@ -99,10 +99,24 @@ func publicRouter(r *gin.Engine, api controller.Api) {
 		wxpayGroup := callbackGroup.Group("/wxpay")
 		{
 			// 单项
-			wxpayGroup.POST("/single", api.CallBack.WxPaySingle)
+			singleGroup := wxpayGroup.Group("/single")
+			{
+				// 支付成功
+				singleGroup.POST("", api.CallBack.WxPaySingle)
+
+				// 退款
+				singleGroup.POST("/refund", api.CallBack.WxPaySingleRefund)
+			}
 
 			// 会员
-			wxpayGroup.POST("/member", api.CallBack.WxPayMember)
+			memberGroup := wxpayGroup.Group("/member")
+			{
+				// 支付成功
+				memberGroup.POST("/", api.CallBack.WxPayMember)
+
+				// 退款
+				memberGroup.POST("/refund", api.CallBack.WxPayMemberRefund)
+			}
 		}
 	}
 }

api/service/OrderMember.go

@@ -62,7 +62,7 @@ func (r *OrderMemberService) AddOrderMember(tx *gorm.DB, UserId, SystemMemberId
 		diffDays := int(diff.Hours() / 24)
 		totalDays := diffDays + int(systemMember.MemberDays)
 		if totalDays > 180 {
-			return nil, errors.New("超出会员有效期")
+			return nil, errors.New("超出会员最大购买天数")
 		}
 	}
 
@@ -241,6 +241,8 @@ func (r *OrderMemberService) CancelOrderSingle(tx *gorm.DB, orderMember *model.O
 	}
 
 	// 修改订单为取消
+	orderMemberDao := dao.OrderMemberDao{}
+
 	orderMemberData := make(map[string]interface{})
 	orderMemberData["order_status"] = 3
 	if cancelReason == 3 {
@@ -250,19 +252,19 @@ func (r *OrderMemberService) CancelOrderSingle(tx *gorm.DB, orderMember *model.O
 	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("订单取消失败")
 	}
 
-	// 退还订单优惠卷
-	err = r.OrderCouponRefund(tx, orderMember)
-	if err != nil {
-		tx.Rollback()
-		return false, err
+	// 处理支付金额为0时退还优惠卷问题
+	if orderMember.PaymentAmountTotal == 0 {
+		// 退还订单优惠卷
+		err = r.OrderCouponRefund(tx, orderMember)
+		if err != nil {
+			tx.Rollback()
+			return false, err
+		}
 	}
 
 	return true, nil

api/service/OrderSingle.go

@@ -274,6 +274,8 @@ func (r *OrderSingleService) CancelOrderSingle(tx *gorm.DB, orderSingle *model.O
 	}
 
 	// 修改订单为取消
+	orderSingleDao := dao.OrderSingleDao{}
+
 	orderSingleData := make(map[string]interface{})
 	orderSingleData["order_status"] = 3
 	if cancelReason == 3 {
@@ -283,19 +285,19 @@ func (r *OrderSingleService) CancelOrderSingle(tx *gorm.DB, orderSingle *model.O
 	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")
-
-	orderSingleDao := dao.OrderSingleDao{}
 	err = orderSingleDao.EditOrderSingleById(tx, orderSingle.OrderId, orderSingleData)
 	if err != nil {
 		return false, errors.New("订单取消失败")
 	}
 
-	// 退还订单优惠卷
-	err = r.OrderCouponRefund(tx, orderSingle)
-	if err != nil {
-		tx.Rollback()
-		return false, err
+	// 处理支付金额为0时退还优惠卷问题
+	if orderSingle.PaymentAmountTotal == 0 {
+		// 退还订单优惠卷
+		err = r.OrderCouponRefund(tx, orderSingle)
+		if err != nil {
+			tx.Rollback()
+			return false, err
+		}
 	}
 
 	return true, nil
@@ -385,6 +387,13 @@ func (r *OrderSingleService) CompleteUnPayOrderSingle(tx *gorm.DB, userId int64)
 		return false, err
 	}
 
+	systemSingleDao := dao.SystemSingleDao{}
+	maps = make(map[string]interface{})
+	systemSingle, err := systemSingleDao.GetSystemSingle(maps)
+	if err != nil {
+		return false, err
+	}
+
 	for _, single := range orderSingles {
 		// 生成第三方支付流水号
 		escrowTradeNo := "GD" + global.Snowflake.Generate().String()
@@ -395,6 +404,7 @@ func (r *OrderSingleService) CompleteUnPayOrderSingle(tx *gorm.DB, userId int64)
 		orderSingleData["pay_time"] = time.Now().Format("2006-01-02 15:04:05")
 		orderSingleData["escrow_trade_no"] = escrowTradeNo
 		orderSingleData["updated_at"] = time.Now().Format("2006-01-02 15:04:05")
+		orderSingleData["valid_date"] = time.Now().Add(time.Duration(systemSingle.ValidDays) * 24 * time.Hour) //有效时间
 		err = orderSingleDao.EditOrderSingleById(tx, single.OrderId, orderSingleData)
 		if err != nil {
 			return false, err