增加了微信支付

api/controller/Base.go

@@ -12,4 +12,5 @@ type Api struct {
 	OrderSingle    // 订单-单项
 	SystemMember   // 会员配置
 	OrderMember    // 订单-会员
+	CallBack       // 回调
 }

api/controller/CallBack.go

@@ -0,0 +1,23 @@
+package controller
+
+import (
+	"github.com/gin-gonic/gin"
+	"hepa-calc-api/api/responses"
+	"hepa-calc-api/extend/weChat"
+	"hepa-calc-api/utils"
+)
+
+// CallBack 回调
+type CallBack struct{}
+
+// WxJsapiPay 微信支付回调-jsapi
+func (r *CallBack) WxJsapiPay(c *gin.Context) {
+	notifyReq, err := weChat.ParseNotify(c)
+	if err != nil {
+		responses.FailWithMessage(err.Error(), c)
+		return
+	}
+
+	// 记录日志
+	utils.LogJsonErr("微信支付回调-jsapi", notifyReq)
+}

api/controller/OrderMember.go

@@ -1,13 +1,17 @@
 package controller
 
 import (
+	"fmt"
 	"github.com/gin-gonic/gin"
 	"hepa-calc-api/api/dao"
 	"hepa-calc-api/api/dto"
 	"hepa-calc-api/api/requests"
 	"hepa-calc-api/api/responses"
+	"hepa-calc-api/api/service"
 	"hepa-calc-api/global"
 	"hepa-calc-api/utils"
+	"strconv"
+	"time"
 )
 
 type OrderMember struct{}
@@ -56,3 +60,157 @@ func (b *OrderMember) GetOrderMemberPage(c *gin.Context) {
 	result["data"] = g
 	responses.OkWithData(result, c)
 }
+
+// AddOrderMember 创建会员订单
+func (b *OrderMember) AddOrderMember(c *gin.Context) {
+	orderMemberRequest := requests.OrderMemberRequest{}
+	req := orderMemberRequest.AddOrderMember
+	if err := c.ShouldBind(&req); err != nil {
+		responses.FailWithMessage(err.Error(), c)
+		return
+	}
+
+	// 参数验证
+	if err := global.Validate.Struct(req); err != nil {
+		responses.FailWithMessage(utils.Translate(err), c)
+		return
+	}
+
+	userId := c.GetInt64("UserId")
+
+	// 将 id 转换为 int64 类型
+	systemMemberId, err := strconv.ParseInt(req.SystemMemberId, 10, 64)
+	if err != nil {
+		responses.Fail(c)
+		return
+	}
+
+	// 用户优惠卷id
+	var userCouponId *int64
+	if req.UserCouponId != "" {
+		id, err := strconv.ParseInt(req.UserCouponId, 10, 64)
+		if err != nil {
+			responses.Fail(c)
+			return
+		}
+
+		userCouponId = &id
+	}
+
+	if req.OrderPrice < 0 {
+		responses.FailWithMessage("价格错误", c)
+		return
+	}
+
+	// 开始事务
+	tx := global.Db.Begin()
+	defer func() {
+		if r := recover(); r != nil {
+			tx.Rollback()
+		}
+	}()
+
+	// 创建会员订单
+	orderMemberService := service.OrderMemberService{}
+	orderMember, err := orderMemberService.AddOrderMember(tx, userId, systemMemberId, userCouponId, req.PayChannel, req.OrderPrice)
+	if err != nil {
+		tx.Rollback()
+		responses.FailWithMessage(err.Error(), c)
+		return
+	}
+
+	tx.Commit()
+
+	// 处理返回值
+	orderId := fmt.Sprintf("%d", orderMember.OrderId)
+
+	responses.OkWithData(orderId, c)
+}
+
+// GetOrderMemberPay 获取会员订单支付数据
+func (b *OrderMember) GetOrderMemberPay(c *gin.Context) {
+	orderMemberRequest := requests.OrderMemberRequest{}
+	req := orderMemberRequest.GetOrderMemberPay
+	if err := c.ShouldBind(&req); err != nil {
+		responses.FailWithMessage(err.Error(), c)
+		return
+	}
+
+	// 参数验证
+	if err := global.Validate.Struct(req); err != nil {
+		responses.FailWithMessage(utils.Translate(err), c)
+		return
+	}
+
+	userId := c.GetInt64("UserId")
+
+	id := c.Param("order_id")
+	if id == "" {
+		responses.FailWithMessage("缺少参数", c)
+		return
+	}
+
+	// 将 id 转换为 int64 类型
+	orderId, err := strconv.ParseInt(id, 10, 64)
+	if err != nil {
+		responses.Fail(c)
+		return
+	}
+
+	// 获取订单数据
+	orderMemberDao := dao.OrderMemberDao{}
+	maps := make(map[string]interface{})
+	maps["user_id"] = userId
+	maps["order_id"] = orderId
+	orderMember, err := orderMemberDao.GetOrderMember(maps)
+	if err != nil {
+		responses.FailWithMessage("订单异常", c)
+		return
+	}
+
+	// 检测订单状态（1:待支付 2:已完成 3:已取消）
+	if orderMember.OrderStatus != 1 {
+		responses.FailWithMessage("订单状态异常", c)
+		return
+	}
+
+	// 支付状态（1:未支付 2:已支付 3:支付中 4:支付失败 5:支付超时 6:支付关闭 7:已撤销 8:转入退款）
+	if orderMember.PayStatus != 1 {
+		responses.FailWithMessage("订单支付状态异常", c)
+		return
+	}
+
+	// 验证订单过期支付时间
+	now := time.Now()
+	validTime := time.Time(orderMember.CreatedAt).Add(30 * time.Minute)
+	if validTime.Before(now) {
+		responses.FailWithMessage("订单已过期", c)
+		return
+	}
+
+	// 处理返回值
+	g := dto.GetOrderMemberPayDto(orderMember)
+
+	// 获取预支付交易会话标识
+	if req.ClientType == 1 {
+		orderMemberService := service.OrderMemberService{}
+		prepay, err := orderMemberService.GetJsapiPrepay(orderMember)
+		if err != nil {
+			responses.FailWithMessage("发起支付失败", c)
+			return
+		}
+
+		g.PrepayJsapi = prepay
+	} else {
+		orderMemberService := service.OrderMemberService{}
+		prepay, err := orderMemberService.GetAppPrepay(orderMember)
+		if err != nil {
+			responses.FailWithMessage("发起支付失败", c)
+			return
+		}
+
+		g.PrepayApp = prepay
+	}
+
+	responses.OkWithData(g, c)
+}

