肝病算一算后台api初始化

.gitignore

@@ -11,7 +11,11 @@
 
 # Output of the go coverage tool, specifically when used with LiteIDE
 *.out
+*.log
 
 # Dependency directories (remove the comment below to include it)
 # vendor/
-
+.idea/
+.git/
+.DS_Store/
+.tmp/

api/controller/Base.go

@@ -0,0 +1,16 @@
+package controller
+
+// Api api接口
+type Api struct {
+	Public        // 公共
+	OrderMember   // 会员订单
+	OrderSingle   // 单项订单
+	User          // 用户
+	Coupon        // 系统优惠卷
+	UserCoupon    // 用户优惠卷
+	BaseClass     // 基础数据-分类
+	Question      // 问题
+	SystemMember  // 会员配置
+	SystemSingle  // 单项配置
+	BaseAgreement // 基础数据-协议
+}

api/controller/BaseAgreement.go

@@ -0,0 +1,197 @@
+package controller
+
+import (
+	"github.com/gin-gonic/gin"
+	"hepa-calc-admin-api/api/dao"
+	"hepa-calc-admin-api/api/dto"
+	"hepa-calc-admin-api/api/model"
+	"hepa-calc-admin-api/api/requests"
+	"hepa-calc-admin-api/api/responses"
+	"hepa-calc-admin-api/global"
+	"hepa-calc-admin-api/utils"
+	"strconv"
+)
+
+type BaseAgreement struct{}
+
+// GetBaseAgreementPage 获取协议列表-分页
+func (b *BaseAgreement) GetBaseAgreementPage(c *gin.Context) {
+	baseAgreementRequest := requests.BaseAgreementRequest{}
+	req := baseAgreementRequest.GetBaseAgreementPage
+	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
+	}
+
+	if req.Page == 0 {
+		req.Page = 1
+	}
+
+	if req.PageSize == 0 {
+		req.PageSize = 20
+	}
+
+	// 获取分类数据
+	baseAgreementDao := dao.BaseAgreementDao{}
+	baseAgreement, total, err := baseAgreementDao.GetBaseAgreementPageSearch(req.Page, req.PageSize)
+	if err != nil {
+		responses.FailWithMessage(err.Error(), c)
+		return
+	}
+
+	// 处理返回值
+	g := dto.GetBaseAgreementListDto(baseAgreement)
+
+	result := make(map[string]interface{})
+	result["page"] = req.Page
+	result["page_size"] = req.PageSize
+	result["total"] = total
+	result["data"] = g
+	responses.OkWithData(result, c)
+}
+
+// GetBaseAgreement 获取协议详情
+func (b *BaseAgreement) GetBaseAgreement(c *gin.Context) {
+	id := c.Param("agreement_id")
+	if id == "" {
+		responses.FailWithMessage("缺少参数", c)
+		return
+	}
+
+	// 将 id 转换为 int64 类型
+	agreementId, err := strconv.ParseInt(id, 10, 64)
+	if err != nil {
+		responses.Fail(c)
+		return
+	}
+
+	// 获取协议数据
+	baseAgreementDao := dao.BaseAgreementDao{}
+	baseAgreement, err := baseAgreementDao.GetBaseAgreementById(agreementId)
+	if err != nil {
+		responses.FailWithMessage("分类异常", c)
+		return
+	}
+
+	// 处理返回值
+	g := dto.GetBaseAgreementDto(baseAgreement)
+
+	responses.OkWithData(g, c)
+}
+
+// PutBaseAgreement 修改协议
+func (b *BaseAgreement) PutBaseAgreement(c *gin.Context) {
+	BaseAgreementRequest := requests.BaseAgreementRequest{}
+	req := BaseAgreementRequest.PutBaseAgreement
+	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
+	}
+
+	id := c.Param("agreement_id")
+	if id == "" {
+		responses.FailWithMessage("缺少参数", c)
+		return
+	}
+
+	// 将 id 转换为 int64 类型
+	agreementId, err := strconv.ParseInt(id, 10, 64)
+	if err != nil {
+		responses.Fail(c)
+		return
+	}
+
+	// 获取协议数据
+	baseAgreementDao := dao.BaseAgreementDao{}
+	baseAgreement, err := baseAgreementDao.GetBaseAgreementById(agreementId)
+	if err != nil {
+		responses.FailWithMessage("分类异常", c)
+		return
+	}
+
+	// 修改值
+	baseAgreementData := make(map[string]interface{})
+
+	// 协议标题
+	if req.AgreementTitle != baseAgreement.AgreementTitle {
+		baseAgreementData["agreement_title"] = req.AgreementTitle
+	}
+
+	// 协议内容
+	if req.AgreementContent != baseAgreement.AgreementContent {
+		baseAgreementData["agreement_content"] = req.AgreementContent
+	}
+
+	if len(baseAgreementData) > 0 {
+		// 开始事务
+		tx := global.Db.Begin()
+		defer func() {
+			if r := recover(); r != nil {
+				tx.Rollback()
+			}
+		}()
+
+		err = baseAgreementDao.EditBaseAgreementById(tx, agreementId, baseAgreementData)
+		if err != nil {
+			tx.Rollback()
+			responses.FailWithMessage("操作失败", c)
+			return
+		}
+
+		tx.Commit()
+	}
+
+	responses.Ok(c)
+}
+
+// AddBaseAgreement 新增协议
+func (b *BaseAgreement) AddBaseAgreement(c *gin.Context) {
+	BaseAgreementRequest := requests.BaseAgreementRequest{}
+	req := BaseAgreementRequest.AddBaseAgreement
+	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
+	}
+
+	// 开始事务
+	tx := global.Db.Begin()
+	defer func() {
+		if r := recover(); r != nil {
+			tx.Rollback()
+		}
+	}()
+
+	baseAgreement := &model.BaseAgreement{
+		AgreementTitle:   req.AgreementTitle,
+		AgreementContent: req.AgreementContent,
+	}
+
+	baseAgreementDao := dao.BaseAgreementDao{}
+	baseAgreement, err := baseAgreementDao.AddBaseAgreement(tx, baseAgreement)
+	if err != nil {
+		tx.Rollback()
+		responses.FailWithMessage(err.Error(), c)
+		return
+	}
+
+	tx.Commit()
+	responses.Ok(c)
+}

api/controller/BaseClass.go

@@ -0,0 +1,307 @@
+package controller
+
+import (
+	"github.com/gin-gonic/gin"
+	"hepa-calc-admin-api/api/dao"
+	"hepa-calc-admin-api/api/dto"
+	"hepa-calc-admin-api/api/model"
+	"hepa-calc-admin-api/api/requests"
+	"hepa-calc-admin-api/api/responses"
+	"hepa-calc-admin-api/global"
+	"hepa-calc-admin-api/utils"
+	"strconv"
+)
+
+type BaseClass struct{}
+
+// GetBaseClassPage 获取基础分类列表-分页
+func (b *BaseClass) GetBaseClassPage(c *gin.Context) {
+	baseClassRequest := requests.BaseClassRequest{}
+	req := baseClassRequest.GetBaseClassPage
+	if err := c.ShouldBindJSON(&req); err != nil {
+		responses.FailWithMessage(err.Error(), c)
+		return
+	}
+
+	// 参数验证
+	if err := global.Validate.Struct(req); err != nil {
+		responses.FailWithMessage(utils.Translate(err), c)
+		return
+	}
+
+	if req.Page == 0 {
+		req.Page = 1
+	}
+
+	if req.PageSize == 0 {
+		req.PageSize = 20
+	}
+
+	// 获取分类数据
+	baseClassDao := dao.BaseClassDao{}
+	baseClass, total, err := baseClassDao.GetBaseClassPageSearch(req, req.Page, req.PageSize)
+	if err != nil {
+		responses.FailWithMessage(err.Error(), c)
+		return
+	}
+
+	// 处理返回值
+	g := dto.GetBaseClassListDto(baseClass)
+
+	result := make(map[string]interface{})
+	result["page"] = req.Page
+	result["page_size"] = req.PageSize
+	result["total"] = total
+	result["data"] = g
+	responses.OkWithData(result, c)
+}
+
+// GetBaseClassList 获取基础分类列表
+func (b *BaseClass) GetBaseClassList(c *gin.Context) {
+	baseClassRequest := requests.BaseClassRequest{}
+	req := baseClassRequest.GetBaseClassList
+	if err := c.ShouldBindJSON(&req); err != nil {
+		responses.FailWithMessage(err.Error(), c)
+		return
+	}
+
+	// 参数验证
+	if err := global.Validate.Struct(req); err != nil {
+		responses.FailWithMessage(utils.Translate(err), c)
+		return
+	}
+
+	// 获取分类数据
+	baseClassDao := dao.BaseClassDao{}
+	baseClass, err := baseClassDao.GetBaseClassListSearch(req)
+	if err != nil {
+		responses.FailWithMessage(err.Error(), c)
+		return
+	}
+
+	// 处理返回值
+	g := dto.GetBaseClassListDto(baseClass)
+	if err != nil {
+		responses.FailWithMessage(err.Error(), c)
+		return
+	}
+
+	responses.OkWithData(g, c)
+}
+
+// PutBaseClassStatus 操作基础分类状态
+func (b *BaseClass) PutBaseClassStatus(c *gin.Context) {
+	baseClassRequest := requests.BaseClassRequest{}
+	req := baseClassRequest.PutBaseClassStatus
+	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
+	}
+
+	id := c.Param("class_id")
+	if id == "" {
+		responses.FailWithMessage("缺少参数", c)
+		return
+	}
+
+	// 将 id 转换为 int64 类型
+	classId, err := strconv.ParseInt(id, 10, 64)
+	if err != nil {
+		responses.Fail(c)
+		return
+	}
+
+	// 获取基础分类数据
+	baseClassDao := dao.BaseClassDao{}
+	baseClass, err := baseClassDao.GetBaseClassById(classId)
+	if err != nil {
+		responses.FailWithMessage("分类异常", c)
+		return
+	}
+
+	// 检测状态
+	if baseClass.ClassStatus == req.ClassStatus {
+		responses.Ok(c)
+		return
+	}
+
+	// 开始事务
+	tx := global.Db.Begin()
+	defer func() {
+		if r := recover(); r != nil {
+			tx.Rollback()
+		}
+	}()
+
+	baseClassData := make(map[string]interface{})
+	baseClassData["class_status"] = req.ClassStatus
+	err = baseClassDao.EditBaseClassById(tx, classId, baseClassData)
+	if err != nil {
+		tx.Rollback()
+		responses.FailWithMessage("操作失败", c)
+		return
+	}
+
+	tx.Commit()
+	responses.Ok(c)
+}
+
+// GetBaseClass 获取基础分类详情
+func (b *BaseClass) GetBaseClass(c *gin.Context) {
+	id := c.Param("class_id")
+	if id == "" {
+		responses.FailWithMessage("缺少参数", c)
+		return
+	}
+
+	// 将 id 转换为 int64 类型
+	classId, err := strconv.ParseInt(id, 10, 64)
+	if err != nil {
+		responses.Fail(c)
+		return
+	}
+
+	// 获取基础分类数据
+	baseClassDao := dao.BaseClassDao{}
+	baseClass, err := baseClassDao.GetBaseClassById(classId)
+	if err != nil {
+		responses.FailWithMessage("分类异常", c)
+		return
+	}
+
+	// 处理返回值
+	g := dto.GetBaseClassDto(baseClass)
+
+	responses.OkWithData(g, c)
+}
+
+// PutBaseClass 修改基础分类
+func (b *BaseClass) PutBaseClass(c *gin.Context) {
+	baseClassRequest := requests.BaseClassRequest{}
+	req := baseClassRequest.PutBaseClass
+	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
+	}
+
+	id := c.Param("class_id")
+	if id == "" {
+		responses.FailWithMessage("缺少参数", c)
+		return
+	}
+
+	// 将 id 转换为 int64 类型
+	classId, err := strconv.ParseInt(id, 10, 64)
+	if err != nil {
+		responses.Fail(c)
+		return
+	}
+
+	// 获取基础分类数据
+	baseClassDao := dao.BaseClassDao{}
+	baseClass, err := baseClassDao.GetBaseClassById(classId)
+	if err != nil {
+		responses.FailWithMessage("分类异常", c)
+		return
+	}
+
+	// 修改值
+	baseClassData := make(map[string]interface{})
+
+	// 分类名称
+	if req.ClassName != baseClass.ClassName {
+		baseClassData["class_name"] = req.ClassName
+	}
+
+	// 图标地址
+	classIcon := utils.RemoveOssDomain(req.ClassIcon)
+	if classIcon != baseClass.ClassIcon {
+		baseClassData["class_icon"] = classIcon
+	}
+
+	// 分类简介
+	if req.ClassBrief != baseClass.ClassBrief {
+		baseClassData["class_brief"] = req.ClassBrief
+	}
+
+	// 排序值
+	if req.Sort != baseClass.Sort {
+		baseClassData["sort"] = req.Sort
+	}
+
+	if len(baseClassData) > 0 {
+		// 开始事务
+		tx := global.Db.Begin()
+		defer func() {
+			if r := recover(); r != nil {
+				tx.Rollback()
+			}
+		}()
+
+		err = baseClassDao.EditBaseClassById(tx, classId, baseClassData)
+		if err != nil {
+			tx.Rollback()
+			responses.FailWithMessage("操作失败", c)
+			return
+		}
+
+		tx.Commit()
+	}
+
+	responses.Ok(c)
+}
+
+// AddBaseClass 新增基础分类
+func (b *BaseClass) AddBaseClass(c *gin.Context) {
+	baseClassRequest := requests.BaseClassRequest{}
+	req := baseClassRequest.AddBaseClass
+	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
+	}
+
+	// 开始事务
+	tx := global.Db.Begin()
+	defer func() {
+		if r := recover(); r != nil {
+			tx.Rollback()
+		}
+	}()
+
+	baseClass := &model.BaseClass{
+		ClassName:   req.ClassName,
+		ClassStatus: 1,
+		ClassIcon:   utils.RemoveOssDomain(req.ClassIcon),
+		ClassBrief:  req.ClassBrief,
+		Sort:        req.Sort,
+	}
+
+	baseClassDao := dao.BaseClassDao{}
+	baseClass, err := baseClassDao.AddBaseClass(tx, baseClass)
+	if err != nil {
+		tx.Rollback()
+		responses.FailWithMessage(err.Error(), c)
+		return
+	}
+
+	tx.Commit()
+	responses.Ok(c)
+}

api/controller/Coupon.go

@@ -0,0 +1,348 @@
+package controller
+
+import (
+	"fmt"
+	"github.com/gin-gonic/gin"
+	"hepa-calc-admin-api/api/dao"
+	"hepa-calc-admin-api/api/dto"
+	"hepa-calc-admin-api/api/model"
+	"hepa-calc-admin-api/api/requests"
+	"hepa-calc-admin-api/api/responses"
+	"hepa-calc-admin-api/global"
+	"hepa-calc-admin-api/utils"
+	"strconv"
+	"time"
+)
+
+type Coupon struct{}
+
+// GetCouponPage 获取系统优惠卷列表-分页
+func (b *Coupon) GetCouponPage(c *gin.Context) {
+	couponRequest := requests.CouponRequest{}
+	req := couponRequest.GetCouponPage
+	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
+	}
+
+	if req.Page == 0 {
+		req.Page = 1
+	}
+
+	if req.PageSize == 0 {
+		req.PageSize = 20
+	}
+
+	// 获取数据
+	couponDao := dao.CouponDao{}
+	coupon, total, err := couponDao.GetCouponPageSearch(req, req.Page, req.PageSize)
+	if err != nil {
+		responses.FailWithMessage(err.Error(), c)
+		return
+	}
+
+	// 处理返回值
+	g := dto.GetCouponListDto(coupon)
+
+	result := make(map[string]interface{})
+	result["page"] = req.Page
+	result["page_size"] = req.PageSize
+	result["total"] = total
+	result["data"] = g
+	responses.OkWithData(result, c)
+}
+
+// GetCoupon 获取系统优惠卷详情
+func (b *Coupon) GetCoupon(c *gin.Context) {
+	id := c.Param("coupon_id")
+	if id == "" {
+		responses.FailWithMessage("缺少参数", c)
+		return
+	}
+
+	// 将 id 转换为 int64 类型
+	couponId, err := strconv.ParseInt(id, 10, 64)
+	if err != nil {
+		responses.Fail(c)
+		return
+	}
+
+	// 获取订单数据
+	couponDao := dao.CouponDao{}
+	coupon, err := couponDao.GetCouponById(couponId)
+	if err != nil {
+		responses.FailWithMessage("优惠卷异常", c)
+		return
+	}
+
+	// 处理返回值
+	g := dto.GetCouponDto(coupon)
+
+	responses.OkWithData(g, c)
+}
+
+// PutCouponStatus 操作系统优惠卷状态
+func (b *Coupon) PutCouponStatus(c *gin.Context) {
+	couponRequest := requests.CouponRequest{}
+	req := couponRequest.PutCouponStatus
+	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
+	}
+
+	id := c.Param("coupon_id")
+	if id == "" {
+		responses.FailWithMessage("缺少参数", c)
+		return
+	}
+
+	// 将 id 转换为 int64 类型
+	couponId, err := strconv.ParseInt(id, 10, 64)
+	if err != nil {
+		responses.Fail(c)
+		return
+	}
+
+	// 获取优惠卷数据
+	couponDao := dao.CouponDao{}
+	coupon, err := couponDao.GetCouponById(couponId)
+	if err != nil {
+		responses.FailWithMessage("优惠卷异常", c)
+		return
+	}
+
+	// 检测优惠卷删除状态
+	if coupon.CouponStatus == req.CouponStatus {
+		responses.Ok(c)
+		return
+	}
+
+	// 开始事务
+	tx := global.Db.Begin()
+	defer func() {
+		if r := recover(); r != nil {
+			tx.Rollback()
+		}
+	}()
+
+	couponData := make(map[string]interface{})
+	couponData["coupon_status"] = req.CouponStatus
+	err = couponDao.EditCouponById(tx, couponId, couponData)
+	if err != nil {
+		tx.Rollback()
+		responses.FailWithMessage("操作失败", c)
+		return
+	}
+
+	tx.Commit()
+	responses.Ok(c)
+}
+
+// AddSystemCoupon 新增系统优惠卷
+func (r *Coupon) AddSystemCoupon(c *gin.Context) {
+	couponRequest := requests.CouponRequest{}
+	req := couponRequest.AddSystemCoupon
+	if err := c.ShouldBindJSON(&req); err != nil {
+		responses.FailWithMessage(err.Error(), c)
+		return
+	}
+
+	// 参数验证
+	if err := global.Validate.Struct(req); err != nil {
+		responses.FailWithMessage(utils.Translate(err), c)
+		return
+	}
+
+	// 满减
+	if req.CouponType == 2 {
+		if *req.WithAmount == 0 {
+			responses.FailWithMessage("请填入符合满减标准金额", c)
+			return
+		}
+	}
+
+	// 适用范围（1:全场通用 2:单项 3:会员）
+	if req.ApplicationScope == 1 {
+		// 全场通用
+		if req.QuestionId == nil && req.SystemMemberId == nil {
+			responses.FailWithMessage("请填入关联选项", c)
+			return
+		}
+	}
+
+	if req.ApplicationScope == 2 {
+		// 单项
+		if req.QuestionId == nil {
+			responses.FailWithMessage("请填入关联算一算", c)
+			return
+		}
+	}
+
+	// 适用范围（1:全场通用 2:单项 3:会员）
+	if req.ApplicationScope == 3 {
+		// 会员
+		if req.SystemMemberId == nil {
+			responses.FailWithMessage("请填入关联会员", c)
+			return
+		}
+	}
+
+	// 有效类型-绝对时效
+	if req.ValidType == 1 {
+		if req.ValidStartTime == nil {
+			responses.FailWithMessage("请填入开始使用时间", c)
+			return
+		}
+
+		if req.ValidEndTime == nil {
+			responses.FailWithMessage("请填入结束使用时间", c)
+			return
+		}
+	}
+
+	// 有效类型-相对时效
+	if req.ValidType == 2 {
+		if req.ValidDays == nil {
+			responses.FailWithMessage("请填入有效天数", c)
+			return
+		}
+	}
+
+	// 开始事务
+	tx := global.Db.Begin()
+	defer func() {
+		if r := recover(); r != nil {
+			tx.Rollback()
+			fmt.Println(r)
+		}
+	}()
+
+	// 新增优惠卷表
+	coupon := &model.Coupon{
+		CouponName:       req.CouponName,
+		CouponType:       req.CouponType,
+		CouponStatus:     1,
+		ApplicationScope: req.ApplicationScope,
+		IsMutex:          req.IsMutex,
+		CouponCount:      req.CouponCount,
+		CouponTakeCount:  0,
+		CouponUsedCount:  0,
+		CouponPrice:      req.CouponPrice,
+		ValidType:        req.ValidType,
+		ValidStartTime:   nil,
+		ValidEndTime:     nil,
+		CouponDesc:       req.CouponDesc,
+		QuestionId:       nil,
+		SystemMemberId:   nil,
+	}
+
+	// 符合满减标准金额
+	if req.WithAmount != nil {
+		coupon.WithAmount = req.WithAmount
+	}
+
+	// 有效天数
+	if req.ValidDays != nil {
+		coupon.ValidDays = req.ValidDays
+	}
+
+	// 时间区间
+	if req.ValidStartTime != nil {
+		// 获取本地时区
+		location, err := time.LoadLocation("Local")
+		if err != nil {
+			tx.Rollback()
+			responses.FailWithMessage("新增失败", c)
+			return
+		}
+
+		t, err := time.ParseInLocation("2006-01-02 15:04:05", *req.ValidStartTime, location)
+		if err != nil {
+			tx.Rollback()
+			responses.FailWithMessage("新增失败", c)
+			return
+		}
+
+		validStartTime := model.LocalTime(t)
+
+		coupon.ValidStartTime = &validStartTime
+	}
+
+	if req.ValidEndTime != nil {
+		// 获取本地时区
+		location, err := time.LoadLocation("Local")
+		if err != nil {
+			tx.Rollback()
+			responses.FailWithMessage("新增失败", c)
+			return
+		}
+
+		t, err := time.ParseInLocation("2006-01-02 15:04:05", *req.ValidEndTime, location)
+		if err != nil {
+			tx.Rollback()
+			responses.FailWithMessage("新增失败", c)
+			return
+		}
+
+		validEndTime := model.LocalTime(t)
+		coupon.ValidEndTime = &validEndTime
+
+		// 检测结束时间-不允许当天结束
+		now := time.Now()
+		year, month, day := now.Date()
+		endOfDay := time.Date(year, month, day, 23, 59, 59, 0, location)
+		if time.Time(validEndTime).Before(endOfDay) {
+			tx.Rollback()
+			responses.FailWithMessage("优惠卷过期时间最低设置为明天", c)
+			return
+		}
+	}
+
+	// 关联单项id
+	if req.QuestionId != nil {
+		questionId, err := strconv.ParseInt(*req.QuestionId, 10, 64)
+		if err != nil {
+			tx.Rollback()
+			responses.FailWithMessage("新增失败", c)
+			return
+		}
+
+		coupon.QuestionId = &questionId
+	}
+
+	// 关联会员id
+	if req.SystemMemberId != nil {
+		systemMemberId, err := strconv.ParseInt(*req.SystemMemberId, 10, 64)
+		if err != nil {
+			tx.Rollback()
+			responses.FailWithMessage("新增失败", c)
+			return
+		}
+
+		coupon.QuestionId = &systemMemberId
+	}
+
+	couponDao := dao.CouponDao{}
+	coupon, err := couponDao.AddCoupon(tx, coupon)
+	if err != nil || coupon == nil {
+		tx.Rollback()
+		responses.FailWithMessage(err.Error(), c)
+		return
+	}
+
+	tx.Commit()
+
+	responses.Ok(c)
+}

api/controller/OrderMember.go

@@ -0,0 +1,219 @@
+package controller
+
+import (
+	"github.com/gin-gonic/gin"
+	"hepa-calc-admin-api/api/dao"
+	"hepa-calc-admin-api/api/dto"
+	"hepa-calc-admin-api/api/requests"
+	"hepa-calc-admin-api/api/responses"
+	"hepa-calc-admin-api/api/service"
+	"hepa-calc-admin-api/global"
+	"hepa-calc-admin-api/utils"
+	"strconv"
+)
+
+type OrderMember struct{}
+
+// GetOrderMemberPage 获取会员订单列表-分页
+func (b *OrderMember) GetOrderMemberPage(c *gin.Context) {
+	orderMemberRequest := requests.OrderMemberRequest{}
+	req := orderMemberRequest.GetOrderMemberPage
+	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
+	}
+
+	if req.Page == 0 {
+		req.Page = 1
+	}
+
+	if req.PageSize == 0 {
+		req.PageSize = 20
+	}
+
+	userId := c.GetInt64("UserId")
+	req.UserId = userId
+
+	// 获取数据
+	orderMemberDao := dao.OrderMemberDao{}
+	orderMember, total, err := orderMemberDao.GetOrderMemberPageSearch(req, req.Page, req.PageSize)
+	if err != nil {
+		responses.FailWithMessage(err.Error(), c)
+		return
+	}
+
+	// 处理返回值
+	g := dto.GetOrderMemberListDto(orderMember)
+
+	result := make(map[string]interface{})
+	result["page"] = req.Page
+	result["page_size"] = req.PageSize
+	result["total"] = total
+	result["data"] = g
+	responses.OkWithData(result, c)
+}
+
+// GetOrderMember 获取会员订单详情
+func (b *OrderMember) GetOrderMember(c *gin.Context) {
+	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{}
+	orderMember, err := orderMemberDao.GetOrderMemberPreloadById(orderId)
+	if err != nil {
+		responses.FailWithMessage("订单异常", c)
+		return
+	}
+
+	// 处理返回值
+	g := dto.GetOrderMemberDto(orderMember)
+
+	// 加载会员数据
+	g.LoadSystemMember(orderMember.SystemMember)
+
+	// 加载用户数据
+	g.LoadUserAttr(orderMember.User)
+
+	responses.OkWithData(g, c)
+}
+
+// PutCancelOrderMember 取消会员订单
+func (b *OrderMember) PutCancelOrderMember(c *gin.Context) {
+	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{}
+	orderMember, err := orderMemberDao.GetOrderMemberById(orderId)
+	if err != nil {
+		responses.FailWithMessage("订单异常", c)
+		return
+	}
+
+	// 开始事务
+	tx := global.Db.Begin()
+	defer func() {
+		if r := recover(); r != nil {
+			tx.Rollback()
+		}
+	}()
+
+	// 取消单项订单
+	orderMemberService := service.OrderMemberService{}
+	res, err := orderMemberService.CancelOrderMember(tx, orderMember.UserId, orderId, 2)
+	if err != nil {
+		tx.Rollback()
+		responses.FailWithMessage(err.Error(), c)
+		return
+	}
+
+	if res == false {
+		tx.Rollback()
+		responses.FailWithMessage("取消订单失败", c)
+		return
+	}
+
+	tx.Commit()
+	responses.Ok(c)
+}
+
+// PutOrderMemberDeleteStatus 操作会员订单删除状态
+func (b *OrderMember) PutOrderMemberDeleteStatus(c *gin.Context) {
+	orderMemberRequest := requests.OrderMemberRequest{}
+	req := orderMemberRequest.PutOrderMemberDeleteStatus
+	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
+	}
+
+	if req.IsDelete != 0 && req.IsDelete != 1 {
+		responses.FailWithMessage("参数错误", c)
+		return
+	}
+
+	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{}
+	orderMember, err := orderMemberDao.GetOrderMemberById(orderId)
+	if err != nil {
+		responses.FailWithMessage("订单异常", c)
+		return
+	}
+
+	// 检测订单状态
+	if orderMember.OrderStatus == 2 {
+		responses.FailWithMessage("订单不允许删除", c)
+		return
+	}
+
+	// 检测订单删除状态
+	if orderMember.IsDelete == req.IsDelete {
+		responses.Ok(c)
+		return
+	}
+
+	// 开始事务
+	tx := global.Db.Begin()
+	defer func() {
+		if r := recover(); r != nil {
+			tx.Rollback()
+		}
+	}()
+
+	orderMemberData := make(map[string]interface{})
+	orderMemberData["is_delete"] = req.IsDelete
+	err = orderMemberDao.EditOrderMemberById(tx, orderId, orderMemberData)
+	if err != nil {
+		tx.Rollback()
+		responses.FailWithMessage("删除失败", c)
+		return
+	}
+
+	tx.Commit()
+	responses.Ok(c)
+}

api/controller/OrderSingle.go

@@ -0,0 +1,274 @@
+package controller
+
+import (
+	"github.com/gin-gonic/gin"
+	"hepa-calc-admin-api/api/dao"
+	"hepa-calc-admin-api/api/dto"
+	"hepa-calc-admin-api/api/requests"
+	"hepa-calc-admin-api/api/responses"
+	"hepa-calc-admin-api/api/service"
+	"hepa-calc-admin-api/global"
+	"hepa-calc-admin-api/utils"
+	"strconv"
+	"time"
+)
+
+type OrderSingle struct{}
+
+// GetOrderSinglePage 获取单项订单列表-分页
+func (b *OrderSingle) GetOrderSinglePage(c *gin.Context) {
+	orderSingleRequest := requests.OrderSingleRequest{}
+	req := orderSingleRequest.GetOrderSinglePage
+	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
+	}
+
+	if req.Page == 0 {
+		req.Page = 1
+	}
+
+	if req.PageSize == 0 {
+		req.PageSize = 20
+	}
+
+	userId := c.GetInt64("UserId")
+	req.UserId = userId
+
+	// 获取数据
+	orderSingleDao := dao.OrderSingleDao{}
+	orderSingles, total, err := orderSingleDao.GetOrderSinglePageSearch(req, req.Page, req.PageSize)
+	if err != nil {
+		responses.FailWithMessage(err.Error(), c)
+		return
+	}
+
+	// 获取单项配置
+	systemSingleDao := dao.SystemSingleDao{}
+
+	maps := make(map[string]interface{})
+	systemSingle, err := systemSingleDao.GetSystemSingle(maps)
+	if err != nil {
+		responses.FailWithMessage("内部错误", c)
+		return
+	}
+
+	// 处理返回值
+	g := dto.GetOrderSingleListDto(orderSingles)
+
+	for _, singleDto := range g {
+		// 有效时间
+		var validTime *time.Time
+
+		// 计算有效期
+		if singleDto.IsMember == 1 {
+			validTime = singleDto.MemberExpireDate
+		} else {
+			if singleDto.PayTime != nil {
+				payTime := singleDto.PayTime.Add(time.Duration(systemSingle.ValidDays) * 24 * time.Hour)
+				validTime = &payTime
+			}
+		}
+
+		singleDto.LoadValidDate(validTime)
+	}
+
+	result := make(map[string]interface{})
+	result["page"] = req.Page
+	result["page_size"] = req.PageSize
+	result["total"] = total
+	result["data"] = g
+	responses.OkWithData(result, c)
+}
+
+// PutCancelOrderSingle 取消单项订单
+func (b *OrderSingle) PutCancelOrderSingle(c *gin.Context) {
+	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
+	}
+
+	// 获取订单数据
+	orderSingleDao := dao.OrderSingleDao{}
+	maps := make(map[string]interface{})
+	maps["order_id"] = orderId
+	orderSingle, err := orderSingleDao.GetOrderSingle(maps)
+	if err != nil {
+		responses.FailWithMessage("订单异常", c)
+		return
+	}
+
+	// 开始事务
+	tx := global.Db.Begin()
+	defer func() {
+		if r := recover(); r != nil {
+			tx.Rollback()
+		}
+	}()
+
+	// 取消单项订单
+	orderSingleService := service.OrderSingleService{}
+	res, err := orderSingleService.CancelOrderSingle(tx, orderSingle.UserId, orderId, 2)
+	if err != nil {
+		tx.Rollback()
+		responses.FailWithMessage(err.Error(), c)
+		return
+	}
+
+	if res == false {
+		tx.Rollback()
+		responses.FailWithMessage("取消订单失败", c)
+		return
+	}
+
+	tx.Commit()
+	responses.Ok(c)
+}
+
+// PutOrderSingleDeleteStatus 操作单项订单删除状态
+func (b *OrderSingle) PutOrderSingleDeleteStatus(c *gin.Context) {
+	orderSingleRequest := requests.OrderSingleRequest{}
+	req := orderSingleRequest.PutOrderSingleDeleteStatus
+	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
+	}
+
+	if req.IsDelete != 0 && req.IsDelete != 1 {
+		responses.FailWithMessage("参数错误", c)
+		return
+	}
+
+	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
+	}
+
+	// 获取订单数据
+	orderSingleDao := dao.OrderSingleDao{}
+	orderSingle, err := orderSingleDao.GetOrderSingleById(orderId)
+	if err != nil {
+		responses.FailWithMessage("订单异常", c)
+		return
+	}
+
+	// 检测订单状态
+	if orderSingle.OrderStatus == 2 {
+		responses.FailWithMessage("订单不允许删除", c)
+		return
+	}
+
+	// 检测订单删除状态
+	if orderSingle.IsDelete == req.IsDelete {
+		responses.Ok(c)
+		return
+	}
+
+	// 开始事务
+	tx := global.Db.Begin()
+	defer func() {
+		if r := recover(); r != nil {
+			tx.Rollback()
+		}
+	}()
+
+	orderSingleData := make(map[string]interface{})
+	orderSingleData["is_delete"] = 1
+	err = orderSingleDao.EditOrderSingleById(tx, orderId, orderSingleData)
+	if err != nil {
+		tx.Rollback()
+		responses.FailWithMessage("删除失败", c)
+		return
+	}
+
+	tx.Commit()
+	responses.Ok(c)
+}
+
+// GetOrderSingle 获取单项订单详情
+func (b *OrderSingle) GetOrderSingle(c *gin.Context) {
+	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
+	}
+
+	// 获取订单数据
+	orderSingleDao := dao.OrderSingleDao{}
+	orderSingle, err := orderSingleDao.GetOrderSinglePreloadById(orderId)
+	if err != nil {
+		responses.FailWithMessage("订单异常", c)
+		return
+	}
+
+	// 获取单项配置
+	systemSingleDao := dao.SystemSingleDao{}
+
+	maps := make(map[string]interface{})
+	systemSingle, err := systemSingleDao.GetSystemSingle(maps)
+	if err != nil {
+		responses.FailWithMessage("内部错误", c)
+		return
+	}
+
+	// 有效时间
+	var validTime *time.Time
+
+	// 计算有效期
+	if orderSingle.User.IsMember == 1 {
+		validTime = orderSingle.User.MemberExpireDate
+	} else {
+		if orderSingle.PayTime != nil {
+			payTime := orderSingle.PayTime.Add(time.Duration(systemSingle.ValidDays) * 24 * time.Hour)
+			validTime = &payTime
+		}
+	}
+
+	g := dto.GetOrderSingleDto(orderSingle)
+
+	// 加载题目数据
+	g.LoadQuestion(orderSingle.Question)
+
+	// 加载到期时间
+	g.LoadValidDate(validTime)
+
+	// 加载用户数据
+	g.LoadUserAttr(orderSingle.User)
+
+	responses.OkWithData(g, c)
+}

api/controller/Public.go

@@ -0,0 +1,328 @@
+package controller
+
+import (
+	"crypto/md5"
+	"encoding/hex"
+	"fmt"
+	"github.com/gin-gonic/gin"
+	"hepa-calc-admin-api/api/dao"
+	"hepa-calc-admin-api/api/dto"
+	"hepa-calc-admin-api/api/requests"
+	"hepa-calc-admin-api/api/responses"
+	"hepa-calc-admin-api/config"
+	"hepa-calc-admin-api/global"
+	"hepa-calc-admin-api/utils"
+	"time"
+)
+
+type Public struct{}
+
+// Login 登陆
+func (b *Public) Login(c *gin.Context) {
+	publicRequest := requests.PublicRequest{}
+	req := publicRequest.Login
+	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
+	}
+
+	if err := c.ShouldBind(&req); err != nil {
+		responses.FailWithMessage(err.Error(), c)
+		return
+	}
+
+	// 验证验证码
+	if config.C.Env == "prod" {
+		isValid := utils.VerifyCaptcha(req.CaptchaId, req.Captcha)
+		if !isValid {
+			// 验证码错误
+			responses.FailWithMessage("验证码错误", c)
+			return
+		}
+	}
+
+	// 获取用户信息
+	AdminUserDao := dao.AdminUserDao{}
+	maps := make(map[string]interface{})
+	maps["access"] = req.Access
+	adminUser, err := AdminUserDao.GetAdminUser(maps)
+	if err != nil || adminUser == nil {
+		responses.FailWithMessage("用户名或密码错误", c)
+		return
+	}
+
+	// 检测用户密码
+	password := md5.Sum([]byte(req.Password + adminUser.Salt))
+	// 将哈希值转换为16进制字符串
+	passwordString := hex.EncodeToString(password[:])
+
+	fmt.Println(passwordString)
+	if passwordString != adminUser.Password {
+		responses.FailWithMessage("用户名或密码错误", c)
+		return
+	}
+
+	// 检测用户状态
+	if adminUser.IsDeleted == 1 {
+		responses.FailWithMessage("非法用户", c)
+		return
+	}
+
+	if adminUser.IsDisabled == 1 {
+		responses.FailWithMessage("您的账号已被禁用，请联系管理员处理", c)
+		return
+	}
+
+	// 下发token
+	token := &utils.Token{
+		UserId: fmt.Sprintf("%d", adminUser.UserId),
+	}
+
+	// 生成jwt
+	jwt, err := token.NewJWT()
+	if err != nil || jwt == "" {
+		responses.FailWithMessage("登陆失败", c)
+		return
+	}
+
+	g := dto.AdminLoginDto(adminUser)
+
+	g.LoadToken(jwt)
+
+	responses.OkWithData(g, c)
+}
+
+// GetCaptcha 获取验证码
+func (b *Public) GetCaptcha(c *gin.Context) {
+	id, b64s, err := utils.GenerateCaptcha()
+	if err != nil {
+		responses.FailWithMessage("验证码获取失败", c)
+	}
+
+	responses.OkWithData(gin.H{
+		"id":   id,
+		"b64s": b64s,
+	}, c)
+}
+
+// GetIndex 首页
+func (b *Public) GetIndex(c *gin.Context) {
+	userDao := dao.UserDao{}
+	questionDao := dao.QuestionDao{}
+	orderMemberDao := dao.OrderMemberDao{}
+	orderSingleDao := dao.OrderSingleDao{}
+
+	// 获取问题数量
+	maps := make(map[string]interface{})
+	maps["question_status"] = 1
+	questionCount, err := questionDao.GetQuestionCount(maps)
+	if err != nil {
+		questionCount = 0
+	}
+
+	// 获取用户数量
+	maps = make(map[string]interface{})
+	userCount, err := userDao.GetUserCount(maps)
+	if err != nil {
+		questionCount = 0
+	}
+
+	// 获取有效会员数
+	maps = make(map[string]interface{})
+	maps["user_status"] = 1
+	maps["is_member"] = 1
+	validMemberCount, err := userDao.GetUserCount(maps)
+	if err != nil {
+		validMemberCount = 0
+	}
+
+	// 获取问题总提交次数
+	maps = make(map[string]interface{})
+	questionSubmitCount, err := questionDao.GetQuestionSum(maps, "submit_count")
+	if err != nil {
+		questionSubmitCount = 0
+	}
+
+	// 获取问题总支付次数
+	maps = make(map[string]interface{})
+	questionPayCount, err := questionDao.GetQuestionSum(maps, "pay_count")
+	if err != nil {
+		questionPayCount = 0
+	}
+
+	// 获取会员购买次数
+	maps = make(map[string]interface{})
+	maps["order_status"] = 2
+	maps["pay_status"] = 2
+	maps["refund_status"] = 0
+	maps["cancel_status"] = 0
+	memberBuyCount, err := orderMemberDao.GetOrderMemberCount(maps)
+	if err != nil {
+		memberBuyCount = 0
+	}
+
+	// 获取会员购买总金额
+	maps = make(map[string]interface{})
+	maps["order_status"] = 2
+	maps["pay_status"] = 2
+	maps["refund_status"] = 0
+	maps["cancel_status"] = 0
+	memberAmountTotal, err := orderMemberDao.GetOrderMemberSum(maps, "payment_amount_total")
+	if err != nil {
+		memberAmountTotal = 0
+	}
+
+	// 获取会员购买总金额
+	maps = make(map[string]interface{})
+	maps["order_status"] = 2
+	maps["pay_status"] = 2
+	maps["refund_status"] = 0
+	maps["cancel_status"] = 0
+	singleAmountTotal, err := orderSingleDao.GetOrderSingleSum(maps, "payment_amount_total")
+	if err != nil {
+		singleAmountTotal = 0
+	}
+
+	g := dto.IndexDto{
+		QuestionCount:       questionCount,
+		UserCount:           userCount,
+		ValidMemberCount:    validMemberCount,
+		QuestionSubmitCount: int64(questionSubmitCount),
+		QuestionPayCount:    int64(questionPayCount),
+		MemberBuyCount:      memberBuyCount,
+		MemberAmountTotal:   memberAmountTotal,
+		SingleAmountTotal:   singleAmountTotal,
+		AmountTotal:         memberAmountTotal + singleAmountTotal,
+	}
+
+	responses.OkWithData(g, c)
+}
+
+// GetIndexData 首页动态统计数据
+func (b *Public) GetIndexData(c *gin.Context) {
+	publicRequest := requests.PublicRequest{}
+	req := publicRequest.GetIndexData
+	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
+	}
+
+	if err := c.ShouldBind(&req); err != nil {
+		responses.FailWithMessage(err.Error(), c)
+		return
+	}
+
+	// 返回值
+	var g []*dto.IndexDataDto
+	results := make(map[string]int64)
+
+	// 分类（1:新增用户数 2:新增算算数 3:新增单项支付数 4:新增会员购买数）
+	if req.Type == 1 {
+		// 新增用户数
+		endTime, _ := time.Parse("2006-01-02", req.EndTime)
+		req.EndTime = endTime.Add(23*time.Hour + 59*time.Minute + 59*time.Second).Format("2006-01-02 15:04:05")
+
+		userDao := dao.UserDao{}
+		maps := make(map[string]interface{})
+		users, err := userDao.GetUserListByTime(maps, req.StartTime, req.EndTime, "created_at")
+		if err != nil {
+			responses.FailWithMessage(err.Error(), c)
+			return
+		}
+
+		for _, user := range users {
+			date := time.Time(user.CreatedAt).Format("2006-01-02")
+			results[date]++
+		}
+
+	}
+
+	// 新增算算数
+	if req.Type == 2 {
+		endTime, _ := time.Parse("2006-01-02", req.EndTime)
+		req.EndTime = endTime.Add(23*time.Hour + 59*time.Minute + 59*time.Second).Format("2006-01-02 15:04:05")
+
+		questionDao := dao.QuestionDao{}
+		maps := make(map[string]interface{})
+		maps["question_status"] = 1
+		questions, err := questionDao.GetQuestionListByTime(maps, req.StartTime, req.EndTime, "created_at")
+		if err != nil {
+			responses.FailWithMessage(err.Error(), c)
+			return
+		}
+
+		for _, question := range questions {
+			date := time.Time(question.CreatedAt).Format("2006-01-02")
+			results[date]++
+		}
+	}
+
+	// 新增单项支付数
+	if req.Type == 3 {
+		endTime, _ := time.Parse("2006-01-02", req.EndTime)
+		req.EndTime = endTime.Add(23*time.Hour + 59*time.Minute + 59*time.Second).Format("2006-01-02 15:04:05")
+
+		orderSingleDao := dao.OrderSingleDao{}
+		maps := make(map[string]interface{})
+		maps["order_status"] = 2
+		maps["pay_status"] = 2
+		maps["refund_status"] = 0
+		maps["cancel_status"] = 0
+		orderSingles, err := orderSingleDao.GetOrderSingleListByTime(maps, req.StartTime, req.EndTime, "pay_time")
+		if err != nil {
+			responses.FailWithMessage(err.Error(), c)
+			return
+		}
+
+		for _, orderSingle := range orderSingles {
+			date := orderSingle.PayTime.Format("2006-01-02")
+			results[date]++
+		}
+	}
+
+	// 新增会员购买数
+	if req.Type == 4 {
+		endTime, _ := time.Parse("2006-01-02", req.EndTime)
+		req.EndTime = endTime.Add(23*time.Hour + 59*time.Minute + 59*time.Second).Format("2006-01-02 15:04:05")
+
+		orderMemberDao := dao.OrderMemberDao{}
+		maps := make(map[string]interface{})
+		maps["order_status"] = 2
+		maps["pay_status"] = 2
+		maps["refund_status"] = 0
+		maps["cancel_status"] = 0
+		orderMembers, err := orderMemberDao.GetOrderMemberListByTime(maps, req.StartTime, req.EndTime, "pay_time")
+		if err != nil {
+			responses.FailWithMessage(err.Error(), c)
+			return
+		}
+
+		for _, orderMember := range orderMembers {
+			date := orderMember.PayTime.Format("2006-01-02")
+			results[date]++
+		}
+	}
+
+	for k, v := range results {
+		response := &dto.IndexDataDto{
+			Date:  k,
+			Count: v,
+		}
+
+		g = append(g, response)
+	}
+
+	responses.OkWithData(g, c)
+}

api/controller/Question.go

@@ -0,0 +1,565 @@
+package controller
+
+import (
+	"github.com/gin-gonic/gin"
+	"hepa-calc-admin-api/api/dao"
+	"hepa-calc-admin-api/api/dto"
+	"hepa-calc-admin-api/api/model"
+	"hepa-calc-admin-api/api/requests"
+	"hepa-calc-admin-api/api/responses"
+	"hepa-calc-admin-api/api/service"
+	"hepa-calc-admin-api/global"
+	"hepa-calc-admin-api/utils"
+	"strconv"
+	"time"
+)
+
+type Question struct{}
+
+// GetQuestionPage 获取问题列表-分页
+func (b *Question) GetQuestionPage(c *gin.Context) {
+	questionRequest := requests.QuestionRequest{}
+	req := questionRequest.GetQuestionPage
+	if err := c.ShouldBindJSON(&req); err != nil {
+		responses.FailWithMessage(err.Error(), c)
+		return
+	}
+
+	// 参数验证
+	if err := global.Validate.Struct(req); err != nil {
+		responses.FailWithMessage(utils.Translate(err), c)
+		return
+	}
+
+	if req.Page == 0 {
+		req.Page = 1
+	}
+
+	if req.PageSize == 0 {
+		req.PageSize = 20
+	}
+
+	// 获取数据
+	questionDao := dao.QuestionDao{}
+	questions, total, err := questionDao.GetQuestionPageSearch(req, req.Page, req.PageSize)
+	if err != nil {
+		responses.FailWithMessage(err.Error(), c)
+		return
+	}
+
+	// 处理返回值
+	g := dto.GetQuestionListDto(questions)
+
+	result := make(map[string]interface{})
+	result["page"] = req.Page
+	result["page_size"] = req.PageSize
+	result["total"] = total
+	result["data"] = g
+	responses.OkWithData(result, c)
+}
+
+// GetQuestionList 获取问题列表
+func (b *Question) GetQuestionList(c *gin.Context) {
+	questionRequest := requests.QuestionRequest{}
+	req := questionRequest.GetQuestionList
+	if err := c.ShouldBindJSON(&req); err != nil {
+		responses.FailWithMessage(err.Error(), c)
+		return
+	}
+
+	// 参数验证
+	if err := global.Validate.Struct(req); err != nil {
+		responses.FailWithMessage(utils.Translate(err), c)
+		return
+	}
+
+	// 获取数据
+	questionDao := dao.QuestionDao{}
+	questions, err := questionDao.GetQuestionListSearch(req)
+	if err != nil {
+		responses.FailWithMessage(err.Error(), c)
+		return
+	}
+
+	// 处理返回值
+	g := dto.GetQuestionListDto(questions)
+
+	responses.OkWithData(g, c)
+}
+
+// GetQuestion 获取问题详情
+func (b *Question) GetQuestion(c *gin.Context) {
+	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.GetQuestionPreloadById(questionId)
+	if err != nil {
+		responses.FailWithMessage("分类异常", c)
+		return
+	}
+
+	// 处理返回值
+	g := dto.GetQuestionDto(question)
+
+	// 获取关联分类数据
+	questionService := service.QuestionService{}
+	g.BaseClass, err = questionService.GetQuestionBaseClass(question.QuestionId)
+
+	responses.OkWithData(g, c)
+}
+
+// PutQuestion 修改问题
+func (b *Question) PutQuestion(c *gin.Context) {
+	questionRequest := requests.QuestionRequest{}
+	req := questionRequest.PutQuestion
+	if err := c.ShouldBindJSON(&req); err != nil {
+		responses.FailWithMessage(err.Error(), c)
+		return
+	}
+
+	// 参数验证
+	if err := global.Validate.Struct(req); err != nil {
+		responses.FailWithMessage(utils.Translate(err), c)
+		return
+	}
+
+	if req.DiscountPrice != nil {
+		if req.DiscountEndTime == nil {
+			responses.FailWithMessage("请填写优惠过期时间", c)
+			return
+		}
+
+		if *req.Price < *req.DiscountPrice {
+			responses.FailWithMessage("优惠价格不可超过原价", c)
+			return
+		}
+	}
+
+	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
+	}
+
+	// 修改值
+	questionData := make(map[string]interface{})
+
+	// 标题
+	if req.QuestionTitle != question.QuestionTitle {
+		questionData["question_title"] = req.QuestionTitle
+	}
+
+	// 副标题
+	if req.QuestionSubtitle != question.QuestionSubtitle {
+		questionData["question_subtitle"] = req.QuestionSubtitle
+	}
+
+	// 唯一标识
+	if req.QuestionIden != question.QuestionIden {
+		questionData["question_iden"] = req.QuestionIden
+	}
+
+	// 问题状态
+	if req.QuestionStatus != question.QuestionStatus {
+		questionData["question_status"] = req.QuestionStatus
+	}
+
+	// 是否隐藏
+	if *req.IsHide != question.IsHide {
+		questionData["is_hide"] = req.IsHide
+	}
+
+	// 是否推荐
+	if *req.IsRecommend != question.IsRecommend {
+		questionData["is_recommend"] = req.IsRecommend
+	}
+
+	// 点击次数
+	if *req.ClickCount != question.ClickCount {
+		questionData["click_count"] = req.ClickCount
+	}
+
+	// 提交次数
+	if *req.SubmitCount != question.SubmitCount {
+		questionData["submit_count"] = req.SubmitCount
+	}
+
+	// 支付次数
+	if *req.PayCount != question.PayCount {
+		questionData["pay_count"] = req.PayCount
+	}
+
+	// 价格
+	if *req.Price != question.Price {
+		questionData["price"] = req.Price
+	}
+
+	// 优惠价格
+	if req.DiscountPrice != nil {
+		if req.DiscountEndTime == nil {
+			responses.FailWithMessage("请填写优惠过期时间", c)
+			return
+		}
+		if question.DiscountPrice == nil {
+			questionData["discount_price"] = req.DiscountPrice
+		} else {
+			if *req.DiscountPrice != *question.DiscountPrice {
+				questionData["discount_price"] = req.DiscountPrice
+			}
+		}
+	} else {
+		if question.DiscountPrice != nil {
+			questionData["discount_price"] = nil
+		}
+	}
+
+	// 优惠截止时间
+	if req.DiscountEndTime != nil {
+		// 获取本地时区
+		location, err := time.LoadLocation("Local")
+		if err != nil {
+			responses.FailWithMessage("优惠截止时间错误", c)
+			return
+		}
+
+		discountEndTime, err := time.ParseInLocation("2006-01-02 15:04:05", *req.DiscountEndTime, location)
+		if err != nil {
+			responses.FailWithMessage("优惠截止时间错误", c)
+			return
+		}
+
+		if question.DiscountEndTime == nil {
+			questionData["discount_end_time"] = discountEndTime
+		} else {
+			if *question.DiscountEndTime != discountEndTime {
+				questionData["discount_end_time"] = discountEndTime
+			}
+		}
+	} else {
+		if question.DiscountEndTime != nil {
+			questionData["discount_end_time"] = nil
+		}
+	}
+
+	// 问题介绍
+	if req.QuestionBrief != question.QuestionBrief {
+		questionData["question_brief"] = req.QuestionBrief
+	}
+
+	// 问题解释/科普
+	if req.QuestionExplain != question.QuestionExplain {
+		questionData["question_explain"] = req.QuestionExplain
+	}
+
+	// 开始事务
+	tx := global.Db.Begin()
+	defer func() {
+		if r := recover(); r != nil {
+			tx.Rollback()
+		}
+	}()
+
+	if len(questionData) > 0 {
+		err = questionDao.EditQuestionById(tx, question.QuestionId, questionData)
+		if err != nil {
+			tx.Rollback()
+			responses.FailWithMessage("操作失败", c)
+			return
+		}
+	}
+
+	// 删除问题关联分类
+	questionClassDao := dao.QuestionClassDao{}
+	err = questionClassDao.DeleteQuestionClassByQuestionId(tx, questionId)
+	if err != nil {
+		tx.Rollback()
+		responses.FailWithMessage("操作失败", c)
+		return
+	}
+
+	// 新增问题关联分类
+	for _, s := range req.ClassId {
+		// 将 id 转换为 int64 类型
+		classId, err := strconv.ParseInt(*s, 10, 64)
+		if err != nil {
+			tx.Rollback()
+			responses.Fail(c)
+			return
+		}
+
+		questionClass := &model.QuestionClass{
+			QuestionId: questionId,
+			ClassId:    classId,
+		}
+
+		questionClass, err = questionClassDao.AddQuestionClass(tx, questionClass)
+		if err != nil {
+			tx.Rollback()
+			responses.Fail(c)
+			return
+		}
+	}
+
+	tx.Commit()
+	responses.Ok(c)
+}
+
+// AddQuestion 新增问题
+func (b *Question) AddQuestion(c *gin.Context) {
+	questionRequest := requests.QuestionRequest{}
+	req := questionRequest.AddQuestion
+	if err := c.ShouldBindJSON(&req); err != nil {
+		responses.FailWithMessage(err.Error(), c)
+		return
+	}
+
+	// 参数验证
+	if err := global.Validate.Struct(req); err != nil {
+		responses.FailWithMessage(utils.Translate(err), c)
+		return
+	}
+
+	if req.DiscountPrice != nil {
+		if *req.Price < *req.DiscountPrice {
+			responses.FailWithMessage("优惠价格不可超过原价", c)
+			return
+		}
+
+		if req.DiscountEndTime == nil {
+			responses.FailWithMessage("请填写优惠过期时间", c)
+			return
+		}
+	}
+
+	// 开始事务
+	tx := global.Db.Begin()
+	defer func() {
+		if r := recover(); r != nil {
+			tx.Rollback()
+		}
+	}()
+
+	question := &model.Question{
+		QuestionTitle:    req.QuestionTitle,
+		QuestionSubtitle: req.QuestionSubtitle,
+		QuestionIden:     req.QuestionIden,
+		QuestionStatus:   req.QuestionStatus,
+		IsHide:           *req.IsHide,
+		IsRecommend:      *req.IsRecommend,
+		ClickCount:       *req.ClickCount,
+		SubmitCount:      *req.SubmitCount,
+		PayCount:         *req.PayCount,
+		Price:            *req.Price,
+		DiscountPrice:    req.DiscountPrice,
+		QuestionBrief:    req.QuestionBrief,
+		QuestionExplain:  req.QuestionExplain,
+	}
+
+	// 处理优惠截止时间
+	if req.DiscountEndTime != nil {
+		// 获取本地时区
+		location, err := time.LoadLocation("Local")
+		if err != nil {
+			tx.Rollback()
+			responses.FailWithMessage("优惠截止时间错误", c)
+			return
+		}
+
+		discountEndTime, err := time.ParseInLocation("2006-01-02 15:04:05", *req.DiscountEndTime, location)
+		if err != nil {
+			tx.Rollback()
+			responses.FailWithMessage("优惠截止时间错误", c)
+			return
+		}
+
+		question.DiscountEndTime = &discountEndTime
+	}
+
+	questionDao := dao.QuestionDao{}
+	question, err := questionDao.AddQuestion(tx, question)
+	if err != nil {
+		tx.Rollback()
+		responses.FailWithMessage("操作失败", c)
+		return
+	}
+
+	// 新增问题关联分类
+	questionClassDao := dao.QuestionClassDao{}
+	for _, s := range req.ClassId {
+		// 将 id 转换为 int64 类型
+		classId, err := strconv.ParseInt(*s, 10, 64)
+		if err != nil {
+			tx.Rollback()
+			responses.Fail(c)
+			return
+		}
+
+		questionClass := &model.QuestionClass{
+			QuestionId: question.QuestionId,
+			ClassId:    classId,
+		}
+
+		questionClass, err = questionClassDao.AddQuestionClass(tx, questionClass)
+		if err != nil {
+			tx.Rollback()
+			responses.Fail(c)
+			return
+		}
+	}
+
+	tx.Commit()
+	responses.Ok(c)
+}
+
+// PutQuestionStatus 操作问题发布状态
+func (b *Question) PutQuestionStatus(c *gin.Context) {
+	questionRequest := requests.QuestionRequest{}
+	req := questionRequest.PutQuestionStatus
+	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
+	}
+
+	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 == req.QuestionStatus {
+		responses.Ok(c)
+		return
+	}
+
+	// 开始事务
+	tx := global.Db.Begin()
+	defer func() {
+		if r := recover(); r != nil {
+			tx.Rollback()
+		}
+	}()
+
+	questionData := make(map[string]interface{})
+	questionData["question_status"] = req.QuestionStatus
+	err = questionDao.EditQuestionById(tx, questionId, questionData)
+	if err != nil {
+		tx.Rollback()
+		responses.FailWithMessage("操作失败", c)
+		return
+	}
+
+	tx.Commit()
+	responses.Ok(c)
+}
+
+// PutQuestionHideStatus 操作问题隐藏状态
+func (b *Question) PutQuestionHideStatus(c *gin.Context) {
+	questionRequest := requests.QuestionRequest{}
+	req := questionRequest.PutQuestionHideStatus
+	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
+	}
+
+	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.IsHide == req.IsHide {
+		responses.Ok(c)
+		return
+	}
+
+	// 开始事务
+	tx := global.Db.Begin()
+	defer func() {
+		if r := recover(); r != nil {
+			tx.Rollback()
+		}
+	}()
+
+	questionData := make(map[string]interface{})
+	questionData["is_hide"] = req.IsHide
+	err = questionDao.EditQuestionById(tx, questionId, questionData)
+	if err != nil {
+		tx.Rollback()
+		responses.FailWithMessage("操作失败", c)
+		return
+	}
+
+	tx.Commit()
+	responses.Ok(c)
+}

api/controller/SystemMember.go

@@ -0,0 +1,259 @@
+package controller
+
+import (
+	"github.com/gin-gonic/gin"
+	"hepa-calc-admin-api/api/dao"
+	"hepa-calc-admin-api/api/dto"
+	"hepa-calc-admin-api/api/model"
+	"hepa-calc-admin-api/api/requests"
+	"hepa-calc-admin-api/api/responses"
+	"hepa-calc-admin-api/global"
+	"hepa-calc-admin-api/utils"
+	"strconv"
+	"time"
+)
+
+type SystemMember struct{}
+
+// GetSystemMemberList 获取会员配置列表
+func (b *SystemMember) GetSystemMemberList(c *gin.Context) {
+	// 获取数据
+	systemMemberDao := dao.SystemMemberDao{}
+	systemMembers, err := systemMemberDao.GetSystemMemberListSearch()
+	if err != nil {
+		responses.FailWithMessage(err.Error(), c)
+		return
+	}
+
+	// 处理返回值
+	g := dto.GetSystemMemberListDto(systemMembers)
+
+	responses.OkWithData(g, c)
+}
+
+// GetSystemMember 获取会员配置详情
+func (b *SystemMember) GetSystemMember(c *gin.Context) {
+	id := c.Param("system_member_id")
+	if id == "" {
+		responses.FailWithMessage("缺少参数", c)
+		return
+	}
+
+	// 将 id 转换为 int64 类型
+	systemMemberId, err := strconv.ParseInt(id, 10, 64)
+	if err != nil {
+		responses.Fail(c)
+		return
+	}
+
+	// 获取问题数据
+	systemMemberDao := dao.SystemMemberDao{}
+	systemMember, err := systemMemberDao.GetSystemMemberById(systemMemberId)
+	if err != nil {
+		responses.FailWithMessage("数据异常", c)
+		return
+	}
+
+	// 处理返回值
+	g := dto.GetSystemMemberDto(systemMember)
+
+	responses.OkWithData(g, c)
+}
+
+// PutSystemMember 修改会员配置
+func (b *SystemMember) PutSystemMember(c *gin.Context) {
+	systemMemberRequest := requests.SystemMemberRequest{}
+	req := systemMemberRequest.PutSystemMember
+	if err := c.ShouldBindJSON(&req); err != nil {
+		responses.FailWithMessage(err.Error(), c)
+		return
+	}
+
+	// 参数验证
+	if err := global.Validate.Struct(req); err != nil {
+		responses.FailWithMessage(utils.Translate(err), c)
+		return
+	}
+
+	if req.DiscountPrice != nil {
+		if req.Price < *req.DiscountPrice {
+			responses.FailWithMessage("优惠价格不可超过原价", c)
+			return
+		}
+
+		if req.DiscountEndTime == nil {
+			responses.FailWithMessage("请填写优惠过期时间", c)
+			return
+		}
+	}
+
+	id := c.Param("system_member_id")
+	if id == "" {
+		responses.FailWithMessage("缺少参数", c)
+		return
+	}
+
+	// 将 id 转换为 int64 类型
+	systemMemberId, err := strconv.ParseInt(id, 10, 64)
+	if err != nil {
+		responses.Fail(c)
+		return
+	}
+
+	// 获取问题数据
+	systemMemberDao := dao.SystemMemberDao{}
+	systemMember, err := systemMemberDao.GetSystemMemberById(systemMemberId)
+	if err != nil {
+		responses.FailWithMessage("数据异常", c)
+		return
+	}
+
+	// 修改值
+	systemMemberData := make(map[string]interface{})
+
+	// 会员天数
+	if req.MemberDays != systemMember.MemberDays {
+		systemMemberData["member_days"] = req.MemberDays
+	}
+
+	// 价格
+	if req.Price != systemMember.Price {
+		systemMemberData["price"] = req.Price
+	}
+
+	// 优惠价格
+	if req.DiscountPrice != nil {
+		if systemMember.DiscountPrice == nil {
+			systemMemberData["discount_price"] = req.DiscountPrice
+		} else {
+			if *req.DiscountPrice != *systemMember.DiscountPrice {
+				systemMemberData["discount_price"] = req.DiscountPrice
+			}
+		}
+	} else {
+		if systemMember.DiscountPrice != nil {
+			systemMemberData["discount_price"] = nil
+		}
+	}
+
+	// 优惠截止时间
+	if req.DiscountEndTime != nil {
+		// 获取本地时区
+		location, err := time.LoadLocation("Local")
+		if err != nil {
+			responses.FailWithMessage("优惠截止时间错误", c)
+			return
+		}
+
+		discountEndTime, err := time.ParseInLocation("2006-01-02 15:04:05", *req.DiscountEndTime, location)
+		if err != nil {
+			responses.FailWithMessage("优惠截止时间错误", c)
+			return
+		}
+
+		if systemMember.DiscountEndTime == nil {
+			systemMemberData["discount_end_time"] = discountEndTime
+		} else {
+			if *systemMember.DiscountEndTime != discountEndTime {
+				systemMemberData["discount_end_time"] = discountEndTime
+			}
+		}
+	} else {
+		if systemMember.DiscountEndTime != nil {
+			systemMemberData["discount_end_time"] = nil
+		}
+	}
+
+	// 开始事务
+	tx := global.Db.Begin()
+	defer func() {
+		if r := recover(); r != nil {
+			tx.Rollback()
+		}
+	}()
+
+	if len(systemMemberData) > 0 {
+		err = systemMemberDao.EditSystemMemberById(tx, systemMember.SystemMemberId, systemMemberData)
+		if err != nil {
+			tx.Rollback()
+			responses.FailWithMessage("操作失败", c)
+			return
+		}
+	}
+
+	tx.Commit()
+	responses.Ok(c)
+}
+
+// AddSystemMember 新增会员配置
+func (b *SystemMember) AddSystemMember(c *gin.Context) {
+	systemMemberRequest := requests.SystemMemberRequest{}
+	req := systemMemberRequest.AddSystemMember
+	if err := c.ShouldBindJSON(&req); err != nil {
+		responses.FailWithMessage(err.Error(), c)
+		return
+	}
+
+	// 参数验证
+	if err := global.Validate.Struct(req); err != nil {
+		responses.FailWithMessage(utils.Translate(err), c)
+		return
+	}
+
+	if req.DiscountPrice != nil {
+		if req.Price < *req.DiscountPrice {
+			responses.FailWithMessage("优惠价格不可超过原价", c)
+			return
+		}
+
+		if req.DiscountEndTime == nil {
+			responses.FailWithMessage("请填写优惠过期时间", c)
+			return
+		}
+	}
+
+	// 开始事务
+	tx := global.Db.Begin()
+	defer func() {
+		if r := recover(); r != nil {
+			tx.Rollback()
+		}
+	}()
+
+	systemMember := &model.SystemMember{
+		MemberDays:    req.MemberDays,
+		Price:         req.Price,
+		DiscountPrice: req.DiscountPrice,
+	}
+
+	// 处理优惠截止时间
+	if req.DiscountEndTime != nil {
+		// 获取本地时区
+		location, err := time.LoadLocation("Local")
+		if err != nil {
+			tx.Rollback()
+			responses.FailWithMessage("优惠截止时间错误", c)
+			return
+		}
+
+		discountEndTime, err := time.ParseInLocation("2006-01-02 15:04:05", *req.DiscountEndTime, location)
+		if err != nil {
+			tx.Rollback()
+			responses.FailWithMessage("优惠截止时间错误", c)
+			return
+		}
+
+		systemMember.DiscountEndTime = &discountEndTime
+	}
+
+	systemMemberDao := dao.SystemMemberDao{}
+	systemMember, err := systemMemberDao.AddSystemMember(tx, systemMember)
+	if err != nil {
+		tx.Rollback()
+		responses.FailWithMessage("操作失败", c)
+		return
+	}
+
+	tx.Commit()
+	responses.Ok(c)
+}

api/controller/SystemSingle.go

@@ -0,0 +1,170 @@
+package controller
+
+import (
+	"github.com/gin-gonic/gin"
+	"hepa-calc-admin-api/api/dao"
+	"hepa-calc-admin-api/api/dto"
+	"hepa-calc-admin-api/api/model"
+	"hepa-calc-admin-api/api/requests"
+	"hepa-calc-admin-api/api/responses"
+	"hepa-calc-admin-api/global"
+	"hepa-calc-admin-api/utils"
+	"strconv"
+)
+
+type SystemSingle struct{}
+
+// GetSystemSingleList 获取单项配置列表
+func (b *SystemSingle) GetSystemSingleList(c *gin.Context) {
+	// 获取数据
+	systemSingleDao := dao.SystemSingleDao{}
+	SystemSingles, err := systemSingleDao.GetSystemSingleListSearch()
+	if err != nil {
+		responses.FailWithMessage(err.Error(), c)
+		return
+	}
+
+	// 处理返回值
+	g := dto.GetSystemSingleListDto(SystemSingles)
+
+	responses.OkWithData(g, c)
+}
+
+// GetSystemSingle 获取单项配置详情
+func (b *SystemSingle) GetSystemSingle(c *gin.Context) {
+	id := c.Param("system_single_id")
+	if id == "" {
+		responses.FailWithMessage("缺少参数", c)
+		return
+	}
+
+	// 将 id 转换为 int64 类型
+	systemSingleId, err := strconv.ParseInt(id, 10, 64)
+	if err != nil {
+		responses.Fail(c)
+		return
+	}
+
+	// 获取数据
+	systemSingleDao := dao.SystemSingleDao{}
+	SystemSingle, err := systemSingleDao.GetSystemSingleById(systemSingleId)
+	if err != nil {
+		responses.FailWithMessage("数据异常", c)
+		return
+	}
+
+	// 处理返回值
+	g := dto.GetSystemSingleDto(SystemSingle)
+
+	responses.OkWithData(g, c)
+}
+
+// PutSystemSingle 修改会员配置
+func (b *SystemSingle) PutSystemSingle(c *gin.Context) {
+	SystemSingleRequest := requests.SystemSingleRequest{}
+	req := SystemSingleRequest.PutSystemSingle
+	if err := c.ShouldBindJSON(&req); err != nil {
+		responses.FailWithMessage(err.Error(), c)
+		return
+	}
+
+	// 参数验证
+	if err := global.Validate.Struct(req); err != nil {
+		responses.FailWithMessage(utils.Translate(err), c)
+		return
+	}
+
+	id := c.Param("system_single_id")
+	if id == "" {
+		responses.FailWithMessage("缺少参数", c)
+		return
+	}
+
+	// 将 id 转换为 int64 类型
+	systemSingleId, err := strconv.ParseInt(id, 10, 64)
+	if err != nil {
+		responses.Fail(c)
+		return
+	}
+
+	// 获取问题数据
+	SystemSingleDao := dao.SystemSingleDao{}
+	systemSingle, err := SystemSingleDao.GetSystemSingleById(systemSingleId)
+	if err != nil {
+		responses.FailWithMessage("数据异常", c)
+		return
+	}
+
+	// 修改值
+	systemSingleData := make(map[string]interface{})
+
+	// 首次购买价格
+	if req.FirstTimePrice != systemSingle.FirstTimePrice {
+		systemSingleData["first_time_price"] = req.FirstTimePrice
+	}
+
+	// 购买后有效天数
+	if req.ValidDays != systemSingle.ValidDays {
+		systemSingleData["valid_days"] = req.ValidDays
+	}
+
+	// 开始事务
+	tx := global.Db.Begin()
+	defer func() {
+		if r := recover(); r != nil {
+			tx.Rollback()
+		}
+	}()
+
+	if len(systemSingleData) > 0 {
+		err = SystemSingleDao.EditSystemSingleById(tx, systemSingle.SystemSingleId, systemSingleData)
+		if err != nil {
+			tx.Rollback()
+			responses.FailWithMessage("操作失败", c)
+			return
+		}
+	}
+
+	tx.Commit()
+	responses.Ok(c)
+}
+
+// AddSystemSingle 新增会员配置
+func (b *SystemSingle) AddSystemSingle(c *gin.Context) {
+	SystemSingleRequest := requests.SystemSingleRequest{}
+	req := SystemSingleRequest.AddSystemSingle
+	if err := c.ShouldBindJSON(&req); err != nil {
+		responses.FailWithMessage(err.Error(), c)
+		return
+	}
+
+	// 参数验证
+	if err := global.Validate.Struct(req); err != nil {
+		responses.FailWithMessage(utils.Translate(err), c)
+		return
+	}
+
+	// 开始事务
+	tx := global.Db.Begin()
+	defer func() {
+		if r := recover(); r != nil {
+			tx.Rollback()
+		}
+	}()
+
+	systemSingle := &model.SystemSingle{
+		FirstTimePrice: req.FirstTimePrice,
+		ValidDays:      req.ValidDays,
+	}
+
+	systemSingleDao := dao.SystemSingleDao{}
+	systemSingle, err := systemSingleDao.AddSystemSingle(tx, systemSingle)
+	if err != nil {
+		tx.Rollback()
+		responses.FailWithMessage("操作失败", c)
+		return
+	}
+
+	tx.Commit()
+	responses.Ok(c)
+}

api/controller/User.go

@@ -0,0 +1,178 @@
+package controller
+
+import (
+	"github.com/gin-gonic/gin"
+	"hepa-calc-admin-api/api/dao"
+	"hepa-calc-admin-api/api/dto"
+	"hepa-calc-admin-api/api/requests"
+	"hepa-calc-admin-api/api/responses"
+	"hepa-calc-admin-api/global"
+	"hepa-calc-admin-api/utils"
+	"strconv"
+)
+
+type User struct{}
+
+// GetUserPage 获取用户列表-分页
+func (b *User) GetUserPage(c *gin.Context) {
+	userRequest := requests.UserRequest{}
+	req := userRequest.GetUserPage
+	if err := c.ShouldBindJSON(&req); err != nil {
+		responses.FailWithMessage(err.Error(), c)
+		return
+	}
+
+	// 参数验证
+	if err := global.Validate.Struct(req); err != nil {
+		responses.FailWithMessage(utils.Translate(err), c)
+		return
+	}
+
+	if req.Page == 0 {
+		req.Page = 1
+	}
+
+	if req.PageSize == 0 {
+		req.PageSize = 20
+	}
+
+	if req.Order != nil {
+		if req.Order.UpdatedAt != "" {
+			if req.Order.UpdatedAt != "desc" && req.Order.UpdatedAt != "asc" {
+				responses.FailWithMessage("排序字段错误", c)
+				return
+			}
+		}
+
+		if req.Order.SingleSubmitCount != "" {
+			if req.Order.SingleSubmitCount != "desc" && req.Order.SingleSubmitCount != "asc" {
+				responses.FailWithMessage("排序字段错误", c)
+				return
+			}
+		}
+
+		if req.Order.SinglePayCount != "" {
+			if req.Order.SinglePayCount != "desc" && req.Order.SinglePayCount != "asc" {
+				responses.FailWithMessage("排序字段错误", c)
+				return
+			}
+		}
+
+		if req.Order.MemberBuyCount != "" {
+			if req.Order.MemberBuyCount != "desc" && req.Order.MemberBuyCount != "asc" {
+				responses.FailWithMessage("排序字段错误", c)
+				return
+			}
+		}
+	}
+
+	// 获取数据
+	userDao := dao.UserDao{}
+	user, total, err := userDao.GetUserPageSearch(req, req.Page, req.PageSize)
+	if err != nil {
+		responses.FailWithMessage(err.Error(), c)
+		return
+	}
+
+	// 处理返回值
+	g := dto.GetUserListDto(user)
+
+	result := make(map[string]interface{})
+	result["page"] = req.Page
+	result["page_size"] = req.PageSize
+	result["total"] = total
+	result["data"] = g
+	responses.OkWithData(result, c)
+}
+
+// GetUser 获取用户详情
+func (b *User) GetUser(c *gin.Context) {
+	id := c.Param("user_id")
+	if id == "" {
+		responses.FailWithMessage("缺少参数", c)
+		return
+	}
+
+	// 将 id 转换为 int64 类型
+	userId, err := strconv.ParseInt(id, 10, 64)
+	if err != nil {
+		responses.Fail(c)
+		return
+	}
+
+	// 获取订单数据
+	userDao := dao.UserDao{}
+	user, err := userDao.GetUserById(userId)
+	if err != nil {
+		responses.FailWithMessage("订单异常", c)
+		return
+	}
+
+	// 处理返回值
+	g := dto.GetUserDto(user)
+
+	responses.OkWithData(g, c)
+}
+
+// PutUserStatus 操作用户状态
+func (b *User) PutUserStatus(c *gin.Context) {
+	userRequest := requests.UserRequest{}
+	req := userRequest.PutUserStatus
+	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
+	}
+
+	id := c.Param("user_id")
+	if id == "" {
+		responses.FailWithMessage("缺少参数", c)
+		return
+	}
+
+	// 将 id 转换为 int64 类型
+	userId, err := strconv.ParseInt(id, 10, 64)
+	if err != nil {
+		responses.Fail(c)
+		return
+	}
+
+	// 获取订单数据
+	userDao := dao.UserDao{}
+	user, err := userDao.GetUserById(userId)
+	if err != nil {
+		responses.FailWithMessage("订单异常", c)
+		return
+	}
+
+	// 检测订单删除状态
+	if user.UserStatus == req.UserStatus {
+		responses.Ok(c)
+		return
+	}
+
+	// 开始事务
+	tx := global.Db.Begin()
+	defer func() {
+		if r := recover(); r != nil {
+			tx.Rollback()
+		}
+	}()
+
+	userData := make(map[string]interface{})
+	userData["user_status"] = req.UserStatus
+	err = userDao.EditUserById(tx, userId, userData)
+	if err != nil {
+		tx.Rollback()
+		responses.FailWithMessage("操作失败", c)
+		return
+	}
+
+	tx.Commit()
+	responses.Ok(c)
+}

api/controller/UserCoupon.go

@@ -0,0 +1,109 @@
+package controller
+
+import (
+	"github.com/gin-gonic/gin"
+	"hepa-calc-admin-api/api/dao"
+	"hepa-calc-admin-api/api/dto"
+	"hepa-calc-admin-api/api/requests"
+	"hepa-calc-admin-api/api/responses"
+	"hepa-calc-admin-api/global"
+	"hepa-calc-admin-api/utils"
+	"strconv"
+)
+
+type UserCoupon struct{}
+
+// GetUserCouponPage 获取用户优惠卷列表-分页
+func (b *UserCoupon) GetUserCouponPage(c *gin.Context) {
+	userCouponRequest := requests.UserCouponRequest{}
+	req := userCouponRequest.GetUserCouponPage
+	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
+	}
+
+	if req.Page == 0 {
+		req.Page = 1
+	}
+
+	if req.PageSize == 0 {
+		req.PageSize = 20
+	}
+
+	// 获取数据
+	userCouponDao := dao.UserCouponDao{}
+	userCoupons, total, err := userCouponDao.GetUserCouponPageSearch(req, req.Page, req.PageSize)
+	if err != nil {
+		responses.FailWithMessage(err.Error(), c)
+		return
+	}
+
+	// 处理返回值
+	g := dto.GetUserCouponListDto(userCoupons)
+
+	result := make(map[string]interface{})
+	result["page"] = req.Page
+	result["page_size"] = req.PageSize
+	result["total"] = total
+	result["data"] = g
+	responses.OkWithData(result, c)
+}
+
+// DeleteUserCoupon 删除用户优惠卷
+func (b *UserCoupon) DeleteUserCoupon(c *gin.Context) {
+	id := c.Param("user_coupon_id")
+	if id == "" {
+		responses.FailWithMessage("缺少参数", c)
+		return
+	}
+
+	// 将 id 转换为 int64 类型
+	userCouponId, err := strconv.ParseInt(id, 10, 64)
+	if err != nil {
+		responses.Fail(c)
+		return
+	}
+
+	// 获取优惠卷数据
+	userCouponDao := dao.UserCouponDao{}
+	userCoupon, err := userCouponDao.GetUserCouponById(userCouponId)
+	if err != nil {
+		responses.FailWithMessage("优惠卷异常", c)
+		return
+	}
+
+	// 检测优惠卷状态（0:未使用 1:已使用 3:已过期）
+	if userCoupon.UserCouponStatus == 1 {
+		responses.FailWithMessage("优惠卷已使用，无需删除", c)
+		return
+	}
+
+	if userCoupon.UserCouponStatus == 3 {
+		responses.FailWithMessage("优惠卷已过期，无需删除", c)
+		return
+	}
+
+	// 开始事务
+	tx := global.Db.Begin()
+	defer func() {
+		if r := recover(); r != nil {
+			tx.Rollback()
+		}
+	}()
+
+	err = userCouponDao.DeleteUserCouponById(tx, userCouponId)
+	if err != nil {
+		tx.Rollback()
+		responses.FailWithMessage("操作失败", c)
+		return
+	}
+
+	tx.Commit()
+	responses.Ok(c)
+}

api/dao/AdminUser.go

@@ -0,0 +1,108 @@
+package dao
+
+import (
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"hepa-calc-admin-api/api/model"
+	"hepa-calc-admin-api/global"
+)
+
+type AdminUserDao struct {
+}
+
+// GetAdminUserById 获取数据-id
+func (r *AdminUserDao) GetAdminUserById(AdminUserId int64) (m *model.AdminUser, err error) {
+	err = global.Db.First(&m, AdminUserId).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetAdminUserPreloadById 获取数据-加载全部关联-id
+func (r *AdminUserDao) GetAdminUserPreloadById(AdminUserId int64) (m *model.AdminUser, err error) {
+	err = global.Db.Preload(clause.Associations).First(&m, AdminUserId).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// DeleteAdminUser 删除
+func (r *AdminUserDao) DeleteAdminUser(tx *gorm.DB, maps interface{}) error {
+	err := tx.Where(maps).Delete(&model.AdminUser{}).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// DeleteAdminUserById 删除-id
+func (r *AdminUserDao) DeleteAdminUserById(tx *gorm.DB, AdminUserId int64) error {
+	if err := tx.Delete(&model.AdminUser{}, AdminUserId).Error; err != nil {
+		return err
+	}
+	return nil
+}
+
+// EditAdminUser 修改
+func (r *AdminUserDao) EditAdminUser(tx *gorm.DB, maps interface{}, data interface{}) error {
+	err := tx.Model(&model.AdminUser{}).Where(maps).Updates(data).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// EditAdminUserById 修改-id
+func (r *AdminUserDao) EditAdminUserById(tx *gorm.DB, AdminUserId int64, data interface{}) error {
+	err := tx.Model(&model.AdminUser{}).Where("AdminUser_id = ?", AdminUserId).Updates(data).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// GetAdminUserList 获取列表
+func (r *AdminUserDao) GetAdminUserList(maps interface{}) (m []*model.AdminUser, err error) {
+	err = global.Db.Where(maps).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetAdminUserCount 获取数量
+func (r *AdminUserDao) GetAdminUserCount(maps interface{}) (total int64, err error) {
+	err = global.Db.Model(&model.AdminUser{}).Where(maps).Count(&total).Error
+	if err != nil {
+		return 0, err
+	}
+	return total, nil
+}
+
+// GetAdminUserListRand 获取列表-随机
+func (r *AdminUserDao) GetAdminUserListRand(maps interface{}, limit int) (m []*model.AdminUser, err error) {
+	err = global.Db.Where(maps).Order("rand()").Limit(limit).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// AddAdminUser 新增
+func (r *AdminUserDao) AddAdminUser(tx *gorm.DB, model *model.AdminUser) (*model.AdminUser, error) {
+	if err := tx.Create(model).Error; err != nil {
+		return nil, err
+	}
+	return model, nil
+}
+
+// GetAdminUser 获取
+func (r *AdminUserDao) GetAdminUser(maps interface{}) (m *model.AdminUser, err error) {
+	err = global.Db.Where(maps).First(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}

api/dao/BaseAgreement.go

@@ -0,0 +1,130 @@
+package dao
+
+import (
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"hepa-calc-admin-api/api/model"
+	"hepa-calc-admin-api/global"
+)
+
+type BaseAgreementDao struct {
+}
+
+// GetBaseAgreementById 获取数据-id
+func (r *BaseAgreementDao) GetBaseAgreementById(agreementId int64) (m *model.BaseAgreement, err error) {
+	err = global.Db.First(&m, agreementId).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetBaseAgreementPreloadById 获取数据-加载全部关联-id
+func (r *BaseAgreementDao) GetBaseAgreementPreloadById(agreementId int64) (m *model.BaseAgreement, err error) {
+	err = global.Db.Preload(clause.Associations).First(&m, agreementId).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// DeleteBaseAgreement 删除
+func (r *BaseAgreementDao) DeleteBaseAgreement(tx *gorm.DB, maps interface{}) error {
+	err := tx.Where(maps).Delete(&model.BaseAgreement{}).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// DeleteBaseAgreementById 删除-id
+func (r *BaseAgreementDao) DeleteBaseAgreementById(tx *gorm.DB, agreementId int64) error {
+	if err := tx.Delete(&model.BaseAgreement{}, agreementId).Error; err != nil {
+		return err
+	}
+	return nil
+}
+
+// EditBaseAgreement 修改
+func (r *BaseAgreementDao) EditBaseAgreement(tx *gorm.DB, maps interface{}, data interface{}) error {
+	err := tx.Model(&model.BaseAgreement{}).Where(maps).Updates(data).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// EditBaseAgreementById 修改-id
+func (r *BaseAgreementDao) EditBaseAgreementById(tx *gorm.DB, agreementId int64, data interface{}) error {
+	err := tx.Model(&model.BaseAgreement{}).Where("agreement_id = ?", agreementId).Updates(data).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// GetBaseAgreementList 获取列表
+func (r *BaseAgreementDao) GetBaseAgreementList(maps interface{}) (m []*model.BaseAgreement, err error) {
+	err = global.Db.Where(maps).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetBaseAgreementCount 获取数量
+func (r *BaseAgreementDao) GetBaseAgreementCount(maps interface{}) (total int64, err error) {
+	err = global.Db.Model(&model.BaseAgreement{}).Where(maps).Count(&total).Error
+	if err != nil {
+		return 0, err
+	}
+	return total, nil
+}
+
+// GetBaseAgreementListRand 获取列表-随机
+func (r *BaseAgreementDao) GetBaseAgreementListRand(maps interface{}, limit int) (m []*model.BaseAgreement, err error) {
+	err = global.Db.Where(maps).Order("rand()").Limit(limit).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// AddBaseAgreement 新增
+func (r *BaseAgreementDao) AddBaseAgreement(tx *gorm.DB, model *model.BaseAgreement) (*model.BaseAgreement, error) {
+	if err := tx.Create(model).Error; err != nil {
+		return nil, err
+	}
+	return model, nil
+}
+
+// GetBaseAgreement 获取
+func (r *BaseAgreementDao) GetBaseAgreement(maps interface{}) (m *model.BaseAgreement, err error) {
+	err = global.Db.Where(maps).First(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetBaseAgreementPageSearch 获取列表-分页
+func (r *BaseAgreementDao) GetBaseAgreementPageSearch(page, pageSize int) (m []*model.BaseAgreement, total int64, err error) {
+	var totalRecords int64
+
+	// 构建查询条件
+	query := global.Db.Model(&model.BaseAgreement{})
+
+	// 排序
+	query = query.Order("created_at desc")
+
+	// 查询总数量
+	if err := query.Count(&totalRecords).Error; err != nil {
+		return nil, 0, err
+	}
+
+	err = query.Scopes(model.Paginate(page, pageSize)).Find(&m).Error
+	if err != nil {
+		return nil, 0, err
+	}
+	return m, totalRecords, nil
+}

api/dao/BaseClass.go

@@ -0,0 +1,180 @@
+package dao
+
+import (
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"hepa-calc-admin-api/api/model"
+	"hepa-calc-admin-api/api/requests"
+	"hepa-calc-admin-api/global"
+)
+
+type BaseClassDao struct {
+}
+
+// GetBaseClassById 获取数据-id
+func (r *BaseClassDao) GetBaseClassById(classId int64) (m *model.BaseClass, err error) {
+	err = global.Db.First(&m, classId).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetBaseClassPreloadById 获取数据-加载全部关联-id
+func (r *BaseClassDao) GetBaseClassPreloadById(classId int64) (m *model.BaseClass, err error) {
+	err = global.Db.Preload(clause.Associations).First(&m, classId).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// DeleteBaseClass 删除
+func (r *BaseClassDao) DeleteBaseClass(tx *gorm.DB, maps interface{}) error {
+	err := tx.Where(maps).Delete(&model.BaseClass{}).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// DeleteBaseClassById 删除-id
+func (r *BaseClassDao) DeleteBaseClassById(tx *gorm.DB, classId int64) error {
+	if err := tx.Delete(&model.BaseClass{}, classId).Error; err != nil {
+		return err
+	}
+	return nil
+}
+
+// EditBaseClass 修改
+func (r *BaseClassDao) EditBaseClass(tx *gorm.DB, maps interface{}, data interface{}) error {
+	err := tx.Model(&model.BaseClass{}).Where(maps).Updates(data).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// EditBaseClassById 修改-id
+func (r *BaseClassDao) EditBaseClassById(tx *gorm.DB, classId int64, data interface{}) error {
+	err := tx.Model(&model.BaseClass{}).Where("class_id = ?", classId).Updates(data).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// GetBaseClassList 获取列表
+func (r *BaseClassDao) GetBaseClassList(maps interface{}) (m []*model.BaseClass, err error) {
+	err = global.Db.Where(maps).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetBaseClassCount 获取数量
+func (r *BaseClassDao) GetBaseClassCount(maps interface{}) (total int64, err error) {
+	err = global.Db.Model(&model.BaseClass{}).Where(maps).Count(&total).Error
+	if err != nil {
+		return 0, err
+	}
+	return total, nil
+}
+
+// GetBaseClassListRand 获取列表-随机
+func (r *BaseClassDao) GetBaseClassListRand(maps interface{}, limit int) (m []*model.BaseClass, err error) {
+	err = global.Db.Where(maps).Order("rand()").Limit(limit).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// AddBaseClass 新增
+func (r *BaseClassDao) AddBaseClass(tx *gorm.DB, model *model.BaseClass) (*model.BaseClass, error) {
+	if err := tx.Create(model).Error; err != nil {
+		return nil, err
+	}
+	return model, nil
+}
+
+// GetBaseClass 获取
+func (r *BaseClassDao) GetBaseClass(maps interface{}) (m *model.BaseClass, err error) {
+	err = global.Db.Where(maps).First(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetBaseClassPageSearch 获取列表-分页
+func (r *BaseClassDao) GetBaseClassPageSearch(req requests.GetBaseClassPage, page, pageSize int) (m []*model.BaseClass, total int64, err error) {
+	var totalRecords int64
+
+	// 构建查询条件
+	query := global.Db.Model(&model.BaseClass{})
+
+	// 分类名称
+	if req.ClassName != "" {
+		query = query.Where("class_name LIKE ?", "%"+req.ClassName+"%")
+	}
+
+	// 分类状态
+	if req.ClassStatus != nil {
+		query = query.Where("class_status = ?", req.ClassStatus)
+	}
+
+	// 排序
+	if req.Order != nil {
+		if req.Order.Sort != "" {
+			query = query.Order("sort " + req.Order.Sort)
+		}
+	}
+
+	// 排序
+	query = query.Order("created_at desc")
+
+	// 查询总数量
+	if err := query.Count(&totalRecords).Error; err != nil {
+		return nil, 0, err
+	}
+
+	err = query.Scopes(model.Paginate(page, pageSize)).Find(&m).Error
+	if err != nil {
+		return nil, 0, err
+	}
+	return m, totalRecords, nil
+}
+
+// GetBaseClassListSearch 获取列表
+func (r *BaseClassDao) GetBaseClassListSearch(req requests.GetBaseClassList) (m []*model.BaseClass, err error) {
+	// 构建查询条件
+	query := global.Db.Model(&model.BaseClass{})
+
+	// 分类名称
+	if req.ClassName != "" {
+		query = query.Where("class_name LIKE ?", "%"+req.ClassName+"%")
+	}
+
+	// 分类状态
+	if req.ClassStatus != nil {
+		query = query.Where("class_status = ?", req.ClassStatus)
+	}
+
+	// 排序
+	if req.Order != nil {
+		if req.Order.Sort != "" {
+			query = query.Order("sort " + req.Order.Sort)
+		}
+	}
+
+	// 排序
+	query = query.Order("created_at desc")
+
+	err = query.Scopes(model.Paginate(1, 10)).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}

api/dao/Coupon.go

@@ -0,0 +1,174 @@
+package dao
+
+import (
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"hepa-calc-admin-api/api/model"
+	"hepa-calc-admin-api/api/requests"
+	"hepa-calc-admin-api/global"
+)
+
+type CouponDao struct {
+}
+
+// GetCouponById 获取数据-id
+func (r *CouponDao) GetCouponById(CouponId int64) (m *model.Coupon, err error) {
+	err = global.Db.First(&m, CouponId).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetCouponPreloadById 获取数据-加载全部关联-id
+func (r *CouponDao) GetCouponPreloadById(CouponId int64) (m *model.Coupon, err error) {
+	err = global.Db.Preload(clause.Associations).First(&m, CouponId).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// DeleteCoupon 删除
+func (r *CouponDao) DeleteCoupon(tx *gorm.DB, maps interface{}) error {
+	err := tx.Where(maps).Delete(&model.Coupon{}).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// DeleteCouponById 删除-id
+func (r *CouponDao) DeleteCouponById(tx *gorm.DB, CouponId int64) error {
+	if err := tx.Delete(&model.Coupon{}, CouponId).Error; err != nil {
+		return err
+	}
+	return nil
+}
+
+// EditCoupon 修改
+func (r *CouponDao) EditCoupon(tx *gorm.DB, maps interface{}, data interface{}) error {
+	err := tx.Model(&model.Coupon{}).Where(maps).Updates(data).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// EditCouponById 修改-id
+func (r *CouponDao) EditCouponById(tx *gorm.DB, CouponId int64, data interface{}) error {
+	err := tx.Model(&model.Coupon{}).Where("coupon_id = ?", CouponId).Updates(data).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// GetCouponList 获取列表
+func (r *CouponDao) GetCouponList(maps interface{}) (m []*model.Coupon, err error) {
+	err = global.Db.Where(maps).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetCouponCount 获取数量
+func (r *CouponDao) GetCouponCount(maps interface{}) (total int64, err error) {
+	err = global.Db.Model(&model.Coupon{}).Where(maps).Count(&total).Error
+	if err != nil {
+		return 0, err
+	}
+	return total, nil
+}
+
+// GetCouponListRand 获取列表-随机
+func (r *CouponDao) GetCouponListRand(maps interface{}, limit int) (m []*model.Coupon, err error) {
+	err = global.Db.Where(maps).Order("rand()").Limit(limit).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// AddCoupon 新增
+func (r *CouponDao) AddCoupon(tx *gorm.DB, model *model.Coupon) (*model.Coupon, error) {
+	if err := tx.Create(model).Error; err != nil {
+		return nil, err
+	}
+	return model, nil
+}
+
+// GetCoupon 获取
+func (r *CouponDao) GetCoupon(maps interface{}) (m *model.Coupon, err error) {
+	err = global.Db.Where(maps).First(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetCouponListByValidTime 获取列表-今天开始时间/过期时间
+func (r *CouponDao) GetCouponListByValidTime(maps interface{}, startTime, endTime string) (m []*model.Coupon, err error) {
+	err = global.Db.Where(maps).Where("valid_end_time BETWEEN ? AND ?", startTime, endTime).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetCouponPageSearch 获取列表-分页
+func (r *CouponDao) GetCouponPageSearch(req requests.GetCouponPage, page, pageSize int) (m []*model.Coupon, total int64, err error) {
+	var totalRecords int64
+
+	// 构建查询条件
+	query := global.Db.Model(&model.Coupon{})
+
+	// 优惠券名称
+	if req.CouponName != "" {
+		query = query.Where("coupon_name LIKE ?", "%"+req.CouponName+"%")
+	}
+
+	// 优惠券类型
+	if req.CouponType != nil {
+		query = query.Where("coupon_type = ?", req.CouponType)
+	}
+
+	// 状态
+	if req.CouponStatus != nil {
+		query = query.Where("coupon_status = ?", req.CouponStatus)
+	}
+
+	// 适用范围
+	if req.ApplicationScope != nil {
+		query = query.Where("application_scope = ?", req.ApplicationScope)
+	}
+
+	// 是否互斥
+	if req.IsMutex != nil {
+		query = query.Where("is_mutex = ?", req.IsMutex)
+	}
+
+	// 有效类型
+	if req.ValidType != nil {
+		query = query.Where("valid_type = ?", req.ValidType)
+	}
+
+	// 优惠券描述
+	if req.CouponDesc != "" {
+		query = query.Where("coupon_desc = ?", req.CouponDesc)
+	}
+
+	query = query.Order("created_at desc")
+
+	// 查询总数量
+	if err := query.Count(&totalRecords).Error; err != nil {
+		return nil, 0, err
+	}
+
+	err = query.Scopes(model.Paginate(page, pageSize)).Find(&m).Error
+	if err != nil {
+		return nil, 0, err
+	}
+	return m, totalRecords, nil
+}

api/dao/OrderMember.go

@@ -0,0 +1,226 @@
+package dao
+
+import (
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"hepa-calc-admin-api/api/model"
+	"hepa-calc-admin-api/api/requests"
+	"hepa-calc-admin-api/global"
+)
+
+type OrderMemberDao struct {
+}
+
+// GetOrderMemberById 获取数据-id
+func (r *OrderMemberDao) GetOrderMemberById(OrderId int64) (m *model.OrderMember, err error) {
+	err = global.Db.First(&m, OrderId).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetOrderMemberPreloadById 获取数据-加载全部关联-id
+func (r *OrderMemberDao) GetOrderMemberPreloadById(OrderId int64) (m *model.OrderMember, err error) {
+	err = global.Db.Preload(clause.Associations).First(&m, OrderId).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// DeleteOrderMember 删除
+func (r *OrderMemberDao) DeleteOrderMember(tx *gorm.DB, maps interface{}) error {
+	err := tx.Where(maps).Delete(&model.OrderMember{}).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// DeleteOrderMemberById 删除-id
+func (r *OrderMemberDao) DeleteOrderMemberById(tx *gorm.DB, OrderMemberId int64) error {
+	if err := tx.Delete(&model.OrderMember{}, OrderMemberId).Error; err != nil {
+		return err
+	}
+	return nil
+}
+
+// EditOrderMember 修改
+func (r *OrderMemberDao) EditOrderMember(tx *gorm.DB, maps interface{}, data interface{}) error {
+	err := tx.Model(&model.OrderMember{}).Where(maps).Updates(data).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// EditOrderMemberById 修改-id
+func (r *OrderMemberDao) EditOrderMemberById(tx *gorm.DB, OrderId int64, data interface{}) error {
+	err := tx.Model(&model.OrderMember{}).Where("order_id = ?", OrderId).Updates(data).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// GetOrderMemberList 获取列表
+func (r *OrderMemberDao) GetOrderMemberList(maps interface{}) (m []*model.OrderMember, err error) {
+	err = global.Db.Where(maps).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetOrderMemberCount 获取数量
+func (r *OrderMemberDao) GetOrderMemberCount(maps interface{}) (total int64, err error) {
+	err = global.Db.Model(&model.OrderMember{}).Where(maps).Count(&total).Error
+	if err != nil {
+		return 0, err
+	}
+	return total, nil
+}
+
+// GetOrderMemberListRand 获取列表-随机
+func (r *OrderMemberDao) GetOrderMemberListRand(maps interface{}, limit int) (m []*model.OrderMember, err error) {
+	err = global.Db.Where(maps).Order("rand()").Limit(limit).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// AddOrderMember 新增
+func (r *OrderMemberDao) AddOrderMember(tx *gorm.DB, model *model.OrderMember) (*model.OrderMember, error) {
+	if err := tx.Create(model).Error; err != nil {
+		return nil, err
+	}
+	return model, nil
+}
+
+// GetOrderMember 获取
+func (r *OrderMemberDao) GetOrderMember(maps interface{}) (m *model.OrderMember, err error) {
+	err = global.Db.Where(maps).First(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetUserFirstTimeBuyOrderMember 获取用户首次购买的订单
+func (r *OrderMemberDao) GetUserFirstTimeBuyOrderMember(userId int64) (m *model.OrderMember, err error) {
+	err = global.Db.
+		Where("user_id = ?", userId).
+		Where("order_status != ?", 2).
+		First(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetOrderMemberSum 获取数量
+func (r *OrderMemberDao) GetOrderMemberSum(maps interface{}, field string) (total float64, err error) {
+	var result struct {
+		Sum float64
+	}
+
+	err = global.Db.Model(&model.OrderMember{}).Where(maps).Select("SUM(" + field + ") as sum").Scan(&result).Error
+	if err != nil {
+		return 0, err
+	}
+
+	return result.Sum, nil
+}
+
+// GetOrderMemberListByTime 获取列表-开始时间/过期时间
+func (r *OrderMemberDao) GetOrderMemberListByTime(maps interface{}, startTime, endTime, field string) (m []*model.OrderMember, err error) {
+	err = global.Db.Where(maps).Where(field+" BETWEEN ? AND ?", startTime, endTime).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetOrderMemberPageSearch 获取列表-分页
+func (r *OrderMemberDao) GetOrderMemberPageSearch(req requests.GetOrderMemberPage, page, pageSize int) (m []*model.OrderMember, total int64, err error) {
+	var totalRecords int64
+
+	// 构建查询条件
+	query := global.Db.Model(&model.OrderMember{})
+	query = query.Preload("SystemMember")
+	query = query.Preload("User")
+
+	// 会员id
+	if req.SystemMemberId != "" {
+		query = query.Where("system_member_id = ?", req.SystemMemberId)
+	}
+
+	// 订单状态（1:待支付 2:已完成 3:已取消）
+	if req.OrderStatus != nil {
+		query = query.Where("order_status = ?", req.OrderStatus)
+	}
+
+	// 支付渠道
+	if req.PayChannel != nil {
+		query = query.Where("pay_channel = ?", req.PayChannel)
+	}
+
+	// 支付状态
+	if req.PayStatus != nil {
+		query = query.Where("pay_status = ?", req.PayStatus)
+	}
+
+	// 订单退款状态
+	if req.RefundStatus != nil {
+		query = query.Where("refund_status = ?", req.RefundStatus)
+	}
+
+	// 系统订单编号
+	if req.OrderNo != "" {
+		query = query.Where("order_no = ?", req.OrderNo)
+	}
+
+	// 第三方支付流水号
+	if req.EscrowTradeNo != "" {
+		query = query.Where("escrow_trade_no = ?", req.EscrowTradeNo)
+	}
+
+	// 取消状态
+	if req.CancelStatus != nil {
+		query = query.Where("cancel_status = ?", req.CancelStatus)
+	}
+
+	// 用户名称
+	if req.UserName != "" {
+		subQuery := global.Db.Model(&model.User{}).
+			Select("user_id").
+			Where("user_name LIKE ?", "%"+req.UserName+"%")
+
+		query = query.Where(gorm.Expr("user_id IN (?)", subQuery))
+	}
+
+	// 会员天数
+	if req.MemberDays != nil {
+		subQuery := global.Db.Model(&model.SystemMember{}).
+			Select("system_member_id").
+			Where("member_days = ?", req.MemberDays)
+
+		query = query.Where(gorm.Expr("system_member_id IN (?)", subQuery))
+	}
+
+	// 排序
+	query = query.Order("created_at desc")
+
+	// 查询总数量
+	if err := query.Count(&totalRecords).Error; err != nil {
+		return nil, 0, err
+	}
+
+	err = query.Scopes(model.Paginate(page, pageSize)).Find(&m).Error
+	if err != nil {
+		return nil, 0, err
+	}
+	return m, totalRecords, nil
+}

api/dao/OrderMemberCoupon.go

@@ -0,0 +1,117 @@
+package dao
+
+import (
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"hepa-calc-admin-api/api/model"
+	"hepa-calc-admin-api/global"
+)
+
+type OrderMemberCouponDao struct {
+}
+
+// GetOrderMemberCouponById 获取数据-id
+func (r *OrderMemberCouponDao) GetOrderMemberCouponById(OrderMemberCouponId int64) (m *model.OrderMemberCoupon, err error) {
+	err = global.Db.First(&m, OrderMemberCouponId).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetOrderMemberCouponPreloadById 获取数据-加载全部关联-id
+func (r *OrderMemberCouponDao) GetOrderMemberCouponPreloadById(OrderMemberCouponId int64) (m *model.OrderMemberCoupon, err error) {
+	err = global.Db.Preload(clause.Associations).First(&m, OrderMemberCouponId).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
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// DeleteOrderMemberCouponById 删除-id
+func (r *OrderMemberCouponDao) DeleteOrderMemberCouponById(tx *gorm.DB, OrderMemberCouponId int64) error {
+	if err := tx.Delete(&model.OrderMemberCoupon{}, OrderMemberCouponId).Error; err != nil {
+		return err
+	}
+	return nil
+}
+
+// EditOrderMemberCoupon 修改
+func (r *OrderMemberCouponDao) EditOrderMemberCoupon(tx *gorm.DB, maps interface{}, data interface{}) error {
+	err := tx.Model(&model.OrderMemberCoupon{}).Where(maps).Updates(data).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// EditOrderMemberCouponById 修改-id
+func (r *OrderMemberCouponDao) EditOrderMemberCouponById(tx *gorm.DB, OrderMemberCouponId int64, data interface{}) error {
+	err := tx.Model(&model.OrderMemberCoupon{}).Where("order_coupon_id = ?", OrderMemberCouponId).Updates(data).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// GetOrderMemberCouponList 获取列表
+func (r *OrderMemberCouponDao) GetOrderMemberCouponList(maps interface{}) (m []*model.OrderMemberCoupon, err error) {
+	err = global.Db.Where(maps).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetOrderMemberCouponCount 获取数量
+func (r *OrderMemberCouponDao) GetOrderMemberCouponCount(maps interface{}) (total int64, err error) {
+	err = global.Db.Model(&model.OrderMemberCoupon{}).Where(maps).Count(&total).Error
+	if err != nil {
+		return 0, err
+	}
+	return total, nil
+}
+
+// GetOrderMemberCouponListRand 获取列表-随机
+func (r *OrderMemberCouponDao) GetOrderMemberCouponListRand(maps interface{}, limit int) (m []*model.OrderMemberCoupon, err error) {
+	err = global.Db.Where(maps).Order("rand()").Limit(limit).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// AddOrderMemberCoupon 新增
+func (r *OrderMemberCouponDao) AddOrderMemberCoupon(tx *gorm.DB, model *model.OrderMemberCoupon) (*model.OrderMemberCoupon, error) {
+	if err := tx.Create(model).Error; err != nil {
+		return nil, err
+	}
+	return model, nil
+}
+
+// GetOrderMemberCoupon 获取
+func (r *OrderMemberCouponDao) GetOrderMemberCoupon(maps interface{}) (m *model.OrderMemberCoupon, err error) {
+	err = global.Db.Where(maps).First(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetOrderMemberCouponByOrderId 获取数据-订单id
+func (r *OrderMemberCouponDao) GetOrderMemberCouponByOrderId(orderId int64) (m *model.OrderMemberCoupon, err error) {
+	err = global.Db.Where("order_id = ?", orderId).First(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}

api/dao/OrderMemberRefund.go

@@ -0,0 +1,108 @@
+package dao
+
+import (
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"hepa-calc-admin-api/api/model"
+	"hepa-calc-admin-api/global"
+)
+
+type OrderMemberRefundDao struct {
+}
+
+// GetOrderMemberRefundById 获取数据-id
+func (r *OrderMemberRefundDao) GetOrderMemberRefundById(OrderMemberRefundId int64) (m *model.OrderMemberRefund, err error) {
+	err = global.Db.First(&m, OrderMemberRefundId).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetOrderMemberRefundPreloadById 获取数据-加载全部关联-id
+func (r *OrderMemberRefundDao) GetOrderMemberRefundPreloadById(OrderMemberRefundId int64) (m *model.OrderMemberRefund, err error) {
+	err = global.Db.Preload(clause.Associations).First(&m, OrderMemberRefundId).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// DeleteOrderMemberRefund 删除
+func (r *OrderMemberRefundDao) DeleteOrderMemberRefund(tx *gorm.DB, maps interface{}) error {
+	err := tx.Where(maps).Delete(&model.OrderMemberRefund{}).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// DeleteOrderMemberRefundById 删除-id
+func (r *OrderMemberRefundDao) DeleteOrderMemberRefundById(tx *gorm.DB, OrderMemberRefundId int64) error {
+	if err := tx.Delete(&model.OrderMemberRefund{}, OrderMemberRefundId).Error; err != nil {
+		return err
+	}
+	return nil
+}
+
+// EditOrderMemberRefund 修改
+func (r *OrderMemberRefundDao) EditOrderMemberRefund(tx *gorm.DB, maps interface{}, data interface{}) error {
+	err := tx.Model(&model.OrderMemberRefund{}).Where(maps).Updates(data).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// EditOrderMemberRefundById 修改-id
+func (r *OrderMemberRefundDao) EditOrderMemberRefundById(tx *gorm.DB, OrderMemberRefundId int64, data interface{}) error {
+	err := tx.Model(&model.OrderMemberRefund{}).Where("order_refund_id = ?", OrderMemberRefundId).Updates(data).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// GetOrderMemberRefundList 获取列表
+func (r *OrderMemberRefundDao) GetOrderMemberRefundList(maps interface{}) (m []*model.OrderMemberRefund, err error) {
+	err = global.Db.Where(maps).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetOrderMemberRefundCount 获取数量
+func (r *OrderMemberRefundDao) GetOrderMemberRefundCount(maps interface{}) (total int64, err error) {
+	err = global.Db.Model(&model.OrderMemberRefund{}).Where(maps).Count(&total).Error
+	if err != nil {
+		return 0, err
+	}
+	return total, nil
+}
+
+// GetOrderMemberRefundListRand 获取列表-随机
+func (r *OrderMemberRefundDao) GetOrderMemberRefundListRand(maps interface{}, limit int) (m []*model.OrderMemberRefund, err error) {
+	err = global.Db.Where(maps).Order("rand()").Limit(limit).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// AddOrderMemberRefund 新增
+func (r *OrderMemberRefundDao) AddOrderMemberRefund(tx *gorm.DB, model *model.OrderMemberRefund) (*model.OrderMemberRefund, error) {
+	if err := tx.Create(model).Error; err != nil {
+		return nil, err
+	}
+	return model, nil
+}
+
+// GetOrderMemberRefund 获取
+func (r *OrderMemberRefundDao) GetOrderMemberRefund(maps interface{}) (m *model.OrderMemberRefund, err error) {
+	err = global.Db.Where(maps).First(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}

api/dao/OrderSingle.go

@@ -0,0 +1,236 @@
+package dao
+
+import (
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"hepa-calc-admin-api/api/model"
+	"hepa-calc-admin-api/api/requests"
+	"hepa-calc-admin-api/global"
+)
+
+type OrderSingleDao struct {
+}
+
+// GetOrderSingleById 获取数据-id
+func (r *OrderSingleDao) GetOrderSingleById(OrderId int64) (m *model.OrderSingle, err error) {
+	err = global.Db.First(&m, OrderId).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetOrderSinglePreloadById 获取数据-加载全部关联-id
+func (r *OrderSingleDao) GetOrderSinglePreloadById(OrderId int64) (m *model.OrderSingle, err error) {
+	err = global.Db.Preload(clause.Associations).First(&m, OrderId).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// DeleteOrderSingle 删除
+func (r *OrderSingleDao) DeleteOrderSingle(tx *gorm.DB, maps interface{}) error {
+	err := tx.Where(maps).Delete(&model.OrderSingle{}).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// DeleteOrderSingleById 删除-id
+func (r *OrderSingleDao) DeleteOrderSingleById(tx *gorm.DB, orderId int64) error {
+	if err := tx.Delete(&model.OrderSingle{}, orderId).Error; err != nil {
+		return err
+	}
+	return nil
+}
+
+// EditOrderSingle 修改
+func (r *OrderSingleDao) EditOrderSingle(tx *gorm.DB, maps interface{}, data interface{}) error {
+	err := tx.Model(&model.OrderSingle{}).Where(maps).Updates(data).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// EditOrderSingleById 修改-id
+func (r *OrderSingleDao) EditOrderSingleById(tx *gorm.DB, orderId int64, data interface{}) error {
+	err := tx.Model(&model.OrderSingle{}).Where("order_id = ?", orderId).Updates(data).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// GetOrderSingleList 获取列表
+func (r *OrderSingleDao) GetOrderSingleList(maps interface{}) (m []*model.OrderSingle, err error) {
+	err = global.Db.Where(maps).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetOrderSingleCount 获取数量
+func (r *OrderSingleDao) GetOrderSingleCount(maps interface{}) (total int64, err error) {
+	err = global.Db.Model(&model.OrderSingle{}).Where(maps).Count(&total).Error
+	if err != nil {
+		return 0, err
+	}
+	return total, nil
+}
+
+// GetOrderSingleListRand 获取列表-随机
+func (r *OrderSingleDao) GetOrderSingleListRand(maps interface{}, limit int) (m []*model.OrderSingle, err error) {
+	err = global.Db.Where(maps).Order("rand()").Limit(limit).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// AddOrderSingle 新增
+func (r *OrderSingleDao) AddOrderSingle(tx *gorm.DB, model *model.OrderSingle) (*model.OrderSingle, error) {
+	if err := tx.Create(model).Error; err != nil {
+		return nil, err
+	}
+	return model, nil
+}
+
+// GetOrderSingle 获取
+func (r *OrderSingleDao) GetOrderSingle(maps interface{}) (m *model.OrderSingle, err error) {
+	err = global.Db.Where(maps).First(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetOrderSingleOrderList 获取列表-排序
+func (r *OrderSingleDao) GetOrderSingleOrderList(maps interface{}, orderField string, limit int) (m []*model.OrderSingle, err error) {
+	err = global.Db.Where(maps).Preload(clause.Associations).Order(orderField).Limit(limit).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetUserFirstTimeBuyOrderSingle 获取用户首次购买的订单
+func (r *OrderSingleDao) GetUserFirstTimeBuyOrderSingle(userId, questionId int64) (m *model.OrderSingle, err error) {
+	err = global.Db.
+		Where("user_id = ?", userId).
+		Where("question_id = ?", questionId).
+		Where("order_status != ?", 3).
+		First(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetOrderSingleSum 获取数量
+func (r *OrderSingleDao) GetOrderSingleSum(maps interface{}, field string) (total float64, err error) {
+	var result struct {
+		Sum float64
+	}
+
+	err = global.Db.Model(&model.OrderSingle{}).Where(maps).Select("SUM(" + field + ") as sum").Scan(&result).Error
+	if err != nil {
+		return 0, err
+	}
+
+	return result.Sum, nil
+}
+
+// GetOrderSingleListByTime 获取列表-开始时间/过期时间
+func (r *OrderSingleDao) GetOrderSingleListByTime(maps interface{}, startTime, endTime, field string) (m []*model.OrderSingle, err error) {
+	err = global.Db.Where(maps).Where(field+" BETWEEN ? AND ?", startTime, endTime).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetOrderSinglePageSearch 获取列表-分页
+func (r *OrderSingleDao) GetOrderSinglePageSearch(req requests.GetOrderSinglePage, page, pageSize int) (m []*model.OrderSingle, total int64, err error) {
+	var totalRecords int64
+
+	// 构建查询条件
+	query := global.Db.Model(&model.OrderSingle{})
+	query = query.Preload("Question")
+	query = query.Preload("User")
+
+	// 问题id
+	if req.QuestionId != "" {
+		query = query.Where("question_id = ?", req.QuestionId)
+	}
+
+	// 订单状态（1:待支付 2:已完成 3:已取消）
+	if req.OrderStatus != nil {
+		query = query.Where("order_status = ?", req.OrderStatus)
+	}
+
+	// 支付渠道
+	if req.PayChannel != nil {
+		query = query.Where("pay_channel = ?", req.PayChannel)
+	}
+
+	// 支付状态
+	if req.PayStatus != nil {
+		query = query.Where("pay_status = ?", req.PayStatus)
+	}
+
+	// 订单退款状态
+	if req.RefundStatus != nil {
+		query = query.Where("refund_status = ?", req.RefundStatus)
+	}
+
+	// 系统订单编号
+	if req.OrderNo != "" {
+		query = query.Where("order_no = ?", req.OrderNo)
+	}
+
+	// 第三方支付流水号
+	if req.EscrowTradeNo != "" {
+		query = query.Where("escrow_trade_no = ?", req.EscrowTradeNo)
+	}
+
+	// 取消状态
+	if req.CancelStatus != nil {
+		query = query.Where("cancel_status = ?", req.CancelStatus)
+	}
+
+	// 问题标题
+	if req.QuestionTitle != "" {
+		subQuery := global.Db.Model(&model.Question{}).
+			Select("question_id").
+			Where("question_title LIKE ?", "%"+req.QuestionTitle+"%")
+
+		query = query.Where(gorm.Expr("question_id IN (?)", subQuery))
+	}
+
+	// 用户名称
+	if req.UserName != "" {
+		subQuery := global.Db.Model(&model.User{}).
+			Select("user_id").
+			Where("user_name LIKE ?", "%"+req.UserName+"%")
+
+		query = query.Where(gorm.Expr("user_id IN (?)", subQuery))
+	}
+
+	// 排序
+	query = query.Order("created_at desc")
+
+	// 查询总数量
+	if err := query.Count(&totalRecords).Error; err != nil {
+		return nil, 0, err
+	}
+
+	err = query.Scopes(model.Paginate(page, pageSize)).Find(&m).Error
+	if err != nil {
+		return nil, 0, err
+	}
+	return m, totalRecords, nil
+}

api/dao/OrderSingleCoupon.go

@@ -0,0 +1,117 @@
+package dao
+
+import (
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"hepa-calc-admin-api/api/model"
+	"hepa-calc-admin-api/global"
+)
+
+type OrderSingleCouponDao struct {
+}
+
+// GetOrderSingleCouponById 获取数据-id
+func (r *OrderSingleCouponDao) GetOrderSingleCouponById(OrderSingleCouponId int64) (m *model.OrderSingleCoupon, err error) {
+	err = global.Db.First(&m, OrderSingleCouponId).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetOrderSingleCouponPreloadById 获取数据-加载全部关联-id
+func (r *OrderSingleCouponDao) GetOrderSingleCouponPreloadById(OrderSingleCouponId int64) (m *model.OrderSingleCoupon, err error) {
+	err = global.Db.Preload(clause.Associations).First(&m, OrderSingleCouponId).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetOrderSingleCouponByOrderId 获取数据-订单id
+func (r *OrderSingleCouponDao) GetOrderSingleCouponByOrderId(orderId int64) (m *model.OrderSingleCoupon, err error) {
+	err = global.Db.Where("order_id = ?", orderId).First(&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
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// DeleteOrderSingleCouponById 删除-id
+func (r *OrderSingleCouponDao) DeleteOrderSingleCouponById(tx *gorm.DB, OrderSingleCouponId int64) error {
+	if err := tx.Delete(&model.OrderSingleCoupon{}, OrderSingleCouponId).Error; err != nil {
+		return err
+	}
+	return nil
+}
+
+// EditOrderSingleCoupon 修改
+func (r *OrderSingleCouponDao) EditOrderSingleCoupon(tx *gorm.DB, maps interface{}, data interface{}) error {
+	err := tx.Model(&model.OrderSingleCoupon{}).Where(maps).Updates(data).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// EditOrderSingleCouponById 修改-id
+func (r *OrderSingleCouponDao) EditOrderSingleCouponById(tx *gorm.DB, OrderSingleCouponId int64, data interface{}) error {
+	err := tx.Model(&model.OrderSingleCoupon{}).Where("order_coupon_id = ?", OrderSingleCouponId).Updates(data).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// GetOrderSingleCouponList 获取列表
+func (r *OrderSingleCouponDao) GetOrderSingleCouponList(maps interface{}) (m []*model.OrderSingleCoupon, err error) {
+	err = global.Db.Where(maps).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetOrderSingleCouponCount 获取数量
+func (r *OrderSingleCouponDao) GetOrderSingleCouponCount(maps interface{}) (total int64, err error) {
+	err = global.Db.Model(&model.OrderSingleCoupon{}).Where(maps).Count(&total).Error
+	if err != nil {
+		return 0, err
+	}
+	return total, nil
+}
+
+// GetOrderSingleCouponListRand 获取列表-随机
+func (r *OrderSingleCouponDao) GetOrderSingleCouponListRand(maps interface{}, limit int) (m []*model.OrderSingleCoupon, err error) {
+	err = global.Db.Where(maps).Order("rand()").Limit(limit).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// AddOrderSingleCoupon 新增
+func (r *OrderSingleCouponDao) AddOrderSingleCoupon(tx *gorm.DB, model *model.OrderSingleCoupon) (*model.OrderSingleCoupon, error) {
+	if err := tx.Create(model).Error; err != nil {
+		return nil, err
+	}
+	return model, nil
+}
+
+// GetOrderSingleCoupon 获取
+func (r *OrderSingleCouponDao) GetOrderSingleCoupon(maps interface{}) (m *model.OrderSingleCoupon, err error) {
+	err = global.Db.Where(maps).First(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}

api/dao/OrderSingleRefund.go

@@ -0,0 +1,108 @@
+package dao
+
+import (
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"hepa-calc-admin-api/api/model"
+	"hepa-calc-admin-api/global"
+)
+
+type OrderSingleRefundDao struct {
+}
+
+// GetOrderSingleRefundById 获取数据-id
+func (r *OrderSingleRefundDao) GetOrderSingleRefundById(OrderSingleRefundId int64) (m *model.OrderSingleRefund, err error) {
+	err = global.Db.First(&m, OrderSingleRefundId).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetOrderSingleRefundPreloadById 获取数据-加载全部关联-id
+func (r *OrderSingleRefundDao) GetOrderSingleRefundPreloadById(OrderSingleRefundId int64) (m *model.OrderSingleRefund, err error) {
+	err = global.Db.Preload(clause.Associations).First(&m, OrderSingleRefundId).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// DeleteOrderSingleRefund 删除
+func (r *OrderSingleRefundDao) DeleteOrderSingleRefund(tx *gorm.DB, maps interface{}) error {
+	err := tx.Where(maps).Delete(&model.OrderSingleRefund{}).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// DeleteOrderSingleRefundById 删除-id
+func (r *OrderSingleRefundDao) DeleteOrderSingleRefundById(tx *gorm.DB, OrderSingleRefundId int64) error {
+	if err := tx.Delete(&model.OrderSingleRefund{}, OrderSingleRefundId).Error; err != nil {
+		return err
+	}
+	return nil
+}
+
+// EditOrderSingleRefund 修改
+func (r *OrderSingleRefundDao) EditOrderSingleRefund(tx *gorm.DB, maps interface{}, data interface{}) error {
+	err := tx.Model(&model.OrderSingleRefund{}).Where(maps).Updates(data).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// EditOrderSingleRefundById 修改-id
+func (r *OrderSingleRefundDao) EditOrderSingleRefundById(tx *gorm.DB, OrderSingleRefundId int64, data interface{}) error {
+	err := tx.Model(&model.OrderSingleRefund{}).Where("order_refund_id = ?", OrderSingleRefundId).Updates(data).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// GetOrderSingleRefundList 获取列表
+func (r *OrderSingleRefundDao) GetOrderSingleRefundList(maps interface{}) (m []*model.OrderSingleRefund, err error) {
+	err = global.Db.Where(maps).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetOrderSingleRefundCount 获取数量
+func (r *OrderSingleRefundDao) GetOrderSingleRefundCount(maps interface{}) (total int64, err error) {
+	err = global.Db.Model(&model.OrderSingleRefund{}).Where(maps).Count(&total).Error
+	if err != nil {
+		return 0, err
+	}
+	return total, nil
+}
+
+// GetOrderSingleRefundListRand 获取列表-随机
+func (r *OrderSingleRefundDao) GetOrderSingleRefundListRand(maps interface{}, limit int) (m []*model.OrderSingleRefund, err error) {
+	err = global.Db.Where(maps).Order("rand()").Limit(limit).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// AddOrderSingleRefund 新增
+func (r *OrderSingleRefundDao) AddOrderSingleRefund(tx *gorm.DB, model *model.OrderSingleRefund) (*model.OrderSingleRefund, error) {
+	if err := tx.Create(model).Error; err != nil {
+		return nil, err
+	}
+	return model, nil
+}
+
+// GetOrderSingleRefund 获取
+func (r *OrderSingleRefundDao) GetOrderSingleRefund(maps interface{}) (m *model.OrderSingleRefund, err error) {
+	err = global.Db.Where(maps).First(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}

api/dao/Question.go

@@ -0,0 +1,423 @@
+package dao
+
+import (
+	"errors"
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"hepa-calc-admin-api/api/model"
+	"hepa-calc-admin-api/api/requests"
+	"hepa-calc-admin-api/global"
+)
+
+type QuestionDao struct {
+}
+
+// GetQuestionById 获取数据-id
+func (r *QuestionDao) GetQuestionById(QuestionId int64) (m *model.Question, err error) {
+	err = global.Db.First(&m, QuestionId).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetQuestionPreloadById 获取数据-加载全部关联-id
+func (r *QuestionDao) GetQuestionPreloadById(QuestionId int64) (m *model.Question, err error) {
+	err = global.Db.Preload(clause.Associations).First(&m, QuestionId).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// DeleteQuestion 删除
+func (r *QuestionDao) DeleteQuestion(tx *gorm.DB, maps interface{}) error {
+	err := tx.Where(maps).Delete(&model.Question{}).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// DeleteQuestionById 删除-id
+func (r *QuestionDao) DeleteQuestionById(tx *gorm.DB, QuestionId int64) error {
+	if err := tx.Delete(&model.Question{}, QuestionId).Error; err != nil {
+		return err
+	}
+	return nil
+}
+
+// EditQuestion 修改
+func (r *QuestionDao) EditQuestion(tx *gorm.DB, maps interface{}, data interface{}) error {
+	err := tx.Model(&model.Question{}).Where(maps).Updates(data).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// EditQuestionById 修改-id
+func (r *QuestionDao) EditQuestionById(tx *gorm.DB, QuestionId int64, data interface{}) error {
+	err := tx.Model(&model.Question{}).Where("question_id = ?", QuestionId).Updates(data).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// GetQuestionList 获取列表
+func (r *QuestionDao) GetQuestionList(maps interface{}) (m []*model.Question, err error) {
+	err = global.Db.Where(maps).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetQuestionCount 获取数量
+func (r *QuestionDao) GetQuestionCount(maps interface{}) (total int64, err error) {
+	err = global.Db.Model(&model.Question{}).Where(maps).Count(&total).Error
+	if err != nil {
+		return 0, err
+	}
+	return total, nil
+}
+
+// GetQuestionListRand 获取列表-随机
+func (r *QuestionDao) GetQuestionListRand(maps interface{}, limit int) (m []*model.Question, err error) {
+	err = global.Db.Where(maps).Order("rand()").Limit(limit).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// AddQuestion 新增
+func (r *QuestionDao) AddQuestion(tx *gorm.DB, model *model.Question) (*model.Question, error) {
+	if err := tx.Create(model).Error; err != nil {
+		return nil, err
+	}
+	return model, nil
+}
+
+// GetQuestion 获取
+func (r *QuestionDao) GetQuestion(maps interface{}) (m *model.Question, err error) {
+	err = global.Db.Where(maps).First(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetQuestionOrderLimitList 获取列表-排序、限制数量
+func (r *QuestionDao) GetQuestionOrderLimitList(maps interface{}, orderField string, limit int) (m []*model.Question, err error) {
+	err = global.Db.Where(maps).Order(orderField).Limit(limit).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// Inc 自增
+func (r *QuestionDao) Inc(tx *gorm.DB, questionId int64, field string, numeral int) error {
+	err := tx.Model(&model.Question{}).Where("question_id = ?", questionId).UpdateColumn(field, gorm.Expr(field+" + ?", numeral)).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// Dec 自减
+func (r *QuestionDao) Dec(tx *gorm.DB, questionId int64, field string, numeral int) error {
+	err := tx.Model(&model.Question{}).Where("question_id = ?", questionId).UpdateColumn(field, gorm.Expr(field+" - ?", numeral)).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// GetQuestionSum 获取数量
+func (r *QuestionDao) GetQuestionSum(maps interface{}, field string) (total float64, err error) {
+	var result struct {
+		Sum float64
+	}
+
+	err = global.Db.Model(&model.Question{}).Where(maps).Select("SUM(" + field + ") as sum").Scan(&result).Error
+	if err != nil {
+		return 0, err
+	}
+
+	return result.Sum, nil
+}
+
+// GetQuestionListByTime 获取列表-开始时间/过期时间
+func (r *QuestionDao) GetQuestionListByTime(maps interface{}, startTime, endTime, field string) (m []*model.Question, err error) {
+	err = global.Db.Where(maps).Where(field+" BETWEEN ? AND ?", startTime, endTime).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetQuestionPageSearch 获取题目列表-分页
+func (r *QuestionDao) GetQuestionPageSearch(req requests.GetQuestionPage, page, pageSize int) (m []*model.Question, total int64, err error) {
+	var totalRecords int64
+
+	// 构建查询条件
+	query := global.Db.Model(&model.Question{})
+
+	// 是否隐藏
+	query = query.Where("is_hide = ?", 0)
+
+	// 主键id
+	if req.QuestionId != "" {
+		query = query.Where("question_id = ?", req.QuestionId)
+	}
+
+	// 标题
+	if req.QuestionTitle != "" {
+		query = query.Where("question_title LIKE ?", "%"+req.QuestionTitle+"%")
+	}
+
+	// 副标题
+	if req.QuestionSubtitle != "" {
+		query = query.Where("question_subtitle LIKE ?", "%"+req.QuestionSubtitle+"%")
+	}
+
+	// 唯一标识
+	if req.QuestionIden != "" {
+		query = query.Where("question_iden = ?", req.QuestionIden)
+	}
+
+	// 问题状态
+	if req.QuestionStatus != nil {
+		query = query.Where("question_status = ?", req.QuestionStatus)
+	}
+
+	// 是否推荐
+	if req.IsRecommend != nil {
+		query = query.Where("is_recommend = ?", req.IsRecommend)
+	}
+
+	// 问题介绍
+	if req.QuestionBrief != "" {
+		query = query.Where("question_brief LIKE ?", "%"+req.QuestionBrief+"%")
+	}
+
+	// 问题解释/科普
+	if req.QuestionExplain != "" {
+		query = query.Where("question_explain LIKE ?", "%"+req.QuestionExplain+"%")
+	}
+
+	// 分类标识
+	if req.ClassId != "" {
+		baseClassQuery := global.Db.Model(&model.BaseClass{}).
+			Select("class_id").
+			Where("class_id = ?", req.ClassId)
+
+		questionClassQuery := global.Db.Model(&model.QuestionClass{}).
+			Select("question_id").
+			Where("class_id IN (?)", baseClassQuery)
+
+		query = query.Where("question_id IN (?)", questionClassQuery)
+	}
+
+	// 排序
+	if req.Order != nil {
+		// 点击次数（点击进入详情页的人次）
+		if req.Order.ClickCount != "" {
+			if req.Order.ClickCount != "desc" && req.Order.ClickCount != "asc" {
+				return nil, 0, errors.New("排序字段错误")
+			}
+
+			query = query.Order("click_count " + req.Order.ClickCount)
+		}
+
+		// 提交次数（提交个人信息进行了算算的人次）
+		if req.Order.SubmitCount != "" {
+			if req.Order.SubmitCount != "desc" && req.Order.SubmitCount != "asc" {
+				return nil, 0, errors.New("排序字段错误")
+			}
+
+			query = query.Order("submit_count " + req.Order.SubmitCount)
+		}
+
+		// 支付次数（查看报告的人次）
+		if req.Order.PayCount != "" {
+			if req.Order.PayCount != "desc" && req.Order.PayCount != "asc" {
+				return nil, 0, errors.New("排序字段错误")
+			}
+
+			query = query.Order("pay_count " + req.Order.PayCount)
+		}
+
+		// 价格（原价）
+		if req.Order.Price != "" {
+			if req.Order.Price != "desc" && req.Order.Price != "asc" {
+				return nil, 0, errors.New("排序字段错误")
+			}
+
+			query = query.Order("price " + req.Order.Price)
+		}
+
+		// 优惠价格
+		if req.Order.DiscountPrice != "" {
+			if req.Order.DiscountPrice != "desc" && req.Order.DiscountPrice != "asc" {
+				return nil, 0, errors.New("排序字段错误")
+			}
+
+			query = query.Order("discount_price " + req.Order.DiscountPrice)
+		}
+
+		if req.Order.UpdatedAt != "" {
+			if req.Order.UpdatedAt != "desc" && req.Order.UpdatedAt != "asc" {
+				return nil, 0, errors.New("排序字段错误")
+			}
+
+			query = query.Order("updated_at " + req.Order.UpdatedAt)
+		}
+	}
+
+	// 排序
+	query = query.Order("created_at desc")
+
+	// 查询总数量
+	if err := query.Count(&totalRecords).Error; err != nil {
+		return nil, 0, err
+	}
+
+	err = query.Scopes(model.Paginate(page, pageSize)).Find(&m).Error
+	if err != nil {
+		return nil, 0, err
+	}
+	return m, totalRecords, nil
+}
+
+// GetQuestionListSearch 获取题目列表
+func (r *QuestionDao) GetQuestionListSearch(req requests.GetQuestionList) (m []*model.Question, err error) {
+	// 构建查询条件
+	query := global.Db.Model(&model.Question{})
+
+	// 主键id
+	if req.QuestionId != "" {
+		query = query.Where("question_id = ?", req.QuestionId)
+	}
+
+	// 是否隐藏
+	if req.IsHide != nil {
+		query = query.Where("is_hide = ?", req.IsHide)
+	}
+
+	// 标题
+	if req.QuestionTitle != "" {
+		query = query.Where("question_title LIKE ?", "%"+req.QuestionTitle+"%")
+	}
+
+	// 副标题
+	if req.QuestionSubtitle != "" {
+		query = query.Where("question_subtitle LIKE ?", "%"+req.QuestionSubtitle+"%")
+	}
+
+	// 唯一标识
+	if req.QuestionIden != "" {
+		query = query.Where("question_iden = ?", req.QuestionIden)
+	}
+
+	// 问题状态
+	if req.QuestionStatus != nil {
+		query = query.Where("question_status = ?", req.QuestionStatus)
+	}
+
+	// 是否推荐
+	if req.IsRecommend != nil {
+		query = query.Where("is_recommend = ?", req.IsRecommend)
+	}
+
+	// 问题介绍
+	if req.QuestionBrief != "" {
+		query = query.Where("question_brief LIKE ?", "%"+req.QuestionBrief+"%")
+	}
+
+	// 问题解释/科普
+	if req.QuestionExplain != "" {
+		query = query.Where("question_explain LIKE ?", "%"+req.QuestionExplain+"%")
+	}
+
+	// 分类标识
+	if req.ClassId != "" {
+		baseClassQuery := global.Db.Model(&model.BaseClass{}).
+			Select("class_id").
+			Where("class_id = ?", req.ClassId)
+
+		questionClassQuery := global.Db.Model(&model.QuestionClass{}).
+			Select("question_id").
+			Where("class_id IN (?)", baseClassQuery)
+
+		query = query.Where("question_id IN (?)", questionClassQuery)
+	}
+
+	// 排序
+	if req.Order != nil {
+		// 点击次数（点击进入详情页的人次）
+		if req.Order.ClickCount != "" {
+			if req.Order.ClickCount != "desc" && req.Order.ClickCount != "asc" {
+				return nil, errors.New("排序字段错误")
+			}
+
+			query = query.Order("click_count " + req.Order.ClickCount)
+		}
+
+		// 提交次数（提交个人信息进行了算算的人次）
+		if req.Order.SubmitCount != "" {
+			if req.Order.SubmitCount != "desc" && req.Order.SubmitCount != "asc" {
+				return nil, errors.New("排序字段错误")
+			}
+
+			query = query.Order("submit_count " + req.Order.SubmitCount)
+		}
+
+		// 支付次数（查看报告的人次）
+		if req.Order.PayCount != "" {
+			if req.Order.PayCount != "desc" && req.Order.PayCount != "asc" {
+				return nil, errors.New("排序字段错误")
+			}
+
+			query = query.Order("pay_count " + req.Order.PayCount)
+		}
+
+		// 价格（原价）
+		if req.Order.Price != "" {
+			if req.Order.Price != "desc" && req.Order.Price != "asc" {
+				return nil, errors.New("排序字段错误")
+			}
+
+			query = query.Order("price " + req.Order.Price)
+		}
+
+		// 优惠价格
+		if req.Order.DiscountPrice != "" {
+			if req.Order.DiscountPrice != "desc" && req.Order.DiscountPrice != "asc" {
+				return nil, errors.New("排序字段错误")
+			}
+
+			query = query.Order("discount_price " + req.Order.DiscountPrice)
+		}
+
+		if req.Order.UpdatedAt != "" {
+			if req.Order.UpdatedAt != "desc" && req.Order.UpdatedAt != "asc" {
+				return nil, errors.New("排序字段错误")
+			}
+
+			query = query.Order("updated_at " + req.Order.UpdatedAt)
+		}
+	}
+
+	// 排序
+	query = query.Order("created_at desc")
+
+	err = query.Scopes(model.Paginate(1, 10)).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}

api/dao/QuestionClass.go

@@ -0,0 +1,125 @@
+package dao
+
+import (
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"hepa-calc-admin-api/api/model"
+	"hepa-calc-admin-api/global"
+)
+
+type QuestionClassDao struct {
+}
+
+// GetQuestionClassById 获取数据-id
+func (r *QuestionClassDao) GetQuestionClassById(QuestionClassId int64) (m *model.QuestionClass, err error) {
+	err = global.Db.First(&m, QuestionClassId).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetQuestionClassPreloadById 获取数据-加载全部关联-id
+func (r *QuestionClassDao) GetQuestionClassPreloadById(QuestionClassId int64) (m *model.QuestionClass, err error) {
+	err = global.Db.Preload(clause.Associations).First(&m, QuestionClassId).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// DeleteQuestionClass 删除
+func (r *QuestionClassDao) DeleteQuestionClass(tx *gorm.DB, maps interface{}) error {
+	err := tx.Where(maps).Delete(&model.QuestionClass{}).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// GetQuestionClassListByQuestionId 获取数据-问题id
+func (r *QuestionClassDao) GetQuestionClassListByQuestionId(questionId int64) (m []*model.QuestionClass, err error) {
+	err = global.Db.Where("question_id = ?", questionId).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// DeleteQuestionClassById 删除-id
+func (r *QuestionClassDao) DeleteQuestionClassById(tx *gorm.DB, QuestionClassId int64) error {
+	if err := tx.Delete(&model.QuestionClass{}, QuestionClassId).Error; err != nil {
+		return err
+	}
+	return nil
+}
+
+// DeleteQuestionClassByQuestionId 删除-问题id
+func (r *QuestionClassDao) DeleteQuestionClassByQuestionId(tx *gorm.DB, questionId int64) error {
+	if err := tx.Where("question_id = ?", questionId).Delete(&model.QuestionClass{}).Error; err != nil {
+		return err
+	}
+	return nil
+}
+
+// EditQuestionClass 修改
+func (r *QuestionClassDao) EditQuestionClass(tx *gorm.DB, maps interface{}, data interface{}) error {
+	err := tx.Model(&model.QuestionClass{}).Where(maps).Updates(data).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// EditQuestionClassById 修改-id
+func (r *QuestionClassDao) EditQuestionClassById(tx *gorm.DB, QuestionClassId int64, data interface{}) error {
+	err := tx.Model(&model.QuestionClass{}).Where("question_class_id = ?", QuestionClassId).Updates(data).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// GetQuestionClassList 获取列表
+func (r *QuestionClassDao) GetQuestionClassList(maps interface{}) (m []*model.QuestionClass, err error) {
+	err = global.Db.Where(maps).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetQuestionClassCount 获取数量
+func (r *QuestionClassDao) GetQuestionClassCount(maps interface{}) (total int64, err error) {
+	err = global.Db.Model(&model.QuestionClass{}).Where(maps).Count(&total).Error
+	if err != nil {
+		return 0, err
+	}
+	return total, nil
+}
+
+// GetQuestionClassListRand 获取列表-随机
+func (r *QuestionClassDao) GetQuestionClassListRand(maps interface{}, limit int) (m []*model.QuestionClass, err error) {
+	err = global.Db.Where(maps).Order("rand()").Limit(limit).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// AddQuestionClass 新增
+func (r *QuestionClassDao) AddQuestionClass(tx *gorm.DB, model *model.QuestionClass) (*model.QuestionClass, error) {
+	if err := tx.Create(model).Error; err != nil {
+		return nil, err
+	}
+	return model, nil
+}
+
+// GetQuestionClass 获取
+func (r *QuestionClassDao) GetQuestionClass(maps interface{}) (m *model.QuestionClass, err error) {
+	err = global.Db.Where(maps).First(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}

api/dao/SystemMember.go

@@ -0,0 +1,123 @@
+package dao
+
+import (
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"hepa-calc-admin-api/api/model"
+	"hepa-calc-admin-api/global"
+)
+
+type SystemMemberDao struct {
+}
+
+// GetSystemMemberById 获取数据-id
+func (r *SystemMemberDao) GetSystemMemberById(SystemMemberId int64) (m *model.SystemMember, err error) {
+	err = global.Db.First(&m, SystemMemberId).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetSystemMemberPreloadById 获取数据-加载全部关联-id
+func (r *SystemMemberDao) GetSystemMemberPreloadById(SystemMemberId int64) (m *model.SystemMember, err error) {
+	err = global.Db.Preload(clause.Associations).First(&m, SystemMemberId).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// DeleteSystemMember 删除
+func (r *SystemMemberDao) DeleteSystemMember(tx *gorm.DB, maps interface{}) error {
+	err := tx.Where(maps).Delete(&model.SystemMember{}).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// DeleteSystemMemberById 删除-id
+func (r *SystemMemberDao) DeleteSystemMemberById(tx *gorm.DB, SystemMemberId int64) error {
+	if err := tx.Delete(&model.SystemMember{}, SystemMemberId).Error; err != nil {
+		return err
+	}
+	return nil
+}
+
+// EditSystemMember 修改
+func (r *SystemMemberDao) EditSystemMember(tx *gorm.DB, maps interface{}, data interface{}) error {
+	err := tx.Model(&model.SystemMember{}).Where(maps).Updates(data).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// EditSystemMemberById 修改-id
+func (r *SystemMemberDao) EditSystemMemberById(tx *gorm.DB, SystemMemberId int64, data interface{}) error {
+	err := tx.Model(&model.SystemMember{}).Where("system_member_id = ?", SystemMemberId).Updates(data).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// GetSystemMemberList 获取列表
+func (r *SystemMemberDao) GetSystemMemberList(maps interface{}) (m []*model.SystemMember, err error) {
+	err = global.Db.Where(maps).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetSystemMemberCount 获取数量
+func (r *SystemMemberDao) GetSystemMemberCount(maps interface{}) (total int64, err error) {
+	err = global.Db.Model(&model.SystemMember{}).Where(maps).Count(&total).Error
+	if err != nil {
+		return 0, err
+	}
+	return total, nil
+}
+
+// GetSystemMemberListRand 获取列表-随机
+func (r *SystemMemberDao) GetSystemMemberListRand(maps interface{}, limit int) (m []*model.SystemMember, err error) {
+	err = global.Db.Where(maps).Order("rand()").Limit(limit).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// AddSystemMember 新增
+func (r *SystemMemberDao) AddSystemMember(tx *gorm.DB, model *model.SystemMember) (*model.SystemMember, error) {
+	if err := tx.Create(model).Error; err != nil {
+		return nil, err
+	}
+	return model, nil
+}
+
+// GetSystemMember 获取
+func (r *SystemMemberDao) GetSystemMember(maps interface{}) (m *model.SystemMember, err error) {
+	err = global.Db.Where(maps).First(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetSystemMemberListSearch 获取列表
+func (r *SystemMemberDao) GetSystemMemberListSearch() (m []*model.SystemMember, err error) {
+	// 构建查询条件
+	query := global.Db.Model(&model.SystemMember{})
+
+	// 排序
+	query = query.Order("created_at desc")
+
+	err = query.Scopes(model.Paginate(1, 10)).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}

api/dao/SystemSingle.go

@@ -0,0 +1,123 @@
+package dao
+
+import (
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"hepa-calc-admin-api/api/model"
+	"hepa-calc-admin-api/global"
+)
+
+type SystemSingleDao struct {
+}
+
+// GetSystemSingleById 获取数据-id
+func (r *SystemSingleDao) GetSystemSingleById(SystemSingleId int64) (m *model.SystemSingle, err error) {
+	err = global.Db.First(&m, SystemSingleId).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetSystemSinglePreloadById 获取数据-加载全部关联-id
+func (r *SystemSingleDao) GetSystemSinglePreloadById(SystemSingleId int64) (m *model.SystemSingle, err error) {
+	err = global.Db.Preload(clause.Associations).First(&m, SystemSingleId).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// DeleteSystemSingle 删除
+func (r *SystemSingleDao) DeleteSystemSingle(tx *gorm.DB, maps interface{}) error {
+	err := tx.Where(maps).Delete(&model.SystemSingle{}).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// DeleteSystemSingleById 删除-id
+func (r *SystemSingleDao) DeleteSystemSingleById(tx *gorm.DB, SystemSingleId int64) error {
+	if err := tx.Delete(&model.SystemSingle{}, SystemSingleId).Error; err != nil {
+		return err
+	}
+	return nil
+}
+
+// EditSystemSingle 修改
+func (r *SystemSingleDao) EditSystemSingle(tx *gorm.DB, maps interface{}, data interface{}) error {
+	err := tx.Model(&model.SystemSingle{}).Where(maps).Updates(data).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// EditSystemSingleById 修改-id
+func (r *SystemSingleDao) EditSystemSingleById(tx *gorm.DB, SystemSingleId int64, data interface{}) error {
+	err := tx.Model(&model.SystemSingle{}).Where("system_single_id = ?", SystemSingleId).Updates(data).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// GetSystemSingleList 获取列表
+func (r *SystemSingleDao) GetSystemSingleList(maps interface{}) (m []*model.SystemSingle, err error) {
+	err = global.Db.Where(maps).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetSystemSingleCount 获取数量
+func (r *SystemSingleDao) GetSystemSingleCount(maps interface{}) (total int64, err error) {
+	err = global.Db.Model(&model.SystemSingle{}).Where(maps).Count(&total).Error
+	if err != nil {
+		return 0, err
+	}
+	return total, nil
+}
+
+// GetSystemSingleListRand 获取列表-随机
+func (r *SystemSingleDao) GetSystemSingleListRand(maps interface{}, limit int) (m []*model.SystemSingle, err error) {
+	err = global.Db.Where(maps).Order("rand()").Limit(limit).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// AddSystemSingle 新增
+func (r *SystemSingleDao) AddSystemSingle(tx *gorm.DB, model *model.SystemSingle) (*model.SystemSingle, error) {
+	if err := tx.Create(model).Error; err != nil {
+		return nil, err
+	}
+	return model, nil
+}
+
+// GetSystemSingle 获取
+func (r *SystemSingleDao) GetSystemSingle(maps interface{}) (m *model.SystemSingle, err error) {
+	err = global.Db.Where(maps).First(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetSystemSingleListSearch 获取列表
+func (r *SystemSingleDao) GetSystemSingleListSearch() (m []*model.SystemSingle, err error) {
+	// 构建查询条件
+	query := global.Db.Model(&model.SystemSingle{})
+
+	// 排序
+	query = query.Order("created_at desc")
+
+	err = query.Scopes(model.Paginate(1, 10)).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}

api/dao/User.go

@@ -0,0 +1,223 @@
+package dao
+
+import (
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"hepa-calc-admin-api/api/model"
+	"hepa-calc-admin-api/api/requests"
+	"hepa-calc-admin-api/global"
+	"strings"
+	"time"
+)
+
+type UserDao struct {
+}
+
+// GetUserById 获取数据-id
+func (r *UserDao) GetUserById(UserId int64) (m *model.User, err error) {
+	err = global.Db.First(&m, UserId).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetUserPreloadById 获取数据-加载全部关联-id
+func (r *UserDao) GetUserPreloadById(UserId int64) (m *model.User, err error) {
+	err = global.Db.Preload(clause.Associations).First(&m, UserId).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// DeleteUser 删除
+func (r *UserDao) DeleteUser(tx *gorm.DB, maps interface{}) error {
+	err := tx.Where(maps).Delete(&model.User{}).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// DeleteUserById 删除-id
+func (r *UserDao) DeleteUserById(tx *gorm.DB, UserId int64) error {
+	if err := tx.Delete(&model.User{}, UserId).Error; err != nil {
+		return err
+	}
+	return nil
+}
+
+// EditUser 修改
+func (r *UserDao) EditUser(tx *gorm.DB, maps interface{}, data interface{}) error {
+	err := tx.Model(&model.User{}).Where(maps).Updates(data).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// EditUserById 修改-id
+func (r *UserDao) EditUserById(tx *gorm.DB, UserId int64, data interface{}) error {
+	err := tx.Model(&model.User{}).Where("user_id = ?", UserId).Updates(data).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// GetUserList 获取列表
+func (r *UserDao) GetUserList(maps interface{}) (m []*model.User, err error) {
+	err = global.Db.Where(maps).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetUserCount 获取数量
+func (r *UserDao) GetUserCount(maps interface{}) (total int64, err error) {
+	err = global.Db.Model(&model.User{}).Where(maps).Count(&total).Error
+	if err != nil {
+		return 0, err
+	}
+	return total, nil
+}
+
+// GetUserListRand 获取列表-随机
+func (r *UserDao) GetUserListRand(maps interface{}, limit int) (m []*model.User, err error) {
+	err = global.Db.Where(maps).Order("rand()").Limit(limit).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// AddUser 新增
+func (r *UserDao) AddUser(tx *gorm.DB, model *model.User) (*model.User, error) {
+	if err := tx.Create(model).Error; err != nil {
+		return nil, err
+	}
+	return model, nil
+}
+
+// GetUser 获取
+func (r *UserDao) GetUser(maps interface{}) (m *model.User, err error) {
+	err = global.Db.Where(maps).First(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetUserListByTime 获取列表-今天开始时间/过期时间
+func (r *UserDao) GetUserListByTime(maps interface{}, startTime, endTime, field string) (m []*model.User, err error) {
+	err = global.Db.Where(maps).Where(field+" BETWEEN ? AND ?", startTime, endTime).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetUserPageSearch 获取列表-分页
+func (r *UserDao) GetUserPageSearch(req requests.GetUserPage, page, pageSize int) (m []*model.User, total int64, err error) {
+	var totalRecords int64
+
+	// 构建查询条件
+	query := global.Db.Model(&model.User{})
+
+	// 用户id
+	if req.UserId != "" {
+		query = query.Where("user_id = ?", req.UserId)
+	}
+
+	// 用户名称
+	if req.UserName != "" {
+		query = query.Where("user_name LIKE ?", "%"+req.UserName+"%")
+	}
+
+	// 手机号
+	if req.Mobile != "" {
+		query = query.Where("mobile LIKE ?", "%"+req.Mobile+"%")
+	}
+
+	// 状态
+	if req.UserStatus != 0 {
+		query = query.Where("user_status = ?", req.UserStatus)
+	}
+
+	// 注册来源
+	if req.RegisterSource != 0 {
+		query = query.Where("register_source = ?", req.RegisterSource)
+	}
+
+	// 用户微信标识
+	if req.OpenId != "" {
+		query = query.Where("open_id LIKE ?", "%"+req.OpenId+"%")
+	}
+
+	// 性别
+	if req.Sex != nil {
+		query = query.Where("sex = ?", req.Sex)
+	}
+
+	// 是否会员
+	if req.IsMember != nil {
+		query = query.Where("is_member = ?", req.IsMember)
+	}
+
+	// 会员到期时间
+	if req.MemberExpireDate != "" {
+		memberExpireDate := strings.Split(req.MemberExpireDate, "&")
+		if len(memberExpireDate) == 2 {
+			startTime, _ := time.Parse("2006-01-02", memberExpireDate[0])
+			endTime, _ := time.Parse("2006-01-02", memberExpireDate[1])
+
+			endTime = endTime.Add(23*time.Hour + 59*time.Minute + 59*time.Second)
+
+			query = query.Where("member_expire_date BETWEEN ? AND ?", startTime, endTime)
+		}
+	}
+
+	// 信息完善状态
+	if req.IsInfoComplete != nil {
+		subQuery := global.Db.Model(&model.UserInfo{}).
+			Where("user_info.user_id  = user.user_id").
+			Where("user_info.nation_id  is not NULL").
+			Where("user_info.disease_class_id  is not NULL").Select("1")
+
+		query = query.Where("EXISTS (?)", subQuery)
+	}
+
+	// 排序
+	if req.Order != nil {
+		if req.Order.UpdatedAt != "" {
+			query = query.Order("updated_at " + req.Order.UpdatedAt)
+		}
+
+		if req.Order.SingleSubmitCount != "" {
+			query = query.Order("single_submit_count " + req.Order.SingleSubmitCount)
+		}
+
+		if req.Order.SinglePayCount != "" {
+			query = query.Order("single_pay_count " + req.Order.SinglePayCount)
+		}
+
+		if req.Order.MemberBuyCount != "" {
+			query = query.Order("member_buy_count " + req.Order.MemberBuyCount)
+		}
+	}
+
+	query = query.Order("created_at desc")
+
+	// 查询总数量
+	if err := query.Count(&totalRecords).Error; err != nil {
+		return nil, 0, err
+	}
+
+	err = query.Scopes(model.Paginate(page, pageSize)).Find(&m).Error
+	if err != nil {
+		return nil, 0, err
+	}
+	return m, totalRecords, nil
+}

api/dao/UserCollection.go

@@ -0,0 +1,108 @@
+package dao
+
+import (
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"hepa-calc-admin-api/api/model"
+	"hepa-calc-admin-api/global"
+)
+
+type UserCollectionDao struct {
+}
+
+// GetUserCollectionById 获取数据-id
+func (r *UserCollectionDao) GetUserCollectionById(UserCollectionId int64) (m *model.UserCollection, err error) {
+	err = global.Db.First(&m, UserCollectionId).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetUserCollectionPreloadById 获取数据-加载全部关联-id
+func (r *UserCollectionDao) GetUserCollectionPreloadById(UserCollectionId int64) (m *model.UserCollection, err error) {
+	err = global.Db.Preload(clause.Associations).First(&m, UserCollectionId).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// DeleteUserCollection 删除
+func (r *UserCollectionDao) DeleteUserCollection(tx *gorm.DB, maps interface{}) error {
+	err := tx.Where(maps).Delete(&model.UserCollection{}).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// DeleteUserCollectionById 删除-id
+func (r *UserCollectionDao) DeleteUserCollectionById(tx *gorm.DB, UserCollectionId int64) error {
+	if err := tx.Delete(&model.UserCollection{}, UserCollectionId).Error; err != nil {
+		return err
+	}
+	return nil
+}
+
+// EditUserCollection 修改
+func (r *UserCollectionDao) EditUserCollection(tx *gorm.DB, maps interface{}, data interface{}) error {
+	err := tx.Model(&model.UserCollection{}).Where(maps).Updates(data).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// EditUserCollectionById 修改-id
+func (r *UserCollectionDao) EditUserCollectionById(tx *gorm.DB, UserCollectionId int64, data interface{}) error {
+	err := tx.Model(&model.UserCollection{}).Where("user_coupon_id = ?", UserCollectionId).Updates(data).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// GetUserCollectionList 获取列表
+func (r *UserCollectionDao) GetUserCollectionList(maps interface{}) (m []*model.UserCollection, err error) {
+	err = global.Db.Where(maps).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetUserCollectionCount 获取数量
+func (r *UserCollectionDao) GetUserCollectionCount(maps interface{}) (total int64, err error) {
+	err = global.Db.Model(&model.UserCollection{}).Where(maps).Count(&total).Error
+	if err != nil {
+		return 0, err
+	}
+	return total, nil
+}
+
+// GetUserCollectionListRand 获取列表-随机
+func (r *UserCollectionDao) GetUserCollectionListRand(maps interface{}, limit int) (m []*model.UserCollection, err error) {
+	err = global.Db.Where(maps).Order("rand()").Limit(limit).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// AddUserCollection 新增
+func (r *UserCollectionDao) AddUserCollection(tx *gorm.DB, model *model.UserCollection) (*model.UserCollection, error) {
+	if err := tx.Create(model).Error; err != nil {
+		return nil, err
+	}
+	return model, nil
+}
+
+// GetUserCollection 获取
+func (r *UserCollectionDao) GetUserCollection(maps interface{}) (m *model.UserCollection, err error) {
+	err = global.Db.Where(maps).First(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}

api/dao/UserCoupon.go

@@ -0,0 +1,181 @@
+package dao
+
+import (
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"hepa-calc-admin-api/api/model"
+	"hepa-calc-admin-api/api/requests"
+	"hepa-calc-admin-api/global"
+)
+
+type UserCouponDao struct {
+}
+
+// GetUserCouponById 获取数据-id
+func (r *UserCouponDao) GetUserCouponById(UserCouponId int64) (m *model.UserCoupon, err error) {
+	err = global.Db.First(&m, UserCouponId).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetUserCouponPreloadById 获取数据-加载全部关联-id
+func (r *UserCouponDao) GetUserCouponPreloadById(UserCouponId int64) (m *model.UserCoupon, err error) {
+	err = global.Db.Preload(clause.Associations).First(&m, UserCouponId).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// DeleteUserCoupon 删除
+func (r *UserCouponDao) DeleteUserCoupon(tx *gorm.DB, maps interface{}) error {
+	err := tx.Where(maps).Delete(&model.UserCoupon{}).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// DeleteUserCouponById 删除-id
+func (r *UserCouponDao) DeleteUserCouponById(tx *gorm.DB, UserCouponId int64) error {
+	if err := tx.Delete(&model.UserCoupon{}, UserCouponId).Error; err != nil {
+		return err
+	}
+	return nil
+}
+
+// EditUserCoupon 修改
+func (r *UserCouponDao) EditUserCoupon(tx *gorm.DB, maps interface{}, data interface{}) error {
+	err := tx.Model(&model.UserCoupon{}).Where(maps).Updates(data).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// EditUserCouponById 修改-id
+func (r *UserCouponDao) EditUserCouponById(tx *gorm.DB, UserCouponId int64, data interface{}) error {
+	err := tx.Model(&model.UserCoupon{}).Where("user_coupon_id = ?", UserCouponId).Updates(data).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// GetUserCouponList 获取列表
+func (r *UserCouponDao) GetUserCouponList(maps interface{}) (m []*model.UserCoupon, err error) {
+	err = global.Db.Where(maps).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetUserCouponPreloadList 获取列表-加载全部关联
+func (r *UserCouponDao) GetUserCouponPreloadList(maps interface{}) (m []*model.UserCoupon, err error) {
+	err = global.Db.Preload(clause.Associations).Where(maps).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetUserCouponCount 获取数量
+func (r *UserCouponDao) GetUserCouponCount(maps interface{}) (total int64, err error) {
+	err = global.Db.Model(&model.UserCoupon{}).Where(maps).Count(&total).Error
+	if err != nil {
+		return 0, err
+	}
+	return total, nil
+}
+
+// GetUserCouponListRand 获取列表-随机
+func (r *UserCouponDao) GetUserCouponListRand(maps interface{}, limit int) (m []*model.UserCoupon, err error) {
+	err = global.Db.Where(maps).Order("rand()").Limit(limit).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// AddUserCoupon 新增
+func (r *UserCouponDao) AddUserCoupon(tx *gorm.DB, model *model.UserCoupon) (*model.UserCoupon, error) {
+	if err := tx.Create(model).Error; err != nil {
+		return nil, err
+	}
+	return model, nil
+}
+
+// GetUserCoupon 获取
+func (r *UserCouponDao) GetUserCoupon(maps interface{}) (m *model.UserCoupon, err error) {
+	err = global.Db.Where(maps).First(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetUserCouponListByValidTime 获取列表-今天开始时间/过期时间
+func (r *UserCouponDao) GetUserCouponListByValidTime(maps interface{}, startTime, endTime string) (m []*model.UserCoupon, err error) {
+	err = global.Db.Where(maps).Where("valid_end_time BETWEEN ? AND ?", startTime, endTime).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetUserCouponPageSearch 获取列表-分页
+func (r *UserCouponDao) GetUserCouponPageSearch(req requests.GetUserCouponPage, page, pageSize int) (m []*model.UserCoupon, total int64, err error) {
+	var totalRecords int64
+
+	// 构建查询条件
+	query := global.Db.Model(&model.UserCoupon{})
+
+	// 优惠卷
+	query = query.Preload("Coupon")
+
+	// 优惠券id
+	if req.CouponId != "" {
+		query = query.Where("coupon_id = ?", req.CouponId)
+	}
+
+	// 用户id
+	if req.UserId != nil {
+		query = query.Where("user_id = ?", req.UserId)
+	}
+
+	// 优惠券id
+	if req.CouponId != "" {
+		query = query.Where("coupon_id = ?", req.CouponId)
+	}
+
+	// 状态（0:未使用 1:已使用 3:已过期）
+	if req.UserCouponStatus != nil {
+		query = query.Where("user_coupon_status = ?", req.UserCouponStatus)
+	}
+
+	// 用户名称
+	if req.UserName != "" {
+		subQuery := global.Db.Model(&model.User{}).
+			Select("user_id").
+			Where("user_name LIKE ?", "%"+req.UserName+"%")
+
+		query = query.Where(gorm.Expr("user_id IN (?)", subQuery))
+	}
+
+	// 排序
+	query = query.Order("created_at desc")
+
+	// 查询总数量
+	if err := query.Count(&totalRecords).Error; err != nil {
+		return nil, 0, err
+	}
+
+	err = query.Scopes(model.Paginate(page, pageSize)).Find(&m).Error
+	if err != nil {
+		return nil, 0, err
+	}
+	return m, totalRecords, nil
+}

api/dao/UserInfo.go

@@ -0,0 +1,108 @@
+package dao
+
+import (
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"hepa-calc-admin-api/api/model"
+	"hepa-calc-admin-api/global"
+)
+
+type UserInfoDao struct {
+}
+
+// GetUserInfoById 获取数据-id
+func (r *UserInfoDao) GetUserInfoById(UserInfoId int64) (m *model.UserInfo, err error) {
+	err = global.Db.First(&m, UserInfoId).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetUserInfoPreloadById 获取数据-加载全部关联-id
+func (r *UserInfoDao) GetUserInfoPreloadById(UserInfoId int64) (m *model.UserInfo, err error) {
+	err = global.Db.Preload(clause.Associations).First(&m, UserInfoId).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// DeleteUserInfo 删除
+func (r *UserInfoDao) DeleteUserInfo(tx *gorm.DB, maps interface{}) error {
+	err := tx.Where(maps).Delete(&model.UserInfo{}).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// DeleteUserInfoById 删除-id
+func (r *UserInfoDao) DeleteUserInfoById(tx *gorm.DB, UserInfoId int64) error {
+	if err := tx.Delete(&model.UserInfo{}, UserInfoId).Error; err != nil {
+		return err
+	}
+	return nil
+}
+
+// EditUserInfo 修改
+func (r *UserInfoDao) EditUserInfo(tx *gorm.DB, maps interface{}, data interface{}) error {
+	err := tx.Model(&model.UserInfo{}).Where(maps).Updates(data).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// EditUserInfoById 修改-id
+func (r *UserInfoDao) EditUserInfoById(tx *gorm.DB, UserInfoId int64, data interface{}) error {
+	err := tx.Model(&model.UserInfo{}).Where("user_info_id = ?", UserInfoId).Updates(data).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// GetUserInfoList 获取列表
+func (r *UserInfoDao) GetUserInfoList(maps interface{}) (m []*model.UserInfo, err error) {
+	err = global.Db.Where(maps).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetUserInfoCount 获取数量
+func (r *UserInfoDao) GetUserInfoCount(maps interface{}) (total int64, err error) {
+	err = global.Db.Model(&model.UserInfo{}).Where(maps).Count(&total).Error
+	if err != nil {
+		return 0, err
+	}
+	return total, nil
+}
+
+// GetUserInfoListRand 获取列表-随机
+func (r *UserInfoDao) GetUserInfoListRand(maps interface{}, limit int) (m []*model.UserInfo, err error) {
+	err = global.Db.Where(maps).Order("rand()").Limit(limit).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// AddUserInfo 新增
+func (r *UserInfoDao) AddUserInfo(tx *gorm.DB, model *model.UserInfo) (*model.UserInfo, error) {
+	if err := tx.Create(model).Error; err != nil {
+		return nil, err
+	}
+	return model, nil
+}
+
+// GetUserInfo 获取
+func (r *UserInfoDao) GetUserInfo(maps interface{}) (m *model.UserInfo, err error) {
+	err = global.Db.Where(maps).First(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}

api/dto/BaseAgreement.go

@@ -0,0 +1,49 @@
+package dto
+
+import (
+	"fmt"
+	"hepa-calc-admin-api/api/model"
+)
+
+// BaseAgreementDto 基础数据-协议
+type BaseAgreementDto struct {
+	AgreementId      string          `json:"agreement_id"`      // 主键id
+	AgreementTitle   string          `json:"agreement_title"`   // 协议标题
+	AgreementContent string          `json:"agreement_content"` // 协议内容
+	CreatedAt        model.LocalTime `json:"created_at"`        // 创建时间
+	UpdatedAt        model.LocalTime `json:"updated_at"`        // 更新时间
+}
+
+// GetBaseAgreementDto 详情-协议-分类表
+func GetBaseAgreementDto(m *model.BaseAgreement) *BaseAgreementDto {
+	return &BaseAgreementDto{
+		AgreementId:      fmt.Sprintf("%d", m.AgreementId),
+		AgreementTitle:   m.AgreementTitle,
+		AgreementContent: m.AgreementContent,
+		CreatedAt:        m.CreatedAt,
+		UpdatedAt:        m.UpdatedAt,
+	}
+}
+
+// GetBaseAgreementListDto 列表-基础数据-协议
+func GetBaseAgreementListDto(m []*model.BaseAgreement) []*BaseAgreementDto {
+	// 处理返回值
+	responses := make([]*BaseAgreementDto, len(m))
+
+	if len(m) > 0 {
+		for i, v := range m {
+			response := &BaseAgreementDto{
+				AgreementId:      fmt.Sprintf("%d", v.AgreementId),
+				AgreementTitle:   v.AgreementTitle,
+				AgreementContent: v.AgreementContent,
+				CreatedAt:        v.CreatedAt,
+				UpdatedAt:        v.UpdatedAt,
+			}
+
+			// 将转换后的结构体添加到新切片中
+			responses[i] = response
+		}
+	}
+
+	return responses
+}

api/dto/BaseClass.go

@@ -0,0 +1,59 @@
+package dto
+
+import (
+	"fmt"
+	"hepa-calc-admin-api/api/model"
+	"hepa-calc-admin-api/utils"
+)
+
+// BaseClassDto 基础数据-分类表
+type BaseClassDto struct {
+	ClassId     string          `json:"class_id"`     // 主键id
+	ClassName   string          `json:"class_name"`   // 分类名称
+	ClassStatus int             `json:"class_status"` // 分类状态（1:正常 2:隐藏）
+	ClassIcon   string          `json:"class_icon"`   // 图标地址
+	ClassBrief  string          `json:"class_brief"`  // 分类简介
+	Sort        uint            `json:"sort"`         // 排序值（越大排名越靠前）
+	CreatedAt   model.LocalTime `json:"created_at"`   // 创建时间
+	UpdatedAt   model.LocalTime `json:"updated_at"`   // 更新时间
+}
+
+// GetBaseClassDto 详情-基础数据-分类表
+func GetBaseClassDto(m *model.BaseClass) *BaseClassDto {
+	return &BaseClassDto{
+		ClassId:     fmt.Sprintf("%d", m.ClassId),
+		ClassName:   m.ClassName,
+		ClassStatus: m.ClassStatus,
+		ClassIcon:   utils.AddOssDomain(m.ClassIcon),
+		ClassBrief:  m.ClassBrief,
+		Sort:        m.Sort,
+		CreatedAt:   m.CreatedAt,
+		UpdatedAt:   m.UpdatedAt,
+	}
+}
+
+// GetBaseClassListDto 列表-基础数据-分类表
+func GetBaseClassListDto(m []*model.BaseClass) []*BaseClassDto {
+	// 处理返回值
+	responses := make([]*BaseClassDto, len(m))
+
+	if len(m) > 0 {
+		for i, v := range m {
+			response := &BaseClassDto{
+				ClassId:     fmt.Sprintf("%d", v.ClassId),
+				ClassName:   v.ClassName,
+				ClassStatus: v.ClassStatus,
+				ClassIcon:   utils.AddOssDomain(v.ClassIcon),
+				ClassBrief:  v.ClassBrief,
+				Sort:        v.Sort,
+				CreatedAt:   v.CreatedAt,
+				UpdatedAt:   v.UpdatedAt,
+			}
+
+			// 将转换后的结构体添加到新切片中
+			responses[i] = response
+		}
+	}
+
+	return responses
+}

api/dto/Coupon.go

@@ -0,0 +1,101 @@
+package dto
+
+import (
+	"fmt"
+	"hepa-calc-admin-api/api/model"
+)
+
+type CouponDto struct {
+	CouponId         string           `json:"coupon_id"`         // 主键id
+	CouponName       string           `json:"coupon_name"`       // 优惠券名称
+	CouponType       int              `json:"coupon_type"`       // 优惠券类型（1:无门槛 2:满减）
+	CouponStatus     int              `json:"coupon_status"`     // 状态（1:正常 2:强制失效 3:结束 4:删除）
+	ApplicationScope int              `json:"application_scope"` // 适用范围（1:全场通用）
+	IsMutex          int              `json:"is_mutex"`          // 是否互斥（0:否 1:是）
+	CouponCount      int              `json:"coupon_count"`      // 发放数量
+	CouponTakeCount  int              `json:"coupon_take_count"` // 已领取数量
+	CouponUsedCount  int              `json:"coupon_used_count"` // 已使用数量
+	CouponPrice      float64          `json:"coupon_price"`      // 优惠券金额
+	WithAmount       float64          `json:"with_amount"`       // 符合满减标准金额（优惠券类型为满减时使用）
+	ValidType        int              `json:"valid_type"`        // 有效类型（1:绝对时效，xxx-xxx时间段有效 2:相对时效 n天内有效）
+	ValidDays        int              `json:"valid_days"`        // 自领取之日起有效天数
+	ValidStartTime   *model.LocalTime `json:"valid_start_time"`  // 开始使用时间
+	ValidEndTime     *model.LocalTime `json:"valid_end_time"`    // 结束使用时间
+	CouponDesc       string           `json:"coupon_desc"`       // 优惠券描述
+	CreatedAt        model.LocalTime  `json:"created_at"`        // 创建时间
+	UpdatedAt        model.LocalTime  `json:"updated_at"`        // 更新时间
+}
+
+// GetCouponListDto 列表
+func GetCouponListDto(m []*model.Coupon) []*CouponDto {
+	// 处理返回值
+	responses := make([]*CouponDto, len(m))
+
+	if len(m) > 0 {
+		for i, v := range m {
+			response := &CouponDto{
+				CouponId:         fmt.Sprintf("%d", v.CouponId),
+				CouponName:       v.CouponName,
+				CouponType:       v.CouponType,
+				CouponStatus:     v.CouponStatus,
+				ApplicationScope: v.ApplicationScope,
+				IsMutex:          v.IsMutex,
+				CouponCount:      v.CouponCount,
+				CouponTakeCount:  v.CouponTakeCount,
+				CouponUsedCount:  v.CouponUsedCount,
+				CouponPrice:      v.CouponPrice,
+				ValidType:        v.ValidType,
+				ValidStartTime:   v.ValidStartTime,
+				ValidEndTime:     v.ValidEndTime,
+				CouponDesc:       v.CouponDesc,
+				CreatedAt:        v.CreatedAt,
+				UpdatedAt:        v.UpdatedAt,
+			}
+
+			if v.WithAmount != nil {
+				response.WithAmount = *v.WithAmount
+			}
+
+			if v.ValidDays != nil {
+				response.ValidDays = *v.ValidDays
+			}
+
+			// 将转换后的结构体添加到新切片中
+			responses[i] = response
+		}
+	}
+
+	return responses
+}
+
+// GetCouponDto 优惠卷详情
+func GetCouponDto(m *model.Coupon) *CouponDto {
+	response := &CouponDto{
+		CouponId:         fmt.Sprintf("%d", m.CouponId),
+		CouponName:       m.CouponName,
+		CouponType:       m.CouponType,
+		CouponStatus:     m.CouponStatus,
+		ApplicationScope: m.ApplicationScope,
+		IsMutex:          m.IsMutex,
+		CouponCount:      m.CouponCount,
+		CouponTakeCount:  m.CouponTakeCount,
+		CouponUsedCount:  m.CouponUsedCount,
+		CouponPrice:      m.CouponPrice,
+		ValidType:        m.ValidType,
+		ValidStartTime:   m.ValidStartTime,
+		ValidEndTime:     m.ValidEndTime,
+		CouponDesc:       m.CouponDesc,
+		CreatedAt:        m.CreatedAt,
+		UpdatedAt:        m.UpdatedAt,
+	}
+
+	if m.WithAmount != nil {
+		response.WithAmount = *m.WithAmount
+	}
+
+	if m.ValidDays != nil {
+		response.ValidDays = *m.ValidDays
+	}
+
+	return response
+}

api/dto/Login.go

@@ -0,0 +1,68 @@
+package dto
+
+import (
+	"fmt"
+	"hepa-calc-admin-api/api/model"
+	"hepa-calc-admin-api/utils"
+	"time"
+)
+
+type WxDto struct {
+	UserId           string     `json:"user_id"`            // 用户id
+	UserName         string     `json:"user_name"`          // 用户名称
+	Mobile           string     `json:"mobile"`             // 手机号
+	OpenId           string     `json:"open_id"`            // 用户微信标识
+	Avatar           string     `json:"avatar"`             // 头像
+	IsMember         int        `json:"is_member"`          // 是否会员（0:否 1:是）
+	MemberExpireDate *time.Time `json:"member_expire_date"` // 会员到期时间（非会员时为null）
+	Token            string     `json:"token"`              // token
+}
+
+type MobileDto struct {
+	UserId           string     `json:"user_id"`            // 用户id
+	UserName         string     `json:"user_name"`          // 用户名称
+	Mobile           string     `json:"mobile"`             // 手机号
+	OpenId           string     `json:"open_id"`            // 用户微信标识
+	Avatar           string     `json:"avatar"`             // 头像
+	IsMember         int        `json:"is_member"`          // 是否会员（0:否 1:是）
+	MemberExpireDate *time.Time `json:"member_expire_date"` // 会员到期时间（非会员时为null）
+	Token            string     `json:"token"`              // token
+}
+
+// LoginWxDto 微信登陆
+func LoginWxDto(m *model.User) *WxDto {
+	return &WxDto{
+		UserId:           fmt.Sprintf("%d", m.UserId),
+		UserName:         m.UserName,
+		Mobile:           m.Mobile,
+		OpenId:           m.OpenId,
+		Avatar:           utils.AddOssDomain(m.Avatar),
+		IsMember:         m.IsMember,
+		MemberExpireDate: m.MemberExpireDate,
+	}
+}
+
+// LoginMobileDto 手机号登陆
+func LoginMobileDto(m *model.User) *MobileDto {
+	return &MobileDto{
+		UserId:           fmt.Sprintf("%d", m.UserId),
+		UserName:         m.UserName,
+		Mobile:           m.Mobile,
+		OpenId:           m.OpenId,
+		Avatar:           utils.AddOssDomain(m.Avatar),
+		IsMember:         m.IsMember,
+		MemberExpireDate: m.MemberExpireDate,
+	}
+}
+
+// LoadToken 加载token
+func (r *WxDto) LoadToken(token string) *WxDto {
+	r.Token = token
+	return r
+}
+
+// LoadToken 加载token
+func (r *MobileDto) LoadToken(token string) *MobileDto {
+	r.Token = token
+	return r
+}

api/dto/OrderMember.go

@@ -0,0 +1,126 @@
+package dto
+
+import (
+	"fmt"
+	"hepa-calc-admin-api/api/model"
+	"hepa-calc-admin-api/utils"
+	"time"
+)
+
+// OrderMemberDto 订单-会员
+type OrderMemberDto struct {
+	OrderId            string           `json:"order_id"`             // 主键id
+	UserId             string           `json:"user_id"`              // 用户id
+	SystemMemberId     string           `json:"system_member_id"`     // 会员id
+	OrderStatus        int              `json:"order_status"`         // 订单状态（1:待支付 2:已完成 3:已取消）
+	IsDelete           int              `json:"is_delete"`            // 用户删除状态（0:否 1:是）
+	PayChannel         int              `json:"pay_channel"`          // 支付渠道（1:h5支付 2:app支付 3:会员支付）
+	PayStatus          int              `json:"pay_status"`           // 支付状态（1:未支付 2:已支付 3:支付中 4:支付失败 5:支付超时 6:支付关闭 7:已撤销 8:转入退款）
+	PayTime            *time.Time       `json:"pay_time"`             // 支付时间
+	RefundStatus       int              `json:"refund_status"`        // 订单退款状态（0:无退款 1:申请退款 2:退款中 3:退款成功 4:拒绝退款 5:退款关闭 6:退款异常 7:部分退款）
+	OrderNo            string           `json:"order_no"`             // 系统订单编号
+	EscrowTradeNo      string           `json:"escrow_trade_no"`      // 第三方支付流水号
+	AmountTotal        float64          `json:"amount_total"`         // 订单金额
+	CouponAmountTotal  float64          `json:"coupon_amount_total"`  // 优惠卷总金额
+	PaymentAmountTotal float64          `json:"payment_amount_total"` // 实际付款金额
+	CancelStatus       int              `json:"cancel_status"`        // 取消状态（0:否 1:是）
+	CancelTime         *time.Time       `json:"cancel_time"`          // 订单取消时间
+	CancelRemarks      string           `json:"cancel_remarks"`       // 取消订单备注
+	OrderRemarks       string           `json:"order_remarks"`        // 订单备注
+	CreatedAt          model.LocalTime  `json:"created_at"`           // 创建时间
+	UpdatedAt          model.LocalTime  `json:"updated_at"`           // 更新时间
+	SystemMember       *SystemMemberDto `json:"system_member"`        // 会员
+	UserName           string           `json:"user_name"`            // 用户名称
+	Avatar             string           `json:"avatar"`               // 用户头像
+}
+
+// GetOrderMemberListDto 列表
+func GetOrderMemberListDto(m []*model.OrderMember) []*OrderMemberDto {
+	// 处理返回值
+	responses := make([]*OrderMemberDto, len(m))
+
+	if len(m) > 0 {
+		for i, v := range m {
+			response := &OrderMemberDto{
+				OrderId:            fmt.Sprintf("%d", v.OrderId),
+				UserId:             fmt.Sprintf("%d", v.UserId),
+				SystemMemberId:     fmt.Sprintf("%d", v.SystemMemberId),
+				OrderStatus:        v.OrderStatus,
+				IsDelete:           v.IsDelete,
+				PayChannel:         v.PayChannel,
+				PayStatus:          v.PayStatus,
+				PayTime:            v.PayTime,
+				RefundStatus:       v.RefundStatus,
+				OrderNo:            v.OrderNo,
+				EscrowTradeNo:      v.EscrowTradeNo,
+				AmountTotal:        v.AmountTotal,
+				CouponAmountTotal:  v.CouponAmountTotal,
+				PaymentAmountTotal: v.PaymentAmountTotal,
+				CancelStatus:       v.CancelStatus,
+				CancelTime:         v.CancelTime,
+				CancelRemarks:      v.CancelRemarks,
+				OrderRemarks:       v.OrderRemarks,
+				CreatedAt:          v.CreatedAt,
+				UpdatedAt:          v.UpdatedAt,
+			}
+
+			// 加载会员数据
+			if v.SystemMember != nil {
+				response = response.LoadSystemMember(v.SystemMember)
+			}
+
+			// 加载用户数据
+			if v.User != nil {
+				response = response.LoadUserAttr(v.User)
+			}
+
+			// 将转换后的结构体添加到新切片中
+			responses[i] = response
+		}
+	}
+
+	return responses
+}
+
+// GetOrderMemberDto 详情
+func GetOrderMemberDto(m *model.OrderMember) *OrderMemberDto {
+	return &OrderMemberDto{
+		OrderId:            fmt.Sprintf("%d", m.OrderId),
+		UserId:             fmt.Sprintf("%d", m.UserId),
+		SystemMemberId:     fmt.Sprintf("%d", m.SystemMemberId),
+		OrderStatus:        m.OrderStatus,
+		IsDelete:           m.IsDelete,
+		PayChannel:         m.PayChannel,
+		PayStatus:          m.PayStatus,
+		PayTime:            m.PayTime,
+		RefundStatus:       m.RefundStatus,
+		OrderNo:            m.OrderNo,
+		EscrowTradeNo:      m.EscrowTradeNo,
+		AmountTotal:        m.AmountTotal,
+		CouponAmountTotal:  m.CouponAmountTotal,
+		PaymentAmountTotal: m.PaymentAmountTotal,
+		CancelStatus:       m.CancelStatus,
+		CancelTime:         m.CancelTime,
+		CancelRemarks:      m.CancelRemarks,
+		OrderRemarks:       m.OrderRemarks,
+		CreatedAt:          m.CreatedAt,
+		UpdatedAt:          m.UpdatedAt,
+	}
+}
+
+// LoadSystemMember 加载会员数据
+func (r *OrderMemberDto) LoadSystemMember(m *model.SystemMember) *OrderMemberDto {
+	if m != nil {
+		r.SystemMember = GetSystemMemberDto(m)
+	}
+	return r
+}
+
+// LoadUserAttr 加载用户数据
+func (r *OrderMemberDto) LoadUserAttr(m *model.User) *OrderMemberDto {
+	if m != nil {
+		r.UserName = m.UserName
+		r.Avatar = utils.AddOssDomain(m.Avatar)
+	}
+	return r
+}

api/dto/OrderSingle.go

@@ -0,0 +1,139 @@
+package dto
+
+import (
+	"fmt"
+	"hepa-calc-admin-api/api/model"
+	"hepa-calc-admin-api/utils"
+	"time"
+)
+
+// OrderSingleDto 订单-单项
+type OrderSingleDto struct {
+	OrderId            string          `json:"order_id"`             // 主键id
+	UserId             string          `json:"user_id"`              // 用户id
+	QuestionId         string          `json:"question_id"`          // 问题id
+	OrderStatus        int             `json:"order_status"`         // 订单状态（1:待支付 2:已完成 3:已取消）
+	IsDelete           int             `json:"is_delete"`            // 用户删除状态（0:否 1:是）
+	PayChannel         int             `json:"pay_channel"`          // 支付渠道（1:h5支付 2:app支付 3:会员支付）
+	PayStatus          int             `json:"pay_status"`           // 支付状态（1:未支付 2:已支付 3:支付中 4:支付失败 5:支付超时 6:支付关闭 7:已撤销 8:转入退款）
+	PayTime            *time.Time      `json:"pay_time"`             // 支付时间
+	RefundStatus       int             `json:"refund_status"`        // 订单退款状态（0:无退款 1:申请退款 2:退款中 3:退款成功 4:拒绝退款 5:退款关闭 6:退款异常 7:部分退款）
+	OrderNo            string          `json:"order_no"`             // 系统订单编号
+	EscrowTradeNo      string          `json:"escrow_trade_no"`      // 第三方支付流水号
+	AmountTotal        float64         `json:"amount_total"`         // 订单金额
+	CouponAmountTotal  float64         `json:"coupon_amount_total"`  // 优惠卷总金额
+	PaymentAmountTotal float64         `json:"payment_amount_total"` // 实际付款金额
+	CancelStatus       int             `json:"cancel_status"`        // 取消状态（0:否 1:是）
+	CancelTime         *time.Time      `json:"cancel_time"`          // 订单取消时间
+	CancelRemarks      string          `json:"cancel_remarks"`       // 取消订单备注
+	OrderRemarks       string          `json:"order_remarks"`        // 订单备注
+	CreatedAt          model.LocalTime `json:"created_at"`           // 创建时间
+	UpdatedAt          model.LocalTime `json:"updated_at"`           // 更新时间
+	Question           *QuestionDto    `json:"question"`             // 问题
+	ValidDate          model.LocalTime `json:"valid_date"`           // 到期时间
+	UserName           string          `json:"user_name"`            // 用户名称
+	Avatar             string          `json:"avatar"`               // 用户头像
+	IsMember           int             `json:"is_member"`            // 是否会员（0:否 1:是）
+	MemberExpireDate   *time.Time      `json:"member_expire_date"`   // 用户会员到期时间（非会员时为null）
+}
+
+// GetOrderSingleListDto 列表
+func GetOrderSingleListDto(m []*model.OrderSingle) []*OrderSingleDto {
+	// 处理返回值
+	responses := make([]*OrderSingleDto, len(m))
+
+	if len(m) > 0 {
+		for i, v := range m {
+			response := &OrderSingleDto{
+				OrderId:            fmt.Sprintf("%d", v.OrderId),
+				UserId:             fmt.Sprintf("%d", v.UserId),
+				QuestionId:         fmt.Sprintf("%d", v.QuestionId),
+				OrderStatus:        v.OrderStatus,
+				IsDelete:           v.IsDelete,
+				PayChannel:         v.PayChannel,
+				PayStatus:          v.PayStatus,
+				PayTime:            v.PayTime,
+				RefundStatus:       v.RefundStatus,
+				OrderNo:            v.OrderNo,
+				EscrowTradeNo:      v.EscrowTradeNo,
+				AmountTotal:        v.AmountTotal,
+				CouponAmountTotal:  v.CouponAmountTotal,
+				PaymentAmountTotal: v.PaymentAmountTotal,
+				CancelStatus:       v.CancelStatus,
+				CancelTime:         v.CancelTime,
+				CancelRemarks:      v.CancelRemarks,
+				OrderRemarks:       v.OrderRemarks,
+				CreatedAt:          v.CreatedAt,
+				UpdatedAt:          v.UpdatedAt,
+			}
+
+			// 加载问题数据
+			if v.Question != nil {
+				response = response.LoadQuestion(v.Question)
+			}
+
+			// 加载用户数据
+			if v.User != nil {
+				response = response.LoadUserAttr(v.User)
+			}
+
+			// 将转换后的结构体添加到新切片中
+			responses[i] = response
+		}
+	}
+
+	return responses
+}
+
+// GetOrderSingleDto 详情
+func GetOrderSingleDto(m *model.OrderSingle) *OrderSingleDto {
+	return &OrderSingleDto{
+		OrderId:            fmt.Sprintf("%d", m.OrderId),
+		UserId:             fmt.Sprintf("%d", m.UserId),
+		QuestionId:         fmt.Sprintf("%d", m.QuestionId),
+		OrderStatus:        m.OrderStatus,
+		IsDelete:           m.IsDelete,
+		PayChannel:         m.PayChannel,
+		PayStatus:          m.PayStatus,
+		PayTime:            m.PayTime,
+		RefundStatus:       m.RefundStatus,
+		OrderNo:            m.OrderNo,
+		EscrowTradeNo:      m.EscrowTradeNo,
+		AmountTotal:        m.AmountTotal,
+		CouponAmountTotal:  m.CouponAmountTotal,
+		PaymentAmountTotal: m.PaymentAmountTotal,
+		CancelStatus:       m.CancelStatus,
+		CancelTime:         m.CancelTime,
+		CancelRemarks:      m.CancelRemarks,
+		OrderRemarks:       m.OrderRemarks,
+		CreatedAt:          m.CreatedAt,
+		UpdatedAt:          m.UpdatedAt,
+	}
+}
+
+// LoadQuestion 加载题目数据
+func (r *OrderSingleDto) LoadQuestion(m *model.Question) *OrderSingleDto {
+	if m != nil {
+		r.Question = GetQuestionDto(m)
+	}
+	return r
+}
+
+// LoadValidDate 加载到期时间
+func (r *OrderSingleDto) LoadValidDate(m *time.Time) *OrderSingleDto {
+	if m != nil {
+		r.ValidDate = model.LocalTime(*m)
+	}
+	return r
+}
+
+// LoadUserAttr 加载用户数据
+func (r *OrderSingleDto) LoadUserAttr(m *model.User) *OrderSingleDto {
+	if m != nil {
+		r.UserName = m.UserName
+		r.Avatar = utils.AddOssDomain(m.Avatar)
+		r.IsMember = m.IsMember
+		r.MemberExpireDate = m.MemberExpireDate
+	}
+	return r
+}

api/dto/Public.go

@@ -0,0 +1,49 @@
+package dto
+
+import (
+	"fmt"
+	"hepa-calc-admin-api/api/model"
+	"hepa-calc-admin-api/utils"
+)
+
+// LoginDto 登陆
+type LoginDto struct {
+	UserId   string `json:"user_id"`   // 用户id
+	NickName string `json:"nick_name"` // 用户名称
+	Avatar   string `json:"avatar"`    // 头像
+	Token    string `json:"token"`     // token
+}
+
+// IndexDto 首页
+type IndexDto struct {
+	QuestionCount       int64   `json:"question_count"`        // 问题数量
+	UserCount           int64   `json:"user_count"`            // 用户数量
+	ValidMemberCount    int64   `json:"valid_member_count"`    // 有效会员数
+	QuestionSubmitCount int64   `json:"question_submit_count"` // 问题总提交次数
+	QuestionPayCount    int64   `json:"question_pay_count"`    // 问题总支付次数
+	MemberBuyCount      int64   `json:"member_buy_count"`      // 会员购买次数
+	MemberAmountTotal   float64 `json:"member_amount_total"`   // 会员购买总金额
+	SingleAmountTotal   float64 `json:"single_amount_total"`   // 单项购买总金额
+	AmountTotal         float64 `json:"amount_total"`          // 会员+单项购买总金额
+}
+
+// IndexDataDto 首页动态统计数据
+type IndexDataDto struct {
+	Date  string `json:"date"`  // 日期
+	Count int64  `json:"count"` // 数量
+}
+
+// AdminLoginDto 微信登陆
+func AdminLoginDto(m *model.AdminUser) *LoginDto {
+	return &LoginDto{
+		UserId:   fmt.Sprintf("%d", m.UserId),
+		NickName: m.NickName,
+		Avatar:   utils.AddOssDomain(m.Avatar),
+	}
+}
+
+// LoadToken 加载token
+func (r *LoginDto) LoadToken(token string) *LoginDto {
+	r.Token = token
+	return r
+}

api/dto/Question.go

@@ -0,0 +1,187 @@
+package dto
+
+import (
+	"fmt"
+	"hepa-calc-admin-api/api/model"
+)
+
+// QuestionDto 问题表
+type QuestionDto struct {
+	QuestionId       string           `json:"question_id"`       // 主键id
+	QuestionTitle    string           `json:"question_title"`    // 标题
+	QuestionSubtitle string           `json:"question_subtitle"` // 副标题
+	QuestionIden     string           `json:"question_iden"`     // 唯一标识
+	QuestionStatus   int              `json:"question_status"`   // 问题状态（1:正常 2:待发布）
+	IsHide           int              `json:"is_hide"`           // 是否隐藏（0:否 1:是）
+	IsRecommend      int              `json:"is_recommend"`      // 是否推荐（0:否 1:是）
+	ClickCount       int              `json:"click_count"`       // 点击次数（点击进入详情页的人次）
+	SubmitCount      int              `json:"submit_count"`      // 提交次数（提交个人信息进行了算算的人次）
+	PayCount         int              `json:"pay_count"`         // 支付次数（查看报告的人次）
+	Price            float64          `json:"price"`             // 价格（原价）
+	DiscountPrice    *float64         `json:"discount_price"`    // 优惠价格
+	DiscountEndTime  *model.LocalTime `json:"discount_end_time"` // 优惠截止时间
+	QuestionBrief    string           `json:"question_brief"`    // 问题介绍
+	QuestionExplain  string           `json:"question_explain"`  // 问题解释/科普
+	CreatedAt        model.LocalTime  `json:"created_at"`        // 创建时间
+	UpdatedAt        model.LocalTime  `json:"updated_at"`        // 更新时间
+	IsCollection     bool             `json:"is_collection"`     // 用户是否收藏
+	FirstTimePrice   *float64         `json:"first_time_price"`  // 首次购买价格
+	BuyCount         int              `json:"buy_count"`         // 被购买数量
+	BaseClass        []*BaseClassDto  `json:"base_class"`        // 关联分类
+}
+
+// GetQuestionDto 详情-问题
+func GetQuestionDto(m *model.Question) *QuestionDto {
+	return &QuestionDto{
+		QuestionId:       fmt.Sprintf("%d", m.QuestionId),
+		QuestionTitle:    m.QuestionTitle,
+		QuestionSubtitle: m.QuestionSubtitle,
+		QuestionIden:     m.QuestionIden,
+		QuestionStatus:   m.QuestionStatus,
+		IsHide:           m.IsHide,
+		IsRecommend:      m.IsRecommend,
+		ClickCount:       m.ClickCount,
+		SubmitCount:      m.SubmitCount,
+		PayCount:         m.PayCount,
+		Price:            m.Price,
+		DiscountPrice:    m.DiscountPrice,
+		DiscountEndTime:  (*model.LocalTime)(m.DiscountEndTime),
+		QuestionBrief:    m.QuestionBrief,
+		QuestionExplain:  m.QuestionExplain,
+		CreatedAt:        m.CreatedAt,
+		UpdatedAt:        m.UpdatedAt,
+	}
+}
+
+// GetQuestionListDto 列表-问题
+func GetQuestionListDto(m []*model.Question) []*QuestionDto {
+	// 处理返回值
+	responses := make([]*QuestionDto, len(m))
+
+	if len(m) > 0 {
+		for i, v := range m {
+			response := &QuestionDto{
+				QuestionId:       fmt.Sprintf("%d", v.QuestionId),
+				QuestionTitle:    v.QuestionTitle,
+				QuestionSubtitle: v.QuestionSubtitle,
+				QuestionIden:     v.QuestionIden,
+				QuestionStatus:   v.QuestionStatus,
+				IsHide:           v.IsHide,
+				IsRecommend:      v.IsRecommend,
+				ClickCount:       v.ClickCount,
+				SubmitCount:      v.SubmitCount,
+				PayCount:         v.PayCount,
+				Price:            v.Price,
+				DiscountPrice:    v.DiscountPrice,
+				DiscountEndTime:  (*model.LocalTime)(v.DiscountEndTime),
+				QuestionBrief:    v.QuestionBrief,
+				QuestionExplain:  v.QuestionExplain,
+				CreatedAt:        v.CreatedAt,
+				UpdatedAt:        v.UpdatedAt,
+			}
+
+			// 将转换后的结构体添加到新切片中
+			responses[i] = response
+		}
+	}
+
+	return responses
+}
+
+// GetHotQuestionListDto 列表-热榜问题
+func GetHotQuestionListDto(m []*model.Question) []*QuestionDto {
+	// 处理返回值
+	responses := make([]*QuestionDto, len(m))
+
+	if len(m) > 0 {
+		for i, v := range m {
+			response := &QuestionDto{
+				QuestionId:       fmt.Sprintf("%d", v.QuestionId),
+				QuestionTitle:    v.QuestionTitle,
+				QuestionSubtitle: v.QuestionSubtitle,
+				QuestionIden:     v.QuestionIden,
+				ClickCount:       v.ClickCount,
+				SubmitCount:      v.SubmitCount,
+				PayCount:         v.PayCount,
+			}
+
+			// 将转换后的结构体添加到新切片中
+			responses[i] = response
+		}
+	}
+
+	return responses
+}
+
+// GetRecommendQuestionListDto 列表-为你推荐
+func GetRecommendQuestionListDto(m []*model.Question) []*QuestionDto {
+	// 处理返回值
+	responses := make([]*QuestionDto, len(m))
+
+	if len(m) > 0 {
+		for i, v := range m {
+			response := &QuestionDto{
+				QuestionId:       fmt.Sprintf("%d", v.QuestionId),
+				QuestionTitle:    v.QuestionTitle,
+				QuestionSubtitle: v.QuestionSubtitle,
+				QuestionIden:     v.QuestionIden,
+				ClickCount:       v.ClickCount,
+				SubmitCount:      v.SubmitCount,
+				PayCount:         v.PayCount,
+			}
+
+			// 将转换后的结构体添加到新切片中
+			responses[i] = response
+		}
+	}
+
+	return responses
+}
+
+// GetGuessUserLikeListDto 列表-猜你喜欢
+func GetGuessUserLikeListDto(m []*model.Question) []*QuestionDto {
+	// 处理返回值
+	responses := make([]*QuestionDto, len(m))
+
+	if len(m) > 0 {
+		for i, v := range m {
+			response := &QuestionDto{
+				QuestionId:       fmt.Sprintf("%d", v.QuestionId),
+				QuestionTitle:    v.QuestionTitle,
+				QuestionSubtitle: v.QuestionSubtitle,
+				QuestionIden:     v.QuestionIden,
+				ClickCount:       v.ClickCount,
+				SubmitCount:      v.SubmitCount,
+				PayCount:         v.PayCount,
+			}
+
+			// 将转换后的结构体添加到新切片中
+			responses[i] = response
+		}
+	}
+
+	return responses
+}
+
+// LoadIsCollection 加载数据-是否收藏
+func (r *QuestionDto) LoadIsCollection(isCollection bool) *QuestionDto {
+	r.IsCollection = isCollection
+
+	return r
+}
+
+// LoadFirstTimePrice 加载数据-首次购买价格
+func (r *QuestionDto) LoadFirstTimePrice(firstTimePrice *float64) *QuestionDto {
+	if firstTimePrice != nil {
+		r.FirstTimePrice = firstTimePrice
+	}
+
+	return r
+}
+
+// LoadBuyCount 加载数据-问题被购买数量
+func (r *QuestionDto) LoadBuyCount(buyCount int) *QuestionDto {
+	r.BuyCount = buyCount
+
+	return r
+}

api/dto/SystemMember.go

@@ -0,0 +1,55 @@
+package dto
+
+import (
+	"fmt"
+	"hepa-calc-admin-api/api/model"
+)
+
+// SystemMemberDto 配置-会员配置
+type SystemMemberDto struct {
+	SystemMemberId  string           `json:"system_member_id"`  // 主键id
+	MemberDays      uint             `json:"member_days"`       // 会员天数
+	Price           float64          `json:"price"`             // 价格（原价）
+	DiscountPrice   *float64         `json:"discount_price"`    // 优惠价格
+	DiscountEndTime *model.LocalTime `json:"discount_end_time"` // 优惠截止时间
+	CreatedAt       model.LocalTime  `json:"created_at"`        // 创建时间
+	UpdatedAt       model.LocalTime  `json:"updated_at"`        // 更新时间
+}
+
+// GetSystemMemberListDto 列表
+func GetSystemMemberListDto(m []*model.SystemMember) []*SystemMemberDto {
+	// 处理返回值
+	responses := make([]*SystemMemberDto, len(m))
+
+	if len(m) > 0 {
+		for i, v := range m {
+			response := &SystemMemberDto{
+				SystemMemberId:  fmt.Sprintf("%d", v.SystemMemberId),
+				MemberDays:      v.MemberDays,
+				Price:           v.Price,
+				DiscountPrice:   v.DiscountPrice,
+				DiscountEndTime: (*model.LocalTime)(v.DiscountEndTime),
+				CreatedAt:       v.CreatedAt,
+				UpdatedAt:       v.UpdatedAt,
+			}
+
+			// 将转换后的结构体添加到新切片中
+			responses[i] = response
+		}
+	}
+
+	return responses
+}
+
+// GetSystemMemberDto 详情
+func GetSystemMemberDto(m *model.SystemMember) *SystemMemberDto {
+	return &SystemMemberDto{
+		SystemMemberId:  fmt.Sprintf("%d", m.SystemMemberId),
+		MemberDays:      m.MemberDays,
+		Price:           m.Price,
+		DiscountPrice:   m.DiscountPrice,
+		DiscountEndTime: (*model.LocalTime)(m.DiscountEndTime),
+		CreatedAt:       m.CreatedAt,
+		UpdatedAt:       m.UpdatedAt,
+	}
+}

api/dto/SystemSingle.go

@@ -0,0 +1,49 @@
+package dto
+
+import (
+	"fmt"
+	"hepa-calc-admin-api/api/model"
+)
+
+// SystemSingleDto 配置-会员配置
+type SystemSingleDto struct {
+	SystemSingleId string          `json:"system_member_id"` // 主键id
+	FirstTimePrice float64         `json:"first_time_price"` // 首次购买价格
+	ValidDays      int             `json:"valid_days"`       // 购买后有效天数
+	CreatedAt      model.LocalTime `json:"created_at"`       // 创建时间
+	UpdatedAt      model.LocalTime `json:"updated_at"`       // 更新时间
+}
+
+// GetSystemSingleListDto 列表
+func GetSystemSingleListDto(m []*model.SystemSingle) []*SystemSingleDto {
+	// 处理返回值
+	responses := make([]*SystemSingleDto, len(m))
+
+	if len(m) > 0 {
+		for i, v := range m {
+			response := &SystemSingleDto{
+				SystemSingleId: fmt.Sprintf("%d", v.SystemSingleId),
+				FirstTimePrice: v.FirstTimePrice,
+				ValidDays:      v.ValidDays,
+				CreatedAt:      v.CreatedAt,
+				UpdatedAt:      v.UpdatedAt,
+			}
+
+			// 将转换后的结构体添加到新切片中
+			responses[i] = response
+		}
+	}
+
+	return responses
+}
+
+// GetSystemSingleDto 详情
+func GetSystemSingleDto(m *model.SystemSingle) *SystemSingleDto {
+	return &SystemSingleDto{
+		SystemSingleId: fmt.Sprintf("%d", m.SystemSingleId),
+		FirstTimePrice: m.FirstTimePrice,
+		ValidDays:      m.ValidDays,
+		CreatedAt:      m.CreatedAt,
+		UpdatedAt:      m.UpdatedAt,
+	}
+}

api/dto/User.go

@@ -0,0 +1,96 @@
+package dto
+
+import (
+	"fmt"
+	"hepa-calc-admin-api/api/model"
+	"hepa-calc-admin-api/utils"
+	"time"
+)
+
+// UserDto 用户表
+type UserDto struct {
+	UserId           string          `json:"user_id"`            // 用户id
+	UserName         string          `json:"user_name"`          // 用户名称
+	Mobile           string          `json:"mobile"`             // 手机号
+	UserStatus       int             `json:"user_status"`        // 状态（1:正常 2:禁用）
+	RegisterSource   int             `json:"register_source"`    // 注册来源（1：app注册 2：公众号注册）
+	OpenId           string          `json:"open_id"`            // 用户微信标识
+	UnionId          string          `json:"union_id"`           // 微信开放平台标识
+	Age              *uint           `json:"age"`                // 年龄
+	Sex              uint            `json:"sex"`                // 性别（0:未知 1:男 2:女）
+	Avatar           string          `json:"avatar"`             // 头像
+	IsMember         int             `json:"is_member"`          // 是否会员（0:否 1:是）
+	MemberExpireDate *time.Time      `json:"member_expire_date"` // 会员到期时间（非会员时为null）
+	LoginAt          model.LocalTime `json:"login_at"`           // 登陆时间
+	LoginIp          string          `json:"login_ip"`           // 登陆ip
+	CreatedAt        model.LocalTime `json:"created_at"`         // 创建时间
+	UpdatedAt        model.LocalTime `json:"updated_at"`         // 更新时间
+	IsInfoComplete   int             `json:"is_info_complete"`   // 信息完善状态 0:否 1:是
+}
+
+// GetUserListDto 列表
+func GetUserListDto(m []*model.User) []*UserDto {
+	// 处理返回值
+	responses := make([]*UserDto, len(m))
+
+	if len(m) > 0 {
+		for i, v := range m {
+			response := &UserDto{
+				UserId:           fmt.Sprintf("%d", v.UserId),
+				UserName:         v.UserName,
+				Mobile:           v.Mobile,
+				UserStatus:       v.UserStatus,
+				RegisterSource:   v.RegisterSource,
+				Age:              v.Age,
+				Sex:              uint(v.Sex),
+				Avatar:           utils.AddOssDomain(v.Avatar),
+				IsMember:         v.IsMember,
+				MemberExpireDate: v.MemberExpireDate,
+				LoginAt:          v.LoginAt,
+				LoginIp:          v.LoginIp,
+				CreatedAt:        v.CreatedAt,
+				UpdatedAt:        v.UpdatedAt,
+			}
+
+			// 加载信息完善状态
+			if v.UserInfo != nil {
+				response = response.LoadIsInfoComplete(v.UserInfo)
+			}
+
+			// 将转换后的结构体添加到新切片中
+			responses[i] = response
+		}
+	}
+
+	return responses
+}
+
+// GetUserDto 详情-问题
+func GetUserDto(m *model.User) *UserDto {
+	return &UserDto{
+		UserId:           fmt.Sprintf("%d", m.UserId),
+		UserName:         m.UserName,
+		Mobile:           m.Mobile,
+		UserStatus:       m.UserStatus,
+		RegisterSource:   m.RegisterSource,
+		Age:              m.Age,
+		Sex:              uint(m.Sex),
+		Avatar:           utils.AddOssDomain(m.Avatar),
+		IsMember:         m.IsMember,
+		MemberExpireDate: m.MemberExpireDate,
+		LoginAt:          m.LoginAt,
+		LoginIp:          m.LoginIp,
+		CreatedAt:        m.CreatedAt,
+		UpdatedAt:        m.UpdatedAt,
+	}
+}
+
+// LoadIsInfoComplete 加载信息完善状态
+func (r *UserDto) LoadIsInfoComplete(m *model.UserInfo) *UserDto {
+	if m != nil {
+		if m.DiseaseClassId != 0 && m.FamilyHistoryId != 0 {
+			r.IsInfoComplete = 1
+		}
+	}
+	return r
+}

api/dto/UserCollection.go

@@ -0,0 +1,62 @@
+package dto
+
+import (
+	"fmt"
+	"hepa-calc-admin-api/api/model"
+)
+
+type UserCollectionDto struct {
+	CollectionId string          `json:"collection_id"` // 主键id
+	UserId       string          `json:"user_id"`       // 用户id
+	QuestionId   string          `json:"question_id"`   // 问题id
+	CreatedAt    model.LocalTime `json:"created_at"`    // 创建时间
+	UpdatedAt    model.LocalTime `json:"updated_at"`    // 更新时间
+	Question     *QuestionDto    `json:"question"`      // 问题
+}
+
+// GetUserCollectionDto 用户收藏详情
+func GetUserCollectionDto(m *model.UserCollection) *UserCollectionDto {
+	return &UserCollectionDto{
+		CollectionId: fmt.Sprintf("%d", m.CollectionId),
+		UserId:       fmt.Sprintf("%d", m.UserId),
+		QuestionId:   fmt.Sprintf("%d", m.QuestionId),
+		CreatedAt:    m.CreatedAt,
+		UpdatedAt:    m.UpdatedAt,
+	}
+}
+
+// GetUserCollectionListDto 列表
+func GetUserCollectionListDto(m []*model.UserCollection) []*UserCollectionDto {
+	// 处理返回值
+	responses := make([]*UserCollectionDto, len(m))
+
+	if len(m) > 0 {
+		for i, v := range m {
+			response := &UserCollectionDto{
+				CollectionId: fmt.Sprintf("%d", v.CollectionId),
+				UserId:       fmt.Sprintf("%d", v.UserId),
+				QuestionId:   fmt.Sprintf("%d", v.QuestionId),
+				CreatedAt:    v.CreatedAt,
+				UpdatedAt:    v.UpdatedAt,
+			}
+
+			// 加载问题数据
+			if v.Question != nil {
+				response = response.LoadQuestion(v.Question)
+			}
+
+			// 将转换后的结构体添加到新切片中
+			responses[i] = response
+		}
+	}
+
+	return responses
+}
+
+// LoadQuestion 加载题目数据
+func (r *UserCollectionDto) LoadQuestion(m *model.Question) *UserCollectionDto {
+	if m != nil {
+		r.Question = GetQuestionDto(m)
+	}
+	return r
+}

api/dto/UserCoupon.go

@@ -0,0 +1,79 @@
+package dto
+
+import (
+	"fmt"
+	"hepa-calc-admin-api/api/model"
+)
+
+type UserCouponDto struct {
+	UserCouponId     string          `json:"user_coupon_id"`     // 主键id
+	UserId           string          `json:"user_id"`            // 用户id
+	CouponId         string          `json:"coupon_id"`          // 优惠券id
+	UserCouponStatus int             `json:"user_coupon_status"` // 状态（0:未使用 1:已使用 3:已过期）
+	IsWindows        int             `json:"is_windows"`         // 是否已弹窗（0:否 1:是）
+	CouponUseDate    model.LocalTime `json:"coupon_use_date"`    // 使用时间
+	ValidStartTime   model.LocalTime `json:"valid_start_time"`   // 有效开始时间
+	ValidEndTime     model.LocalTime `json:"valid_end_time"`     // 过期时间
+	CreatedAt        model.LocalTime `json:"created_at"`         // 创建时间
+	UpdatedAt        model.LocalTime `json:"updated_at"`         // 更新时间
+	Coupon           *CouponDto      `json:"coupon"`             // 优惠卷
+}
+
+// GetUserCouponDto 用户优惠卷详情
+func GetUserCouponDto(m *model.UserCoupon) *UserCouponDto {
+	return &UserCouponDto{
+		UserCouponId:     fmt.Sprintf("%d", m.UserCouponId),
+		UserId:           fmt.Sprintf("%d", m.UserId),
+		CouponId:         fmt.Sprintf("%d", m.CouponId),
+		UserCouponStatus: m.UserCouponStatus,
+		IsWindows:        m.IsWindows,
+		CouponUseDate:    m.CouponUseDate,
+		ValidStartTime:   m.ValidStartTime,
+		ValidEndTime:     m.ValidEndTime,
+		CreatedAt:        m.CreatedAt,
+		UpdatedAt:        m.UpdatedAt,
+	}
+}
+
+// GetUserCouponListDto 列表
+func GetUserCouponListDto(m []*model.UserCoupon) []*UserCouponDto {
+	// 处理返回值
+	responses := make([]*UserCouponDto, len(m))
+
+	if len(m) > 0 {
+		for i, v := range m {
+			response := &UserCouponDto{
+				UserCouponId:     fmt.Sprintf("%d", v.UserCouponId),
+				UserId:           fmt.Sprintf("%d", v.UserId),
+				CouponId:         fmt.Sprintf("%d", v.CouponId),
+				UserCouponStatus: v.UserCouponStatus,
+				IsWindows:        v.IsWindows,
+				CouponUseDate:    v.CouponUseDate,
+				ValidStartTime:   v.ValidStartTime,
+				ValidEndTime:     v.ValidEndTime,
+				CreatedAt:        v.CreatedAt,
+				UpdatedAt:        v.UpdatedAt,
+			}
+
+			// 加载优惠卷数据
+			if v.Coupon != nil {
+				response = response.LoadCoupon(v.Coupon)
+			}
+
+			// 将转换后的结构体添加到新切片中
+			responses[i] = response
+		}
+	}
+
+	return responses
+}
+
+// LoadCoupon 加载优惠卷数据
+func (r *UserCouponDto) LoadCoupon(m *model.Coupon) *UserCouponDto {
+	if m != nil {
+		d := GetCouponDto(m)
+
+		r.Coupon = d
+	}
+	return r
+}

api/exception/exception.go

@@ -0,0 +1,43 @@
+package exception
+
+import (
+	"github.com/gin-gonic/gin"
+	"hepa-calc-admin-api/consts"
+	"log"
+	"net/http"
+	"runtime/debug"
+)
+
+// Recover
+// @Description: 处理全局异常
+// @return gin.HandlerFunc
+func Recover() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		defer func() {
+			if r := recover(); r != nil {
+				// 打印错误堆栈信息
+				log.Printf("panic: %v\n", r)
+				debug.PrintStack()
+				c.JSON(http.StatusInternalServerError, gin.H{
+					"code":    consts.ServerError,
+					"message": errorToString(r),
+					"data":    "",
+				})
+				// 终止后续接口调用，不加的话recover到异常后，还会继续执行接口里后续代码
+				c.Abort()
+			}
+		}()
+		// 加载完 defer recover，继续后续接口调用
+		c.Next()
+	}
+}
+
+// recover错误，转string
+func errorToString(r interface{}) string {
+	switch v := r.(type) {
+	case error:
+		return v.Error()
+	default:
+		return r.(string)
+	}
+}

api/middlewares/auth.go

@@ -0,0 +1,57 @@
+package middlewares
+
+import (
+	"github.com/gin-gonic/gin"
+	"hepa-calc-admin-api/api/dao"
+	"hepa-calc-admin-api/api/responses"
+)
+
+// Auth Auth认证
+func Auth() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		// 获取用户id
+		adminUserId := c.GetInt64("AdminUserId")
+		if adminUserId == 0 {
+			responses.Fail(c)
+			c.Abort()
+			return
+		}
+
+		// 获取用户数据
+		adminUserDao := dao.AdminUserDao{}
+		adminUser, err := adminUserDao.GetAdminUserById(adminUserId)
+		if err != nil || adminUser == nil {
+			responses.FailWithMessage("用户数据错误", c)
+			c.Abort()
+			return
+		}
+
+		if adminUser.Status == 2 {
+			responses.FailWithMessage("用户审核中", c)
+			c.Abort()
+			return
+		}
+
+		if adminUser.Status == 3 {
+			responses.FailWithMessage("用户状态异常", c)
+			c.Abort()
+			return
+		}
+
+		if adminUser.IsDisabled == 1 {
+			responses.FailWithMessage("用户已被禁用", c)
+			c.Abort()
+			return
+		}
+
+		if adminUser.IsDeleted == 1 {
+			responses.FailWithMessage("用户状态异常", c)
+			c.Abort()
+			return
+		}
+
+		c.Set("AdminUserId", adminUserId) // 用户id
+
+		c.Next()
+	}
+}

api/middlewares/cors.go

@@ -0,0 +1,29 @@
+package middlewares
+
+import (
+	"github.com/gin-gonic/gin"
+	"net/http"
+)
+
+// Cors
+// @Description: 跨域中间件
+// @return gin.HandlerFunc
+func Cors() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		method := c.Request.Method
+		origin := c.Request.Header.Get("Origin")
+		if origin != "" {
+			c.Header("Access-Control-Allow-Origin", origin)
+			c.Header("Access-Control-Allow-Methods", "POST, GET, OPTIONS, PUT, DELETE, UPDATE")
+			c.Header("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept, Authorization")
+			c.Header("Access-Control-Expose-Headers", "Content-Length, Access-Control-Allow-Origin, Access-Control-Allow-Headers, Cache-Control, Content-Language, Content-Type")
+			c.Header("Access-Control-Allow-Credentials", "false")
+			c.Set("content-type", "application/json")
+		}
+		if method == "OPTIONS" {
+			c.AbortWithStatus(http.StatusNoContent)
+			return
+		}
+		c.Next()
+	}
+}

api/middlewares/jwt.go

@@ -0,0 +1,72 @@
+package middlewares
+
+import (
+	"github.com/gin-gonic/gin"
+	"hepa-calc-admin-api/consts"
+	"hepa-calc-admin-api/global"
+	"hepa-calc-admin-api/utils"
+	"net/http"
+	"strconv"
+	"strings"
+)
+
+// Jwt jwt认证
+func Jwt() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		authorization := c.Request.Header.Get("Authorization")
+		if authorization == "" || !strings.HasPrefix(authorization, "Bearer ") {
+			c.JSON(http.StatusUnauthorized, gin.H{
+				"message": "请求未授权",
+				"code":    consts.TokenError,
+				"data":    "",
+			})
+			c.Abort()
+			return
+		}
+
+		// 去除Bearer
+		authorization = authorization[7:] // 截取字符
+
+		// 检测是否存在黑名单
+		res, _ := global.Redis.Get(c, "jwt_black_"+authorization).Result()
+		if res != "" {
+			c.JSON(http.StatusOK, gin.H{
+				"message": "token错误/过期",
+				"code":    consts.TokenError,
+				"data":    "",
+			})
+
+			c.Abort()
+			return
+		}
+
+		// 解析jwt
+		t, err := utils.ParseJwt(authorization)
+		if err != nil {
+			c.JSON(http.StatusOK, gin.H{
+				"message": "token错误/过期",
+				"code":    consts.TokenError,
+				"data":    "",
+			})
+
+			c.Abort()
+			return
+		}
+
+		// 转换类型
+		userId, err := strconv.ParseInt(t.UserId, 10, 64)
+		if err != nil {
+			c.JSON(http.StatusOK, gin.H{
+				"message": "token错误",
+				"code":    consts.TokenError,
+				"data":    "",
+			})
+
+			c.Abort()
+			return
+		}
+
+		c.Set("AdminUserId", userId) // 用户id
+		c.Next()
+	}
+}

api/middlewares/logrus.go

@@ -0,0 +1,60 @@
+package middlewares
+
+import (
+	"fmt"
+	"github.com/gin-gonic/gin"
+	"github.com/sirupsen/logrus"
+	"hepa-calc-admin-api/global"
+	"time"
+)
+
+// Logrus 日志中间件
+func Logrus() gin.HandlerFunc {
+	return func(c *gin.Context) {
+
+		// 开始时间
+		startTime := time.Now()
+
+		// 处理请求
+		c.Next()
+
+		// 获取 请求 参数
+		params := make(map[string]string)
+
+		paramsRaw, ok := c.Get("params")
+		if ok {
+			requestParams, ok := paramsRaw.(map[string]string)
+			if ok || len(requestParams) > 0 {
+				params = requestParams
+			}
+		}
+
+		// 结束时间
+		endTime := time.Now()
+
+		// 执行时间
+		latencyTime := fmt.Sprintf("%6v", endTime.Sub(startTime))
+
+		// 请求方式
+		reqMethod := c.Request.Method
+
+		// 请求路由
+		reqUri := c.Request.RequestURI
+
+		// 状态码
+		statusCode := c.Writer.Status()
+
+		// 请求IP
+		clientIP := c.ClientIP()
+
+		// 日志格式
+		global.Logger.WithFields(logrus.Fields{
+			"http_status": statusCode,
+			"total_time":  latencyTime,
+			"ip":          clientIP,
+			"method":      reqMethod,
+			"uri":         reqUri,
+			"params":      params,
+		}).Info("access")
+	}
+}

api/middlewares/requestParamsMiddleware.go

@@ -0,0 +1,92 @@
+package middlewares
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"github.com/gin-gonic/gin"
+	"hepa-calc-admin-api/consts"
+	"io"
+	"net/http"
+)
+
+// RequestParamsMiddleware 获取请求参数中间件
+func RequestParamsMiddleware() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		contentType := c.Request.Header.Get("Content-Type")
+
+		params := make(map[string]string)
+
+		// 判断请求参数类型
+		switch contentType {
+		case "application/json":
+			// 解析 application/json 请求体
+			bodyBytes, err := io.ReadAll(c.Request.Body)
+			if err != nil {
+				c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to read request body"})
+				c.Abort()
+				return
+			}
+
+			// 创建新的请求对象，并设置请求体数据
+			c.Request.Body = io.NopCloser(bytes.NewBuffer(bodyBytes))
+
+			var jsonParams map[string]interface{}
+			err = json.Unmarshal(bodyBytes, &jsonParams)
+			if err != nil {
+				c.JSON(http.StatusBadRequest, gin.H{
+					"message": "Invalid JSON data",
+					"code":    consts.HttpError,
+					"data":    "",
+				})
+				c.Abort()
+				return
+			}
+
+			for key, value := range jsonParams {
+				params[key] = fmt.Sprintf("%v", value)
+			}
+
+			// 存储参数到上下文
+			c.Set("params", params)
+
+		case "multipart/form-data", "application/form-data", "application/x-www-form-urlencoded":
+			// 解析 Form 表单参数
+			err := c.Request.ParseForm()
+			if err != nil {
+				c.JSON(http.StatusBadRequest, gin.H{
+					"message": "Invalid form data",
+					"code":    consts.HttpError,
+					"data":    "",
+				})
+				c.Abort()
+				return
+			}
+
+			for key, values := range c.Request.Form {
+				if len(values) > 0 {
+					params[key] = fmt.Sprintf("%v", values[0])
+				}
+			}
+
+			// 存储参数到上下文
+			c.Set("params", params)
+
+		default:
+			// 解析 URL 参数
+			queryParams := c.Request.URL.Query()
+
+			for key, values := range queryParams {
+				if len(values) > 0 {
+					params[key] = fmt.Sprintf("%v", values[0])
+				}
+			}
+
+			// 存储参数到上下文
+			c.Set("params", params)
+		}
+
+		// 继续处理请求
+		c.Next()
+	}
+}

api/model/AdminUser.go

@@ -0,0 +1,42 @@
+package model
+
+import (
+	"gorm.io/gorm"
+	"hepa-calc-admin-api/global"
+	"time"
+)
+
+// AdminUser 后台-用户表
+type AdminUser struct {
+	UserId     int64  `gorm:"column:user_id;type:bigint(19);primary_key;comment:主键id" json:"user_id"`
+	Access     string `gorm:"column:access;type:varchar(64);comment:账号;NOT NULL" json:"access"`
+	Password   string `gorm:"column:password;type:varchar(128);comment:密码;NOT NULL" json:"password"`
+	Salt       string `gorm:"column:salt;type:varchar(255);comment:密码掩码;NOT NULL" json:"salt"`
+	NickName   string `gorm:"column:nick_name;type:varchar(255);comment:昵称" json:"nick_name"`
+	Status     int    `gorm:"column:status;type:tinyint(1);default:2;comment:状态（1:正常 2:审核中 3:审核失败）" json:"status"`
+	IsDeleted  int    `gorm:"column:is_deleted;type:tinyint(1);default:0;comment:是否被删除（0:否 1:是）" json:"is_deleted"`
+	IsDisabled int    `gorm:"column:is_disabled;type:tinyint(1);default:0;comment:是否被禁用（0:否 1:是）" json:"is_disabled"`
+	Phone      string `gorm:"column:phone;type:varchar(11);comment:手机号" json:"phone"`
+	Avatar     string `gorm:"column:avatar;type:varchar(255);comment:头像" json:"avatar"`
+	Sex        int    `gorm:"column:sex;type:tinyint(1);comment:性别（1:男 2:女）" json:"sex"`
+	Email      string `gorm:"column:email;type:varchar(100);comment:邮箱" json:"email"`
+	Model
+}
+
+func (m *AdminUser) TableName() string {
+	return "admin_user"
+}
+
+func (m *AdminUser) BeforeCreate(tx *gorm.DB) error {
+	if m.UserId == 0 {
+		m.UserId = global.Snowflake.Generate().Int64()
+	}
+
+	m.CreatedAt = LocalTime(time.Now())
+	tx.Statement.SetColumn("CreatedAt", m.CreatedAt)
+
+	m.UpdatedAt = LocalTime(time.Now())
+	tx.Statement.SetColumn("UpdatedAt", m.UpdatedAt)
+
+	return nil
+}

api/model/BaseAgreement.go

@@ -0,0 +1,33 @@
+package model
+
+import (
+	"gorm.io/gorm"
+	"hepa-calc-admin-api/global"
+	"time"
+)
+
+// BaseAgreement 基础数据-协议
+type BaseAgreement struct {
+	AgreementId      int64  `gorm:"column:agreement_id;type:bigint(19);primary_key;comment:主键id" json:"agreement_id"`
+	AgreementTitle   string `gorm:"column:agreement_title;type:varchar(100);comment:协议标题" json:"agreement_title"`
+	AgreementContent string `gorm:"column:agreement_content;type:text;comment:协议内容" json:"agreement_content"`
+	Model
+}
+
+func (m *BaseAgreement) TableName() string {
+	return "base_agreement"
+}
+
+func (m *BaseAgreement) BeforeCreate(tx *gorm.DB) error {
+	if m.AgreementId == 0 {
+		m.AgreementId = global.Snowflake.Generate().Int64()
+	}
+
+	m.CreatedAt = LocalTime(time.Now())
+	tx.Statement.SetColumn("CreatedAt", m.CreatedAt)
+
+	m.UpdatedAt = LocalTime(time.Now())
+	tx.Statement.SetColumn("UpdatedAt", m.UpdatedAt)
+
+	return nil
+}

api/model/BaseClass.go

@@ -0,0 +1,36 @@
+package model
+
+import (
+	"gorm.io/gorm"
+	"hepa-calc-admin-api/global"
+	"time"
+)
+
+// BaseClass 基础数据-分类表
+type BaseClass struct {
+	ClassId     int64  `gorm:"column:class_id;type:bigint(19);primary_key;comment:主键id" json:"class_id"`
+	ClassName   string `gorm:"column:class_name;type:varchar(100);comment:分类名称" json:"class_name"`
+	ClassStatus int    `gorm:"column:class_status;type:tinyint(1);default:1;comment:分类状态（1:正常 2:隐藏）" json:"class_status"`
+	ClassIcon   string `gorm:"column:class_icon;type:varchar(255);comment:图标地址" json:"class_icon"`
+	ClassBrief  string `gorm:"column:class_brief;type:text;comment:分类简介" json:"class_brief"`
+	Sort        uint   `gorm:"column:sort;type:int(10) unsigned;default:1;comment:排序值（越大排名越靠前）" json:"sort"`
+	Model
+}
+
+func (m *BaseClass) TableName() string {
+	return "base_class"
+}
+
+func (m *BaseClass) BeforeCreate(tx *gorm.DB) error {
+	if m.ClassId == 0 {
+		m.ClassId = global.Snowflake.Generate().Int64()
+	}
+
+	m.CreatedAt = LocalTime(time.Now())
+	tx.Statement.SetColumn("CreatedAt", m.CreatedAt)
+
+	m.UpdatedAt = LocalTime(time.Now())
+	tx.Statement.SetColumn("UpdatedAt", m.UpdatedAt)
+
+	return nil
+}

api/model/Coupon.go

@@ -0,0 +1,47 @@
+package model
+
+import (
+	"gorm.io/gorm"
+	"hepa-calc-admin-api/global"
+	"time"
+)
+
+type Coupon struct {
+	CouponId         int64      `gorm:"column:coupon_id;type:bigint(19);primary_key;comment:主键id" json:"coupon_id"`
+	CouponName       string     `gorm:"column:coupon_name;type:varchar(255);comment:优惠卷名称" json:"coupon_name"`
+	CouponType       int        `gorm:"column:coupon_type;type:varchar(255);comment:优惠卷类型（1:无门槛 2:满减）" json:"coupon_type"`
+	CouponStatus     int        `gorm:"column:coupon_status;type:tinyint(1);default:1;comment:状态（1:正常 2:强制失效 3:结束 4:删除）" json:"coupon_status"`
+	ApplicationScope int        `gorm:"column:application_scope;type:tinyint(1);default:1;comment:适用范围（1:全场通用 2:单项 3:会员）" json:"application_scope"`
+	IsMutex          int        `gorm:"column:is_mutex;type:tinyint(1);default:1;comment:是否互斥（0:否 1:是）互斥情况下无法和其他优惠卷同时使用" json:"is_mutex"`
+	CouponCount      int        `gorm:"column:coupon_count;type:int(10);default:1;comment:发放数量;NOT NULL" json:"coupon_count"`
+	CouponTakeCount  int        `gorm:"column:coupon_take_count;type:int(10);comment:已领取数量" json:"coupon_take_count"`
+	CouponUsedCount  int        `gorm:"column:coupon_used_count;type:int(10);default:0;comment:已使用数量" json:"coupon_used_count"`
+	CouponPrice      float64    `gorm:"column:coupon_price;type:decimal(10,2) unsigned;default:0.00;comment:优惠卷金额" json:"coupon_price"`
+	WithAmount       *float64   `gorm:"column:with_amount;type:decimal(10,2);comment:符合满减标准金额（优惠卷类型为满减时使用）" json:"with_amount"`
+	ValidType        int        `gorm:"column:valid_type;type:tinyint(1);comment:有效类型（1:绝对时效，xxx-xxx时间段有效 2:相对时效 n天内有效）;NOT NULL" json:"valid_type"`
+	ValidDays        *int       `gorm:"column:valid_days;type:int(3);comment:自领取之日起有效天数" json:"valid_days"`
+	ValidStartTime   *LocalTime `gorm:"column:valid_start_time;type:datetime;comment:开始使用时间" json:"valid_start_time"`
+	ValidEndTime     *LocalTime `gorm:"column:valid_end_time;type:datetime;comment:结束使用时间" json:"valid_end_time"`
+	QuestionId       *int64     `gorm:"column:question_id;type:bigint(19);comment:问题id（适用范围为单项时生效，如果此项为null，则表示所有单项通用）" json:"question_id"`
+	SystemMemberId   *int64     `gorm:"column:system_member_id;type:bigint(19);comment:会员id（适用范围为会员时生效，如果此项为null，则表示所有会员通用）" json:"system_member_id"`
+	CouponDesc       string     `gorm:"column:coupon_desc;type:varchar(200);comment:优惠卷描述" json:"coupon_desc"`
+	Model
+}
+
+func (m *Coupon) TableName() string {
+	return "coupon"
+}
+
+func (m *Coupon) BeforeCreate(tx *gorm.DB) error {
+	if m.CouponId == 0 {
+		m.CouponId = global.Snowflake.Generate().Int64()
+	}
+
+	m.CreatedAt = LocalTime(time.Now())
+	tx.Statement.SetColumn("CreatedAt", m.CreatedAt)
+
+	m.UpdatedAt = LocalTime(time.Now())
+	tx.Statement.SetColumn("UpdatedAt", m.UpdatedAt)
+
+	return nil
+}

api/model/OrderMember.go

@@ -0,0 +1,50 @@
+package model
+
+import (
+	"gorm.io/gorm"
+	"hepa-calc-admin-api/global"
+	"time"
+)
+
+// OrderMember 订单-单项
+type OrderMember struct {
+	OrderId            int64      `gorm:"column:order_id;type:bigint(19);primary_key;comment:主键id" json:"order_id"`
+	UserId             int64      `gorm:"column:user_id;type:bigint(19);comment:用户id;NOT NULL" json:"user_id"`
+	SystemMemberId     int64      `gorm:"column:system_member_id;type:bigint(19);comment:会员id;NOT NULL" json:"system_member_id"`
+	OrderStatus        int        `gorm:"column:order_status;type:tinyint(1);default:1;comment:订单状态（1:待支付 2:已完成 3:已取消）" json:"order_status"`
+	IsDelete           int        `gorm:"column:is_delete;type:tinyint(1);default:0;comment:用户删除状态（0:否 1:是）" json:"is_delete"`
+	PayChannel         int        `gorm:"column:pay_channel;type:tinyint(1);comment:支付渠道（1:h5支付 2:app支付 3:会员支付）;NOT NULL" json:"pay_channel"`
+	PayStatus          int        `gorm:"column:pay_status;type:tinyint(1);default:1;comment:支付状态（1:未支付 2:已支付 3:支付中 4:支付失败 5:支付超时 6:支付关闭 7:已撤销 8:转入退款）;NOT NULL" json:"pay_status"`
+	PayTime            *time.Time `gorm:"column:pay_time;type:datetime;comment:支付时间" json:"pay_time"`
+	RefundStatus       int        `gorm:"column:refund_status;type:tinyint(1);default:0;comment:订单退款状态（0:无退款 1:申请退款 2:退款中 3:退款成功 4:拒绝退款 5:退款关闭 6:退款异常 7:部分退款）;NOT NULL" json:"refund_status"`
+	OrderNo            string     `gorm:"column:order_no;type:varchar(30);comment:系统订单编号;NOT NULL" json:"order_no"`
+	EscrowTradeNo      string     `gorm:"column:escrow_trade_no;type:varchar(100);comment:第三方支付流水号;NOT NULL" json:"escrow_trade_no"`
+	AmountTotal        float64    `gorm:"column:amount_total;type:decimal(10,2) unsigned;default:0.00;comment:订单金额" json:"amount_total"`
+	CouponAmountTotal  float64    `gorm:"column:coupon_amount_total;type:decimal(10,2);default:0.00;comment:优惠卷总金额" json:"coupon_amount_total"`
+	PaymentAmountTotal float64    `gorm:"column:payment_amount_total;type:decimal(10,2);default:0.00;comment:实际付款金额" json:"payment_amount_total"`
+	CancelStatus       int        `gorm:"column:cancel_status;type:tinyint(1);default:0;comment:取消状态（0:否 1:是）" json:"cancel_status"`
+	CancelTime         *time.Time `gorm:"column:cancel_time;type:datetime;comment:订单取消时间" json:"cancel_time"`
+	CancelRemarks      string     `gorm:"column:cancel_remarks;type:varchar(255);comment:取消订单备注" json:"cancel_remarks"`
+	OrderRemarks       string     `gorm:"column:order_remarks;type:varchar(255);comment:订单备注" json:"order_remarks"`
+	Model
+	SystemMember *SystemMember `gorm:"foreignKey:SystemMemberId;references:system_member_id" json:"system_member"`
+	User         *User         `gorm:"foreignKey:UserId;references:user_id" json:"user"`
+}
+
+func (m *OrderMember) TableName() string {
+	return "order_member"
+}
+
+func (m *OrderMember) BeforeCreate(tx *gorm.DB) error {
+	if m.OrderId == 0 {
+		m.OrderId = global.Snowflake.Generate().Int64()
+	}
+
+	m.CreatedAt = LocalTime(time.Now())
+	tx.Statement.SetColumn("CreatedAt", m.CreatedAt)
+
+	m.UpdatedAt = LocalTime(time.Now())
+	tx.Statement.SetColumn("UpdatedAt", m.UpdatedAt)
+
+	return nil
+}

api/model/OrderMemberCoupon.go

@@ -0,0 +1,35 @@
+package model
+
+import (
+	"gorm.io/gorm"
+	"hepa-calc-admin-api/global"
+	"time"
+)
+
+// OrderMemberCoupon 订单-单项-优惠卷表
+type OrderMemberCoupon struct {
+	OrderCouponId  int64   `gorm:"column:order_coupon_id;type:bigint(19);primary_key;comment:主键id" json:"order_coupon_id"`
+	OrderId        int64   `gorm:"column:order_id;type:bigint(19);comment:单项订单id;NOT NULL" json:"order_id"`
+	UserCouponId   int64   `gorm:"column:user_coupon_id;type:bigint(19);comment:用户优惠卷表id;NOT NULL" json:"user_coupon_id"`
+	CouponName     string  `gorm:"column:coupon_name;type:varchar(255);comment:优惠卷名称" json:"coupon_name"`
+	CouponUsePrice float64 `gorm:"column:coupon_use_price;type:decimal(10,2) unsigned;default:0.00;comment:优惠卷使用金额" json:"coupon_use_price"`
+	Model
+}
+
+func (m *OrderMemberCoupon) TableName() string {
+	return "order_member_coupon"
+}
+
+func (m *OrderMemberCoupon) BeforeCreate(tx *gorm.DB) error {
+	if m.OrderCouponId == 0 {
+		m.OrderCouponId = global.Snowflake.Generate().Int64()
+	}
+
+	m.CreatedAt = LocalTime(time.Now())
+	tx.Statement.SetColumn("CreatedAt", m.CreatedAt)
+
+	m.UpdatedAt = LocalTime(time.Now())
+	tx.Statement.SetColumn("UpdatedAt", m.UpdatedAt)
+
+	return nil
+}

api/model/OrderMemberRefund.go

@@ -0,0 +1,39 @@
+package model
+
+import (
+	"gorm.io/gorm"
+	"hepa-calc-admin-api/global"
+	"time"
+)
+
+// OrderMemberRefund 订单-会员-退款表
+type OrderMemberRefund struct {
+	OrderRefundId int64     `gorm:"column:order_refund_id;type:bigint(19);primary_key;comment:主键id" json:"order_refund_id"`
+	UserId        int64     `gorm:"column:user_id;type:bigint(19);comment:用户id;NOT NULL" json:"user_id"`
+	OrderId       int64     `gorm:"column:order_id;type:bigint(19);comment:订单id;NOT NULL" json:"order_id"`
+	OrderNo       string    `gorm:"column:order_no;type:varchar(40);comment:系统订单编号" json:"order_no"`
+	RefundNo      string    `gorm:"column:refund_no;type:varchar(50);comment:系统退款编号" json:"refund_no"`
+	RefundId      string    `gorm:"column:refund_id;type:varchar(50);comment:第三方退款单号" json:"refund_id"`
+	RefundStatus  int       `gorm:"column:refund_status;type:tinyint(1);default:0;comment:订单退款状态（0:无退款 1:申请退款 2:退款中 3:退款成功 4:拒绝退款 5:退款关闭 6:退款异常 7:部分退款）" json:"refund_status"`
+	RefundTotal   float64   `gorm:"column:refund_total;type:decimal(10,2) unsigned;default:0.00;comment:退款金额" json:"refund_total"`
+	RefundReason  string    `gorm:"column:refund_reason;type:varchar(255);comment:退款原因" json:"refund_reason"`
+	SuccessTime   LocalTime `gorm:"column:success_time;type:datetime;comment:退款成功时间" json:"success_time"`
+	Model
+}
+
+func (m *OrderMemberRefund) TableName() string {
+	return "order_member_refund"
+}
+func (m *OrderMemberRefund) BeforeCreate(tx *gorm.DB) error {
+	if m.OrderRefundId == 0 {
+		m.OrderRefundId = global.Snowflake.Generate().Int64()
+	}
+
+	m.CreatedAt = LocalTime(time.Now())
+	tx.Statement.SetColumn("CreatedAt", m.CreatedAt)
+
+	m.UpdatedAt = LocalTime(time.Now())
+	tx.Statement.SetColumn("UpdatedAt", m.UpdatedAt)
+
+	return nil
+}

api/model/OrderSingle.go

@@ -0,0 +1,50 @@
+package model
+
+import (
+	"gorm.io/gorm"
+	"hepa-calc-admin-api/global"
+	"time"
+)
+
+// OrderSingle 订单-单项
+type OrderSingle struct {
+	OrderId            int64      `gorm:"column:order_id;type:bigint(19);primary_key;comment:主键id" json:"order_id"`
+	UserId             int64      `gorm:"column:user_id;type:bigint(19);comment:用户id;NOT NULL" json:"user_id"`
+	QuestionId         int64      `gorm:"column:question_id;type:bigint(19);comment:问题id;NOT NULL" json:"question_id"`
+	OrderStatus        int        `gorm:"column:order_status;type:tinyint(1);default:1;comment:订单状态（1:待支付 2:已完成 3:已取消）" json:"order_status"`
+	IsDelete           int        `gorm:"column:is_delete;type:tinyint(1);default:0;comment:用户删除状态（0:否 1:是）" json:"is_delete"`
+	PayChannel         int        `gorm:"column:pay_channel;type:tinyint(1);comment:支付渠道（1:h5支付 2:app支付 3:会员支付）;NOT NULL" json:"pay_channel"`
+	PayStatus          int        `gorm:"column:pay_status;type:tinyint(1);default:1;comment:支付状态（1:未支付 2:已支付 3:支付中 4:支付失败 5:支付超时 6:支付关闭 7:已撤销 8:转入退款）;NOT NULL" json:"pay_status"`
+	PayTime            *time.Time `gorm:"column:pay_time;type:datetime;comment:支付时间" json:"pay_time"`
+	RefundStatus       int        `gorm:"column:refund_status;type:tinyint(1);default:0;comment:订单退款状态（0:无退款 1:申请退款 2:退款中 3:退款成功 4:拒绝退款 5:退款关闭 6:退款异常 7:部分退款）;NOT NULL" json:"refund_status"`
+	OrderNo            string     `gorm:"column:order_no;type:varchar(30);comment:系统订单编号;NOT NULL" json:"order_no"`
+	EscrowTradeNo      string     `gorm:"column:escrow_trade_no;type:varchar(100);comment:第三方支付流水号;NOT NULL" json:"escrow_trade_no"`
+	AmountTotal        float64    `gorm:"column:amount_total;type:decimal(10,2) unsigned;default:0.00;comment:订单金额" json:"amount_total"`
+	CouponAmountTotal  float64    `gorm:"column:coupon_amount_total;type:decimal(10,2);default:0.00;comment:优惠卷总金额" json:"coupon_amount_total"`
+	PaymentAmountTotal float64    `gorm:"column:payment_amount_total;type:decimal(10,2);default:0.00;comment:实际付款金额" json:"payment_amount_total"`
+	CancelStatus       int        `gorm:"column:cancel_status;type:tinyint(1);default:0;comment:取消状态（0:否 1:是）" json:"cancel_status"`
+	CancelTime         *time.Time `gorm:"column:cancel_time;type:datetime;comment:订单取消时间" json:"cancel_time"`
+	CancelRemarks      string     `gorm:"column:cancel_remarks;type:varchar(255);comment:取消订单备注" json:"cancel_remarks"`
+	OrderRemarks       string     `gorm:"column:order_remarks;type:varchar(255);comment:订单备注" json:"order_remarks"`
+	Model
+	Question *Question `gorm:"foreignKey:QuestionId;references:question_id" json:"question"`
+	User     *User     `gorm:"foreignKey:UserId;references:user_id" json:"user"`
+}
+
+func (m *OrderSingle) TableName() string {
+	return "order_single"
+}
+
+func (m *OrderSingle) BeforeCreate(tx *gorm.DB) error {
+	if m.OrderId == 0 {
+		m.OrderId = global.Snowflake.Generate().Int64()
+	}
+
+	m.CreatedAt = LocalTime(time.Now())
+	tx.Statement.SetColumn("CreatedAt", m.CreatedAt)
+
+	m.UpdatedAt = LocalTime(time.Now())
+	tx.Statement.SetColumn("UpdatedAt", m.UpdatedAt)
+
+	return nil
+}

api/model/OrderSingleCoupon.go

@@ -0,0 +1,35 @@
+package model
+
+import (
+	"gorm.io/gorm"
+	"hepa-calc-admin-api/global"
+	"time"
+)
+
+// OrderSingleCoupon 订单-单项-优惠卷表
+type OrderSingleCoupon struct {
+	OrderCouponId  int64   `gorm:"column:order_coupon_id;type:bigint(19);primary_key;comment:主键id" json:"order_coupon_id"`
+	OrderId        int64   `gorm:"column:order_id;type:bigint(19);comment:单项订单id;NOT NULL" json:"order_id"`
+	UserCouponId   int64   `gorm:"column:user_coupon_id;type:bigint(19);comment:用户优惠卷表id;NOT NULL" json:"user_coupon_id"`
+	CouponName     string  `gorm:"column:coupon_name;type:varchar(255);comment:优惠卷名称" json:"coupon_name"`
+	CouponUsePrice float64 `gorm:"column:coupon_use_price;type:decimal(10,2) unsigned;default:0.00;comment:优惠卷使用金额" json:"coupon_use_price"`
+	Model
+}
+
+func (m *OrderSingleCoupon) TableName() string {
+	return "order_single_coupon"
+}
+
+func (m *OrderSingleCoupon) BeforeCreate(tx *gorm.DB) error {
+	if m.OrderCouponId == 0 {
+		m.OrderCouponId = global.Snowflake.Generate().Int64()
+	}
+
+	m.CreatedAt = LocalTime(time.Now())
+	tx.Statement.SetColumn("CreatedAt", m.CreatedAt)
+
+	m.UpdatedAt = LocalTime(time.Now())
+	tx.Statement.SetColumn("UpdatedAt", m.UpdatedAt)
+
+	return nil
+}

api/model/OrderSingleRefund.go

@@ -0,0 +1,40 @@
+package model
+
+import (
+	"gorm.io/gorm"
+	"hepa-calc-admin-api/global"
+	"time"
+)
+
+// OrderSingleRefund 订单-单项-退款表
+type OrderSingleRefund struct {
+	OrderRefundId int64     `gorm:"column:order_refund_id;type:bigint(19);primary_key;comment:主键id" json:"order_refund_id"`
+	UserId        int64     `gorm:"column:user_id;type:bigint(19);comment:用户id;NOT NULL" json:"user_id"`
+	OrderId       int64     `gorm:"column:order_id;type:bigint(19);comment:订单id;NOT NULL" json:"order_id"`
+	OrderNo       string    `gorm:"column:order_no;type:varchar(40);comment:系统订单编号" json:"order_no"`
+	RefundNo      string    `gorm:"column:refund_no;type:varchar(50);comment:系统退款编号" json:"refund_no"`
+	RefundId      string    `gorm:"column:refund_id;type:varchar(50);comment:第三方退款单号" json:"refund_id"`
+	RefundStatus  int       `gorm:"column:refund_status;type:tinyint(1);default:0;comment:订单退款状态（0:无退款 1:申请退款 2:退款中 3:退款成功 4:拒绝退款 5:退款关闭 6:退款异常 7:部分退款）" json:"refund_status"`
+	RefundTotal   float64   `gorm:"column:refund_total;type:decimal(10,2) unsigned;default:0.00;comment:退款金额" json:"refund_total"`
+	RefundReason  string    `gorm:"column:refund_reason;type:varchar(255);comment:退款原因" json:"refund_reason"`
+	SuccessTime   LocalTime `gorm:"column:success_time;type:datetime;comment:退款成功时间" json:"success_time"`
+	Model
+}
+
+func (m *OrderSingleRefund) TableName() string {
+	return "order_single_refund"
+}
+
+func (m *OrderSingleRefund) BeforeCreate(tx *gorm.DB) error {
+	if m.OrderRefundId == 0 {
+		m.OrderRefundId = global.Snowflake.Generate().Int64()
+	}
+
+	m.CreatedAt = LocalTime(time.Now())
+	tx.Statement.SetColumn("CreatedAt", m.CreatedAt)
+
+	m.UpdatedAt = LocalTime(time.Now())
+	tx.Statement.SetColumn("UpdatedAt", m.UpdatedAt)
+
+	return nil
+}

api/model/Question.go

@@ -0,0 +1,45 @@
+package model
+
+import (
+	"gorm.io/gorm"
+	"hepa-calc-admin-api/global"
+	"time"
+)
+
+// Question 问题表
+type Question struct {
+	QuestionId       int64      `gorm:"column:question_id;type:bigint(19);primary_key;comment:主键id" json:"question_id"`
+	QuestionTitle    string     `gorm:"column:question_title;type:varchar(200);comment:标题" json:"question_title"`
+	QuestionSubtitle string     `gorm:"column:question_subtitle;type:varchar(200);comment:副标题" json:"question_subtitle"`
+	QuestionIden     string     `gorm:"column:question_iden;type:varchar(255);comment:唯一标识（用于和前端对应）" json:"question_iden"`
+	QuestionStatus   int        `gorm:"column:question_status;type:tinyint(1);default:2;comment:问题状态（1:正常 2:待发布）" json:"question_status"`
+	IsHide           int        `gorm:"column:is_hide;type:tinyint(1);default:0;comment:是否隐藏（0:否 1:是）" json:"is_hide"`
+	IsRecommend      int        `gorm:"column:is_recommend;type:tinyint(1);default:0;comment:是否推荐（0:否 1:是）" json:"is_recommend"`
+	ClickCount       int        `gorm:"column:click_count;type:int(5);default:0;comment:点击次数（点击进入详情页的人次）" json:"click_count"`
+	SubmitCount      int        `gorm:"column:submit_count;type:int(5);default:0;comment:提交次数（提交个人信息进行了算算的人次）" json:"submit_count"`
+	PayCount         int        `gorm:"column:pay_count;type:int(5);default:0;comment:支付次数（查看报告的人次）" json:"pay_count"`
+	Price            float64    `gorm:"column:price;type:decimal(10,2) unsigned;default:0.00;comment:价格（原价）" json:"price"`
+	DiscountPrice    *float64   `gorm:"column:discount_price;type:decimal(10,2);comment:优惠价格" json:"discount_price"`
+	DiscountEndTime  *time.Time `gorm:"column:discount_end_time;type:datetime;comment:优惠截止时间" json:"discount_end_time"`
+	QuestionBrief    string     `gorm:"column:question_brief;type:text;comment:问题介绍" json:"question_brief"`
+	QuestionExplain  string     `gorm:"column:question_explain;type:text;comment:问题解释/科普" json:"question_explain"`
+	Model
+}
+
+func (m *Question) TableName() string {
+	return "question"
+}
+
+func (m *Question) BeforeCreate(tx *gorm.DB) error {
+	if m.QuestionId == 0 {
+		m.QuestionId = global.Snowflake.Generate().Int64()
+	}
+
+	m.CreatedAt = LocalTime(time.Now())
+	tx.Statement.SetColumn("CreatedAt", m.CreatedAt)
+
+	m.UpdatedAt = LocalTime(time.Now())
+	tx.Statement.SetColumn("UpdatedAt", m.UpdatedAt)
+
+	return nil
+}

api/model/QuestionClass.go

@@ -0,0 +1,33 @@
+package model
+
+import (
+	"gorm.io/gorm"
+	"hepa-calc-admin-api/global"
+	"time"
+)
+
+// QuestionClass 中间表-问题/分类
+type QuestionClass struct {
+	QuestionClassId int64 `gorm:"column:question_class_id;type:bigint(19);primary_key;comment:主键id" json:"question_class_id"`
+	QuestionId      int64 `gorm:"column:question_id;type:bigint(19);comment:问题id;NOT NULL" json:"question_id"`
+	ClassId         int64 `gorm:"column:class_id;type:bigint(19);comment:分类id;NOT NULL" json:"class_id"`
+	Model
+}
+
+func (m *QuestionClass) TableName() string {
+	return "question_class"
+}
+
+func (m *QuestionClass) BeforeCreate(tx *gorm.DB) error {
+	if m.QuestionClassId == 0 {
+		m.QuestionClassId = global.Snowflake.Generate().Int64()
+	}
+
+	m.CreatedAt = LocalTime(time.Now())
+	tx.Statement.SetColumn("CreatedAt", m.CreatedAt)
+
+	m.UpdatedAt = LocalTime(time.Now())
+	tx.Statement.SetColumn("UpdatedAt", m.UpdatedAt)
+
+	return nil
+}

api/model/SystemMember.go

@@ -0,0 +1,35 @@
+package model
+
+import (
+	"gorm.io/gorm"
+	"hepa-calc-admin-api/global"
+	"time"
+)
+
+// SystemMember 配置-会员配置
+type SystemMember struct {
+	SystemMemberId  int64      `gorm:"column:system_member_id;type:bigint(19);primary_key;comment:主键id" json:"system_member_id"`
+	MemberDays      uint       `gorm:"column:member_days;type:int(10) unsigned;default:0;comment:会员天数" json:"member_days"`
+	Price           float64    `gorm:"column:price;type:decimal(10,2);default:0.00;comment:价格（原价）" json:"price"`
+	DiscountPrice   *float64   `gorm:"column:discount_price;type:decimal(10,2);comment:优惠价格" json:"discount_price"`
+	DiscountEndTime *time.Time `gorm:"column:discount_end_time;type:datetime;comment:优惠截止时间" json:"discount_end_time"`
+	Model
+}
+
+func (m *SystemMember) TableName() string {
+	return "system_member"
+}
+
+func (m *SystemMember) BeforeCreate(tx *gorm.DB) error {
+	if m.SystemMemberId == 0 {
+		m.SystemMemberId = global.Snowflake.Generate().Int64()
+	}
+
+	m.CreatedAt = LocalTime(time.Now())
+	tx.Statement.SetColumn("CreatedAt", m.CreatedAt)
+
+	m.UpdatedAt = LocalTime(time.Now())
+	tx.Statement.SetColumn("UpdatedAt", m.UpdatedAt)
+
+	return nil
+}

api/model/SystemSingle.go

@@ -0,0 +1,33 @@
+package model
+
+import (
+	"gorm.io/gorm"
+	"hepa-calc-admin-api/global"
+	"time"
+)
+
+// SystemSingle 配置-单项配置
+type SystemSingle struct {
+	SystemSingleId int64   `gorm:"column:system_single_id;type:bigint(19);primary_key;comment:主键id" json:"system_single_id"`
+	FirstTimePrice float64 `gorm:"column:first_time_price;type:decimal(10,2);default:0.00;comment:首次购买价格" json:"first_time_price"`
+	ValidDays      int     `gorm:"column:valid_days;type:int(5);default:1;comment:购买后有效天数" json:"valid_days"`
+	Model
+}
+
+func (m *SystemSingle) TableName() string {
+	return "system_single"
+}
+
+func (m *SystemSingle) BeforeCreate(tx *gorm.DB) error {
+	if m.SystemSingleId == 0 {
+		m.SystemSingleId = global.Snowflake.Generate().Int64()
+	}
+
+	m.CreatedAt = LocalTime(time.Now())
+	tx.Statement.SetColumn("CreatedAt", m.CreatedAt)
+
+	m.UpdatedAt = LocalTime(time.Now())
+	tx.Statement.SetColumn("UpdatedAt", m.UpdatedAt)
+
+	return nil
+}

api/model/User.go

@@ -0,0 +1,48 @@
+package model
+
+import (
+	"gorm.io/gorm"
+	"hepa-calc-admin-api/global"
+	"time"
+)
+
+// User 用户表
+type User struct {
+	UserId            int64      `gorm:"column:user_id;type:bigint(19);primary_key;comment:用户id" json:"user_id"`
+	UserName          string     `gorm:"column:user_name;type:varchar(200);comment:用户名称" json:"user_name"`
+	Mobile            string     `gorm:"column:mobile;type:varchar(20);comment:手机号;NOT NULL" json:"mobile"`
+	UserStatus        int        `gorm:"column:user_status;type:tinyint(1);default:1;comment:状态（1:正常 2:禁用）" json:"user_status"`
+	RegisterSource    int        `gorm:"column:register_source;type:tinyint(1);default:1;comment:注册来源（1：app注册 2：公众号注册）" json:"register_source"`
+	OpenId            string     `gorm:"column:open_id;type:varchar(100);comment:用户微信标识" json:"open_id"`
+	UnionId           string     `gorm:"column:union_id;type:varchar(100);comment:微信开放平台标识" json:"union_id"`
+	Age               *uint      `gorm:"column:age;type:int(10) unsigned;comment:年龄" json:"age"`
+	Sex               int        `gorm:"column:sex;type:tinyint(1) unsigned;default:0;comment:性别（0:未知 1:男 2:女）" json:"sex"`
+	Avatar            string     `gorm:"column:avatar;type:varchar(255);comment:头像" json:"avatar"`
+	IsMember          int        `gorm:"column:is_member;type:tinyint(1);default:0;comment:是否会员（0:否 1:是）" json:"is_member"`
+	MemberExpireDate  *time.Time `gorm:"column:member_expire_date;type:datetime;comment:会员到期时间（非会员时为null）" json:"member_expire_date"`
+	SingleSubmitCount int        `gorm:"column:single_submit_count;type:int(5);default:0;comment:单项提交次数（提交个人信息进行了算算的人次）" json:"single_submit_count"`
+	SinglePayCount    int        `gorm:"column:single_pay_count;type:int(5);default:0;comment:单项支付次数（查看报告的人次）" json:"single_pay_count"`
+	MemberBuyCount    int        `gorm:"column:member_buy_count;type:int(5);default:0;comment:会员购买次数" json:"member_buy_count"`
+	LoginAt           LocalTime  `gorm:"column:login_at;type:datetime;comment:登陆时间" json:"login_at"`
+	LoginIp           string     `gorm:"column:login_ip;type:varchar(255);comment:登陆ip" json:"login_ip"`
+	Model
+	UserInfo *UserInfo `gorm:"foreignKey:UserId;references:user_id" json:"user_info"`
+}
+
+func (m *User) TableName() string {
+	return "user"
+}
+
+func (m *User) BeforeCreate(tx *gorm.DB) error {
+	if m.UserId == 0 {
+		m.UserId = global.Snowflake.Generate().Int64()
+	}
+
+	m.CreatedAt = LocalTime(time.Now())
+	tx.Statement.SetColumn("CreatedAt", m.CreatedAt)
+
+	m.UpdatedAt = LocalTime(time.Now())
+	tx.Statement.SetColumn("UpdatedAt", m.UpdatedAt)
+
+	return nil
+}

api/model/UserCollection.go

@@ -0,0 +1,34 @@
+package model
+
+import (
+	"gorm.io/gorm"
+	"hepa-calc-admin-api/global"
+	"time"
+)
+
+// UserCollection 用户收藏表
+type UserCollection struct {
+	CollectionId int64 `gorm:"column:collection_id;type:bigint(19);primary_key;comment:主键id" json:"collection_id"`
+	UserId       int64 `gorm:"column:user_id;type:bigint(19);comment:用户id" json:"user_id"`
+	QuestionId   int64 `gorm:"column:question_id;type:bigint(19);comment:问题id" json:"question_id"`
+	Model
+	Question *Question `gorm:"foreignKey:QuestionId;references:question_id" json:"question"`
+}
+
+func (m *UserCollection) TableName() string {
+	return "user_collection"
+}
+
+func (m *UserCollection) BeforeCreate(tx *gorm.DB) error {
+	if m.CollectionId == 0 {
+		m.CollectionId = global.Snowflake.Generate().Int64()
+	}
+
+	m.CreatedAt = LocalTime(time.Now())
+	tx.Statement.SetColumn("CreatedAt", m.CreatedAt)
+
+	m.UpdatedAt = LocalTime(time.Now())
+	tx.Statement.SetColumn("UpdatedAt", m.UpdatedAt)
+
+	return nil
+}

api/model/UserCoupon.go

@@ -0,0 +1,38 @@
+package model
+
+import (
+	"gorm.io/gorm"
+	"hepa-calc-admin-api/global"
+	"time"
+)
+
+type UserCoupon struct {
+	UserCouponId     int64     `gorm:"column:user_coupon_id;type:bigint(19);primary_key;comment:主键id" json:"user_coupon_id"`
+	UserId           int64     `gorm:"column:user_id;type:bigint(19);comment:用户id;NOT NULL" json:"user_id"`
+	CouponId         int64     `gorm:"column:coupon_id;type:bigint(19);comment:优惠卷id;NOT NULL" json:"coupon_id"`
+	UserCouponStatus int       `gorm:"column:user_coupon_status;type:tinyint(1);default:0;comment:状态（0:未使用 1:已使用 3:已过期）" json:"user_coupon_status"`
+	IsWindows        int       `gorm:"column:is_windows;type:tinyint(1);default:0;comment:是否已弹窗（0:否 1:是）" json:"is_windows"`
+	CouponUseDate    LocalTime `gorm:"column:coupon_use_date;type:datetime;comment:使用时间" json:"coupon_use_date"`
+	ValidStartTime   LocalTime `gorm:"column:valid_start_time;type:datetime;comment:有效使用时间" json:"valid_start_time"`
+	ValidEndTime     LocalTime `gorm:"column:valid_end_time;type:datetime;comment:过期使用时间" json:"valid_end_time"`
+	Model
+	Coupon *Coupon `gorm:"foreignKey:CouponId;references:coupon_id" json:"coupon"`
+}
+
+func (m *UserCoupon) TableName() string {
+	return "user_coupon"
+}
+
+func (m *UserCoupon) BeforeCreate(tx *gorm.DB) error {
+	if m.UserCouponId == 0 {
+		m.UserCouponId = global.Snowflake.Generate().Int64()
+	}
+
+	m.CreatedAt = LocalTime(time.Now())
+	tx.Statement.SetColumn("CreatedAt", m.CreatedAt)
+
+	m.UpdatedAt = LocalTime(time.Now())
+	tx.Statement.SetColumn("UpdatedAt", m.UpdatedAt)
+
+	return nil
+}

api/model/UserInfo.go

@@ -0,0 +1,43 @@
+package model
+
+import (
+	"gorm.io/gorm"
+	"hepa-calc-admin-api/global"
+	"time"
+)
+
+// UserInfo 用户表-基础信息
+type UserInfo struct {
+	UserInfoId      int64  `gorm:"column:user_info_id;type:bigint(19);primary_key;comment:主键id" json:"user_info_id"`
+	UserId          int64  `gorm:"column:user_id;type:bigint(19);comment:用户id" json:"user_id"`
+	Height          string `gorm:"column:height;type:varchar(20);comment:身高（cm）" json:"height"`
+	Weight          string `gorm:"column:weight;type:varchar(20);comment:体重（kg）" json:"weight"`
+	NationId        int64  `gorm:"column:nation_id;type:bigint(19);comment:民族id" json:"nation_id"`
+	FamilyHistoryId int64  `gorm:"column:family_history_id;type:bigint(19);comment:家族病史id" json:"family_history_id"`
+	ProvinceId      int    `gorm:"column:province_id;type:int(11);comment:省份id" json:"province_id"`
+	Province        string `gorm:"column:province;type:varchar(40);comment:省份" json:"province"`
+	CityId          int    `gorm:"column:city_id;type:int(11);comment:城市id" json:"city_id"`
+	City            string `gorm:"column:city;type:varchar(50);comment:城市" json:"city"`
+	CountyId        int    `gorm:"column:county_id;type:int(11);comment:区县id" json:"county_id"`
+	County          string `gorm:"column:county;type:varchar(255);comment:区县" json:"county"`
+	DiseaseClassId  int64  `gorm:"column:disease_class_id;type:bigint(19);comment:疾病分类id" json:"disease_class_id"`
+	Model
+}
+
+func (m *UserInfo) TableName() string {
+	return "user_info"
+}
+
+func (m *UserInfo) BeforeCreate(tx *gorm.DB) error {
+	if m.UserInfoId == 0 {
+		m.UserInfoId = global.Snowflake.Generate().Int64()
+	}
+
+	m.CreatedAt = LocalTime(time.Now())
+	tx.Statement.SetColumn("CreatedAt", m.CreatedAt)
+
+	m.UpdatedAt = LocalTime(time.Now())
+	tx.Statement.SetColumn("UpdatedAt", m.UpdatedAt)
+
+	return nil
+}

api/model/model.go

@@ -0,0 +1,87 @@
+package model
+
+import (
+	"database/sql/driver"
+	"errors"
+	"fmt"
+	"gorm.io/gorm"
+	"strings"
+	"time"
+)
+
+type Model struct {
+	CreatedAt LocalTime `gorm:"column:created_at;type:datetime;comment:创建时间" json:"created_at"`
+	UpdatedAt LocalTime `gorm:"column:updated_at;type:datetime;comment:修改时间" json:"updated_at"`
+}
+
+// LocalTime 自定义数据类型
+type LocalTime time.Time
+
+func (t *LocalTime) UnmarshalJSON(data []byte) error {
+	if string(data) == "null" {
+		return nil
+	}
+	var err error
+	// 前端接收的时间字符串
+	str := string(data)
+	// 去除接收的str收尾多余的"
+	timeStr := strings.Trim(str, "\"")
+	t1, err := time.Parse("2006-01-02 15:04:05", timeStr)
+	*t = LocalTime(t1)
+	return err
+}
+
+func (t LocalTime) MarshalJSON() ([]byte, error) {
+	formatted := fmt.Sprintf("\"%v\"", time.Time(t).Format("2006-01-02 15:04:05"))
+	return []byte(formatted), nil
+}
+
+func (t LocalTime) Value() (driver.Value, error) {
+	// MyTime 转换成 time.Time 类型
+	tTime := time.Time(t)
+	return tTime.Format("2006-01-02 15:04:05"), nil
+}
+
+func (t *LocalTime) Scan(v interface{}) error {
+	switch vt := v.(type) {
+	case time.Time:
+		// 字符串转成 time.Time 类型
+		*t = LocalTime(vt)
+	default:
+		return errors.New("类型处理错误")
+	}
+	return nil
+}
+
+func (t *LocalTime) String() string {
+	return fmt.Sprintf("hhh:%s", time.Time(*t).String())
+}
+
+func (t *LocalTime) IsEmpty() bool {
+	return time.Time(*t).IsZero()
+}
+
+func (m *Model) BeforeUpdate(tx *gorm.DB) (err error) {
+	m.UpdatedAt = LocalTime(time.Now())
+	tx.Statement.SetColumn("UpdatedAt", m.UpdatedAt)
+
+	return nil
+}
+
+func Paginate(page, pageSize int) func(db *gorm.DB) *gorm.DB {
+	return func(db *gorm.DB) *gorm.DB {
+		if page <= 0 {
+			page = 1
+		}
+
+		switch {
+		case pageSize > 100:
+			pageSize = 100
+		case pageSize <= 0:
+			pageSize = 10
+		}
+
+		offset := (page - 1) * pageSize
+		return db.Offset(offset).Limit(pageSize)
+	}
+}

api/requests/BaseAgreement.go

@@ -0,0 +1,25 @@
+package requests
+
+type BaseAgreementRequest struct {
+	GetBaseAgreementPage // 获取协议列表-分页
+	PutBaseAgreement     // 修改协议
+	AddBaseAgreement     // 新增协议
+}
+
+// GetBaseAgreementPage 获取协议列表-分页
+type GetBaseAgreementPage struct {
+	Page     int `json:"page" form:"page" label:"页码"`
+	PageSize int `json:"page_size" form:"page_size" label:"每页个数"`
+}
+
+// PutBaseAgreement 修改协议
+type PutBaseAgreement struct {
+	AgreementTitle   string `json:"agreement_title" form:"agreement_title" label:"协议标题"`
+	AgreementContent string `json:"agreement_content" form:"agreement_content" label:"协议内容"`
+}
+
+// AddBaseAgreement 新增协议
+type AddBaseAgreement struct {
+	AgreementTitle   string `json:"agreement_title" form:"agreement_title" label:"协议标题"`
+	AgreementContent string `json:"agreement_content" form:"agreement_content" label:"协议内容"`
+}

api/requests/BaseClass.go

@@ -0,0 +1,56 @@
+package requests
+
+type BaseClassRequest struct {
+	GetBaseClassPage   // 获取基础分类列表-分页
+	GetBaseClassList   // 获取基础分类列表
+	PutBaseClassStatus // 操作基础分类状态
+	PutBaseClass       // 修改基础分类
+	AddBaseClass       // 新增基础分类
+}
+
+// GetBaseClassPage 获取基础分类列表-分页
+type GetBaseClassPage struct {
+	Page        int                    `json:"page" form:"page" label:"页码"`
+	PageSize    int                    `json:"page_size" form:"page_size" label:"每页个数"`
+	ClassName   string                 `json:"class_name" form:"class_name" label:"分类名称"`
+	ClassStatus *int                   `json:"class_status" form:"class_status" label:"分类状态"` // （1:正常 2:隐藏）
+	Order       *GetBaseClassPageOrder `json:"order"   form:"order" label:"排序"`
+}
+
+// GetBaseClassPageOrder 获取基础分类列表-分页-排序条件
+type GetBaseClassPageOrder struct {
+	Sort string `json:"sort" form:"sort" label:"排序"` // 排序值
+}
+
+// GetBaseClassList 获取基础分类列表
+type GetBaseClassList struct {
+	ClassName   string                 `json:"class_name" form:"class_name" label:"分类名称"`
+	ClassStatus *int                   `json:"class_status" form:"class_status" label:"分类状态"` // （1:正常 2:隐藏）
+	Order       *GetBaseClassListOrder `json:"order"   form:"order" label:"排序"`
+}
+
+// GetBaseClassListOrder 获取基础分类列表-排序条件
+type GetBaseClassListOrder struct {
+	Sort string `json:"sort" form:"sort" label:"排序"` // 排序值
+}
+
+// PutBaseClassStatus 操作基础分类状态
+type PutBaseClassStatus struct {
+	ClassStatus int `json:"class_status" form:"class_status" label:"分类状态"  validate:"required,oneof=1 2"` // （1:正常 2:隐藏）
+}
+
+// PutBaseClass 修改基础分类
+type PutBaseClass struct {
+	ClassName  string `json:"class_name" form:"class_name" label:"分类名称" validate:"required"`
+	ClassIcon  string `json:"class_icon" form:"class_icon" label:"图标地址" validate:"required"`
+	ClassBrief string `json:"class_brief" form:"class_brief" label:"分类简介" validate:"required"`
+	Sort       uint   `json:"sort" form:"sort" label:"排序值" validate:"required,number,min=1"`
+}
+
+// AddBaseClass 新增基础分类
+type AddBaseClass struct {
+	ClassName  string `json:"class_name" form:"class_name" label:"分类名称" validate:"required"`
+	ClassIcon  string `json:"class_icon" form:"class_icon" label:"图标地址" validate:"required"`
+	ClassBrief string `json:"class_brief" form:"class_brief" label:"分类简介" validate:"required"`
+	Sort       uint   `json:"sort" form:"sort" label:"排序值" validate:"required,number,min=1"`
+}

api/requests/Coupon.go

@@ -0,0 +1,43 @@
+package requests
+
+type CouponRequest struct {
+	GetCouponPage   // 获取系统优惠卷列表-分页
+	PutCouponStatus // 修改系统优惠卷状态
+	AddSystemCoupon // 新增系统优惠卷
+}
+
+// GetCouponPage 获取系统优惠卷列表-分页
+type GetCouponPage struct {
+	Page             int    `json:"page" form:"page" label:"页码"`
+	PageSize         int    `json:"page_size" form:"page_size" label:"每页个数"`
+	CouponName       string `json:"coupon_name" form:"coupon_name" label:"优惠券名称"`
+	CouponType       *int   `json:"coupon_type" form:"coupon_type" label:"优惠券类型"`            // （1:无门槛 2:满减）
+	CouponStatus     *int   `json:"coupon_status" form:"coupon_status" label:"状态"`           // （1:正常 2:强制失效 3:结束 4:删除）
+	ApplicationScope *int   `json:"application_scope" form:"application_scope" label:"适用范围"` // 适用范围（1:全场通用 2:单项 3:会员）
+	IsMutex          *int   `json:"is_mutex" form:"is_mutex" label:"是否互斥"`                   // （0:否 1:是）
+	ValidType        *int   `json:"valid_type" form:"valid_type" label:"有效类型"`               //  （1:绝对时效，xxx-xxx时间段有效 2:相对时效 n天内有效）
+	CouponDesc       string `json:"coupon_desc" form:"coupon_desc" label:"优惠券描述"`
+}
+
+// PutCouponStatus 修改系统优惠卷状态
+type PutCouponStatus struct {
+	CouponStatus int `json:"coupon_status" form:"coupon_status" label:"状态"  validate:"required,oneof=2 3 4"` // （1:正常 2:强制失效 3:结束 4:删除）
+}
+
+// AddSystemCoupon 新增系统优惠卷
+type AddSystemCoupon struct {
+	CouponName       string   `json:"coupon_name" form:"coupon_name" label:"优惠券名称" validate:"required"`
+	CouponType       int      `json:"coupon_type" form:"coupon_type" label:"优惠券类型" validate:"required,oneof=1 2"`              // （1:无门槛 2:满减）
+	ApplicationScope int      `json:"application_scope" form:"application_scope" label:"适用范围" validate:"required,oneof=1 2 3"` // 适用范围（1:全场通用 2:单项 3:会员）
+	IsMutex          int      `json:"is_mutex" form:"is_mutex" label:"是否互斥" validate:"required,oneof=0 1"`                     // （0:否 1:是）
+	CouponCount      int      `json:"coupon_count" form:"coupon_count" label:"发放数量" validate:"required,number,min=1"`
+	CouponPrice      float64  `json:"coupon_price" form:"coupon_price" label:"优惠券金额" validate:"required,numeric,gt=0"`
+	WithAmount       *float64 `json:"with_amount" form:"with_amount" label:"满减条件金额" validate:"omitempty,gt=1"`
+	ValidType        int      `json:"valid_type" form:"valid_type" label:"有效类型" validate:"required,oneof=1 2"` // （1:绝对时效，xxx-xxx时间段有效 2:相对时效 n天内有效）
+	ValidDays        *int     `json:"valid_days" form:"valid_days" label:"有效天数" validate:"omitempty,numeric,min=1"`
+	ValidStartTime   *string  `json:"valid_start_time" form:"valid_start_time" label:"开始使用时间"` // 假设转换为字符串格式
+	ValidEndTime     *string  `json:"valid_end_time" form:"valid_end_time" label:"结束使用时间"`     // 假设转换为字符串格式
+	QuestionId       *string  `json:"question_id" form:"question_id" label:"问题id"`             // 从int64转换为string
+	SystemMemberId   *string  `json:"system_member_id" form:"system_member_id" label:"会员id"`   // 从int64转换为string
+	CouponDesc       string   `json:"coupon_desc" form:"coupon_desc" label:"优惠券描述"`
+}

api/requests/OrderMember.go

@@ -0,0 +1,28 @@
+package requests
+
+type OrderMemberRequest struct {
+	GetOrderMemberPage         // 获取会员订单列表-分页
+	PutOrderMemberDeleteStatus // 操作会员订单删除状态
+}
+
+// GetOrderMemberPage 获取会员订单列表-分页
+type GetOrderMemberPage struct {
+	Page           int    `json:"page" form:"page" label:"页码"`
+	PageSize       int    `json:"page_size" form:"page_size" label:"每页个数"`
+	UserId         int64  `json:"user_id" form:"user_id" label:"用户id"`
+	SystemMemberId string `json:"system_member_id" form:"system_member_id" label:"会员id"`
+	OrderStatus    *int   `json:"order_status" form:"order_status" label:"订单状态"` // 订单状态（1:待支付 2:已完成 3:已取消）
+	PayChannel     *int   `json:"pay_channel" form:"pay_channel" label:"支付渠道"`   // 支付渠道（1:h5支付 2:app支付 3:会员支付）
+	PayStatus      *int   `json:"pay_status" form:"pay_status" label:"支付状态"`     // 支付状态（1:未支付 2:已支付 3:支付中 4:支付失败 5:支付超时 6:支付关闭 7:已撤销 8:转入退款）
+	RefundStatus   *int   `json:"refund_status" form:"refund_status" label:"订单退款状态"`
+	OrderNo        string `json:"order_no" form:"order_no" label:"系统订单编号"`
+	EscrowTradeNo  string `json:"escrow_trade_no" form:"escrow_trade_no" label:"第三方支付流水号"`
+	CancelStatus   *int   `json:"cancel_status" form:"cancel_status" label:"取消状态"`
+	MemberDays     *int   `json:"member_days" form:"member_days" label:"会员天数"`
+	UserName       string `json:"user_name" form:"user_name" label:"用户名称"`
+}
+
+// PutOrderMemberDeleteStatus 操作会员订单删除状态
+type PutOrderMemberDeleteStatus struct {
+	IsDelete int `json:"is_delete" form:"is_delete" label:"删除状态"` // 用户删除状态（0:否 1:是）
+}

api/requests/OrderSingle.go

@@ -0,0 +1,28 @@
+package requests
+
+type OrderSingleRequest struct {
+	GetOrderSinglePage         // 获取单项订单列表-分页
+	PutOrderSingleDeleteStatus // 操作单项订单删除状态
+}
+
+// GetOrderSinglePage 获取单项订单列表-分页
+type GetOrderSinglePage struct {
+	Page          int    `json:"page" form:"page" label:"页码"`
+	PageSize      int    `json:"page_size" form:"page_size" label:"每页个数"`
+	UserId        int64  `json:"user_id" form:"user_id" label:"用户id"`
+	QuestionId    string `json:"question_id" form:"question_id" label:"问题id"`
+	OrderStatus   *int   `json:"order_status" form:"order_status" label:"订单状态"`
+	PayChannel    *int   `json:"pay_channel" form:"pay_channel" label:"支付渠道"`
+	PayStatus     *int   `json:"pay_status" form:"pay_status" label:"支付状态"`
+	RefundStatus  *int   `json:"refund_status" form:"refund_status" label:"订单退款状态"`
+	OrderNo       string `json:"order_no" form:"order_no" label:"系统订单编号"`
+	EscrowTradeNo string `json:"escrow_trade_no" form:"escrow_trade_no" label:"第三方支付流水号"`
+	CancelStatus  *int   `json:"cancel_status" form:"cancel_status" label:"取消状态"`
+	UserName      string `json:"user_name" form:"user_name" label:"用户名称"`
+	QuestionTitle string `json:"question_title" form:"question_title" label:"问题标题"`
+}
+
+// PutOrderSingleDeleteStatus 操作单项订单删除状态
+type PutOrderSingleDeleteStatus struct {
+	IsDelete int `json:"is_delete" form:"is_delete" label:"删除状态"` // 用户删除状态（0:否 1:是）
+}

api/requests/Public.go

@@ -0,0 +1,21 @@
+package requests
+
+type PublicRequest struct {
+	Login        // 登陆
+	GetIndexData // 首页动态统计数据
+}
+
+// Login 登陆
+type Login struct {
+	Access    string `json:"access" form:"access" validate:"required" label:"用户名"`     // 用户名
+	Password  string `json:"password" form:"password" validate:"required"  label:"密码"` // 密码
+	Captcha   string `json:"captcha" form:"captcha" validate:"required"  label:"验证码"`  // 验证码
+	CaptchaId string `json:"captchaId" form:"captchaId" validate:"required"`           // 验证码ID
+}
+
+// GetIndexData 首页动态统计数据
+type GetIndexData struct {
+	Type      int    `json:"type" form:"type" validate:"required,oneof=1 2 3 4" label:"分类"` // 分类（1:新增用户数 2:新增算算数 3:新增单项支付数 4:新增会员购买数）
+	StartTime string `json:"start_time" form:"start_time" validate:"required" label:"开始时间"`
+	EndTime   string `json:"end_time" form:"end_time" validate:"required" label:"结束时间"`
+}

api/requests/Question.go

@@ -0,0 +1,112 @@
+package requests
+
+type QuestionRequest struct {
+	GetQuestionPage       // 获取问题列表-分页
+	GetQuestionList       // 获取问题列表
+	PutQuestion           // 修改问题
+	AddQuestion           // 新增问题
+	PutQuestionStatus     // 操作问题发布状态
+	PutQuestionHideStatus // 操作问题隐藏状态
+}
+
+// GetQuestionPage 获取问题列表-分页
+type GetQuestionPage struct {
+	Page             int                   `json:"page" form:"page" label:"页码"`
+	PageSize         int                   `json:"page_size" form:"page_size" label:"每页个数"`
+	QuestionId       string                `json:"question_id" form:"question_id" label:"主键id"`
+	QuestionTitle    string                `json:"question_title" form:"question_title" label:"标题"`
+	QuestionSubtitle string                `json:"question_subtitle" form:"question_subtitle" label:"副标题"`
+	QuestionIden     string                `json:"question_iden" form:"question_iden" label:"唯一标识"`
+	QuestionStatus   *int                  `json:"question_status" form:"question_status" label:"问题状态"` // 问题状态（1:正常 2:待发布）
+	IsHide           *int                  `json:"is_hide" form:"is_hide" label:"是否隐藏"`                 // 是否隐藏（0:否 1:是）
+	IsRecommend      *int                  `json:"is_recommend" form:"is_recommend" label:"是否推荐"`       // 是否推荐（0:否 1:是）
+	QuestionBrief    string                `json:"question_brief" form:"question_brief" label:"问题介绍"`
+	QuestionExplain  string                `json:"question_explain" form:"question_explain" label:"问题解释/科普"`
+	ClassId          string                `json:"class_id" form:"class_id" label:"分类标识"`
+	Order            *GetQuestionPageOrder `json:"order"   form:"order" label:"排序"`
+}
+
+// GetQuestionPageOrder 获取问答题库列表-分页-排序条件
+type GetQuestionPageOrder struct {
+	ClickCount    string `json:"click_count" form:"click_count" label:"排序"`       // 点击次数（点击进入详情页的人次）
+	SubmitCount   string `json:"submit_count" form:"submit_count" label:"排序"`     // 提交次数（提交个人信息进行了算算的人次）
+	PayCount      string `json:"pay_count" form:"pay_count" label:"排序"`           // 支付次数（查看报告的人次）
+	Price         string `json:"price" form:"price" label:"排序"`                   // 价格（原价）
+	DiscountPrice string `json:"discount_price" form:"discount_price" label:"排序"` // 优惠价格
+	UpdatedAt     string `json:"updated_at" form:"updated_at" label:"排序"`
+}
+
+// GetQuestionList 获取问题列表
+type GetQuestionList struct {
+	Page             int                   `json:"page" form:"page" label:"页码"`
+	PageSize         int                   `json:"page_size" form:"page_size" label:"每页个数"`
+	QuestionId       string                `json:"question_id" form:"question_id" label:"主键id"`
+	QuestionTitle    string                `json:"question_title" form:"question_title" label:"标题"`
+	QuestionSubtitle string                `json:"question_subtitle" form:"question_subtitle" label:"副标题"`
+	QuestionIden     string                `json:"question_iden" form:"question_iden" label:"唯一标识"`
+	QuestionStatus   *int                  `json:"question_status" form:"question_status" label:"问题状态"` // 问题状态（1:正常 2:待发布）
+	IsHide           *int                  `json:"is_hide" form:"is_hide" label:"是否隐藏"`                 // 是否隐藏（0:否 1:是）
+	IsRecommend      *int                  `json:"is_recommend" form:"is_recommend" label:"是否推荐"`       // 是否推荐（0:否 1:是）
+	QuestionBrief    string                `json:"question_brief" form:"question_brief" label:"问题介绍"`
+	QuestionExplain  string                `json:"question_explain" form:"question_explain" label:"问题解释/科普"`
+	ClassId          string                `json:"class_id" form:"class_id" label:"分类标识"`
+	Order            *GetQuestionPageOrder `json:"order"   form:"order" label:"排序"`
+}
+
+// GetQuestionListOrder 获取问题列表-排序条件
+type GetQuestionListOrder struct {
+	ClickCount    string `json:"click_count" form:"click_count" label:"排序"`       // 点击次数（点击进入详情页的人次）
+	SubmitCount   string `json:"submit_count" form:"submit_count" label:"排序"`     // 提交次数（提交个人信息进行了算算的人次）
+	PayCount      string `json:"pay_count" form:"pay_count" label:"排序"`           // 支付次数（查看报告的人次）
+	Price         string `json:"price" form:"price" label:"排序"`                   // 价格（原价）
+	DiscountPrice string `json:"discount_price" form:"discount_price" label:"排序"` // 优惠价格
+	UpdatedAt     string `json:"updated_at" form:"updated_at" label:"排序"`
+}
+
+// PutQuestion 修改问题
+type PutQuestion struct {
+	QuestionTitle    string    `json:"question_title" form:"question_title" label:"标题"  validate:"required"`
+	QuestionSubtitle string    `json:"question_subtitle" form:"question_subtitle" label:"副标题" validate:"required"`
+	QuestionIden     string    `json:"question_iden" form:"question_iden" label:"唯一标识" validate:"required"`
+	QuestionStatus   int       `json:"question_status" form:"question_status" label:"问题状态"  validate:"required,oneof=1 2"`   // 问题状态（1:正常 2:待发布）
+	IsHide           *int      `json:"is_hide" form:"is_hide" label:"是否隐藏" validate:"required,oneof=0 1"`                    // 是否隐藏（0:否 1:是）
+	IsRecommend      *int      `json:"is_recommend" form:"is_recommend" label:"是否推荐" validate:"required,oneof=0 1"`          // 是否推荐（0:否 1:是）
+	ClickCount       *int      `json:"click_count" form:"click_count" label:"点击次数" validate:"required,numeric,min=0"`        // 点击次数（点击进入详情页的人次）
+	SubmitCount      *int      `json:"submit_count" form:"submit_count" label:"提交次数" validate:"required,numeric,min=0"`      // 提交次数（提交个人信息进行了算算的人次）
+	PayCount         *int      `json:"pay_count" form:"pay_count" label:"支付次数" validate:"required,numeric,min=0"`            // 支付次数（查看报告的人次）
+	Price            *float64  `json:"price" form:"price" label:"价格" validate:"required,numeric,min=0"`                      // （原价）
+	DiscountPrice    *float64  `json:"discount_price" form:"discount_price" label:"优惠价格" validate:"omitempty,numeric,min=0"` // 优惠价格
+	DiscountEndTime  *string   `json:"discount_end_time" form:"discount_end_time" label:"优惠截止时间"`                            // 优惠截止时间
+	QuestionBrief    string    `json:"question_brief" form:"question_brief" label:"问题介绍" validate:"required"`
+	QuestionExplain  string    `json:"question_explain" form:"question_explain" label:"问题解释/科普" validate:"required"`
+	ClassId          []*string `json:"class_id" form:"class_id" label:"分类" validate:"required"` // 分类标识
+}
+
+// AddQuestion 新增问题
+type AddQuestion struct {
+	QuestionTitle    string    `json:"question_title" form:"question_title" label:"标题"  validate:"required"`
+	QuestionSubtitle string    `json:"question_subtitle" form:"question_subtitle" label:"副标题" validate:"required"`
+	QuestionIden     string    `json:"question_iden" form:"question_iden" label:"唯一标识" validate:"required"`
+	QuestionStatus   int       `json:"question_status" form:"question_status" label:"问题状态"  validate:"required,oneof=1 2"`   // 问题状态（1:正常 2:待发布）
+	IsHide           *int      `json:"is_hide" form:"is_hide" label:"是否隐藏" validate:"required,oneof=0 1"`                    // 是否隐藏（0:否 1:是）
+	IsRecommend      *int      `json:"is_recommend" form:"is_recommend" label:"是否推荐" validate:"required,oneof=0 1"`          // 是否推荐（0:否 1:是）
+	ClickCount       *int      `json:"click_count" form:"click_count" label:"点击次数" validate:"required,numeric,min=0"`        // 点击次数（点击进入详情页的人次）
+	SubmitCount      *int      `json:"submit_count" form:"submit_count" label:"提交次数" validate:"required,numeric,min=0"`      // 提交次数（提交个人信息进行了算算的人次）
+	PayCount         *int      `json:"pay_count" form:"pay_count" label:"支付次数" validate:"required,numeric,min=0"`            // 支付次数（查看报告的人次）
+	Price            *float64  `json:"price" form:"price" label:"价格" validate:"required,numeric,min=0"`                      // （原价）
+	DiscountPrice    *float64  `json:"discount_price" form:"discount_price" label:"优惠价格" validate:"omitempty,numeric,min=0"` // 优惠价格
+	DiscountEndTime  *string   `json:"discount_end_time" form:"discount_end_time" label:"优惠截止时间"`                            // 优惠截止时间
+	QuestionBrief    string    `json:"question_brief" form:"question_brief" label:"问题介绍" validate:"required"`
+	QuestionExplain  string    `json:"question_explain" form:"question_explain" label:"问题解释/科普" validate:"required"`
+	ClassId          []*string `json:"class_id" form:"class_id" label:"分类" validate:"required"` // 分类标识
+}
+
+// PutQuestionStatus 操作问题发布状态
+type PutQuestionStatus struct {
+	QuestionStatus int `json:"question_status" form:"question_status" label:"状态"  validate:"required,oneof=1 2"` // 问题状态（1:正常 2:待发布）
+}
+
+// PutQuestionHideStatus 操作问题隐藏状态
+type PutQuestionHideStatus struct {
+	IsHide int `json:"is_hide" form:"is_hide" label:"状态"  validate:"required,oneof=0 1"` // 是否隐藏（0:否 1:是）
+}

api/requests/SystemMember.go

@@ -0,0 +1,22 @@
+package requests
+
+type SystemMemberRequest struct {
+	PutSystemMember // 修改会员配置
+	AddSystemMember // 新增会员配置
+}
+
+// PutSystemMember 修改会员配置
+type PutSystemMember struct {
+	MemberDays      uint     `json:"member_days" form:"member_days" label:"会员天数" validate:"required,numeric,min=0"`
+	Price           float64  `json:"price" form:"price" label:"价格（原价）" validate:"required,numeric,min=0"`
+	DiscountPrice   *float64 `json:"discount_price" form:"discount_price" label:"优惠价格" validate:"omitempty,numeric,min=0"`
+	DiscountEndTime *string  `json:"discount_end_time" form:"discount_end_time" label:"优惠截止时间"`
+}
+
+// AddSystemMember 新增会员配置
+type AddSystemMember struct {
+	MemberDays      uint     `json:"member_days" form:"member_days" label:"会员天数" validate:"required,numeric,min=0"`
+	Price           float64  `json:"price" form:"price" label:"价格（原价）" validate:"required,numeric,min=0"`
+	DiscountPrice   *float64 `json:"discount_price" form:"discount_price" label:"优惠价格" validate:"omitempty,numeric,min=0"`
+	DiscountEndTime *string  `json:"discount_end_time" form:"discount_end_time" label:"优惠截止时间"`
+}

api/requests/SystemSingle.go

@@ -0,0 +1,18 @@
+package requests
+
+type SystemSingleRequest struct {
+	PutSystemSingle // 修改单项配置
+	AddSystemSingle // 新增单项配置
+}
+
+// PutSystemSingle 修改单项配置
+type PutSystemSingle struct {
+	FirstTimePrice float64 `json:"first_time_price" form:"first_time_price" label:"首次购买价格" validate:"required,numeric,min=0"`
+	ValidDays      int     `json:"valid_days" form:"valid_days" label:"购买后有效天数" validate:"required,numeric,min=0"`
+}
+
+// AddSystemSingle 新增单项配置
+type AddSystemSingle struct {
+	FirstTimePrice float64 `json:"first_time_price" form:"first_time_price" label:"首次购买价格" validate:"required,numeric,min=0"`
+	ValidDays      int     `json:"valid_days" form:"valid_days" label:"购买后有效天数" validate:"required,numeric,min=0"`
+}

api/requests/User.go

@@ -0,0 +1,36 @@
+package requests
+
+type UserRequest struct {
+	GetUserPage   // 获取用户列表-分页
+	PutUserStatus // 操作用户状态
+}
+
+// GetUserPage  获取用户列表-分页
+type GetUserPage struct {
+	Page             int               `json:"page" form:"page" label:"页码"`
+	PageSize         int               `json:"page_size" form:"page_size" label:"每页个数"`
+	UserId           string            `json:"user_id" form:"user_id" label:"用户id"`
+	UserName         string            `json:"user_name" form:"user_name" label:"用户名称"`
+	Mobile           string            `json:"mobile" form:"mobile" label:"手机号"`
+	UserStatus       int               `json:"user_status" form:"user_status" label:"状态"`
+	RegisterSource   int               `json:"register_source" form:"register_source" label:"注册来源"`
+	OpenId           string            `json:"open_id" form:"open_id" label:"用户微信标识"`
+	Sex              *int              `json:"sex" form:"sex" label:"性别"`
+	IsMember         *int              `json:"is_member" form:"is_member" label:"是否会员"`
+	MemberExpireDate string            `json:"member_expire_date" form:"member_expire_date" label:"会员到期时间"` // 假设转换为可选字符串
+	IsInfoComplete   *int              `json:"is_info_complete" form:"is_info_complete" label:"信息完善状态"`     // 0:否 1:是
+	Order            *GetUserPageOrder `json:"order"   form:"order" label:"排序"`
+}
+
+// GetUserPageOrder 获取用户列表-分页-排序条件
+type GetUserPageOrder struct {
+	UpdatedAt         string `json:"updated_at" form:"updated_at" label:"排序"`
+	SingleSubmitCount string `json:"single_submit_count" form:"single_submit_count" label:"排序"` // 提交次数
+	SinglePayCount    string `json:"single_pay_count" form:"single_pay_count" label:"排序"`       // 支付次数
+	MemberBuyCount    string `json:"member_buy_count" form:"member_buy_count" label:"排序"`       // 会员购买次数
+}
+
+// PutUserStatus 操作用户状态
+type PutUserStatus struct {
+	UserStatus int `json:"user_status" form:"user_status" label:"删除状态" validate:"required,oneof=1 2"` // 状态（1:正常 2:禁用）
+}

api/requests/UserCoupon.go

@@ -0,0 +1,15 @@
+package requests
+
+type UserCouponRequest struct {
+	GetUserCouponPage // 获取用户优惠卷列表-分页
+}
+
+// GetUserCouponPage 获取用户优惠卷列表-分页
+type GetUserCouponPage struct {
+	Page             int    `json:"page" form:"page" label:"页码"`
+	PageSize         int    `json:"page_size" form:"page_size" label:"每页个数"`
+	UserId           *int64 `json:"user_id" form:"user_id" label:"用户id"`
+	CouponId         string `json:"coupon_id" form:"coupon_id" label:"优惠券id"`
+	UserCouponStatus *int   `json:"user_coupon_status" form:"user_coupon_status" label:"状态"` // 状态（0:未使用 1:已使用 3:已过期）
+	UserName         string `json:"user_name" form:"user_name" label:"用户名称"`
+}

api/requests/base.go

@@ -0,0 +1,4 @@
+package requests
+
+type Requests struct {
+}

api/responses/responses.go

@@ -0,0 +1,52 @@
+package responses
+
+import (
+	"github.com/gin-gonic/gin"
+	"hepa-calc-admin-api/consts"
+	"net/http"
+)
+
+type res struct {
+	Code    int         `json:"code"`
+	Data    interface{} `json:"data"`
+	Message string      `json:"message"`
+}
+
+func result(code int, data interface{}, msg string, c *gin.Context) {
+	if data == nil {
+		data = gin.H{}
+	}
+	c.JSON(http.StatusOK, res{
+		code,
+		data,
+		msg,
+	})
+}
+
+func Ok(c *gin.Context) {
+	result(consts.HttpSuccess, map[string]interface{}{}, "成功", c)
+}
+
+func OkWithMessage(message string, c *gin.Context) {
+	result(consts.HttpSuccess, map[string]interface{}{}, message, c)
+}
+
+func OkWithData(data interface{}, c *gin.Context) {
+	result(consts.HttpSuccess, data, "成功", c)
+}
+
+func OkWithDetailed(data interface{}, message string, c *gin.Context) {
+	result(consts.HttpSuccess, data, message, c)
+}
+
+func Fail(c *gin.Context) {
+	result(consts.HttpError, map[string]interface{}{}, "失败", c)
+}
+
+func FailWithMessage(message string, c *gin.Context) {
+	result(consts.HttpError, map[string]interface{}{}, message, c)
+}
+
+func FailWithDetailed(data interface{}, message string, c *gin.Context) {
+	result(consts.HttpError, data, message, c)
+}

api/router/router.go

@@ -0,0 +1,290 @@
+package router
+
+import (
+	"fmt"
+	"github.com/gin-gonic/gin"
+	"hepa-calc-admin-api/api/controller"
+	"hepa-calc-admin-api/api/exception"
+	"hepa-calc-admin-api/api/middlewares"
+	"hepa-calc-admin-api/config"
+	"hepa-calc-admin-api/consts"
+	"net/http"
+)
+
+// Init 初始化路由
+func Init() *gin.Engine {
+	r := gin.New()
+
+	// 环境设置
+	if config.C.Env == "prod" {
+		gin.SetMode(gin.ReleaseMode)
+	}
+
+	// 获取请求参数中间件-json格式下会导致接口获取不到请求数据
+	r.Use(middlewares.RequestParamsMiddleware())
+
+	// 日志中间件
+	r.Use(middlewares.Logrus())
+
+	// 异常
+	r.Use(gin.Recovery())
+
+	// 404处理
+	r.NoRoute(func(c *gin.Context) {
+		path := c.Request.URL.Path
+		method := c.Request.Method
+		c.JSON(http.StatusNotFound, gin.H{
+			"msg":  fmt.Sprintf("%s %s not found", method, path),
+			"code": consts.ClientHttpNotFound,
+			"data": "",
+		})
+	})
+
+	// 异常处理
+	r.Use(exception.Recover())
+
+	// 跨域处理
+	r.Use(middlewares.Cors())
+
+	// 加载基础路由
+	api := controller.Api{}
+
+	// 公开路由-不验证权限
+	publicRouter(r, api)
+
+	// 验证jwt
+	r.Use(middlewares.Jwt())
+
+	// 验证权限
+	r.Use(middlewares.Auth())
+
+	// 私有路由-验证权限
+	privateRouter(r, api)
+
+	// 公共路由-验证权限
+	adminRouter(r, api)
+
+	// 基础数据-验证权限
+	basicRouter(r, api)
+
+	return r
+}
+
+// publicRouter 公开路由-不验证权限
+func publicRouter(r *gin.Engine, api controller.Api) {
+	adminGroup := r.Group("/admin")
+
+	// 登录
+	adminGroup.POST("/login", api.Public.Login)
+
+	// 验证码
+	adminGroup.GET("/captcha", api.Public.GetCaptcha)
+}
+
+// adminRouter 公共路由-验证权限
+func adminRouter(r *gin.Engine, api controller.Api) {
+	adminGroup := r.Group("/admin")
+
+	// 首页
+	indexGroup := adminGroup.Group("/index")
+	{
+		// 首页
+		indexGroup.GET("", api.Public.GetIndex)
+
+		// 首页动态统计数据
+		indexGroup.GET("/data", api.Public.GetIndexData)
+	}
+}
+
+// basicRouter 基础数据-验证权限
+func basicRouter(r *gin.Engine, api controller.Api) {
+
+}
+
+// privateRouter 私有路由-验证权限
+func privateRouter(r *gin.Engine, api controller.Api) {
+	adminGroup := r.Group("/admin")
+
+	// 订单
+	orderGroup := adminGroup.Group("/order")
+	{
+		// 单项订单
+		singleGroup := orderGroup.Group("/single")
+		{
+			// 获取单项订单列表-分页
+			singleGroup.GET("/page", api.OrderSingle.GetOrderSinglePage)
+
+			// 获取单项订单详情
+			singleGroup.GET("/:order_id", api.OrderSingle.GetOrderSingle)
+
+			// 取消单项订单
+			singleGroup.PUT("/cancel/:order_id", api.OrderSingle.PutCancelOrderSingle)
+
+			// 操作单项订单删除状态
+			singleGroup.PUT("/delete/:order_id", api.OrderSingle.PutOrderSingleDeleteStatus)
+
+			// 获取单项订单操作结果
+		}
+
+		// 会员订单
+		memberGroup := orderGroup.Group("/member")
+		{
+			// 获取会员订单列表-分页
+			memberGroup.GET("/page", api.OrderMember.GetOrderMemberPage)
+
+			// 获取会员订单详情
+			memberGroup.GET("/:order_id", api.OrderMember.GetOrderMember)
+
+			// 取消会员订单
+			memberGroup.PUT("/cancel/:order_id", api.OrderMember.PutCancelOrderMember)
+
+			// 操作会员订单删除状态
+			memberGroup.PUT("/delete/:order_id", api.OrderMember.PutOrderMemberDeleteStatus)
+		}
+	}
+
+	// 用户
+	userGroup := adminGroup.Group("/user")
+	{
+		// 获取用户列表-分页
+		userGroup.POST("/page", api.User.GetUserPage)
+
+		// 获取用户详情
+		userGroup.GET("/:user_id", api.User.GetUser)
+
+		// 操作用户状态
+		userGroup.PUT("/status/:user_id", api.User.PutUserStatus)
+
+		// 获取用户信息详情
+
+	}
+
+	// 优惠卷
+	couponGroup := adminGroup.Group("/coupon")
+	{
+		// 系统优惠卷
+		systemGroup := couponGroup.Group("/system")
+		{
+			// 获取系统优惠卷列表-分页
+			systemGroup.GET("/page", api.Coupon.GetCouponPage)
+
+			// 获取系统优惠卷详情
+			systemGroup.GET("/:coupon_id", api.Coupon.GetCoupon)
+
+			// 添加系统优惠卷
+			systemGroup.POST("", api.Coupon.AddSystemCoupon)
+
+			// 操作系统优惠卷状态
+			systemGroup.PUT("/status/:coupon_id", api.Coupon.PutCouponStatus)
+		}
+
+		// 用户优惠卷
+		userGroup := couponGroup.Group("/user")
+		{
+			// 获取用户优惠卷列表-分页
+			userGroup.GET("/page", api.UserCoupon.GetUserCouponPage)
+
+			// 删除用户优惠卷
+			userGroup.DELETE("/:user_coupon_id", api.UserCoupon.DeleteUserCoupon)
+		}
+	}
+
+	// 分类
+	classGroup := adminGroup.Group("/class")
+	{
+		// 获取基础分类列表-分页
+		classGroup.POST("/page", api.BaseClass.GetBaseClassPage)
+
+		// 获取基础分类列表
+		classGroup.POST("/list", api.BaseClass.GetBaseClassList)
+
+		// 操作基础分类状态
+		classGroup.PUT("/status/:class_id", api.BaseClass.PutBaseClassStatus)
+
+		// 获取基础分类详情
+		classGroup.GET("/:class_id", api.BaseClass.GetBaseClass)
+
+		// 修改基础分类
+		classGroup.PUT("/:class_id", api.BaseClass.PutBaseClass)
+
+		// 新增基础分类
+		classGroup.POST("", api.BaseClass.AddBaseClass)
+	}
+
+	// 问题
+	questionGroup := adminGroup.Group("/question")
+	{
+		// 获取问题列表-分页
+		questionGroup.POST("/page", api.Question.GetQuestionPage)
+
+		// 获取问题列表
+		questionGroup.POST("/list", api.Question.GetQuestionList)
+
+		// 获取问题详情
+		questionGroup.GET("/:question_id", api.Question.GetQuestion)
+
+		// 修改问题
+		questionGroup.PUT("/:question_id", api.Question.PutQuestion)
+
+		// 新增问题
+		questionGroup.POST("", api.Question.AddQuestion)
+
+		// 操作问题发布状态
+		questionGroup.PUT("/status/:question_id", api.Question.PutQuestionStatus)
+
+		// 操作问题隐藏状态
+		questionGroup.PUT("/hide/:question_id", api.Question.PutQuestionHideStatus)
+	}
+
+	// 配置
+	systemGroup := adminGroup.Group("/system")
+	{
+		// 会员配置
+		memberGroup := systemGroup.Group("/member")
+		{
+			// 获取会员配置列表
+			memberGroup.GET("/list", api.SystemMember.GetSystemMemberList)
+
+			// 获取会员配置详情
+			memberGroup.GET("/:system_member_id", api.SystemMember.GetSystemMember)
+
+			// 修改会员配置
+			memberGroup.PUT("/:system_member_id", api.SystemMember.PutSystemMember)
+
+			// 新增会员配置
+			memberGroup.POST("", api.SystemMember.AddSystemMember)
+		}
+
+		// 单项配置
+		singleGroup := systemGroup.Group("/single")
+		{
+			// 获取单项配置列表
+			singleGroup.GET("/list", api.SystemSingle.GetSystemSingleList)
+
+			// 获取单项配置详情
+			singleGroup.GET("/:system_single_id", api.SystemSingle.GetSystemSingle)
+
+			// 修改单项配置
+			singleGroup.PUT("/:system_single_id", api.SystemSingle.PutSystemSingle)
+
+			// 新增单项配置
+			singleGroup.POST("", api.SystemSingle.AddSystemSingle)
+		}
+	}
+
+	// 协议
+	agreementGroup := adminGroup.Group("/agreement")
+	{
+		// 获取协议列表-分页
+		agreementGroup.GET("/page", api.BaseAgreement.GetBaseAgreementPage)
+
+		// 获取协议详情
+		agreementGroup.GET("/:agreement_id", api.BaseAgreement.GetBaseAgreement)
+
+		// 修改协议
+		agreementGroup.PUT("/:agreement_id", api.BaseAgreement.PutBaseAgreement)
+
+		// 新增协议
+		agreementGroup.POST("", api.BaseAgreement.AddBaseAgreement)
+	}
+}

api/service/BaseClass.go

@@ -0,0 +1,4 @@
+package service
+
+type BaseClassService struct {
+}

api/service/OrderMember.go

@@ -0,0 +1,185 @@
+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-admin-api/api/dao"
+	"hepa-calc-admin-api/api/model"
+	"hepa-calc-admin-api/config"
+	"hepa-calc-admin-api/extend/weChat"
+	"hepa-calc-admin-api/global"
+	"hepa-calc-admin-api/utils"
+	"time"
+)
+
+type OrderMemberService struct {
+}
+
+// CancelOrderMember 取消会员订单
+// cancelReason:订单取消原因（1:主动取消 2:后台取消 3:支付超时取消）
+func (r *OrderMemberService) CancelOrderMember(tx *gorm.DB, userId, orderId int64, cancelReason int) (bool, error) {
+	// 检测多次请求
+	redisKey := "CancelOrderMember" + 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("取消订单失败")
+	}
+
+	// 获取订单数据
+	orderMemberDao := dao.OrderMemberDao{}
+	maps := make(map[string]interface{})
+	maps["order_id"] = orderId
+	orderMember, err := orderMemberDao.GetOrderMember(maps)
+	if err != nil {
+		return false, errors.New("订单异常")
+	}
+
+	// 订单状态（1:待支付 2:已完成 3:已取消）
+	if orderMember.OrderStatus == 2 {
+		return false, errors.New("订单已完成,无法取消")
+	}
+
+	if orderMember.OrderStatus == 3 {
+		return false, errors.New("订单已取消,请勿重复操作")
+	}
+
+	// 取消状态（0:否 1:是）
+	if orderMember.CancelStatus == 1 {
+		return false, errors.New("订单已取消")
+	}
+
+	// 支付状态（1:未支付 2:已支付 3:支付中 4:支付失败 5:支付超时 6:支付关闭 7:已撤销 8:转入退款）
+	if orderMember.PayStatus == 2 {
+		return false, errors.New("订单已支付,无法取消")
+	}
+
+	// 订单退款状态（0:无退款 1:申请退款 2:退款中 3:退款成功 4:拒绝退款 5:退款关闭 6:退款异常 7:部分退款）
+	if orderMember.RefundStatus == 1 {
+		return false, errors.New("订单已申请退款")
+	}
+
+	if orderMember.RefundStatus == 2 {
+		return false, errors.New("订单退款中")
+	}
+
+	if orderMember.RefundStatus == 3 {
+		return false, errors.New("订单已退款成功")
+	}
+
+	if orderMember.RefundStatus == 6 {
+		return false, errors.New("订单退款异常")
+	}
+
+	// 修改订单为取消
+	orderMemberData := make(map[string]interface{})
+	orderMemberData["order_status"] = 3
+	if cancelReason == 3 {
+		// 支付超时取消
+		orderMemberData["pay_status"] = 5
+	}
+	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")
+	err = orderMemberDao.EditOrderMemberById(tx, orderId, orderMemberData)
+	if err != nil {
+		return false, errors.New("订单取消失败")
+	}
+
+	// 退还订单优惠卷
+	if orderMember.CouponAmountTotal != 0 {
+		// 获取订单优惠卷数据
+		orderMemberCouponDao := dao.OrderMemberCouponDao{}
+		orderMemberCoupon, err := orderMemberCouponDao.GetOrderMemberCouponByOrderId(orderId)
+		if err != nil {
+			tx.Rollback()
+			return false, errors.New("订单取消失败")
+		}
+
+		userCouponService := &UserCouponService{}
+		userCouponService.ReturnUserCoupon(tx, orderMemberCoupon.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.Pay1281030301.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.Pay1281030301.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

@@ -0,0 +1,410 @@
+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-admin-api/api/dao"
+	"hepa-calc-admin-api/api/model"
+	"hepa-calc-admin-api/config"
+	"hepa-calc-admin-api/extend/rabbitMq"
+	"hepa-calc-admin-api/extend/weChat"
+	"hepa-calc-admin-api/global"
+	"hepa-calc-admin-api/utils"
+	"time"
+)
+
+type OrderSingleService struct {
+}
+
+// AddOrderSingle 创建单项订单
+// payChannel:支付渠道（1:h5支付 2:app支付 3:会员支付）
+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()
+	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("生成订单失败")
+	}
+
+	// 获取题目数据
+	questionDao := dao.QuestionDao{}
+	question, err := questionDao.GetQuestionById(QuestionId)
+	if err != nil {
+		return nil, errors.New("题目异常")
+	}
+
+	// 检测题目
+	questionService := &QuestionService{}
+	isNormal, err := questionService.CheckQuestion(question)
+	if err != nil || isNormal == false {
+		return nil, err
+	}
+
+	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 {
+		// 获取优惠卷数据
+		UserCouponDao := dao.UserCouponDao{}
+		userCoupon, err = UserCouponDao.GetUserCouponPreloadById(*UserCouponId)
+		if err != nil {
+			return nil, errors.New("优惠券异常")
+		}
+
+		userCouponService := &UserCouponService{}
+		isCanUse, err := userCouponService.CheckUserCoupon(userCoupon, QuestionId, 1, *amountTotal)
+		if err != nil || isCanUse == false {
+			return nil, errors.New("价格异常")
+		}
+
+		// 优惠卷总金额
+		couponAmountTotal = userCoupon.Coupon.CouponPrice
+	}
+
+	// 会员支付
+	if payChannel == 3 {
+		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   // 支付时间
+	}
+
+	// 生成订单号
+	orderNo := global.Snowflake.Generate().String()
+
+	// 创建订单
+	orderSingle = &model.OrderSingle{
+		UserId:             UserId,
+		QuestionId:         QuestionId,
+		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:       "",
+	}
+
+	orderSingleDao := dao.OrderSingleDao{}
+	orderSingle, err = orderSingleDao.AddOrderSingle(tx, orderSingle)
+	if err != nil {
+		return nil, errors.New("订单创建失败")
+	}
+
+	// 创建优惠卷表
+	if userCoupon != nil {
+		orderSingleCoupon := &model.OrderSingleCoupon{
+			OrderId:        orderSingle.OrderId,
+			UserCouponId:   *UserCouponId,
+			CouponName:     userCoupon.Coupon.CouponName,
+			CouponUsePrice: userCoupon.Coupon.CouponPrice,
+		}
+
+		orderSingleCouponDao := dao.OrderSingleCouponDao{}
+		orderSingleCoupon, err = orderSingleCouponDao.AddOrderSingleCoupon(tx, orderSingleCoupon)
+		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("订单创建失败")
+		}
+	}
+
+	// 增加未支付取消订单延迟队列
+	if payChannel == 1 || payChannel == 2 {
+		delay := 30 * time.Minute
+
+		if config.C.Env == "dev" {
+			delay = 3 * time.Minute
+		}
+
+		data := make(map[string]interface{})
+		data["order_id"] = fmt.Sprintf("%d", orderSingle.OrderId)
+		data["order_no"] = orderSingle.OrderNo
+		data["user_id"] = fmt.Sprintf("%d", orderSingle.UserId)
+		data["order_type"] = 1
+		data["pay_channel"] = orderSingle.PayChannel
+
+		p := rabbitMq.PublishS{
+			QueueName:    "cancel.unpay.order.delay.queue",
+			ExchangeName: "amqp.delay.direct",
+			RoutingKey:   "CancelUnPayOrder",
+			Message:      data,
+			Delay:        delay,
+		}
+		err := p.PublishWithDelay()
+		if err != nil {
+			utils.LogJsonErr("添加处理取消未支付订单队列失败:", err.Error())
+			return nil, errors.New("订单创建失败")
+		}
+	}
+
+	return orderSingle, nil
+}
+
+// CancelOrderSingle 取消单项订单
+// cancelReason:订单取消原因（1:主动取消 2:后台取消 3:支付超时取消）
+func (r *OrderSingleService) CancelOrderSingle(tx *gorm.DB, userId, orderId int64, cancelReason int) (bool, error) {
+	// 检测多次请求
+	redisKey := "CancelOrderSingle" + 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["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 *OrderSingleService) GetJsapiPrepay(m *model.OrderSingle) (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.Pay1281030301.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 *OrderSingleService) GetAppPrepay(m *model.OrderSingle) (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.Pay1281030301.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
+}
+
+// CompleteUnPayOrderSingle 完成未支付单项订单-开通会员成功时使用
+func (r *OrderSingleService) CompleteUnPayOrderSingle(tx *gorm.DB, userId int64) (bool, error) {
+	// 获取所有未支付单项订单
+	orderSingleDao := dao.OrderSingleDao{}
+	maps := make(map[string]interface{})
+	maps["user_id"] = userId
+	maps["order_status"] = 1
+	maps["pay_status"] = 1
+	maps["cancel_status"] = 0
+	orderSingles, err := orderSingleDao.GetOrderSingleList(maps)
+	if err != nil {
+		return false, err
+	}
+
+	for _, single := range orderSingles {
+		// 生成第三方支付流水号
+		escrowTradeNo := "GD" + global.Snowflake.Generate().String()
+
+		orderSingleData := make(map[string]interface{})
+		orderSingleData["order_status"] = 2
+		orderSingleData["pay_status"] = 2
+		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")
+		err = orderSingleDao.EditOrderSingleById(tx, single.OrderId, orderSingleData)
+		if err != nil {
+			return false, err
+		}
+
+		// 增加题目支付次数
+		questionDao := dao.QuestionDao{}
+		err = questionDao.Inc(tx, single.QuestionId, "pay_count", 1)
+		if err != nil {
+			return false, err
+		}
+	}
+
+	return true, nil
+}

api/service/Public.go

@@ -0,0 +1,85 @@
+package service
+
+import (
+	"context"
+	"errors"
+	"hepa-calc-admin-api/extend/aliyun"
+	"hepa-calc-admin-api/global"
+	"math/rand"
+	"net/http"
+	"strconv"
+	"time"
+)
+
+type PublicService struct {
+}
+
+// GetPhoneCode 获取手机验证码
+func (r *PublicService) GetPhoneCode(scene int, phone string) (bool, error) {
+	var sendCodeCount int   // // 获取验证码最大次数
+	var code string         // 验证码
+	var templateCode string // 短信模版
+
+	// 登录获取验证码
+	if scene == 1 {
+		// 验证发送次数
+		res, _ := global.Redis.Get(context.Background(), "login_code_count_"+phone).Result()
+		if res != "" {
+			sendCodeCount, err := strconv.Atoi(res)
+			if err != nil {
+				return false, err
+			}
+
+			if sendCodeCount > 3 {
+				// 超出规定时间内最大获取次数
+				return false, errors.New("手机号超出规定时间内最大获取次数，请您稍后再试")
+			}
+		}
+
+		// 生成随机数
+		rand.New(rand.NewSource(time.Now().UnixNano()))
+		code = strconv.Itoa(rand.Intn(9000) + 1000)
+
+		// 模版
+		templateCode = "SMS_243055263"
+
+		sendCodeCount = sendCodeCount + 1
+	}
+
+	if code == "" || templateCode == "" {
+		return false, errors.New("验证码发送失败，请您稍后再试")
+	}
+
+	// 发送验证码
+	templateParam := make(map[string]interface{})
+	templateParam["code"] = code
+	err := aliyun.SendSms(phone, templateCode, "获取验证码", templateParam)
+	if err != nil {
+		return false, err
+	}
+
+	// 记录发送次数
+	if sendCodeCount != 0 {
+		_, err = global.Redis.Set(context.Background(), "login_code_count_"+phone, time.Now().Unix(), 60*5*time.Second).Result()
+		if err != nil {
+			return false, errors.New("验证码发送失败，请您稍后再试")
+		}
+	}
+
+	// 设置验证码有效期
+	_, err = global.Redis.Set(context.Background(), "login_code_"+phone, code, 60*5*time.Second).Result()
+	if err != nil {
+		return false, errors.New("验证码发送失败，请您稍后再试")
+	}
+
+	return true, nil
+}
+
+// GetUserIP 获取用户ip
+func (r *PublicService) GetUserIP(h *http.Request) string {
+	forwarded := h.Header.Get("X-FORWARDED-FOR")
+	if forwarded != "" {
+		return forwarded
+	}
+	return h.RemoteAddr
+}

api/service/Question.go

@@ -0,0 +1,230 @@
+package service
+
+import (
+	"errors"
+	"hepa-calc-admin-api/api/dao"
+	"hepa-calc-admin-api/api/dto"
+	"hepa-calc-admin-api/api/model"
+	"time"
+)
+
+type QuestionService struct {
+}
+
+// GetHotList 获取算一算热榜-人气数最高的9个
+func (r *QuestionService) GetHotList() (m []*model.Question, err error) {
+	questionDao := dao.QuestionDao{}
+
+	maps := make(map[string]interface{})
+	maps["question_status"] = 1
+	maps["is_hide"] = 0
+	questions, err := questionDao.GetQuestionOrderLimitList(maps, "click_count desc", 9)
+	if err != nil {
+		return nil, err
+	}
+
+	return questions, nil
+}
+
+// GetRecommendList 获取为你推荐-后台指定的推广
+func (r *QuestionService) GetRecommendList() (m []*model.Question, err error) {
+	questionDao := dao.QuestionDao{}
+
+	maps := make(map[string]interface{})
+	maps["question_status"] = 1
+	maps["is_hide"] = 0
+	maps["is_recommend"] = 1
+	questions, err := questionDao.GetQuestionList(maps)
+	if err != nil {
+		return nil, err
+	}
+
+	return questions, nil
+}
+
+// GetGuessUserLIkeList 获取猜你喜欢-暂用公众参与过的最新算一算，至多显示3个。若未参与，则指定或者随机显示3个
+func (r *QuestionService) GetGuessUserLIkeList(userId int64) (m []*model.Question, err error) {
+	orderSingleDao := dao.OrderSingleDao{}
+	questionDao := dao.QuestionDao{}
+
+	var questions []*model.Question
+
+	if userId != 0 {
+		maps := make(map[string]interface{})
+		maps["user_id"] = userId
+		orderSingles, err := orderSingleDao.GetOrderSingleOrderList(maps, "created_at desc", 3)
+		if err != nil {
+			return nil, err
+		}
+
+		// 参与过
+		if len(orderSingles) > 0 {
+			for i, single := range orderSingles {
+				questions[i] = single.Question
+			}
+		}
+	}
+
+	// 未参与过/未指定用户
+	if len(questions) == 0 {
+		maps := make(map[string]interface{})
+		maps["question_status"] = 1
+		maps["is_hide"] = 0
+		questions, err = questionDao.GetQuestionListRand(maps, 3)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return questions, nil
+}
+
+// CheckUserCollectionQuestion 检测问题是否被用户收藏
+func (r *QuestionService) CheckUserCollectionQuestion(userId, questionId int64) (bool, error) {
+	userCollectionDao := dao.UserCollectionDao{}
+
+	maps := make(map[string]interface{})
+	maps["user_id"] = userId
+	maps["question_id"] = questionId
+	userCollection, err := userCollectionDao.GetUserCollection(maps)
+	if userCollection == nil {
+		return false, err
+	}
+
+	return true, nil
+}
+
+// CheckUserBuyQuestion 检测用户是否购买过该问题
+func (r *QuestionService) CheckUserBuyQuestion(userId, questionId int64) bool {
+	orderSingleDao := dao.OrderSingleDao{}
+	orderSingle, _ := orderSingleDao.GetUserFirstTimeBuyOrderSingle(userId, questionId)
+	if orderSingle == nil {
+		return false
+	}
+
+	return true
+}
+
+// GetUserFirstTimeBuyPrice 获取用户首次购买价格
+func (r *QuestionService) GetUserFirstTimeBuyPrice(userId, questionId int64) (f *float64, err error) {
+	// 检测用户是否购买过该问题
+	isFirstBuy := r.CheckUserBuyQuestion(userId, questionId)
+	if isFirstBuy == false {
+		// 未购买过
+		systemSingleDao := dao.SystemSingleDao{}
+
+		maps := make(map[string]interface{})
+		systemSingle, err := systemSingleDao.GetSystemSingle(maps)
+		if err != nil {
+			return nil, err
+		}
+
+		return &systemSingle.FirstTimePrice, nil
+	}
+
+	return nil, nil
+}
+
+// GetQuestionBuyCount 获取问题被购买数量
+func (r *QuestionService) GetQuestionBuyCount(userId, questionId int64) (c int, err error) {
+	// 未购买过
+	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 := orderSingleDao.GetOrderSingleCount(maps)
+	if err != nil {
+		return 0, err
+	}
+
+	return int(buyCount), nil
+}
+
+// GetUserBuyPrice 获取问题最终价格
+func (r *QuestionService) GetUserBuyPrice(userId, questionId int64) (p *float64, err error) {
+	// 获取问题详情
+	questionDao := dao.QuestionDao{}
+	question, err := questionDao.GetQuestionById(questionId)
+	if err != nil {
+		return nil, errors.New("题目异常")
+	}
+
+	// 检测用户是否购买过该问题
+	isFirstBuy := r.CheckUserBuyQuestion(userId, questionId)
+	if isFirstBuy == false {
+		// 未购买过
+		systemSingleDao := dao.SystemSingleDao{}
+
+		maps := make(map[string]interface{})
+		systemSingle, err := systemSingleDao.GetSystemSingle(maps)
+		if err != nil {
+			return nil, err
+		}
+
+		p = &systemSingle.FirstTimePrice
+	}
+
+	// 处理问题优惠价格
+	if p == nil {
+		p = r.HandleQuestionDiscountPrice(question.DiscountPrice, question.DiscountEndTime)
+	}
+
+	if p == nil {
+		p = &question.Price
+	}
+
+	return p, nil
+}
+
+// CheckQuestion 检测题目
+func (r *QuestionService) CheckQuestion(m *model.Question) (bool, error) {
+	if m.QuestionStatus != 1 {
+		return false, errors.New("题目异常")
+	}
+
+	if m.IsHide != 0 {
+		return false, errors.New("题目异常")
+	}
+
+	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
+}
+
+// GetQuestionBaseClass 获取问题关联分类
+func (r *QuestionService) GetQuestionBaseClass(questionId int64) (g []*dto.BaseClassDto, err error) {
+	questionClassDao := dao.QuestionClassDao{}
+	questionClass, _ := questionClassDao.GetQuestionClassListByQuestionId(questionId)
+	if len(questionClass) > 0 {
+		baseClassDao := dao.BaseClassDao{}
+		for _, class := range questionClass {
+			baseClass, err := baseClassDao.GetBaseClassById(class.ClassId)
+			if err != nil {
+				return nil, errors.New("题目异常")
+			}
+
+			baseClassDto := dto.GetBaseClassDto(baseClass)
+
+			g = append(g, baseClassDto)
+		}
+	}
+
+	return g, nil
+}

api/service/SystemMember.go

@@ -0,0 +1,17 @@
+package service
+
+import "hepa-calc-admin-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

@@ -0,0 +1,107 @@
+package service
+
+import (
+	"errors"
+	"fmt"
+	"gorm.io/gorm"
+	"hepa-calc-admin-api/api/dao"
+	"hepa-calc-admin-api/api/model"
+	"hepa-calc-admin-api/extend/aliyun"
+	"io"
+	"math/rand"
+	"net/http"
+	"time"
+)
+
+type UserService struct {
+}
+
+// HandleUserAvatar 处理用户头像
+func (r *UserService) HandleUserAvatar(wxAvatar string) (avatar string, err error) {
+	if wxAvatar == "" {
+		return "", nil
+	}
+
+	// 发送GET请求
+	resp, err := http.Get(wxAvatar)
+	if err != nil {
+		return "", err
+	}
+
+	defer func(Body io.ReadCloser) {
+		_ = Body.Close()
+	}(resp.Body)
+
+	if resp.StatusCode != 200 {
+		return "", errors.New("请求失败")
+	}
+
+	// 读取响应体
+	respBody, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return "", err
+	}
+
+	// 设置文件名字
+	now := time.Now()
+	dateTimeString := now.Format("20060102150405")  // 当前时间字符串
+	rand.New(rand.NewSource(time.Now().UnixNano())) // 设置随机数
+	ossPath := "user/avatar/" + dateTimeString + fmt.Sprintf("%d", rand.Intn(9000)+1000) + ".png"
+
+	// 上传oss
+	_, err = aliyun.PutObjectByte(ossPath, respBody)
+	if err != nil {
+		return "", err
+	}
+
+	ossPath = "/" + ossPath
+
+	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
+}
+
+// AddUserMemberValidDate 增加用户会员过期时间
+func (r *UserService) AddUserMemberValidDate(tx *gorm.DB, user *model.User, d int) bool {
+	userData := make(map[string]interface{})
+	if user.IsMember == 0 {
+		userData["is_member"] = 1
+	}
+
+	if user.MemberExpireDate == nil {
+		userData["is_member"] = time.Now().Format("2006-01-02 15:04:05")
+	} else {
+		userData["is_member"] = user.MemberExpireDate.Add(time.Duration(d) * 24 * time.Hour)
+	}
+
+	userDao := dao.UserDao{}
+	err := userDao.EditUserById(tx, user.UserId, userData)
+	if err != nil {
+		return false
+	}
+
+	return true
+}

api/service/UserCollection.go

@@ -0,0 +1,91 @@
+package service
+
+import (
+	"errors"
+	"hepa-calc-admin-api/api/dao"
+	"hepa-calc-admin-api/api/model"
+	"hepa-calc-admin-api/global"
+)
+
+type UserCollectionService struct {
+}
+
+// GetUserCollectionQuestionStatus 检测用户收藏状态
+func (r *UserCollectionService) GetUserCollectionQuestionStatus(userId, questionId int64) bool {
+	userCollectionDao := dao.UserCollectionDao{}
+
+	maps := make(map[string]interface{})
+	maps["user_id"] = userId
+	maps["question_id"] = questionId
+	userCollection, _ := userCollectionDao.GetUserCollection(maps)
+	if userCollection == nil {
+		return false
+	}
+
+	return true
+}
+
+// PutUserCollection 收藏题目
+func (r *UserCollectionService) PutUserCollection(userId, questionId int64) (bool, error) {
+	// 检测用户收藏状态
+	IsCollection := r.GetUserCollectionQuestionStatus(userId, questionId)
+	if IsCollection == true {
+		// 已收藏
+		return true, nil
+	}
+
+	// 开始事务
+	tx := global.Db.Begin()
+	defer func() {
+		if r := recover(); r != nil {
+			tx.Rollback()
+		}
+	}()
+
+	userCollection := &model.UserCollection{
+		UserId:     userId,
+		QuestionId: questionId,
+	}
+
+	userCollectionDao := dao.UserCollectionDao{}
+	userCollection, err := userCollectionDao.AddUserCollection(tx, userCollection)
+	if err != nil {
+		tx.Rollback()
+		return false, errors.New("收藏失败")
+	}
+
+	tx.Commit()
+	return true, nil
+}
+
+// PutUserCollectionCancel 取消收藏题目
+func (r *UserCollectionService) PutUserCollectionCancel(userId, questionId int64) (bool, error) {
+	// 检测用户收藏状态
+	IsCollection := r.GetUserCollectionQuestionStatus(userId, questionId)
+	if IsCollection == false {
+		// 已收藏
+		return true, nil
+	}
+
+	// 开始事务
+	tx := global.Db.Begin()
+	defer func() {
+		if r := recover(); r != nil {
+			tx.Rollback()
+		}
+	}()
+
+	userCollectionDao := dao.UserCollectionDao{}
+
+	maps := make(map[string]interface{})
+	maps["user_id"] = userId
+	maps["question_id"] = questionId
+	err := userCollectionDao.DeleteUserCollection(tx, maps)
+	if err != nil {
+		tx.Rollback()
+		return false, errors.New("取消收藏失败")
+	}
+
+	tx.Commit()
+	return true, nil
+}

api/service/UserCoupon.go

@@ -0,0 +1,208 @@
+package service
+
+import (
+	"errors"
+	"gorm.io/gorm"
+	"hepa-calc-admin-api/api/dao"
+	"hepa-calc-admin-api/api/dto"
+	"hepa-calc-admin-api/api/model"
+	"time"
+)
+
+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("优惠卷异常")
+	}
+
+	if m.UserCouponStatus == 2 {
+		return false, errors.New("优惠卷已过期，无法使用")
+	}
+
+	now := time.Now()
+	validEndTime := time.Time(m.ValidEndTime)
+	if validEndTime.Before(now) {
+		return false, errors.New("优惠卷已过期，无法使用")
+	}
+
+	if m.Coupon == nil {
+		return false, errors.New("优惠卷异常")
+	}
+
+	// 检测优惠卷状态
+	if m.Coupon.CouponStatus == 2 {
+		return false, errors.New("优惠卷已失效，无法使用")
+	}
+
+	if m.Coupon.CouponStatus == 3 {
+		return false, errors.New("优惠卷无法使用")
+	}
+
+	if m.Coupon.CouponStatus == 4 {
+		return false, errors.New("优惠卷异常，无法使用")
+	}
+
+	// 检测价格
+	if m.Coupon.CouponType == 2 {
+		if *m.Coupon.WithAmount > amountTotal {
+			return false, errors.New("优惠卷不符合满减金额标准，无法使用")
+		}
+	}
+
+	// 单项
+	if orderType == 1 {
+		if m.Coupon.ApplicationScope != 1 && m.Coupon.ApplicationScope != 2 {
+			return false, errors.New("优惠卷无法使用")
+		}
+
+		if id != *m.Coupon.QuestionId {
+			return false, errors.New("优惠卷无法使用")
+		}
+	}
+
+	// 会员
+	if orderType == 2 {
+		if m.Coupon.ApplicationScope != 1 && m.Coupon.ApplicationScope != 3 {
+			return false, errors.New("优惠卷无法使用")
+		}
+
+		if id != *m.Coupon.SystemMemberId {
+			return false, errors.New("优惠卷无法使用")
+		}
+	}
+
+	// 检测优惠劵过期时间
+	if m.Coupon.ValidType == 1 {
+		validEndTime = time.Time(*m.Coupon.ValidEndTime)
+		if validEndTime.Before(now) {
+			return false, errors.New("优惠卷已过期，无法使用")
+		}
+	}
+
+	return true, nil
+}
+
+// ReturnUserCoupon 退还优惠卷
+func (r *UserCouponService) ReturnUserCoupon(tx *gorm.DB, userCouponId int64) bool {
+	// 获取优惠卷数据
+	UserCouponDao := dao.UserCouponDao{}
+	userCoupon, err := UserCouponDao.GetUserCouponPreloadById(userCouponId)
+	if err != nil {
+		// 无该优惠卷数据，无需处理
+		return true
+	}
+
+	userCouponDao := dao.UserCouponDao{}
+	userCouponData := make(map[string]interface{})
+
+	// 检测优惠卷过期时间。判断是否需要退还
+	now := time.Now()
+	validEndTime := time.Time(userCoupon.ValidEndTime)
+	if validEndTime.Before(now) {
+		userCouponData["user_coupon_status"] = 3
+	} else {
+		userCouponData["user_coupon_status"] = 0
+	}
+
+	userCouponData["coupon_use_date"] = nil
+	err = userCouponDao.EditUserCouponById(tx, userCoupon.UserCouponId, userCouponData)
+	if err != nil {
+		return false
+	}
+
+	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
+}

config.yaml

@@ -0,0 +1,69 @@
+port: 8598 # 启动端口
+
+env: dev # 环境配置
+
+snowflake: 1 # 雪花算法机器id
+
+# [数据库配置]
+mysql:
+  host: '42.193.16.243'
+  username: root
+  password: 'gdxz123456^%$d'
+  port: 30001
+  db-name: hepa_calc
+  max-idle-cons: 5
+  max-open-cons: 20
+  debug: true
+
+log:
+  file-path: "./log/"
+  file-name: "hepa-calc-admin-api.log"
+
+# [redis]
+redis:
+  host: '139.155.127.177'
+  port: 30002
+  password: gdxz2022&dj.
+  pool-size: 100
+  db: 3
+
+# [jwt]
+jwt:
+  sign-key: 123456899 # 私钥
+  ttl : 72 # 过期时间 小时
+  algo : HS256 # 加密方式
+
+oss:
+  oss-access-key: LTAI5tKmFrVCghcxX7yHyGhm
+  oss-access-key-secret: q1aiIZCJJuf92YbKk2cSXnPES4zx26
+  oss-bucket: dev-knowledge
+  oss-endpoint: oss-cn-beijing.aliyuncs.com
+  oss-custom-domain-name: https://dev-knowledge.oss-cn-beijing.aliyuncs.com
+
+# [阿里大鱼短信]
+dysms:
+  dysms-access-key: LTAI4GGygjsKhyBwvvC3CghV
+  dysms-access-secret: rcx7lO9kQxG10m8NqNPEfEtT9IS8EI
+
+# [微信]
+wechat:
+  app-id: wx68affaa9d23528f8
+  app-secret: 2963c90242ddb2421c939591ad9e903d
+  pay-notify-url: callback/wxpay/single
+  refund-notify-url: callback/wxpay/inquiry/refund
+  refund-notify-domain: https://dev-hepa.igandan.com/api/
+  pay-1281030301:
+    mch-id: 1281030301
+    v3-api-secret: sB2tCkT70uwEy7cQCu1llA6nilTbek6F
+    mch-certificate-serial-number: 3D1685894CEDD41753A470211F975D40AE1375F5
+    platform-certs: extend/weChat/certs/1281030301/wechatpay_5B5C8A69CC86D1127F6B6AA06AAAF10531EEFE90.pem
+    private-key: extend/weChat/certs/1281030301/apiclient_key.pem
+    certificate: extend/weChat/certs/1281030301/apiclient_cert.pem
+
+# [rabbitMq]
+amqp:
+  host: 42.193.16.243
+  port: 5672
+  user: gdxz_2022rabbitmq
+  password: qwr2p&¥e@3.2p
+  vhost: gdxz_hepa

config/amqp.go

@@ -0,0 +1,9 @@
+package config
+
+type Amqp struct {
+	Host     string `mapstructure:"host" json:"host" yaml:"host"`             // 服务器地址
+	Port     int    `mapstructure:"port" json:"port" yaml:"port"`             // 服务器端口
+	Password string `mapstructure:"password" json:"password" yaml:"password"` // 密码
+	User     string `mapstructure:"user" json:"user" yaml:"user"`
+	Vhost    string `mapstructure:"vhost" json:"vhost" yaml:"vhost"`
+}

config/config.go

@@ -0,0 +1,17 @@
+package config
+
+var C Config
+
+type Config struct {
+	Port      int    `mapstructure:"port" json:"port" yaml:"port"`
+	Env       string `mapstructure:"env" json:"Env" yaml:"Env"`
+	Mysql     Mysql  `mapstructure:"mysql" json:"mysql" yaml:"mysql"`
+	Log       Log    `mapstructure:"log" json:"log" yaml:"log"`
+	Redis     Redis  `mapstructure:"redis" json:"redis" yaml:"redis"`
+	Jwt       Jwt    `mapstructure:"jwt" json:"jwt" yaml:"jwt"`
+	Oss       Oss    `mapstructure:"oss" json:"oss" yaml:"oss"`
+	Snowflake int64  `mapstructure:"snowflake" json:"snowflake" yaml:"snowflake"`
+	Dysms     Dysms  `mapstructure:"dysms" json:"dysms" yaml:"dysms"`
+	Wechat    Wechat `mapstructure:"wechat" json:"wechat" yaml:"wechat"`
+	Amqp      Amqp   `mapstructure:"amqp" json:"amqp" yaml:"amqp"`
+}

config/dysms.go

@@ -0,0 +1,6 @@
+package config
+
+type Dysms struct {
+	DysmsAccessKey    string `mapstructure:"dysms-access-key" json:"dysms-access-key" yaml:"dysms-access-key"`
+	DysmsAccessSecret string `mapstructure:"dysms-access-secret" json:"dysms-access-secret" yaml:"dysms-access-secret"`
+}

config/jwt.go

@@ -0,0 +1,7 @@
+package config
+
+type Jwt struct {
+	SignKey string `mapstructure:"sign-key" json:"sign-key" yaml:"sign-key"` // 私钥
+	Ttl     int    `mapstructure:"ttl" json:"ttl" yaml:"ttl"`                // 过期时间 小时
+	Algo    string `mapstructure:"algo" json:"algo" yaml:"algo"`             // 加密方式
+}

config/log.go

@@ -0,0 +1,6 @@
+package config
+
+type Log struct {
+	FilePath string `mapstructure:"file-path" json:"file-path" yaml:"file-path"` // 日志目录
+	FileName string `mapstructure:"file-name" json:"file-name" yaml:"file-name"` // 日志名称
+}

config/mysql.go

@@ -0,0 +1,12 @@
+package config
+
+type Mysql struct {
+	Host         string `mapstructure:"host" json:"host" yaml:"host"`                           // 服务器地址
+	Port         int    `mapstructure:"port" json:"port" yaml:"port"`                           // 端口
+	DbName       string `mapstructure:"db-name" json:"db-name" yaml:"db-name"`                  // 数据库名
+	Username     string `mapstructure:"username" json:"username" yaml:"username"`               // 数据库用户名
+	Password     string `mapstructure:"password" json:"password" yaml:"password"`               // 数据库密码
+	MaxIdleConns int    `mapstructure:"max-idle-cons" json:"MaxIdleConns" yaml:"max-idle-cons"` // 空闲中的最大连接数
+	MaxOpenConns int    `mapstructure:"max-open-cons" json:"MaxOpenConns" yaml:"max-open-cons"` // 打开到数据库的最大连接数
+	Debug        bool   `mapstructure:"debug" json:"debug" yaml:"debug"`                        // 是否开启Gorm全局日志
+}

config/oss.go

@@ -0,0 +1,9 @@
+package config
+
+type Oss struct {
+	OssAccessKey        string `mapstructure:"oss-access-key" json:"oss-access-key" yaml:"oss-access-key"`
+	OssAccessKeySecret  string `mapstructure:"oss-access-key-secret" json:"oss-access-key-secret" yaml:"oss-access-key-secret"`
+	OssBucket           string `mapstructure:"oss-bucket" json:"oss-bucket" yaml:"oss-bucket"`
+	OssEndpoint         string `mapstructure:"oss-endpoint" json:"oss-endpoint" yaml:"oss-endpoint"`
+	OssCustomDomainName string `mapstructure:"oss-custom-domain-name" json:"oss-custom-domain-name" yaml:"oss-custom-domain-name"`
+}