肝病算一算后台api初始化

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)
+}