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:
admin
2024-07-25 14:39:57 +08:00
parent 8c84ed3656
commit a525a67a01
29 changed files with 1173 additions and 149 deletions
Download Patch File Download Diff File Expand all files Collapse all files
api/service/OrderMember.go
+350
View File
@@ -0,0 +1,350 @@
package service
import (
"context"
"errors"
"fmt"
"github.com/wechatpay-apiv3/wechatpay-go/services/payments/app"
"github.com/wechatpay-apiv3/wechatpay-go/services/payments/jsapi"
"gorm.io/gorm"
"hepa-calc-api/api/dao"
"hepa-calc-api/api/model"
"hepa-calc-api/config"
"hepa-calc-api/extend/weChat"
"hepa-calc-api/global"
"hepa-calc-api/utils"
"time"
)
type OrderMemberService struct {
}
// AddOrderMember 创建会员订单
func (r *OrderMemberService) AddOrderMember(tx *gorm.DB, UserId, SystemMemberId int64, UserCouponId *int64, payChannel int, orderPrice float64) (orderMember *model.OrderMember, err error) {
// 检测多次请求
redisKey := "AddOrderMember" + fmt.Sprintf("%d", UserId) + fmt.Sprintf("%d", SystemMemberId)
res, _ := global.Redis.Get(context.Background(), redisKey).Result()
if res != "" {
return nil, errors.New("请勿重复操作")
}
defer func(redisKey string) {
global.Redis.Del(context.Background(), redisKey)
}(redisKey)
// 添加缓存
_, err = global.Redis.Set(context.Background(), redisKey, "1", (10)*time.Second).Result()
if err != nil {
return nil, errors.New("生成订单失败")
}
// 获取会员配置数据
systemMemberDao := dao.SystemMemberDao{}
systemMember, err := systemMemberDao.GetSystemMemberById(SystemMemberId)
if err != nil {
return nil, errors.New("会员配置异常")
}
// 获取用户数据
userDao := dao.UserDao{}
user, err := userDao.GetUserById(UserId)
if err != nil || user == nil {
return nil, errors.New("用户错误")
}
// 检测会员有效期
if user.IsMember == 1 {
now := time.Now()
diff := user.MemberExpireDate.Sub(now)
// 将差值转换为天数
diffDays := int(diff.Hours() / 24)
totalDays := diffDays + int(systemMember.MemberDays)
if totalDays > 180 {
return nil, errors.New("超出会员有效期")
}
}
var amountTotal float64 // 总金额
var couponAmountTotal float64 // 优惠卷总金额
var paymentAmountTotal float64 // 实际付款金额
var orderStatus int // 订单状态（1:待支付 2:已完成 3:已取消）
var payStatus int // 支付状态（1:未支付 2:已支付 3:支付中 4:支付失败 5:支付超时 6:支付关闭 7:已撤销 8:转入退款）
var payTime *time.Time // 支付时间
var escrowTradeNo string // 第三方支付流水号
// 获取会员购买价格
systemMemberService := &SystemMemberService{}
amountTotal = systemMemberService.GetSystemMemberBuyPrice(systemMember)
if err != nil {
return nil, err
}
// 检测用户优惠卷
var userCoupon *model.UserCoupon
if UserCouponId != nil {
// 检测用户是否购买过会员
userService := &UserService{}
isBuy := userService.CheckUserBuyOrderMember(UserId)
if isBuy == true {
// 已购买过会员，无法使用优惠卷
return nil, errors.New("优惠券异常")
}
// 获取优惠卷数据
UserCouponDao := dao.UserCouponDao{}
userCoupon, err = UserCouponDao.GetUserCouponPreloadById(*UserCouponId)
if err != nil {
return nil, errors.New("优惠券异常")
}
userCouponService := &UserCouponService{}
isCanUse, err := userCouponService.CheckUserCoupon(userCoupon, SystemMemberId, 2, amountTotal)
if err != nil || isCanUse == false {
return nil, errors.New("价格异常")
}
// 优惠卷总金额
couponAmountTotal = userCoupon.Coupon.CouponPrice
}
// 实际付款金额
paymentAmountTotal = amountTotal - couponAmountTotal // 实际付款金额
if paymentAmountTotal < 0 {
return nil, errors.New("价格异常")
}
if orderPrice != paymentAmountTotal {
return nil, errors.New("价格异常")
}
orderStatus = 1 // 订单状态（1:待支付 2:已完成 3:已取消）
payStatus = 1 // 支付状态（1:未支付 2:已支付 3:支付中 4:支付失败 5:支付超时 6:支付关闭 7:已撤销 8:转入退款）
payTime = nil // 支付时间
// 生成订单号
orderNo := global.Snowflake.Generate().String()
// 创建订单
orderMember = &model.OrderMember{
UserId: UserId,
SystemMemberId: SystemMemberId,
OrderStatus: orderStatus,
IsDelete: 0,
PayChannel: payChannel,
PayStatus: payStatus,
PayTime: payTime,
RefundStatus: 0,
OrderNo: orderNo,
EscrowTradeNo: escrowTradeNo,
AmountTotal: amountTotal,
CouponAmountTotal: couponAmountTotal,
PaymentAmountTotal: paymentAmountTotal,
CancelStatus: 0,
CancelTime: nil,
CancelRemarks: "",
OrderRemarks: "",
}
orderMemberDao := dao.OrderMemberDao{}
orderMember, err = orderMemberDao.AddOrderMember(tx, orderMember)
if err != nil {
return nil, errors.New("订单创建失败")
}
// 创建优惠卷表
if userCoupon != nil {
orderMemberCoupon := &model.OrderMemberCoupon{
OrderId: orderMember.OrderId,
UserCouponId: *UserCouponId,
CouponName: userCoupon.Coupon.CouponName,
CouponUsePrice: userCoupon.Coupon.CouponPrice,
}
orderMemberCouponDao := dao.OrderMemberCouponDao{}
orderMemberCoupon, err = orderMemberCouponDao.AddOrderMemberCoupon(tx, orderMemberCoupon)
if err != nil {
tx.Rollback()
return nil, errors.New("订单创建失败")
}
// 修改优惠卷使用状态
userCouponDao := dao.UserCouponDao{}
userCouponData := make(map[string]interface{})
userCouponData["user_coupon_status"] = 1
userCouponData["coupon_use_date"] = time.Now().Format("2006-01-02 15:04:05")
err := userCouponDao.EditUserCouponById(tx, userCoupon.UserCouponId, userCouponData)
if err != nil {
return nil, errors.New("订单创建失败")
}
}
return orderMember, nil
}
// PutCancelOrderMember 取消会员订单
// cancelReason:订单取消原因（1:主动取消 2:后台取消 3:支付超时取消）
func (r *OrderMemberService) PutCancelOrderMember(tx *gorm.DB, userId, orderId int64, cancelReason int) (bool, error) {
// 检测多次请求
redisKey := "PutCancelOrderSingle" + fmt.Sprintf("%d", userId) + fmt.Sprintf("%d", orderId)
res, _ := global.Redis.Get(context.Background(), redisKey).Result()
if res != "" {
return false, errors.New("请勿重复操作")
}
defer func(redisKey string) {
global.Redis.Del(context.Background(), redisKey)
}(redisKey)
// 添加缓存
_, err := global.Redis.Set(context.Background(), redisKey, "1", (10)*time.Second).Result()
if err != nil {
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("订单已完成,无法取消")
}
if orderSingle.OrderStatus == 3 {
return false, errors.New("订单已取消,请勿重复操作")
}
// 取消状态（0:否 1:是）
if orderSingle.CancelStatus == 1 {
return false, errors.New("订单已取消")
}
// 支付状态（1:未支付 2:已支付 3:支付中 4:支付失败 5:支付超时 6:支付关闭 7:已撤销 8:转入退款）
if orderSingle.PayStatus == 2 {
return false, errors.New("订单已支付,无法取消")
}
// 订单退款状态（0:无退款 1:申请退款 2:退款中 3:退款成功 4:拒绝退款 5:退款关闭 6:退款异常 7:部分退款）
if orderSingle.RefundStatus == 1 {
return false, errors.New("订单已申请退款")
}
if orderSingle.RefundStatus == 2 {
return false, errors.New("订单退款中")
}
if orderSingle.RefundStatus == 3 {
return false, errors.New("订单已退款成功")
}
if orderSingle.RefundStatus == 6 {
return false, errors.New("订单退款异常")
}
// 修改订单为取消
orderSingleData := make(map[string]interface{})
orderSingleData["order_status"] = 3
if cancelReason == 3 {
// 支付超时取消
orderSingleData["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)
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)
}
return true, nil
}
// GetJsapiPrepay 获取jsapi预支付交易会话标识
func (r *OrderMemberService) GetJsapiPrepay(m *model.OrderMember) (prepay *jsapi.PrepayWithRequestPaymentResponse, err error) {
// 获取用户数据
userDao := dao.UserDao{}
user, err := userDao.GetUserById(m.UserId)
if err != nil || user == nil {
return nil, errors.New("用户错误")
}
if user.OpenId != "" {
return nil, errors.New("发起支付失败")
}
jsapiRequest := weChat.JsapiRequest{
AppId: config.C.Wechat.AppId,
MchId: config.C.Wechat.Pay1659662936.MchId,
Description: "肝病算一算",
OutTradeNo: m.OrderNo,
NotifyUrl: config.C.Wechat.RefundNotifyDomain + config.C.Wechat.RefundNotifyUrl,
Amount: weChat.JsapiRequestAmountRequest{
Total: int64(m.PaymentAmountTotal * 100),
Currency: "CNY",
},
Payer: weChat.JsapiRequestPayerRequest{OpenId: user.OpenId},
}
prepay, err = jsapiRequest.GetJsapiPrepay()
if err != nil {
return nil, err
}
return prepay, nil
}
// GetAppPrepay 获取app预支付交易会话标识
func (r *OrderMemberService) GetAppPrepay(m *model.OrderMember) (prepay *app.PrepayWithRequestPaymentResponse, err error) {
// 获取用户数据
userDao := dao.UserDao{}
user, err := userDao.GetUserById(m.UserId)
if err != nil || user == nil {
return nil, errors.New("用户错误")
}
if user.OpenId != "" {
return nil, errors.New("发起支付失败")
}
appRequest := weChat.AppRequest{
AppId: config.C.Wechat.AppId,
MchId: config.C.Wechat.Pay1659662936.MchId,
Description: "肝病算一算",
OutTradeNo: m.OrderNo,
NotifyUrl: config.C.Wechat.RefundNotifyDomain + config.C.Wechat.RefundNotifyUrl,
Amount: weChat.AppRequestAmountRequest{
Total: int64(m.PaymentAmountTotal * 100),
Currency: "CNY",
},
}
prepay, err = appRequest.GetAppPrepay()
if err != nil {
return nil, err
}
return prepay, nil
}
api/service/OrderSingle.go
+38 -16
View File
@@ -20,7 +20,7 @@ type OrderSingleService struct {
}
// AddOrderSingle 创建单项订单
func (r *OrderSingleService) AddOrderSingle(tx *gorm.DB, UserId, QuestionId int64, UserCouponId *int64, payChannel int) (orderSingle *model.OrderSingle, err error) {
func (r *OrderSingleService) AddOrderSingle(tx *gorm.DB, UserId, QuestionId int64, UserCouponId *int64, payChannel int, orderPrice float64) (orderSingle *model.OrderSingle, err error) {
// 检测多次请求
redisKey := "AddOrderSingle" + fmt.Sprintf("%d", UserId) + fmt.Sprintf("%d", QuestionId)
res, _ := global.Redis.Get(context.Background(), redisKey).Result()
@@ -52,16 +52,24 @@ func (r *OrderSingleService) AddOrderSingle(tx *gorm.DB, UserId, QuestionId int6
return nil, err
}
var amountTotal float64 // 总金额
var amountTotal *float64 // 总金额
var couponAmountTotal float64 // 优惠卷总金额
var paymentAmountTotal float64 // 实际付款金额
var orderStatus int // 订单状态（1:待支付 2:已完成 3:已取消）
var payStatus int // 支付状态（1:未支付 2:已支付 3:支付中 4:支付失败 5:支付超时 6:支付关闭 7:已撤销 8:转入退款）
var payTime *time.Time // 支付时间
var escrowTradeNo string // 第三方支付流水号
// 获取问题价格
// 获取问题最终价格
amountTotal, err = questionService.GetUserBuyPrice(UserId, QuestionId)
if err != nil {
return nil, err
}
if amountTotal == nil {
return nil, errors.New("价格错误")
}
// 检测用户优惠卷
var userCoupon *model.UserCoupon
if UserCouponId != nil {
@@ -73,7 +81,7 @@ func (r *OrderSingleService) AddOrderSingle(tx *gorm.DB, UserId, QuestionId int6
}
userCouponService := &UserCouponService{}
isCanUse, err := userCouponService.CheckUserCoupon(userCoupon, QuestionId, 1, amountTotal)
isCanUse, err := userCouponService.CheckUserCoupon(userCoupon, QuestionId, 1, *amountTotal)
if err != nil || isCanUse == false {
return nil, errors.New("价格异常")
}
@@ -82,15 +90,26 @@ func (r *OrderSingleService) AddOrderSingle(tx *gorm.DB, UserId, QuestionId int6
couponAmountTotal = userCoupon.Coupon.CouponPrice
}
// 实际付款金额
paymentAmountTotal = amountTotal - couponAmountTotal
if paymentAmountTotal < 0 {
return nil, errors.New("价格异常")
}
// 会员支付
if payChannel == 3 {
paymentAmountTotal = 0
paymentAmountTotal = 0 // 实际付款金额
orderStatus = 2 // 订单状态（1:待支付 2:已完成 3:已取消）
payStatus = 2 // 支付状态（1:未支付 2:已支付 3:支付中 4:支付失败 5:支付超时 6:支付关闭 7:已撤销 8:转入退款）
now := time.Now()
payTime = &now // 支付时间
escrowTradeNo = "GD" + global.Snowflake.Generate().String() // 第三方支付流水号
} else {
// 实际付款金额
paymentAmountTotal = *amountTotal - couponAmountTotal
if orderPrice != paymentAmountTotal {
return nil, errors.New("价格异常")
}
orderStatus = 1 // 订单状态（1:待支付 2:已完成 3:已取消）
payStatus = 1 // 支付状态（1:未支付 2:已支付 3:支付中 4:支付失败 5:支付超时 6:支付关闭 7:已撤销 8:转入退款）
payTime = nil // 支付时间
}
// 生成订单号
@@ -100,15 +119,15 @@ func (r *OrderSingleService) AddOrderSingle(tx *gorm.DB, UserId, QuestionId int6
orderSingle = &model.OrderSingle{
UserId: UserId,
QuestionId: QuestionId,
OrderStatus: 1,
OrderStatus: orderStatus,
IsDelete: 0,
PayChannel: payChannel,
PayStatus: 1,
PayTime: nil,
PayStatus: payStatus,
PayTime: payTime,
RefundStatus: 0,
OrderNo: orderNo,
EscrowTradeNo: "",
AmountTotal: amountTotal,
EscrowTradeNo: escrowTradeNo,
AmountTotal: *amountTotal,
CouponAmountTotal: couponAmountTotal,
PaymentAmountTotal: paymentAmountTotal,
CancelStatus: 0,
@@ -152,6 +171,9 @@ func (r *OrderSingleService) AddOrderSingle(tx *gorm.DB, UserId, QuestionId int6
}
// 增加至未支付取消订单延迟队列
if payChannel == 1 || payChannel == 2 {
}
return orderSingle, nil
}
api/service/Question.go
+33 -14
View File
@@ -4,6 +4,7 @@ import (
"errors"
"hepa-calc-api/api/dao"
"hepa-calc-api/api/model"
"time"
)
type QuestionService struct {
@@ -126,14 +127,14 @@ func (r *QuestionService) GetUserFirstTimeBuyPrice(userId, questionId int64) (f
// GetQuestionBuyCount 获取问题被购买数量
func (r *QuestionService) GetQuestionBuyCount(userId, questionId int64) (c int, err error) {
// 未购买过
systemSingleDao := dao.SystemSingleDao{}
orderSingleDao := dao.OrderSingleDao{}
maps := make(map[string]interface{})
maps["user_id"] = userId
maps["question_id"] = questionId
maps["order_status"] = 2
maps["refund_status"] = 0
buyCount, err := systemSingleDao.GetSystemSingleCount(maps)
buyCount, err := orderSingleDao.GetOrderSingleCount(maps)
if err != nil {
return 0, err
}
@@ -141,20 +142,13 @@ func (r *QuestionService) GetQuestionBuyCount(userId, questionId int64) (c int,
return int(buyCount), nil
}
// GetUserBuyPrice 获取问题价格
func (r *QuestionService) GetUserBuyPrice(userId, questionId int64) (p float64, err error) {
// GetUserBuyPrice 获取问题最终价格
func (r *QuestionService) GetUserBuyPrice(userId, questionId int64) (p *float64, err error) {
// 获取问题详情
questionDao := dao.QuestionDao{}
question, err := questionDao.GetQuestionById(questionId)
if err != nil {
return 0, errors.New("题目异常")
}
// 问题价格
p = question.Price
if question.DiscountPrice != nil {
p = *question.DiscountPrice
return nil, errors.New("题目异常")
}
// 检测用户是否购买过该问题
@@ -166,10 +160,19 @@ func (r *QuestionService) GetUserBuyPrice(userId, questionId int64) (p float64,
maps := make(map[string]interface{})
systemSingle, err := systemSingleDao.GetSystemSingle(maps)
if err != nil {
return 0, err
return nil, err
}
p = systemSingle.FirstTimePrice
p = &systemSingle.FirstTimePrice
}
// 处理问题优惠价格
if p == nil {
p = r.HandleQuestionDiscountPrice(question.DiscountPrice, question.DiscountEndTime)
}
if p == nil {
p = &question.Price
}
return p, nil
@@ -187,3 +190,19 @@ func (r *QuestionService) CheckQuestion(m *model.Question) (bool, error) {
return true, nil
}
// HandleQuestionDiscountPrice 处理问题优惠价格
func (r *QuestionService) HandleQuestionDiscountPrice(discountPrice *float64, discountEndTime *time.Time) (p *float64) {
// 优惠价格
if discountPrice != nil {
// 检测是否超出优惠时间
now := time.Now()
if discountEndTime.Before(now) {
p = nil
} else {
p = discountPrice
}
}
return p
}
api/service/SystemMember.go
+17
View File
@@ -0,0 +1,17 @@
package service
import "hepa-calc-api/api/model"
type SystemMemberService struct {
}
// GetSystemMemberBuyPrice 获取会员购买价格
func (r *SystemMemberService) GetSystemMemberBuyPrice(m *model.SystemMember) (p float64) {
p = m.Price
if m.DiscountPrice != nil {
p = *m.DiscountPrice
}
return p
}
api/service/User.go
+27
View File
@@ -3,6 +3,8 @@ package service
import (
"errors"
"fmt"
"hepa-calc-api/api/dao"
"hepa-calc-api/api/model"
"hepa-calc-api/extend/aliyun"
"io"
"math/rand"
@@ -55,3 +57,28 @@ func (r *UserService) HandleUserAvatar(wxAvatar string) (avatar string, err erro
return ossPath, nil
}
// CheckUserMember 检测用户会员
func (r *UserService) CheckUserMember(user *model.User) bool {
if user.IsMember == 0 {
return false
}
now := time.Now()
if user.MemberExpireDate.Before(now) {
return false
}
return true
}
// CheckUserBuyOrderMember 检测用户是否购买过会员
func (r *UserService) CheckUserBuyOrderMember(userId int64) bool {
orderMemberDao := dao.OrderMemberDao{}
orderMember, _ := orderMemberDao.GetUserFirstTimeBuyOrderMember(userId)
if orderMember == nil {
return false
}
return true
}
api/service/UserCollection.go
+6 -6
View File
@@ -10,8 +10,8 @@ import (
type UserCollectionService struct {
}
// CheckUserCollectionQuestion 检测问题是否被用户收藏
func (r *UserCollectionService) CheckUserCollectionQuestion(userId, questionId int64) bool {
// GetUserCollectionQuestionStatus 检测用户收藏状态
func (r *UserCollectionService) GetUserCollectionQuestionStatus(userId, questionId int64) bool {
userCollectionDao := dao.UserCollectionDao{}
maps := make(map[string]interface{})
@@ -27,8 +27,8 @@ func (r *UserCollectionService) CheckUserCollectionQuestion(userId, questionId i
// PutUserCollection 收藏题目
func (r *UserCollectionService) PutUserCollection(userId, questionId int64) (bool, error) {
// 检测问题是否被用户收藏
IsCollection := r.CheckUserCollectionQuestion(userId, questionId)
// 检测用户收藏状态
IsCollection := r.GetUserCollectionQuestionStatus(userId, questionId)
if IsCollection == true {
// 已收藏
return true, nil
@@ -60,8 +60,8 @@ func (r *UserCollectionService) PutUserCollection(userId, questionId int64) (boo
// PutUserCollectionCancel 取消收藏题目
func (r *UserCollectionService) PutUserCollectionCancel(userId, questionId int64) (bool, error) {
// 检测问题是否被用户收藏
IsCollection := r.CheckUserCollectionQuestion(userId, questionId)
// 检测用户收藏状态
IsCollection := r.GetUserCollectionQuestionStatus(userId, questionId)
if IsCollection == false {
// 已收藏
return true, nil
api/service/UserCoupon.go
+92
View File
@@ -4,6 +4,7 @@ import (
"errors"
"gorm.io/gorm"
"hepa-calc-api/api/dao"
"hepa-calc-api/api/dto"
"hepa-calc-api/api/model"
"time"
)
@@ -12,6 +13,7 @@ type UserCouponService struct {
}
// CheckUserCoupon 检测用户优惠卷
// orderType:类型（1:单项 2:会员）
func (r *UserCouponService) CheckUserCoupon(m *model.UserCoupon, id int64, orderType int, amountTotal float64) (bool, error) {
if m.UserCouponStatus == 1 {
return false, errors.New("优惠卷异常")
@@ -114,3 +116,93 @@ func (r *UserCouponService) ReturnUserCoupon(tx *gorm.DB, userCouponId int64) bo
return true
}
// GetUserUsableQuestionCoupon 获取患者可使用优惠卷-单项
func (r *UserCouponService) GetUserUsableQuestionCoupon(userId, questionId int64, amountTotal float64) (g []*dto.UserCouponDto, err error) {
// 获取用户数据
userDao := dao.UserDao{}
user, err := userDao.GetUserById(userId)
if err != nil || user == nil {
return nil, errors.New("用户错误")
}
// 检测用户会员
userService := &UserService{}
isMember := userService.CheckUserMember(user)
if isMember == true {
// 会员无需使用优惠卷
return nil, nil
}
// 获取用户优惠卷
UserCouponDao := dao.UserCouponDao{}
maps := make(map[string]interface{})
maps["user_id"] = userId
maps["user_coupon_status"] = 0
userCoupons, err := UserCouponDao.GetUserCouponPreloadList(maps)
if err != nil {
return nil, errors.New("优惠券异常")
}
//定义返回数据
var responses []*model.UserCoupon
for _, userCoupon := range userCoupons {
isCanUse, err := r.CheckUserCoupon(userCoupon, questionId, 1, amountTotal)
if err != nil || isCanUse == false {
continue
}
responses = append(responses, userCoupon)
}
g = dto.GetUserCouponListDto(responses)
return g, nil
}
// GetUserUsableMemberCoupon 获取患者可使用优惠卷-会员
func (r *UserCouponService) GetUserUsableMemberCoupon(userId, systemMemberId int64, amountTotal float64) (g []*dto.UserCouponDto, err error) {
// 获取用户数据
userDao := dao.UserDao{}
user, err := userDao.GetUserById(userId)
if err != nil || user == nil {
return nil, errors.New("用户错误")
}
// 检测用户会员
userService := &UserService{}
isMember := userService.CheckUserMember(user)
if isMember == true {
// 会员无需使用优惠卷
return nil, nil
}
// 获取用户优惠卷
UserCouponDao := dao.UserCouponDao{}
maps := make(map[string]interface{})
maps["user_id"] = userId
maps["user_coupon_status"] = 0
userCoupons, err := UserCouponDao.GetUserCouponPreloadList(maps)
if err != nil {
return nil, errors.New("优惠券异常")
}
//定义返回数据
var responses []*model.UserCoupon
for _, userCoupon := range userCoupons {
isCanUse, err := r.CheckUserCoupon(userCoupon, systemMemberId, 2, amountTotal)
if err != nil || isCanUse == false {
continue
}
responses = append(responses, userCoupon)
}
g = dto.GetUserCouponListDto(responses)
return g, nil
}