api/controller/OrderSingle.go

@@ -97,6 +97,25 @@ 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
+	}
+
 	// 开始事务
 	tx := global.Db.Begin()
 	defer func() {
@@ -107,7 +126,7 @@ func (b *OrderSingle) AddOrderSingle(c *gin.Context) {
 
 	// 创建单项订单
 	orderSingleService := service.OrderSingleService{}
-	orderSingle, err := orderSingleService.AddOrderSingle(tx, userId, questionId, userCouponId, req.PayChannel)
+	orderSingle, err := orderSingleService.AddOrderSingle(tx, userId, questionId, userCouponId, req.PayChannel, req.OrderPrice)
 	if err != nil {
 		tx.Rollback()
 		responses.FailWithMessage(err.Error(), c)

api/controller/Question.go

@@ -10,6 +10,7 @@ import (
 	"hepa-calc-api/global"
 	"hepa-calc-api/utils"
 	"strconv"
+	"time"
 )
 
 type Question struct{}
@@ -99,12 +100,16 @@ func (r *Question) GetQuestion(c *gin.Context) {
 		return
 	}
 
-	// 检测问题是否被用户收藏
+	questionService := service.QuestionService{}
+
+	// 处理问题优惠价格
+	question.DiscountPrice = questionService.HandleQuestionDiscountPrice(question.DiscountPrice, question.DiscountEndTime)
+
+	// 检测用户收藏状态
 	userCollectionService := service.UserCollectionService{}
-	IsCollection := userCollectionService.CheckUserCollectionQuestion(userId, questionId)
+	IsCollection := userCollectionService.GetUserCollectionQuestionStatus(userId, questionId)
 
 	// 获取用户首次购买价格
-	questionService := service.QuestionService{}
 	firstTimePrice, err := questionService.GetUserFirstTimeBuyPrice(userId, questionId)
 	if err != nil {
 		responses.FailWithMessage("题目错误", c)
@@ -112,7 +117,7 @@ func (r *Question) GetQuestion(c *gin.Context) {
 	}
 
 	// 获取问题被购买数量
-	buyCount, err := questionService.GetQuestionBuyCount(userId, questionId)
+	buyCount, _ := questionService.GetQuestionBuyCount(userId, questionId)
 
 	g := dto.GetQuestionDto(question)
 
@@ -127,3 +132,117 @@ func (r *Question) GetQuestion(c *gin.Context) {
 
 	responses.OkWithData(g, c)
 }
+
+// GetQuestionBuyStatus 获取问题购买状态
+func (r *Question) GetQuestionBuyStatus(c *gin.Context) {
+	// 购买状态（0:否 1:是）
+	var status int
+	userId := c.GetInt64("UserId")
+
+	id := c.Param("question_id")
+	if id == "" {
+		responses.FailWithMessage("缺少参数", c)
+		return
+	}
+
+	// 将 id 转换为 int64 类型
+	questionId, err := strconv.ParseInt(id, 10, 64)
+	if err != nil {
+		responses.Fail(c)
+		return
+	}
+
+	// 获取题目数据
+	questionDao := dao.QuestionDao{}
+	question, err := questionDao.GetQuestionById(questionId)
+	if err != nil {
+		responses.FailWithMessage("题目错误", c)
+		return
+	}
+
+	if question.QuestionStatus != 1 {
+		responses.FailWithMessage("题目错误", c)
+		return
+	}
+
+	// 获取用户数据
+	userDao := dao.UserDao{}
+	user, err := userDao.GetUserById(userId)
+	if err != nil || user == nil {
+		responses.FailWithMessage("用户错误", c)
+		return
+	}
+
+	// 检测用户会员
+	userService := service.UserService{}
+	isMember := userService.CheckUserMember(user)
+	if isMember == true {
+		// 用户为会员，可直接查看
+		status = 1
+		responses.OkWithData(status, c)
+		return
+	}
+
+	// 获取单项配置
+	systemSingleDao := dao.SystemSingleDao{}
+
+	maps := make(map[string]interface{})
+	systemSingle, err := systemSingleDao.GetSystemSingle(maps)
+	if err != nil {
+		responses.FailWithMessage("内部错误", c)
+		return
+	}
+
+	// 获取用户订单
+	orderSingleDao := dao.OrderSingleDao{}
+	maps = make(map[string]interface{})
+	maps["user_id"] = userId
+	maps["question_id"] = questionId
+	orderSingles, err := orderSingleDao.GetOrderSingleList(maps)
+	if err != nil {
+		responses.FailWithMessage("用户错误", c)
+		return
+	}
+
+	// 是否购买过（0:否 1:是）
+	var isBuy int
+	for _, single := range orderSingles {
+		// 订单状态（1:待支付 2:已完成 3:已取消）
+		if single.OrderStatus != 2 {
+			continue
+		}
+
+		// 支付状态（1:未支付 2:已支付 3:支付中 4:支付失败 5:支付超时 6:支付关闭 7:已撤销 8:转入退款）
+		if single.PayStatus != 2 {
+			continue
+		}
+
+		// 订单退款状态（0:无退款 1:申请退款 2:退款中 3:退款成功 4:拒绝退款 5:退款关闭 6:退款异常 7:部分退款）
+		if single.RefundStatus != 0 {
+			continue
+		}
+
+		// 取消状态（0:否 1:是）
+		if single.CancelStatus == 1 {
+			continue
+		}
+
+		// 判断是否还在有效期内
+		now := time.Now()
+		ValidTime := single.PayTime.Add(time.Duration(systemSingle.ValidDays))
+		if ValidTime.Before(now) {
+			continue
+		}
+
+		isBuy = 1
+		break
+	}
+
+	if isBuy == 1 {
+		status = 1
+		responses.OkWithData(status, c)
+		return
+	}
+
+	responses.OkWithData(status, c)
+}

api/controller/SystemMember.go

@@ -1,27 +1,40 @@
 package controller
 
 import (
+	"fmt"
 	"github.com/gin-gonic/gin"
 	"hepa-calc-api/api/dao"
 	"hepa-calc-api/api/dto"
 	"hepa-calc-api/api/responses"
+	"hepa-calc-api/api/service"
 )
 
 type SystemMember struct{}
 
 // GetSystemMember 获取会员配置数据
 func (b *SystemMember) GetSystemMember(c *gin.Context) {
+	userId := c.GetInt64("UserId")
+
 	systemMemberDao := dao.SystemMemberDao{}
 
 	maps := make(map[string]interface{})
-	systemMember, err := systemMemberDao.GetSystemMemberList(maps)
+	systemMembers, err := systemMemberDao.GetSystemMemberList(maps)
 	if err != nil {
 		responses.FailWithMessage(err.Error(), c)
 		return
 	}
 
+	// 检测用户是否购买过会员
+	userService := service.UserService{}
+	isBuy := userService.CheckUserBuyOrderMember(userId)
+	if isBuy == true {
+		for _, member := range systemMembers {
+			fmt.Println(member)
+		}
+	}
+
 	// 处理返回值
-	g := dto.GetSystemMemberListDto(systemMember)
+	g := dto.GetSystemMemberListDto(systemMembers)
 
 	responses.OkWithData(g, c)
 }

api/controller/UserCoupon.go

@@ -6,8 +6,10 @@ import (
 	"hepa-calc-api/api/dto"
 	"hepa-calc-api/api/requests"
 	"hepa-calc-api/api/responses"
+	"hepa-calc-api/api/service"
 	"hepa-calc-api/global"
 	"hepa-calc-api/utils"
+	"strconv"
 )
 
 type UserCoupon struct{}
@@ -89,10 +91,10 @@ func (b *UserCoupon) GetUserCouponUnnotified(c *gin.Context) {
 	responses.OkWithData(g, c)
 }
 
-// GetUserUsableCoupon 获取用户当前可用优惠卷
-func (b *UserCoupon) GetUserUsableCoupon(c *gin.Context) {
+// GetUserUsableQuestionCoupon 获取患者可使用优惠卷-单项
+func (b *UserCoupon) GetUserUsableQuestionCoupon(c *gin.Context) {
 	userCouponRequest := requests.UserCouponRequest{}
-	req := userCouponRequest.GetUserCouponPage
+	req := userCouponRequest.GetUserUsableQuestionCoupon
 	if err := c.ShouldBind(&req); err != nil {
 		responses.FailWithMessage(err.Error(), c)
 		return
@@ -104,32 +106,49 @@ func (b *UserCoupon) GetUserUsableCoupon(c *gin.Context) {
 		return
 	}
 
-	if req.Page == 0 {
-		req.Page = 1
-	}
-
-	if req.PageSize == 0 {
-		req.PageSize = 20
-	}
-
 	userId := c.GetInt64("UserId")
-	req.UserId = userId
 
-	// 获取数据
-	userCouponDao := dao.UserCouponDao{}
-	userCoupon, total, err := userCouponDao.GetUserCouponPageSearch(req, req.Page, req.PageSize)
+	// 将 id 转换为 int64 类型
+	questionId, err := strconv.ParseInt(req.QuestionId, 10, 64)
 	if err != nil {
+		responses.Fail(c)
+		return
+	}
+
+	// 获取患者可使用优惠卷-单项
+	userCouponService := service.UserCouponService{}
+	userCoupon, _ := userCouponService.GetUserUsableQuestionCoupon(userId, questionId, req.AmountTotal)
+
+	responses.OkWithData(userCoupon, c)
+}
+
+// GetUserUsableMemberCoupon 获取患者可使用优惠卷-会员
+func (b *UserCoupon) GetUserUsableMemberCoupon(c *gin.Context) {
+	userCouponRequest := requests.UserCouponRequest{}
+	req := userCouponRequest.GetUserUsableMemberCoupon
+	if err := c.ShouldBind(&req); err != nil {
 		responses.FailWithMessage(err.Error(), c)
 		return
 	}
 
-	// 处理返回值
-	g := dto.GetUserCouponListDto(userCoupon)
+	// 参数验证
+	if err := global.Validate.Struct(req); err != nil {
+		responses.FailWithMessage(utils.Translate(err), c)
+		return
+	}
 
-	result := make(map[string]interface{})
-	result["page"] = req.Page
-	result["page_size"] = req.PageSize
-	result["total"] = total
-	result["data"] = g
-	responses.OkWithData(result, c)
+	userId := c.GetInt64("UserId")
+
+	// 将 id 转换为 int64 类型
+	systemMemberId, err := strconv.ParseInt(req.SystemMemberId, 10, 64)
+	if err != nil {
+		responses.Fail(c)
+		return
+	}
+
+	// 获取患者可使用优惠卷-会员
+	userCouponService := service.UserCouponService{}
+	userCoupon, _ := userCouponService.GetUserUsableMemberCoupon(userId, systemMemberId, req.AmountTotal)
+
+	responses.OkWithData(userCoupon, c)
 }