新增：获取服务包订单服务权益详情

api/controller/orderServicePackage.go

@@ -6,8 +6,10 @@ import (
 	"hospital-admin-api/api/dto"
 	"hospital-admin-api/api/requests"
 	"hospital-admin-api/api/responses"
+	"hospital-admin-api/api/service"
 	"hospital-admin-api/global"
 	"hospital-admin-api/utils"
+	"strconv"
 )
 
 type OrderServicePackage struct{}
@@ -56,3 +58,55 @@ func (r *OrderServicePackage) GetOrderServicePackagePage(c *gin.Context) {
 	result["data"] = GetOrderInquiryPageResponses
 	responses.OkWithData(result, c)
 }
+
+// GetOrderServicePackage 获取服务包订单详情
+func (r *OrderServicePackage) GetOrderServicePackage(c *gin.Context) {
+	id := c.Param("order_service_id")
+	if id == "" {
+		responses.FailWithMessage("缺少参数", c)
+		return
+	}
+
+	// 将 id 转换为 int64 类型
+	orderServiceId, err := strconv.ParseInt(id, 10, 64)
+	if err != nil {
+		responses.Fail(c)
+		return
+	}
+
+	// 业务处理
+	orderServicePackageService := service.OrderServicePackageService{}
+	getResponses, err := orderServicePackageService.GetOrderServicePackage(orderServiceId)
+	if err != nil {
+		responses.FailWithMessage(err.Error(), c)
+		return
+	}
+
+	responses.OkWithData(getResponses, c)
+}
+
+// GetOrderServicePackageDetailInfo 获取服务包订单服务权益详情
+func (r *OrderServicePackage) GetOrderServicePackageDetailInfo(c *gin.Context) {
+	id := c.Param("order_service_id")
+	if id == "" {
+		responses.FailWithMessage("缺少参数", c)
+		return
+	}
+
+	// 将 id 转换为 int64 类型
+	orderServiceId, err := strconv.ParseInt(id, 10, 64)
+	if err != nil {
+		responses.Fail(c)
+		return
+	}
+
+	// 业务处理
+	orderServicePackageService := service.OrderServicePackageService{}
+	getResponses, err := orderServicePackageService.GetOrderServicePackageDetailInfo(orderServiceId)
+	if err != nil {
+		responses.FailWithMessage(err.Error(), c)
+		return
+	}
+
+	responses.OkWithData(getResponses, c)
+}

api/dao/healthPackageProduct.go

@@ -0,0 +1,74 @@
+package dao
+
+import (
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"hospital-admin-api/api/model"
+	"hospital-admin-api/global"
+)
+
+type HealthPackageProductDao struct {
+}
+
+// GetHealthPackageProductById 获取数据-id
+func (r *HealthPackageProductDao) GetHealthPackageProductById(packageProductId int64) (m *model.HealthPackageProduct, err error) {
+	err = global.Db.First(&m, packageProductId).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetHealthPackageProductPreloadById 获取数据-加载全部关联-id
+func (r *HealthPackageProductDao) GetHealthPackageProductPreloadById(packageProductId int64) (m *model.HealthPackageProduct, err error) {
+	err = global.Db.Preload(clause.Associations).First(&m, packageProductId).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetHealthPackageProductByPackageId 获取数据-id
+func (r *HealthPackageProductDao) GetHealthPackageProductByPackageId(packageId int64) (m []*model.HealthPackageProduct,
+	err error) {
+	err = global.Db.Where("package_id = ?", packageId).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// DeleteHealthPackageProduct 删除
+func (r *HealthPackageProductDao) DeleteHealthPackageProduct(tx *gorm.DB, maps interface{}) error {
+	err := tx.Where(maps).Delete(&model.HealthPackageProduct{}).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// EditHealthPackageProduct 修改
+func (r *HealthPackageProductDao) EditHealthPackageProduct(tx *gorm.DB, maps interface{}, data interface{}) error {
+	err := tx.Model(&model.HealthPackageProduct{}).Where(maps).Updates(data).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// GetHealthPackageProductList 获取列表
+func (r *HealthPackageProductDao) GetHealthPackageProductList(maps interface{}) (m []*model.HealthPackageProduct, err error) {
+	err = global.Db.Where(maps).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// AddHealthPackageProduct 新增
+func (r *HealthPackageProductDao) AddHealthPackageProduct(tx *gorm.DB, model *model.HealthPackageProduct) (*model.HealthPackageProduct, error) {
+	if err := tx.Create(model).Error; err != nil {
+		return nil, err
+	}
+	return model, nil
+}

api/dao/orderServicePackage.go

@@ -31,8 +31,8 @@ func (r *OrderServicePackageDao) GetOrderServicePackagePreloadById(orderServiceI
 	return m, nil
 }
 
-// GetOrderServicePackageByOrderProductId 获取数据-药品订单id
-func (r *OrderServicePackageDao) GetOrderServicePackageByOrderProductId(orderId int64) (m *model.OrderServicePackage, err error) {
+// GetOrderServicePackageByOrderId 获取数据-订单id
+func (r *OrderServicePackageDao) GetOrderServicePackageByOrderId(orderId int64) (m *model.OrderServicePackage, err error) {
 	err = global.Db.Where("order_id = ?", orderId).First(&m).Error
 	if err != nil {
 		return nil, err

api/dao/orderServicePackageCase.go

@@ -0,0 +1,100 @@
+package dao
+
+import (
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"hospital-admin-api/api/model"
+	"hospital-admin-api/global"
+)
+
+type OrderServicePackageCaseDao struct {
+}
+
+// GetOrderServicePackageCaseById 获取数据-id
+func (r *OrderServicePackageCaseDao) GetOrderServicePackageCaseById(orderServiceCaseId int64) (m *model.OrderServicePackageCase, err error) {
+	err = global.Db.First(&m, orderServiceCaseId).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetOrderServicePackageCasePreloadById 获取数据-加载全部关联-id
+func (r *OrderServicePackageCaseDao) GetOrderServicePackageCasePreloadById(orderServiceCaseId int64) (m *model.OrderServicePackageCase, err error) {
+	err = global.Db.Preload(clause.Associations).First(&m, orderServiceCaseId).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetOrderServicePackageCaseByOrderId 获取数据-订单id
+func (r *OrderServicePackageCaseDao) GetOrderServicePackageCaseByOrderId(orderId int64) (m *model.OrderServicePackageCase, err error) {
+	err = global.Db.Where("order_id = ?", orderId).First(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetOrderServicePackageCaseByOrderServicePackageId 获取数据-订单id
+func (r *OrderServicePackageCaseDao) GetOrderServicePackageCaseByOrderServicePackageId(orderServicePackageId int64) (m *model.OrderServicePackageCase, err error) {
+	err = global.Db.Where("order_service_id = ?", orderServicePackageId).First(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// DeleteOrderServicePackageCase 删除
+func (r *OrderServicePackageCaseDao) DeleteOrderServicePackageCase(tx *gorm.DB, maps interface{}) error {
+	err := tx.Where(maps).Delete(&model.OrderServicePackageCase{}).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// EditOrderServicePackageCase 修改
+func (r *OrderServicePackageCaseDao) EditOrderServicePackageCase(tx *gorm.DB, maps interface{}, data interface{}) error {
+	err := tx.Model(&model.OrderServicePackageCase{}).Where(maps).Updates(data).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// EditOrderServicePackageCaseByOrderServicePackageId 修改-id
+func (r *OrderServicePackageCaseDao) EditOrderServicePackageCaseByOrderServicePackageId(tx *gorm.DB, orderServicePackageId int64, data interface{}) error {
+	err := tx.Model(&model.OrderServicePackageCase{}).Where("order_service_id = ?", orderServicePackageId).Updates(data).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// EditOrderServicePackageCaseById 修改-药品订单id
+func (r *OrderServicePackageCaseDao) EditOrderServicePackageCaseById(tx *gorm.DB, orderId int64, data interface{}) error {
+	err := tx.Model(&model.OrderServicePackageCase{}).Where("order_id = ?", orderId).Updates(data).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// GetOrderServicePackageCaseList 获取列表
+func (r *OrderServicePackageCaseDao) GetOrderServicePackageCaseList(maps interface{}) (m []*model.OrderServicePackageCase, err error) {
+	err = global.Db.Where(maps).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// AddOrderServicePackageCase 新增
+func (r *OrderServicePackageCaseDao) AddOrderServicePackageCase(tx *gorm.DB, model *model.OrderServicePackageCase) (*model.OrderServicePackageCase, error) {
+	if err := tx.Create(model).Error; err != nil {
+		return nil, err
+	}
+	return model, nil
+}

api/dao/orderServicePackageDetail.go

@@ -0,0 +1,100 @@
+package dao
+
+import (
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"hospital-admin-api/api/model"
+	"hospital-admin-api/global"
+)
+
+type OrderServicePackageDetailDao struct {
+}
+
+// GetOrderServicePackageDetailById 获取数据-id
+func (r *OrderServicePackageDetailDao) GetOrderServicePackageDetailById(orderServiceDetailId int64) (m *model.OrderServicePackageDetail, err error) {
+	err = global.Db.First(&m, orderServiceDetailId).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetOrderServicePackageDetailPreloadById 获取数据-加载全部关联-id
+func (r *OrderServicePackageDetailDao) GetOrderServicePackageDetailPreloadById(orderServiceDetailId int64) (m *model.OrderServicePackageDetail, err error) {
+	err = global.Db.Preload(clause.Associations).First(&m, orderServiceDetailId).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetOrderServicePackageDetailByOrderId 获取数据-订单id
+func (r *OrderServicePackageDetailDao) GetOrderServicePackageDetailByOrderId(orderId int64) (m *model.OrderServicePackageDetail, err error) {
+	err = global.Db.Where("order_id = ?", orderId).First(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetOrderServicePackageDetailByOrderServicePackageId 获取数据-订单id
+func (r *OrderServicePackageDetailDao) GetOrderServicePackageDetailByOrderServicePackageId(orderServicePackageId int64) (m *model.OrderServicePackageDetail, err error) {
+	err = global.Db.Where("order_service_id = ?", orderServicePackageId).First(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// DeleteOrderServicePackageDetail 删除
+func (r *OrderServicePackageDetailDao) DeleteOrderServicePackageDetail(tx *gorm.DB, maps interface{}) error {
+	err := tx.Where(maps).Delete(&model.OrderServicePackageDetail{}).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// EditOrderServicePackageDetail 修改
+func (r *OrderServicePackageDetailDao) EditOrderServicePackageDetail(tx *gorm.DB, maps interface{}, data interface{}) error {
+	err := tx.Model(&model.OrderServicePackageDetail{}).Where(maps).Updates(data).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// EditOrderServicePackageDetailByOrderServicePackageId 修改-id
+func (r *OrderServicePackageDetailDao) EditOrderServicePackageDetailByOrderServicePackageId(tx *gorm.DB, orderServicePackageId int64, data interface{}) error {
+	err := tx.Model(&model.OrderServicePackageDetail{}).Where("order_service_id = ?", orderServicePackageId).Updates(data).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// EditOrderServicePackageDetailById 修改-药品订单id
+func (r *OrderServicePackageDetailDao) EditOrderServicePackageDetailById(tx *gorm.DB, orderId int64, data interface{}) error {
+	err := tx.Model(&model.OrderServicePackageDetail{}).Where("order_id = ?", orderId).Updates(data).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// GetOrderServicePackageDetailList 获取列表
+func (r *OrderServicePackageDetailDao) GetOrderServicePackageDetailList(maps interface{}) (m []*model.OrderServicePackageDetail, err error) {
+	err = global.Db.Where(maps).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// AddOrderServicePackageDetail 新增
+func (r *OrderServicePackageDetailDao) AddOrderServicePackageDetail(tx *gorm.DB, model *model.OrderServicePackageDetail) (*model.OrderServicePackageDetail, error) {
+	if err := tx.Create(model).Error; err != nil {
+		return nil, err
+	}
+	return model, nil
+}

api/dao/orderServicePackageInquiry.go

@@ -0,0 +1,74 @@
+package dao
+
+import (
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"hospital-admin-api/api/model"
+	"hospital-admin-api/global"
+)
+
+type OrderServicePackageInquiryDao struct {
+}
+
+// GetOrderServicePackageInquiryById 获取数据-id
+func (r *OrderServicePackageInquiryDao) GetOrderServicePackageInquiryById(serviceProductId int64) (m *model.OrderServicePackageInquiry, err error) {
+	err = global.Db.First(&m, serviceProductId).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetOrderServicePackageInquiryPreloadById 获取数据-加载全部关联-id
+func (r *OrderServicePackageInquiryDao) GetOrderServicePackageInquiryPreloadById(serviceProductId int64) (m *model.OrderServicePackageInquiry, err error) {
+	err = global.Db.Preload(clause.Associations).First(&m, serviceProductId).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetOrderServicePackageInquiryByOrderNo 获取数据-系统订单编号
+func (r *OrderServicePackageInquiryDao) GetOrderServicePackageInquiryByOrderNo(orderNo string) (m []*model.OrderServicePackageInquiry, err error) {
+	err = global.Db.Where("order_service_no = ?", orderNo).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetOrderServicePackageInquiryPreloadByOrderNo 获取数据-系统订单编号
+func (r *OrderServicePackageInquiryDao) GetOrderServicePackageInquiryPreloadByOrderNo(orderNo string) (m []*model.OrderServicePackageInquiry, err error) {
+	err = global.Db.Preload(clause.Associations).Where("order_service_no = ?", orderNo).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// DeleteOrderServicePackageInquiry 删除
+func (r *OrderServicePackageInquiryDao) DeleteOrderServicePackageInquiry(tx *gorm.DB, maps interface{}) error {
+	err := tx.Where(maps).Delete(&model.OrderServicePackageInquiry{}).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// EditOrderServicePackageInquiry 修改
+func (r *OrderServicePackageInquiryDao) EditOrderServicePackageInquiry(tx *gorm.DB, maps interface{}, data interface{}) error {
+	err := tx.Model(&model.OrderServicePackageInquiry{}).Where(maps).Updates(data).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// GetOrderServicePackageInquiryList 获取列表
+func (r *OrderServicePackageInquiryDao) GetOrderServicePackageInquiryList(maps interface{}) (m []*model.OrderServicePackageInquiry, err error) {
+	err = global.Db.Where(maps).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}

api/dao/orderServicePackageProduct.go

@@ -0,0 +1,57 @@
+package dao
+
+import (
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"hospital-admin-api/api/model"
+	"hospital-admin-api/global"
+)
+
+type OrderServicePackageProductDao struct {
+}
+
+// GetOrderServicePackageProductById 获取数据-id
+func (r *OrderServicePackageProductDao) GetOrderServicePackageProductById(serviceProductId int64) (m *model.OrderServicePackageProduct, err error) {
+	err = global.Db.First(&m, serviceProductId).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetOrderServicePackageProductPreloadById 获取数据-加载全部关联-id
+func (r *OrderServicePackageProductDao) GetOrderServicePackageProductPreloadById(serviceProductId int64) (m *model.OrderServicePackageProduct, err error) {
+	err = global.Db.Preload(clause.Associations).First(&m, serviceProductId).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetOrderServicePackageProductPreloadByOrderServiceId 获取数据
+func (r *OrderServicePackageProductDao) GetOrderServicePackageProductPreloadByOrderServiceId(orderServiceId int64) (m []*model.
+	OrderServicePackageProduct, err error) {
+	err = global.Db.Where("order_service_id = ?", orderServiceId).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// EditOrderServicePackageProduct 修改
+func (r *OrderServicePackageProductDao) EditOrderServicePackageProduct(tx *gorm.DB, maps interface{}, data interface{}) error {
+	err := tx.Model(&model.OrderServicePackageProduct{}).Where(maps).Updates(data).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// GetOrderServicePackageProductList 获取列表
+func (r *OrderServicePackageProductDao) GetOrderServicePackageProductList(maps interface{}) (m []*model.OrderServicePackageProduct, err error) {
+	err = global.Db.Where(maps).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}

api/dao/orderServicePackageRefund.go

@@ -0,0 +1,100 @@
+package dao
+
+import (
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"hospital-admin-api/api/model"
+	"hospital-admin-api/global"
+)
+
+type OrderServicePackageRefundDao struct {
+}
+
+// GetOrderServicePackageRefundById 获取数据-id
+func (r *OrderServicePackageRefundDao) GetOrderServicePackageRefundById(serviceRefundId int64) (m *model.OrderServicePackageRefund, err error) {
+	err = global.Db.First(&m, serviceRefundId).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetOrderServicePackageRefundPreloadById 获取数据-加载全部关联-id
+func (r *OrderServicePackageRefundDao) GetOrderServicePackageRefundPreloadById(serviceRefundId int64) (m *model.OrderServicePackageRefund, err error) {
+	err = global.Db.Preload(clause.Associations).First(&m, serviceRefundId).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetOrderServicePackageRefundByOrderServicePackageId 获取数据-服务包订单id
+func (r *OrderServicePackageRefundDao) GetOrderServicePackageRefundByOrderServicePackageId(orderServicePackageId int64) (m *model.OrderServicePackageRefund, err error) {
+	err = global.Db.Where("order_service_id = ?", orderServicePackageId).First(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetOrderServicePackageRefundByOrderNo 获取数据-系统订单id
+func (r *OrderServicePackageRefundDao) GetOrderServicePackageRefundByOrderNo(orderNo int64) (m *model.OrderServicePackageRefund, err error) {
+	err = global.Db.Where("order_service_no = ?", orderNo).First(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// DeleteOrderServicePackageRefund 删除
+func (r *OrderServicePackageRefundDao) DeleteOrderServicePackageRefund(tx *gorm.DB, maps interface{}) error {
+	err := tx.Where(maps).Delete(&model.OrderServicePackageRefund{}).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// EditOrderServicePackageRefund 修改
+func (r *OrderServicePackageRefundDao) EditOrderServicePackageRefund(tx *gorm.DB, maps interface{}, data interface{}) error {
+	err := tx.Model(&model.OrderServicePackageRefund{}).Where(maps).Updates(data).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// EditOrderServicePackageRefundByOrderServicePackageId 修改-id
+func (r *OrderServicePackageRefundDao) EditOrderServicePackageRefundByOrderServicePackageId(tx *gorm.DB, orderServicePackageId int64, data interface{}) error {
+	err := tx.Model(&model.OrderServicePackageRefund{}).Where("order_service_id = ?", orderServicePackageId).Updates(data).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// EditOrderServicePackageRefundById 修改-药品订单id
+func (r *OrderServicePackageRefundDao) EditOrderServicePackageRefundById(tx *gorm.DB, orderNo string, data interface{}) error {
+	err := tx.Model(&model.OrderServicePackageRefund{}).Where("order_service_no = ?", orderNo).Updates(data).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// GetOrderServicePackageRefundList 获取列表
+func (r *OrderServicePackageRefundDao) GetOrderServicePackageRefundList(maps interface{}) (m []*model.OrderServicePackageRefund, err error) {
+	err = global.Db.Where(maps).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// AddOrderServicePackageRefund 新增
+func (r *OrderServicePackageRefundDao) AddOrderServicePackageRefund(tx *gorm.DB, model *model.OrderServicePackageRefund) (*model.OrderServicePackageRefund, error) {
+	if err := tx.Create(model).Error; err != nil {
+		return nil, err
+	}
+	return model, nil
+}

api/dao/userCoupon.go

@@ -5,6 +5,7 @@ import (
 	"gorm.io/gorm/clause"
 	"hospital-admin-api/api/model"
 	"hospital-admin-api/global"
+	"time"
 )
 
 type UserCouponDao struct {
@@ -79,3 +80,40 @@ func (r *UserCouponDao) AddUserCoupon(tx *gorm.DB, model *model.UserCoupon) (*mo
 	}
 	return model, nil
 }
+
+// GetUserAllObjectTypeCoupon 获取用户某一类型优惠卷
+func (r *UserCouponDao) GetUserAllObjectTypeCoupon(userId int64, distributionObject int) (m []*model.UserCoupon, err error) {
+	// 构建查询条件
+	query := global.Db.Model(&model.UserCoupon{})
+
+	query = query.Preload("Coupon")
+
+	// 用户优惠卷搜索条件
+	query = query.Where("user_id = ?", userId)
+
+	// 获取当前时间
+	currentTime := time.Now()
+
+	// 格式化时间为 "Y-m-d H:i:s"
+	formattedTime := currentTime.Format("2006-01-02 15:04:05")
+
+	query = query.Where("valid_start_time < ?", formattedTime) // 有效使用时间
+	query = query.Where("valid_end_time > ?", formattedTime)   // 过期使用时间
+
+	// 优惠卷搜索条件
+	subQuery := global.Db.Model(&model.Coupon{}).
+		Where("gdxz_user_coupon.coupon_id  = gdxz_coupon.coupon_id").
+		Where("gdxz_coupon.distribution_object = ?", distributionObject).
+		Where("gdxz_coupon.coupon_client = ?", 1).
+		Where("gdxz_coupon.coupon_status = ?", 1)
+
+	query = query.Where("EXISTS (?)", subQuery)
+
+	query = query.Group("coupon_id")
+
+	err = query.Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}

api/dto/HealthPackageProduct.go

@@ -0,0 +1,56 @@
+package dto
+
+import (
+	"fmt"
+	"hospital-admin-api/api/model"
+)
+
+// HealthPackageProductDto 健康包-关联商品
+type HealthPackageProductDto struct {
+	PackageProductId     string          `json:"package_product_id"`     // 主键id
+	PackageId            string          `json:"package_id"`             // 健康包id
+	ProductId            string          `json:"product_id"`             // 商品id
+	ProductName          string          `json:"product_name"`           // 商品名称
+	Quantity             int             `json:"quantity"`               // 数量
+	DiscountProductPrice float64         `json:"discount_product_price"` // 折扣商品价格
+	CreatedAt            model.LocalTime `json:"created_at"`             // 创建时间
+	UpdatedAt            model.LocalTime `json:"updated_at"`             // 修改时间
+}
+
+func GetHealthPackageProductDto(m *model.HealthPackageProduct) *HealthPackageProductDto {
+	return &HealthPackageProductDto{
+		PackageProductId:     fmt.Sprintf("%d", m.PackageProductId),
+		PackageId:            fmt.Sprintf("%d", m.PackageId),
+		ProductId:            fmt.Sprintf("%d", m.ProductId),
+		ProductName:          m.ProductName,
+		Quantity:             m.Quantity,
+		DiscountProductPrice: m.DiscountProductPrice,
+		CreatedAt:            m.CreatedAt,
+		UpdatedAt:            m.UpdatedAt,
+	}
+}
+
+func GetHealthPackageProductListDto(m []*model.HealthPackageProduct) []*HealthPackageProductDto {
+	// 处理返回值
+	responses := make([]*HealthPackageProductDto, len(m))
+
+	if len(m) > 0 {
+		for i, v := range m {
+			response := &HealthPackageProductDto{
+				PackageProductId:     fmt.Sprintf("%d", v.PackageProductId),
+				PackageId:            fmt.Sprintf("%d", v.PackageId),
+				ProductId:            fmt.Sprintf("%d", v.ProductId),
+				ProductName:          v.ProductName,
+				Quantity:             v.Quantity,
+				DiscountProductPrice: v.DiscountProductPrice,
+				CreatedAt:            v.CreatedAt,
+				UpdatedAt:            v.UpdatedAt,
+			}
+
+			// 将转换后的结构体添加到新切片中
+			responses[i] = response
+		}
+	}
+
+	return responses
+}

api/dto/OrderInquiry.go

@@ -337,7 +337,7 @@ func (r *OrderInquiryDto) LoadUserName(m *model.User) *OrderInquiryDto {
 // LoadOrderInquiryRefund 加载订单退款数据
 func (r *OrderInquiryDto) LoadOrderInquiryRefund(m *model.OrderInquiryRefund) *OrderInquiryDto {
 	if m != nil {
-		d := GetOrderInquiryRefundBankDto(m)
+		d := GetOrderInquiryRefundDto(m)
 
 		r.OrderInquiryRefund = d
 	}

api/dto/OrderInquiryRefund.go

@@ -12,7 +12,7 @@ type OrderInquiryRefundDto struct {
 	InquiryNo           string          `json:"inquiry_no"`            // 系统订单编号
 	InquiryRefundNo     string          `json:"inquiry_refund_no"`     // 系统退款编号
 	RefundId            string          `json:"refund_id"`             // 第三方退款单号
-	InquiryRefundStatus int             `json:"inquiry_refund_status"` // 问诊订单退款状态（0:无退款 1:申请退款 2:退款中 3:退款成功 4:拒绝退款 5:退款关闭 6:退款异常）
+	InquiryRefundStatus int             `json:"inquiry_refund_status"` // 问诊订单退款状态（0:无退款 1:申请退款 2:退款中 3:退款成功 4 // :拒绝退款 5:退款关闭 6:退款异常）
 	RefundTotal         float64         `json:"refund_total"`          // 退款金额
 	RefundReason        string          `json:"refund_reason"`         // 退款原因
 	SuccessTime         model.LocalTime `json:"success_time"`          // 退款成功时间
@@ -20,7 +20,7 @@ type OrderInquiryRefundDto struct {
 	UpdatedAt           model.LocalTime `json:"updated_at"`            // 修改时间
 }
 
-func GetOrderInquiryRefundBankDto(m *model.OrderInquiryRefund) *OrderInquiryRefundDto {
+func GetOrderInquiryRefundDto(m *model.OrderInquiryRefund) *OrderInquiryRefundDto {
 	return &OrderInquiryRefundDto{
 		InquiryRefundId:     fmt.Sprintf("%d", m.InquiryRefundId),
 		PatientId:           fmt.Sprintf("%d", m.PatientId),

api/dto/OrderServicePackage.go

@@ -5,42 +5,71 @@ import (
 	"hospital-admin-api/api/model"
 )
 
-// OrderServicePackageDto 订单-服务包表
+// OrderServicePackageDto 订单-服务包
 type OrderServicePackageDto struct {
-	OrderServiceId      string          `json:"order_service_id"`       // 主键id
-	OrderId             string          `json:"order_id"`               // 订单id
-	UserId              string          `json:"user_id"`                // 用户id-患者
-	PatientId           string          `json:"patient_id"`             // 患者id
-	DoctorId            string          `json:"doctor_id"`              // 医生id
-	FamilyId            string          `json:"family_id"`              // 家庭成员id（就诊用户）
-	OrderServiceType    int             `json:"order_service_type"`     // 服务包类型（1:健康包 2:随访包）
-	OrderServiceStatus  int             `json:"order_service_status"`   // 订单状态（1:待支付 2:未开始 3:服务中 4:服务完成 5:服务取消）
-	IsDelete            int             `json:"is_delete"`              // 删除状态（0:否 1:是）
-	RefundStatus        int             `json:"refund_status"`          // 订单退款状态（0:无退款 1:申请退款 2:退款中 3:退款成功 4:拒绝退款 5:退款关闭 6:退款异常 7:部分退款）
-	PayChannel          int             `json:"pay_channel"`            // 支付渠道（1:小程序支付 2:微信扫码支付 3:模拟支付）
-	PayStatus           int             `json:"pay_status"`             // 支付状态（1:未支付 2:已支付 3:支付中 4:支付失败 5:支付超时 6:支付关闭 7:已撤销 8:转入退款）
-	OrderServiceNo      string          `json:"order_service_no"`       // 系统订单编号
-	EscrowTradeNo       string          `json:"escrow_trade_no"`        // 第三方支付流水号
-	AmountTotal         float64         `json:"amount_total"`           // 订单金额
-	CouponAmountTotal   float64         `json:"coupon_amount_total"`    // 优惠卷总金额
-	PaymentAmountTotal  float64         `json:"payment_amount_total"`   // 实际付款金额
-	PayTime             model.LocalTime `json:"pay_time"`               // 支付时间
-	StartTime           model.LocalTime `json:"start_time"`             // 开始服务时间
-	FinishTime          model.LocalTime `json:"finish_time"`            // 结束服务时间
-	CancelTime          model.LocalTime `json:"cancel_time"`            // 订单取消时间
-	CancelReason        int             `json:"cancel_reason"`          // 取消订单原因（1:医生未接受服务 2:主动取消 4:客服取消 5:支付超时）
-	CancelRemarks       string          `json:"cancel_remarks"`         // 取消订单备注
-	AddFinishStatus     int             `json:"add_finish_status"`      // 添加完成订单延迟队列状态（0:未添加 1:已添加 2:添加失败）
-	AddFinishTime       model.LocalTime `json:"add_finish_time"`        // 添加完成订单延迟队列时间
-	AddFinishFailReason string          `json:"add_finish_fail_reason"` // 添加完成订单延迟队列失败原因
-	PatientName         string          `json:"patient_name"`           // 患者姓名-就诊人
-	PatientNameMask     string          `json:"patient_name_mask"`      // 患者姓名-就诊人(掩码)
-	PatientSex          int             `json:"patient_sex"`            // 患者性别-就诊人（0:未知 1:男 2:女）
-	PatientAge          int             `json:"patient_age"`            // 患者年龄-就诊人
-	CreatedAt           model.LocalTime `json:"created_at"`             // 创建时间
-	UpdatedAt           model.LocalTime `json:"updated_at"`             // 更新时间
-	DoctorName          string          `json:"doctor_name"`            // 医生姓名
-	UserName            string          `json:"user_name"`              // 用户姓名（患者）
+	OrderServiceId            string                        `json:"order_service_id"`             // 主键id
+	OrderId                   string                        `json:"order_id"`                     // 订单id
+	UserId                    string                        `json:"user_id"`                      // 用户id-患者
+	PatientId                 string                        `json:"patient_id"`                   // 患者id
+	DoctorId                  string                        `json:"doctor_id"`                    // 医生id
+	FamilyId                  string                        `json:"family_id"`                    // 家庭成员id（就诊用户）
+	OrderServiceType          int                           `json:"order_service_type"`           // 服务包类型（1:健康包 2:随访包）
+	OrderServiceStatus        int                           `json:"order_service_status"`         // 订单状态（1:待支付 2:未开始 3:服务中 4:服务完成 5:服务取消）
+	IsDelete                  int                           `json:"is_delete"`                    // 删除状态（0:否 1:是）
+	RefundStatus              int                           `json:"refund_status"`                // 订单退款状态（0:无退款 1:申请退款 2:退款中 3:退款成功 4:拒绝退款 5:退款关闭 6:退款异常 7:部分退款）
+	PayChannel                int                           `json:"pay_channel"`                  // 支付渠道（1:小程序支付 2:微信扫码支付 3:模拟支付）
+	PayStatus                 int                           `json:"pay_status"`                   // 支付状态（1:未支付 2:已支付 3:支付中 4:支付失败 5:支付超时 6:支付关闭 7:已撤销 8:转入退款）
+	OrderServiceNo            string                        `json:"order_service_no"`             // 系统订单编号
+	EscrowTradeNo             string                        `json:"escrow_trade_no"`              // 第三方支付流水号
+	AmountTotal               float64                       `json:"amount_total"`                 // 订单金额
+	CouponAmountTotal         float64                       `json:"coupon_amount_total"`          // 优惠卷总金额
+	PaymentAmountTotal        float64                       `json:"payment_amount_total"`         // 实际付款金额
+	PayTime                   model.LocalTime               `json:"pay_time"`                     // 支付时间
+	StartTime                 model.LocalTime               `json:"start_time"`                   // 开始服务时间
+	FinishTime                model.LocalTime               `json:"finish_time"`                  // 结束服务时间
+	CancelTime                model.LocalTime               `json:"cancel_time"`                  // 订单取消时间
+	CancelReason              int                           `json:"cancel_reason"`                // 取消订单原因（1:医生未接受服务 2:主动取消 4:客服取消 5:支付超时）
+	CancelRemarks             string                        `json:"cancel_remarks"`               // 取消订单备注
+	AddFinishStatus           int                           `json:"add_finish_status"`            // 添加完成订单延迟队列状态（0:未添加 1:已添加 2:添加失败）
+	AddFinishTime             model.LocalTime               `json:"add_finish_time"`              // 添加完成订单延迟队列时间
+	AddFinishFailReason       string                        `json:"add_finish_fail_reason"`       // 添加完成订单延迟队列失败原因
+	PatientName               string                        `json:"patient_name"`                 // 患者姓名-就诊人
+	PatientNameMask           string                        `json:"patient_name_mask"`            // 患者姓名-就诊人(掩码)
+	PatientSex                int                           `json:"patient_sex"`                  // 患者性别-就诊人（0:未知 1:男 2:女）
+	PatientAge                int                           `json:"patient_age"`                  // 患者年龄-就诊人
+	CreatedAt                 model.LocalTime               `json:"created_at"`                   // 创建时间
+	UpdatedAt                 model.LocalTime               `json:"updated_at"`                   // 更新时间
+	DoctorName                string                        `json:"doctor_name"`                  // 医生姓名
+	UserName                  string                        `json:"user_name"`                    // 用户姓名（患者）
+	UserDoctor                *UserDoctorDto                `json:"user_doctor"`                  // 医生数据
+	OrderServicePackageCase   *OrderServicePackageCaseDto   `json:"order_service_package_case"`   // 病例
+	OrderServicePackageRefund *OrderServicePackageRefundDto `json:"order_service_package_refund"` // 退款数据
+}
+
+// OrderServicePackageDetailInfoDto 服务包权益
+type OrderServicePackageDetailInfoDto struct {
+	OrderServiceId             string                           `json:"order_service_id"`              // 主键id
+	OrderId                    string                           `json:"order_id"`                      // 订单id
+	UserId                     string                           `json:"user_id"`                       // 用户id-患者
+	PatientId                  string                           `json:"patient_id"`                    // 患者id
+	DoctorId                   string                           `json:"doctor_id"`                     // 医生id
+	FamilyId                   string                           `json:"family_id"`                     // 家庭成员id（就诊用户）
+	OrderServiceType           int                              `json:"order_service_type"`            // 服务包类型（1:健康包 2:随访包）
+	OrderServiceStatus         int                              `json:"order_service_status"`          // 订单状态（1:待支付 2:未开始 3:服务中 4:服务完成 5:服务取消）
+	IsDelete                   int                              `json:"is_delete"`                     // 删除状态（0:否 1:是）
+	OrderServiceNo             string                           `json:"order_service_no"`              // 系统订单编号
+	PayTime                    model.LocalTime                  `json:"pay_time"`                      // 支付时间
+	StartTime                  model.LocalTime                  `json:"start_time"`                    // 开始服务时间
+	FinishTime                 model.LocalTime                  `json:"finish_time"`                   // 结束服务时间
+	CreatedAt                  model.LocalTime                  `json:"created_at"`                    // 创建时间
+	OrderServicePackageProduct []*OrderServicePackageProductDto `json:"order_service_package_product"` // 关联商品订单
+	OrderServicePackageInquiry []*OrderServicePackageInquiryDto `json:"order_service_package_inquiry"` // 关联问诊订单
+	UserCoupon                 []*UserCouponDto                 `json:"user_coupon"`                   // 关联优惠卷
+	OrderServicePackageDetail  *OrderServicePackageDetailDto    `json:"order_service_package_detail"`  // 服务包订单详情
+	CurrentMonthStartDate      string                           `json:"current_month_start_date"`      // 当月开始时间
+	CurrentMonthFinishDate     string                           `json:"current_month_finish_date"`     // 当月结束时间
+	MonthInquiryCount          int                              `json:"month_inquiry_count"`           // 当月问诊次数
+	RemainingInquiryCount      string                           `json:"remaining_inquiry_count"`       // 当月剩余问诊次数
 }
 
 // GetOrderServicePackageDto 服务包订单详情
@@ -141,6 +170,26 @@ func GetOrderServicePackageListDto(m []*model.OrderServicePackage) []*OrderServi
 	return responses
 }
 
+// GetOrderServicePackageDetailInfoDto 服务包权益详情
+func GetOrderServicePackageDetailInfoDto(m *model.OrderServicePackage) *OrderServicePackageDetailInfoDto {
+	return &OrderServicePackageDetailInfoDto{
+		OrderServiceId:     fmt.Sprintf("%d", m.OrderServiceId),
+		OrderId:            fmt.Sprintf("%d", m.OrderId),
+		UserId:             fmt.Sprintf("%d", m.UserId),
+		PatientId:          fmt.Sprintf("%d", m.PatientId),
+		DoctorId:           fmt.Sprintf("%d", m.DoctorId),
+		FamilyId:           fmt.Sprintf("%d", m.FamilyId),
+		OrderServiceType:   m.OrderServiceType,
+		OrderServiceStatus: m.OrderServiceStatus,
+		IsDelete:           m.IsDelete,
+		OrderServiceNo:     m.OrderServiceNo,
+		PayTime:            m.PayTime,
+		StartTime:          m.StartTime,
+		FinishTime:         m.FinishTime,
+		CreatedAt:          m.CreatedAt,
+	}
+}
+
 // LoadDoctorName 加载医生名称
 func (r *OrderServicePackageDto) LoadDoctorName(m *model.UserDoctor) *OrderServicePackageDto {
 	if m != nil {
@@ -156,3 +205,64 @@ func (r *OrderServicePackageDto) LoadUserName(m *model.User) *OrderServicePackag
 	}
 	return r
 }
+
+// LoadOrderServicePackageRefund 加载订单退款数据
+func (r *OrderServicePackageDto) LoadOrderServicePackageRefund(m *model.OrderServicePackageRefund) *OrderServicePackageDto {
+	if m != nil {
+		d := GetOrderServicePackageRefundDto(m)
+
+		r.OrderServicePackageRefund = d
+	}
+	return r
+}
+
+// LoadMaskOrderServicePackageCase 加载病例
+func (r *OrderServicePackageDto) LoadMaskOrderServicePackageCase(m *model.OrderServicePackageCase) *OrderServicePackageDto {
+	if m != nil {
+		d := GetOrderServicePackageCaseDto(m)
+
+		r.OrderServicePackageCase = d
+	}
+	return r
+}
+
+// LoadOrderServicePackageProduct 加载关联商品订单
+func (r *OrderServicePackageDetailInfoDto) LoadOrderServicePackageProduct(m []*model.OrderServicePackageProduct) *OrderServicePackageDetailInfoDto {
+	if len(m) > 0 {
+		d := GetOrderServicePackageProductListDto(m)
+
+		r.OrderServicePackageProduct = d
+	}
+	return r
+}
+
+// LoadOrderServicePackageInquiry 加载关联问诊订单
+func (r *OrderServicePackageDetailInfoDto) LoadOrderServicePackageInquiry(m []*model.OrderServicePackageInquiry) *OrderServicePackageDetailInfoDto {
+	if len(m) > 0 {
+		d := GetOrderServicePackageInquiryListDto(m)
+
+		r.OrderServicePackageInquiry = d
+	}
+	return r
+}
+
+// LoadUserCoupon 加载优惠卷数据
+func (r *OrderServicePackageDetailInfoDto) LoadUserCoupon(m []*model.UserCoupon) *OrderServicePackageDetailInfoDto {
+	if len(m) > 0 {
+		d := GetUserCouponListDto(m)
+
+		r.UserCoupon = d
+	}
+	return r
+}
+
+// LoadOrderServicePackageDetail 加载服务包订单详情数据
+func (r *OrderServicePackageDetailInfoDto) LoadOrderServicePackageDetail(m *model.
+	OrderServicePackageDetail) *OrderServicePackageDetailInfoDto {
+	if m != nil {
+		d := GetOrderServicePackageDetailDto(m)
+
+		r.OrderServicePackageDetail = d
+	}
+	return r
+}

api/dto/OrderServicePackageCase.go

@@ -0,0 +1,106 @@
+package dto
+
+import (
+	"fmt"
+	"hospital-admin-api/api/model"
+)
+
+// OrderServicePackageCaseDto 订单-服务包病例表
+type OrderServicePackageCaseDto struct {
+	OrderServiceCaseId string          `json:"order_service_case_id"` // 主键id
+	UserId             string          `json:"user_id"`               // 用户id; NOT NULL
+	PatientId          string          `json:"patient_id"`            // 患者id; NOT NULL
+	OrderId            string          `json:"order_id"`              // 订单id; NOT NULL
+	OrderServiceId     string          `json:"order_service_id"`      // 订单-服务包id; NOT NULL
+	FamilyId           string          `json:"family_id"`             // 家庭成员id; NOT NULL
+	DiseaseClassId     string          `json:"disease_class_id"`      // 疾病分类id-系统
+	Relation           int             `json:"relation"`              // 与患者关系（1:本人 2:父母 3:爱人 4:子女 5:亲戚 6:其他 ）
+	Status             int             `json:"status"`                // 状态（1:正常 2:删除）
+	Name               string          `json:"name"`                  // 患者名称
+	Sex                int             `json:"sex"`                   // 患者性别（0:未知 1:男 2:女）
+	Age                int             `json:"age"`                   // 患者年龄
+	DiseaseClassName   string          `json:"disease_class_name"`    // 疾病名称-系统
+	DiagnosisDate      model.LocalTime `json:"diagnosis_date"`        // 确诊日期
+	DiseaseDesc        string          `json:"disease_desc"`          // 病情描述（主诉）
+	DiagnoseImages     string          `json:"diagnose_images"`       // 复诊凭证(多个使用逗号分隔)
+	IsAllergyHistory   int             `json:"is_allergy_history"`    // 是否存在过敏史（0:否 1:是）
+	AllergyHistory     string          `json:"allergy_history"`       // 过敏史描述
+	IsFamilyHistory    int             `json:"is_family_history"`     // 是否存在家族病史（0:否 1:是）
+	FamilyHistory      string          `json:"family_history"`        // 家族病史描述
+	IsPregnant         int             `json:"is_pregnant"`           // 是否备孕、妊娠、哺乳期（0:否 1:是）
+	Pregnant           string          `json:"pregnant"`              // 备孕、妊娠、哺乳期描述
+	CreatedAt          model.LocalTime `json:"created_at"`            // 创建时间
+	UpdatedAt          model.LocalTime `json:"updated_at"`            // 修改时间
+}
+
+// GetOrderServicePackageCaseDto 服务包订单病例详情
+func GetOrderServicePackageCaseDto(m *model.OrderServicePackageCase) *OrderServicePackageCaseDto {
+	return &OrderServicePackageCaseDto{
+		OrderServiceCaseId: fmt.Sprintf("%d", m.OrderServiceCaseId),
+		UserId:             fmt.Sprintf("%d", m.UserId),
+		PatientId:          fmt.Sprintf("%d", m.PatientId),
+		OrderId:            fmt.Sprintf("%d", m.OrderId),
+		OrderServiceId:     fmt.Sprintf("%d", m.OrderServiceId),
+		FamilyId:           fmt.Sprintf("%d", m.FamilyId),
+		DiseaseClassId:     fmt.Sprintf("%d", m.DiseaseClassId),
+		Relation:           m.Relation,
+		Status:             m.Status,
+		Name:               m.Name,
+		Sex:                m.Sex,
+		Age:                m.Age,
+		DiseaseClassName:   m.DiseaseClassName,
+		DiagnosisDate:      m.DiagnosisDate,
+		DiseaseDesc:        m.DiseaseDesc,
+		DiagnoseImages:     m.DiagnoseImages,
+		IsAllergyHistory:   m.IsAllergyHistory,
+		AllergyHistory:     m.AllergyHistory,
+		IsFamilyHistory:    m.IsFamilyHistory,
+		FamilyHistory:      m.FamilyHistory,
+		IsPregnant:         m.IsPregnant,
+		Pregnant:           m.Pregnant,
+		CreatedAt:          m.CreatedAt,
+		UpdatedAt:          m.UpdatedAt,
+	}
+}
+
+// GetOrderServicePackageCaseListDto 服务包订单病例列表
+func GetOrderServicePackageCaseListDto(m []*model.OrderServicePackageCase) []*OrderServicePackageCaseDto {
+	// 处理返回值
+	responses := make([]*OrderServicePackageCaseDto, len(m))
+
+	if len(m) > 0 {
+		for i, v := range m {
+			response := &OrderServicePackageCaseDto{
+				OrderServiceCaseId: fmt.Sprintf("%d", v.OrderServiceCaseId),
+				UserId:             fmt.Sprintf("%d", v.UserId),
+				PatientId:          fmt.Sprintf("%d", v.PatientId),
+				OrderId:            fmt.Sprintf("%d", v.OrderId),
+				OrderServiceId:     fmt.Sprintf("%d", v.OrderServiceId),
+				FamilyId:           fmt.Sprintf("%d", v.FamilyId),
+				DiseaseClassId:     fmt.Sprintf("%d", v.DiseaseClassId),
+				Relation:           v.Relation,
+				Status:             v.Status,
+				Name:               v.Name,
+				Sex:                v.Sex,
+				Age:                v.Age,
+				DiseaseClassName:   v.DiseaseClassName,
+				DiagnosisDate:      v.DiagnosisDate,
+				DiseaseDesc:        v.DiseaseDesc,
+				DiagnoseImages:     v.DiagnoseImages,
+				IsAllergyHistory:   v.IsAllergyHistory,
+				AllergyHistory:     v.AllergyHistory,
+				IsFamilyHistory:    v.IsFamilyHistory,
+				FamilyHistory:      v.FamilyHistory,
+				IsPregnant:         v.IsPregnant,
+				Pregnant:           v.Pregnant,
+				CreatedAt:          v.CreatedAt,
+				UpdatedAt:          v.UpdatedAt,
+			}
+
+			// 将转换后的结构体添加到新切片中
+			responses[i] = response
+		}
+	}
+
+	return responses
+}

api/dto/OrderServicePackageDetail.go

@@ -0,0 +1,77 @@
+package dto
+
+import (
+	"fmt"
+	"hospital-admin-api/api/model"
+)
+
+// OrderServicePackageDetailDto 订单-服务包详情表
+type OrderServicePackageDetailDto struct {
+	OrderServiceDetailId string          `json:"order_service_detail_id"` // 主键id
+	OrderServiceId       string          `json:"order_service_id"`        // 服务包订单id
+	OrderId              string          `json:"order_id"`                // 订单id
+	PackageId            string          `json:"package_id"`              // 健康包配置id（随访包时为空）
+	OrderServiceNo       string          `json:"order_service_no"`        // 系统订单编号
+	ServicePeriod        int             `json:"service_period"`          // 服务周期（天）
+	ServiceCount         int             `json:"service_count"`           // 总服务次数（0表示不限次）
+	MonthlyFrequency     int             `json:"monthly_frequency"`       // 每月次数（0表示不限次）
+	SingleInquiryPrice   float64         `json:"single_inquiry_price"`    // 单次图文问诊价格
+	ServicePrice         float64         `json:"service_price"`           // 总服务价格
+	CreatedAt            model.LocalTime `json:"created_at"`              // 创建时间
+	UpdatedAt            model.LocalTime `json:"updated_at"`              // 修改时间
+	RemainingQuantity    int             `json:"remaining_quantity"`      // 药品的剩余数量
+}
+
+// GetOrderServicePackageDetailDto 订单-服务包详情详情
+func GetOrderServicePackageDetailDto(m *model.OrderServicePackageDetail) *OrderServicePackageDetailDto {
+	return &OrderServicePackageDetailDto{
+		OrderServiceDetailId: fmt.Sprintf("%d", m.OrderServiceDetailId),
+		OrderServiceId:       fmt.Sprintf("%d", m.OrderServiceId),
+		OrderId:              fmt.Sprintf("%d", m.OrderId),
+		PackageId:            fmt.Sprintf("%d", m.PackageId),
+		OrderServiceNo:       m.OrderServiceNo,
+		ServicePeriod:        m.ServicePeriod,
+		ServiceCount:         m.ServiceCount,
+		MonthlyFrequency:     m.MonthlyFrequency,
+		SingleInquiryPrice:   m.SingleInquiryPrice,
+		ServicePrice:         m.ServicePrice,
+		CreatedAt:            m.CreatedAt,
+		UpdatedAt:            m.UpdatedAt,
+	}
+}
+
+// GetOrderServicePackageDetailListDto 订单-服务包详情列表
+func GetOrderServicePackageDetailListDto(m []*model.OrderServicePackageDetail) []*OrderServicePackageDetailDto {
+	// 处理返回值
+	responses := make([]*OrderServicePackageDetailDto, len(m))
+
+	if len(m) > 0 {
+		for i, v := range m {
+			response := &OrderServicePackageDetailDto{
+				OrderServiceDetailId: fmt.Sprintf("%d", v.OrderServiceDetailId),
+				OrderServiceId:       fmt.Sprintf("%d", v.OrderServiceId),
+				OrderId:              fmt.Sprintf("%d", v.OrderId),
+				PackageId:            fmt.Sprintf("%d", v.PackageId),
+				OrderServiceNo:       v.OrderServiceNo,
+				ServicePeriod:        v.ServicePeriod,
+				ServiceCount:         v.ServiceCount,
+				MonthlyFrequency:     v.MonthlyFrequency,
+				SingleInquiryPrice:   v.SingleInquiryPrice,
+				ServicePrice:         v.ServicePrice,
+				CreatedAt:            v.CreatedAt,
+				UpdatedAt:            v.UpdatedAt,
+			}
+
+			// 将转换后的结构体添加到新切片中
+			responses[i] = response
+		}
+	}
+
+	return responses
+}
+
+// LoadRemainingQuantity 加载药品剩余数量
+func (r *OrderServicePackageDetailDto) LoadRemainingQuantity(remainingQuantity int) *OrderServicePackageDetailDto {
+	r.RemainingQuantity = remainingQuantity
+	return r
+}

api/dto/OrderServicePackageInquiry.go

@@ -0,0 +1,71 @@
+package dto
+
+import (
+	"fmt"
+	"hospital-admin-api/api/model"
+)
+
+// OrderServicePackageInquiryDto 服务包关联问诊订单表
+type OrderServicePackageInquiryDto struct {
+	ServiceInquiryId string           `json:"service_inquiry_id"` // 主键id
+	OrderServiceId   string           `json:"order_service_id"`   // 订单-服务包id
+	OrderInquiryId   string           `json:"order_inquiry_id"`   // 订单-问诊id
+	OrderServiceNo   string           `json:"order_service_no"`   // 服务包系统订单编号
+	InquiryNo        string           `json:"inquiry_no"`         // 问诊系统订单编号
+	CreatedAt        model.LocalTime  `json:"created_at"`         // 创建时间
+	UpdatedAt        model.LocalTime  `json:"updated_at"`         // 修改时间
+	OrderInquiry     *OrderInquiryDto `json:"order_inquiry"`      // 问诊订单
+}
+
+// GetOrderServicePackageInquiryDto 服务包关联问诊订单详情
+func GetOrderServicePackageInquiryDto(m *model.OrderServicePackageInquiry) *OrderServicePackageInquiryDto {
+	return &OrderServicePackageInquiryDto{
+		ServiceInquiryId: fmt.Sprintf("%d", m.ServiceInquiryId),
+		OrderServiceId:   fmt.Sprintf("%d", m.OrderServiceId),
+		OrderInquiryId:   fmt.Sprintf("%d", m.OrderInquiryId),
+		OrderServiceNo:   m.OrderServiceNo,
+		InquiryNo:        m.InquiryNo,
+		CreatedAt:        m.CreatedAt,
+		UpdatedAt:        m.UpdatedAt,
+	}
+}
+
+// GetOrderServicePackageInquiryListDto 服务包关联问诊订单列表
+func GetOrderServicePackageInquiryListDto(m []*model.OrderServicePackageInquiry) []*OrderServicePackageInquiryDto {
+	// 处理返回值
+	responses := make([]*OrderServicePackageInquiryDto, len(m))
+
+	if len(m) > 0 {
+		for i, v := range m {
+			response := &OrderServicePackageInquiryDto{
+				ServiceInquiryId: fmt.Sprintf("%d", v.ServiceInquiryId),
+				OrderServiceId:   fmt.Sprintf("%d", v.OrderServiceId),
+				OrderInquiryId:   fmt.Sprintf("%d", v.OrderInquiryId),
+				OrderServiceNo:   v.OrderServiceNo,
+				InquiryNo:        v.InquiryNo,
+				CreatedAt:        v.CreatedAt,
+				UpdatedAt:        v.UpdatedAt,
+			}
+
+			// 加载问诊订单数据
+			if v.OrderInquiry != nil {
+				response = response.LoadOrderInquiry(v.OrderInquiry)
+			}
+
+			// 将转换后的结构体添加到新切片中
+			responses[i] = response
+		}
+	}
+
+	return responses
+}
+
+// LoadOrderInquiry 加载问诊订单数据
+func (r *OrderServicePackageInquiryDto) LoadOrderInquiry(m *model.OrderInquiry) *OrderServicePackageInquiryDto {
+	if m != nil {
+		d := GetOrderInquiryDto(m)
+
+		r.OrderInquiry = d
+	}
+	return r
+}

api/dto/OrderServicePackageProduct.go

@@ -0,0 +1,77 @@
+package dto
+
+import (
+	"fmt"
+	"hospital-admin-api/api/model"
+)
+
+// OrderServicePackageProductDto 订单-服务包-关联商品订单表
+type OrderServicePackageProductDto struct {
+	ServiceProductId string           `json:"service_product_id"` // 主键id
+	OrderServiceId   string           `json:"order_service_id"`   // 订单-服务包id
+	OrderProductId   string           `json:"order_product_id"`   // 订单-商品id
+	OrderProductNo   string           `json:"order_product_no"`   // 订单-商品系统编号
+	ProductItemId    string           `json:"product_item_id"`    // 订单-商品明细id
+	ProductId        string           `json:"product_id"`         // 商品id
+	UsedQuantity     int              `json:"used_quantity"`      // 商品使用数量
+	CreatedAt        model.LocalTime  `json:"created_at"`         // 创建时间
+	UpdatedAt        model.LocalTime  `json:"updated_at"`         // 修改时间
+	OrderProduct     *OrderProductDto `json:"order_product"`      // 药品订单
+}
+
+// GetOrderServicePackageProductDto 服务包订单病例详情
+func GetOrderServicePackageProductDto(m *model.OrderServicePackageProduct) *OrderServicePackageProductDto {
+	return &OrderServicePackageProductDto{
+		ServiceProductId: fmt.Sprintf("%d", m.ServiceProductId),
+		OrderServiceId:   fmt.Sprintf("%d", m.OrderServiceId),
+		OrderProductId:   fmt.Sprintf("%d", m.OrderProductId),
+		OrderProductNo:   m.OrderProductNo,
+		ProductItemId:    fmt.Sprintf("%d", m.ProductItemId),
+		ProductId:        fmt.Sprintf("%d", m.ProductId),
+		UsedQuantity:     m.UsedQuantity,
+		CreatedAt:        m.CreatedAt,
+		UpdatedAt:        m.UpdatedAt,
+	}
+}
+
+// GetOrderServicePackageProductListDto 服务包订单病例列表
+func GetOrderServicePackageProductListDto(m []*model.OrderServicePackageProduct) []*OrderServicePackageProductDto {
+	// 处理返回值
+	responses := make([]*OrderServicePackageProductDto, len(m))
+
+	if len(m) > 0 {
+		for i, v := range m {
+			response := &OrderServicePackageProductDto{
+				ServiceProductId: fmt.Sprintf("%d", v.ServiceProductId),
+				OrderServiceId:   fmt.Sprintf("%d", v.OrderServiceId),
+				OrderProductId:   fmt.Sprintf("%d", v.OrderProductId),
+				OrderProductNo:   v.OrderProductNo,
+				ProductItemId:    fmt.Sprintf("%d", v.ProductItemId),
+				ProductId:        fmt.Sprintf("%d", v.ProductId),
+				UsedQuantity:     v.UsedQuantity,
+				CreatedAt:        v.CreatedAt,
+				UpdatedAt:        v.UpdatedAt,
+			}
+
+			// 加载问诊订单数据
+			if v.OrderProduct != nil {
+				response = response.LoadOrderProduct(v.OrderProduct)
+			}
+
+			// 将转换后的结构体添加到新切片中
+			responses[i] = response
+		}
+	}
+
+	return responses
+}
+
+// LoadOrderProduct 加载药品订单数据
+func (r *OrderServicePackageProductDto) LoadOrderProduct(m *model.OrderProduct) *OrderServicePackageProductDto {
+	if m != nil {
+		d := GetOrderProductDto(m)
+
+		r.OrderProduct = d
+	}
+	return r
+}

api/dto/OrderServicePackageRefund.go

@@ -0,0 +1,70 @@
+package dto
+
+import (
+	"fmt"
+	"hospital-admin-api/api/model"
+)
+
+// OrderServicePackageRefundDto 订单-服务包-退款表
+type OrderServicePackageRefundDto struct {
+	ServiceRefundId string          `json:"service_refund_id"` // 主键id
+	PatientId       string          `json:"patient_id"`        // 患者id
+	OrderServiceId  string          `json:"order_service_id"`  // 订单-服务包id
+	OrderServiceNo  string          `json:"order_service_no"`  // 系统订单编号
+	ServiceRefundNo string          `json:"service_refund_no"` // 系统退款编号
+	RefundId        string          `json:"refund_id"`         // 第三方退款单号
+	RefundStatus    int             `json:"refund_status"`     // 订单退款状态（0:无退款 1:申请退款 2:退款中 3:退款成功 4:拒绝退款 5:退款关闭 6 // :退款异常 7:部分退款）
+	RefundTotal     float64         `json:"refund_total"`      // 退款金额
+	RefundReason    string          `json:"refund_reason"`     // 退款原因
+	SuccessTime     model.LocalTime `json:"success_time"`      // 退款成功时间
+	CreatedAt       model.LocalTime `json:"created_at"`        // 创建时间
+	UpdatedAt       model.LocalTime `json:"updated_at"`        // 修改时间
+}
+
+// GetOrderServicePackageRefundDto 服务包订单病例详情
+func GetOrderServicePackageRefundDto(m *model.OrderServicePackageRefund) *OrderServicePackageRefundDto {
+	return &OrderServicePackageRefundDto{
+		ServiceRefundId: fmt.Sprintf("%d", m.ServiceRefundId),
+		PatientId:       fmt.Sprintf("%d", m.PatientId),
+		OrderServiceId:  fmt.Sprintf("%d", m.OrderServiceId),
+		OrderServiceNo:  m.OrderServiceNo,
+		ServiceRefundNo: m.ServiceRefundNo,
+		RefundId:        m.RefundId,
+		RefundStatus:    m.RefundStatus,
+		RefundTotal:     m.RefundTotal,
+		RefundReason:    m.RefundReason,
+		SuccessTime:     m.SuccessTime,
+		CreatedAt:       m.CreatedAt,
+		UpdatedAt:       m.UpdatedAt,
+	}
+}
+
+// GetOrderServicePackageRefundListDto 服务包订单病例列表
+func GetOrderServicePackageRefundListDto(m []*model.OrderServicePackageRefund) []*OrderServicePackageRefundDto {
+	// 处理返回值
+	responses := make([]*OrderServicePackageRefundDto, len(m))
+
+	if len(m) > 0 {
+		for i, v := range m {
+			response := &OrderServicePackageRefundDto{
+				ServiceRefundId: fmt.Sprintf("%d", v.ServiceRefundId),
+				PatientId:       fmt.Sprintf("%d", v.PatientId),
+				OrderServiceId:  fmt.Sprintf("%d", v.OrderServiceId),
+				OrderServiceNo:  v.OrderServiceNo,
+				ServiceRefundNo: v.ServiceRefundNo,
+				RefundId:        v.RefundId,
+				RefundStatus:    v.RefundStatus,
+				RefundTotal:     v.RefundTotal,
+				RefundReason:    v.RefundReason,
+				SuccessTime:     v.SuccessTime,
+				CreatedAt:       v.CreatedAt,
+				UpdatedAt:       v.UpdatedAt,
+			}
+
+			// 将转换后的结构体添加到新切片中
+			responses[i] = response
+		}
+	}
+
+	return responses
+}

api/dto/UserCoupon.go

@@ -0,0 +1,80 @@
+package dto
+
+import (
+	"fmt"
+	"hospital-admin-api/api/model"
+)
+
+// UserCouponDto 用户优惠卷表
+type UserCouponDto struct {
+	UserCouponId     string          `json:"user_coupon_id"`     // 主键id
+	UserId           string          `json:"user_id"`            // 用户id
+	PatientId        string          `json:"patient_id"`         // 患者id
+	CouponId         string          `json:"coupon_id"`          // 优惠卷id
+	UserCouponStatus int             `json:"user_coupon_status"` // 状态（0:未使用 1:已使用 3:已过期）
+	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),
+		PatientId:        fmt.Sprintf("%d", m.PatientId),
+		CouponId:         fmt.Sprintf("%d", m.CouponId),
+		UserCouponStatus: m.UserCouponStatus,
+		CouponUseDate:    model.LocalTime(m.CouponUseDate),
+		ValidStartTime:   model.LocalTime(m.ValidStartTime),
+		ValidEndTime:     model.LocalTime(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),
+				PatientId:        fmt.Sprintf("%d", v.PatientId),
+				CouponId:         fmt.Sprintf("%d", v.CouponId),
+				UserCouponStatus: v.UserCouponStatus,
+				CouponUseDate:    model.LocalTime(v.CouponUseDate),
+				ValidStartTime:   model.LocalTime(v.ValidStartTime),
+				ValidEndTime:     model.LocalTime(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/dto/coupon.go

@@ -0,0 +1,124 @@
+package dto
+
+import (
+	"fmt"
+	"hospital-admin-api/api/model"
+)
+
+// CouponDto 优惠卷表
+type CouponDto struct {
+	CouponId                string          `json:"coupon_id"`                  // 主键id
+	CouponName              string          `json:"coupon_name"`                // 优惠卷名称
+	CouponIcon              string          `json:"coupon_icon"`                // 优惠卷图片
+	CouponClient            int             `json:"coupon_client"`              // 使用平台（1:小程序）
+	CouponType              int             `json:"coupon_type"`                // 优惠卷类型（1:无门槛 2:满减 3:数量）
+	CouponStatus            int             `json:"coupon_status"`              // 状态（1:正常 2:强制失效 3:结束 4:删除）
+	DistributionObject      int             `json:"distribution_object"`        // 发放对象（1:全部用户 2:新注册用户 3:会员 4:近期消费 5:近期购药 6:存量用户 7:健康包服务用户）
+	ApplicationScope        int             `json:"application_scope"`          // 适用范围（1:全场通用 2:问诊 3:按品牌适用 4:按类别适用 5:单品使用 6:全品类药品）
+	InquiryType             string          `json:"inquiry_type"`               // 关联问诊类型，application_scope=问诊时存在生效，逗号分隔（1:全部 2:快速问诊 3:专家问诊 4:公益问诊 5:问诊购药 6:检测）
+	BrandId                 string          `json:"brand_id"`                   // 关联品牌id（如不限制品牌，此项为空）
+	IsMutex                 int             `json:"is_mutex"`                   // 是否互斥（0:否 1:是）互斥情况下无法和其他优惠卷同时使用
+	IsDisplay               int             `json:"is_display"`                 // 是否展示（0:否 1:是）
+	DistributionWithDay     int             `json:"distribution_with_day"`      // 发放关联天数（发放对象为近期消费等类型时规定天数）
+	MinUsableNumber         int             `json:"min_usable_number"`          // 单商品最小可使用数量（默认为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"`             // 结束使用时间
+	ProductId               string          `json:"product_id"`                 // 关联商品id，逗号分隔，指定商品时，填入此项。
+	ReissueIntervalDays     int             `json:"reissue_interval_days"`      // 确认收货后的再次发放间隔天数(如果设置为 0，则表示不再次发放。当适用范围为商品时生效)
+	IsReissuableAfterExpire int             `json:"is_reissuable_after_expire"` // 过期之后是否允许再次发放(0:否 1:是)
+	IsPopup                 int             `json:"is_popup"`                   // 是否首页弹窗（0:否 1:是）
+	CouponDesc              string          `json:"coupon_desc"`                // 优惠卷描述
+	CreatedAt               model.LocalTime `json:"created_at"`                 // 创建时间
+	UpdatedAt               model.LocalTime `json:"updated_at"`                 // 修改时间
+}
+
+// GetCouponDto 优惠卷详情
+func GetCouponDto(m *model.Coupon) *CouponDto {
+	return &CouponDto{
+		CouponId:                fmt.Sprintf("%d", m.CouponId),
+		CouponName:              m.CouponName,
+		CouponIcon:              m.CouponIcon,
+		CouponClient:            m.CouponClient,
+		CouponType:              m.CouponType,
+		CouponStatus:            m.CouponStatus,
+		DistributionObject:      m.DistributionObject,
+		ApplicationScope:        m.ApplicationScope,
+		InquiryType:             m.InquiryType,
+		BrandId:                 fmt.Sprintf("%d", m.BrandId),
+		IsMutex:                 m.IsMutex,
+		IsDisplay:               m.IsDisplay,
+		DistributionWithDay:     m.DistributionWithDay,
+		MinUsableNumber:         m.MinUsableNumber,
+		CouponCount:             m.CouponCount,
+		CouponTakeCount:         m.CouponTakeCount,
+		CouponUsedCount:         m.CouponUsedCount,
+		CouponPrice:             m.CouponPrice,
+		WithAmount:              m.WithAmount,
+		ValidType:               m.ValidType,
+		ValidDays:               m.ValidDays,
+		ValidStartTime:          m.ValidStartTime,
+		ValidEndTime:            m.ValidEndTime,
+		ProductId:               fmt.Sprintf("%d", m.ProductId),
+		ReissueIntervalDays:     m.ReissueIntervalDays,
+		IsReissuableAfterExpire: m.IsReissuableAfterExpire,
+		IsPopup:                 m.IsPopup,
+		CouponDesc:              m.CouponDesc,
+		CreatedAt:               m.CreatedAt,
+		UpdatedAt:               m.UpdatedAt,
+	}
+}
+
+// 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,
+				CouponIcon:              v.CouponIcon,
+				CouponClient:            v.CouponClient,
+				CouponType:              v.CouponType,
+				CouponStatus:            v.CouponStatus,
+				DistributionObject:      v.DistributionObject,
+				ApplicationScope:        v.ApplicationScope,
+				InquiryType:             v.InquiryType,
+				BrandId:                 fmt.Sprintf("%d", v.BrandId),
+				IsMutex:                 v.IsMutex,
+				IsDisplay:               v.IsDisplay,
+				DistributionWithDay:     v.DistributionWithDay,
+				MinUsableNumber:         v.MinUsableNumber,
+				CouponCount:             v.CouponCount,
+				CouponTakeCount:         v.CouponTakeCount,
+				CouponUsedCount:         v.CouponUsedCount,
+				CouponPrice:             v.CouponPrice,
+				WithAmount:              v.WithAmount,
+				ValidType:               v.ValidType,
+				ValidDays:               v.ValidDays,
+				ValidStartTime:          v.ValidStartTime,
+				ValidEndTime:            v.ValidEndTime,
+				ProductId:               fmt.Sprintf("%d", v.ProductId),
+				ReissueIntervalDays:     v.ReissueIntervalDays,
+				IsReissuableAfterExpire: v.IsReissuableAfterExpire,
+				IsPopup:                 v.IsPopup,
+				CouponDesc:              v.CouponDesc,
+				CreatedAt:               v.CreatedAt,
+				UpdatedAt:               v.UpdatedAt,
+			}
+
+			// 将转换后的结构体添加到新切片中
+			responses[i] = response
+		}
+	}
+
+	return responses
+}

api/model/coupon.go

@@ -0,0 +1,58 @@
+package model
+
+import (
+	"gorm.io/gorm"
+	"hospital-admin-api/global"
+	"time"
+)
+
+// Coupon 优惠卷表
+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"`
+	CouponIcon              string    `gorm:"column:coupon_icon;type:varchar(255);comment:优惠卷图片" json:"coupon_icon"`
+	CouponClient            int       `gorm:"column:coupon_client;type:tinyint(1);comment:使用平台（1:小程序）;NOT NULL" json:"coupon_client"`
+	CouponType              int       `gorm:"column:coupon_type;type:tinyint(1);comment:优惠卷类型（1:无门槛 2:满减 3:数量）;NOT NULL" json:"coupon_type"`
+	CouponStatus            int       `gorm:"column:coupon_status;type:tinyint(1);default:1;comment:状态（1:正常 2:强制失效 3:结束 4:删除）" json:"coupon_status"`
+	DistributionObject      int       `gorm:"column:distribution_object;type:tinyint(1);default:1;comment:发放对象（1:全部用户 2:新注册用户 3:会员 4:近期消费 5:近期购药 6:存量用户 7:健康包服务用户）" json:"distribution_object"`
+	ApplicationScope        int       `gorm:"column:application_scope;type:tinyint(1);default:1;comment:适用范围（1:全场通用 2:问诊 3:按品牌适用 4:按类别适用 5:单品使用 6:全品类药品）" json:"application_scope"`
+	InquiryType             string    `gorm:"column:inquiry_type;type:varchar(100);comment:关联问诊类型，application_scope=问诊时存在生效，逗号分隔（1:全部 2:快速问诊 3:专家问诊 4:公益问诊 5:问诊购药 6:检测）" json:"inquiry_type"`
+	BrandId                 int64     `gorm:"column:brand_id;type:bigint(19);comment:关联品牌id（如不限制品牌，此项为空）" json:"brand_id"`
+	IsMutex                 int       `gorm:"column:is_mutex;type:tinyint(1);default:1;comment:是否互斥（0:否 1:是）互斥情况下无法和其他优惠卷同时使用" json:"is_mutex"`
+	IsDisplay               int       `gorm:"column:is_display;type:tinyint(1);comment:是否展示（0:否 1:是）" json:"is_display"`
+	DistributionWithDay     int       `gorm:"column:distribution_with_day;type:int(11);default:0;comment:发放关联天数（发放对象为近期消费等类型时规定天数）" json:"distribution_with_day"`
+	MinUsableNumber         int       `gorm:"column:min_usable_number;type:int(11);default:1;comment:单商品最小可使用数量（默认为1，类型为数量时使用，如需限制优惠卷使用数量，请填写此处）" json:"min_usable_number"`
+	CouponCount             int       `gorm:"column:coupon_count;type:int(10);default:0;comment:发放数量" json:"coupon_count"`
+	CouponTakeCount         int       `gorm:"column:coupon_take_count;type:int(10);default:0;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);default:0.00;comment:优惠卷金额" json:"coupon_price"`
+	WithAmount              float64   `gorm:"column:with_amount;type:decimal(10,2);default:0.00;comment:符合满减标准金额（优惠卷类型为满减时使用）" json:"with_amount"`
+	ValidType               int       `gorm:"column:valid_type;type:tinyint(4);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"`
+	ProductId               string    `gorm:"column:product_id;type:text;comment:关联商品id，逗号分隔，指定商品时，填入此项。" json:"product_id"`
+	ReissueIntervalDays     int       `gorm:"column:reissue_interval_days;type:int(5);default:0;comment:确认收货后的再次发放间隔天数(如果设置为 0，则表示不再次发放。当适用范围为商品时生效)" json:"reissue_interval_days"`
+	IsReissuableAfterExpire int       `gorm:"column:is_reissuable_after_expire;type:tinyint(1);default:0;comment:过期之后是否允许再次发放(0:否 1:是)" json:"is_reissuable_after_expire"`
+	IsPopup                 int       `gorm:"column:is_popup;type:tinyint(1);default:0;comment:是否首页弹窗（0:否 1:是）" json:"is_popup"`
+	CouponDesc              string    `gorm:"column:coupon_desc;type:text;comment:优惠卷描述" json:"coupon_desc"`
+	Model
+}
+
+func (m *Coupon) TableName() string {
+	return "gdxz_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/orderServicePackage.go

@@ -39,8 +39,10 @@ type OrderServicePackage struct {
 	PatientSex          int       `gorm:"column:patient_sex;type:tinyint(1);default:0;comment:患者性别-就诊人（0:未知 1:男 2:女）" json:"patient_sex"`
 	PatientAge          int       `gorm:"column:patient_age;type:int(1);comment:患者年龄-就诊人" json:"patient_age"`
 	Model
-	UserDoctor *UserDoctor `gorm:"foreignKey:DoctorId;references:doctor_id" json:"user_doctor"` // 医生
-	User       *User       `gorm:"foreignKey:UserId;references:user_id" json:"user"`            // 患者
+	UserDoctor                 *UserDoctor                   `gorm:"foreignKey:DoctorId;references:doctor_id" json:"user_doctor"`                                // 医生
+	User                       *User                         `gorm:"foreignKey:UserId;references:user_id" json:"user"`                                           // 患者
+	OrderServicePackageInquiry []*OrderServicePackageInquiry `gorm:"foreignKey:OrderServiceId;references:order_service_id" json:"order_service_package_inquiry"` // 关联问诊订单
+	OrderServicePackageProduct []*OrderServicePackageProduct `gorm:"foreignKey:OrderServiceId;references:order_service_id" json:"order_service_package_product"` // 关联商品订单
 }
 
 func (m *OrderServicePackage) TableName() string {

api/model/orderServicePackageInquiry.go

@@ -14,6 +14,7 @@ type OrderServicePackageInquiry struct {
 	OrderServiceNo   string `gorm:"column:order_service_no;type:varchar(30);comment:服务包系统订单编号" json:"order_service_no"`
 	InquiryNo        string `gorm:"column:inquiry_no;type:varchar(30);comment:问诊系统订单编号" json:"inquiry_no"`
 	Model
+	OrderInquiry *OrderInquiry `gorm:"foreignKey:OrderInquiryId;references:order_inquiry_id" json:"order_inquiry"` // 关联问诊订单
 }
 
 func (m *OrderServicePackageInquiry) TableName() string {

api/model/orderServicePackageProduct.go

@@ -16,6 +16,7 @@ type OrderServicePackageProduct struct {
 	ProductId        int64  `gorm:"column:product_id;type:bigint(19);comment:商品id;NOT NULL" json:"product_id"`
 	UsedQuantity     int    `gorm:"column:used_quantity;type:int(1);default:0;comment:商品使用数量" json:"used_quantity"`
 	Model
+	OrderProduct *OrderProduct `gorm:"foreignKey:OrderProductId;references:order_product_id" json:"order_product"` // 关联药品订单
 }
 
 func (m *OrderServicePackageProduct) TableName() string {

api/model/userCoupon.go

@@ -17,6 +17,7 @@ type UserCoupon struct {
 	ValidStartTime   time.Time `gorm:"column:valid_start_time;type:datetime;comment:有效使用时间" json:"valid_start_time"`
 	ValidEndTime     time.Time `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 {

api/router/router.go

@@ -454,11 +454,14 @@ func privateRouter(r *gin.Engine, api controller.Api) {
 			// 获取服务包订单列表-分页
 			serviceGroup.POST("/page", api.OrderServicePackage.GetOrderServicePackagePage)
 
-			// 问诊订单详情
-			serviceGroup.GET("/:order_inquiry_id", api.OrderInquiry.GetOrderInquiry)
+			// 获取服务包订单详情
+			serviceGroup.GET("/:order_service_id", api.OrderServicePackage.GetOrderServicePackage)
+
+			// 获取服务包订单服务权益详情
+			serviceGroup.GET("/detail/:order_service_id", api.OrderServicePackage.GetOrderServicePackageDetailInfo)
 
 			// 取消问诊订单
-			serviceGroup.PUT("/cancel/:order_inquiry_id", api.OrderInquiry.CancelOrderInquiry)
+			serviceGroup.PUT("/cancel/:order_inquiry_id", api.OrderServicePackage.GetOrderServicePackageDetailInfo)
 		}
 
 	}

api/service/orderServicePackage.go

@@ -0,0 +1,255 @@
+package service
+
+import (
+	"errors"
+	"hospital-admin-api/api/dao"
+	"hospital-admin-api/api/dto"
+	"hospital-admin-api/api/model"
+	"strconv"
+	"time"
+)
+
+type OrderServicePackageService struct {
+}
+
+// GetOrderServicePackage 服务包订单详情
+func (r *OrderServicePackageService) GetOrderServicePackage(orderServiceId int64) (g *dto.OrderServicePackageDto, err error) {
+	// 获取订单数据
+	orderServicePackageDao := dao.OrderServicePackageDao{}
+	orderServicePackage, err := orderServicePackageDao.GetOrderServicePackageById(orderServiceId)
+	if err != nil || orderServicePackage == nil {
+		return nil, errors.New(err.Error())
+	}
+
+	// 获取病例
+	orderServicePackageCaseDao := dao.OrderServicePackageCaseDao{}
+	orderServicePackageCase, err := orderServicePackageCaseDao.GetOrderServicePackageCaseByOrderServicePackageId(orderServiceId)
+	if orderServicePackageCase == nil {
+		return nil, errors.New("数据错误，无问诊病例")
+	}
+
+	// 获取退款数据
+	orderServicePackageRefundDao := dao.OrderServicePackageRefundDao{}
+	orderServicePackageRefund, err := orderServicePackageRefundDao.GetOrderServicePackageRefundByOrderServicePackageId(orderServiceId)
+
+	// 医生数据
+	userDoctorService := UserDoctorService{}
+	userDoctor, err := userDoctorService.GetUserDoctorById(orderServicePackage.DoctorId)
+	if err != nil {
+		return nil, errors.New(err.Error())
+	}
+
+	// 处理返回值
+	g = dto.GetOrderServicePackageDto(orderServicePackage)
+
+	// 加载医生数据
+	g.UserDoctor = userDoctor
+
+	// 加载订单退款数据
+	g.LoadOrderServicePackageRefund(orderServicePackageRefund)
+
+	// 加载问诊病例
+	g.LoadMaskOrderServicePackageCase(orderServicePackageCase)
+
+	return g, nil
+}
+
+// GetOrderServicePackageDetailInfo 获取服务包订单服务权益详情
+func (r *OrderServicePackageService) GetOrderServicePackageDetailInfo(orderServiceId int64) (g *dto.OrderServicePackageDetailInfoDto, err error) {
+	// 获取订单数据
+	orderServicePackageDao := dao.OrderServicePackageDao{}
+	orderServicePackage, err := orderServicePackageDao.GetOrderServicePackageById(orderServiceId)
+	if err != nil || orderServicePackage == nil {
+		return nil, errors.New(err.Error())
+	}
+
+	// 获取关联问诊订单
+	orderServicePackageInquiryDao := dao.OrderServicePackageInquiryDao{}
+	orderServicePackageInquiry, err := orderServicePackageInquiryDao.GetOrderServicePackageInquiryPreloadByOrderNo(orderServicePackage.OrderServiceNo)
+
+	// 获取订单详情数据
+	orderServicePackageDDao := dao.OrderServicePackageDetailDao{}
+	orderServicePackageDetail, err := orderServicePackageDDao.GetOrderServicePackageDetailByOrderServicePackageId(orderServiceId)
+	if err != nil || orderServicePackageDetail == nil {
+		return nil, errors.New(err.Error())
+	}
+
+	// 处理返回值
+	g = dto.GetOrderServicePackageDetailInfoDto(orderServicePackage)
+
+	// 加载关联问诊订单数据
+	g.LoadOrderServicePackageInquiry(orderServicePackageInquiry)
+
+	// 加载服务包订单详情数据
+	g.LoadOrderServicePackageDetail(orderServicePackageDetail)
+
+	// 获取服务包当前月时间区间
+	CurrentMonthStartDate, CurrentMonthFinishDate, err := r.getOrderServicePackageCurrentMonthDate(g.StartTime)
+	g.CurrentMonthStartDate = CurrentMonthStartDate.Format("2006年01月02日 15时04分")
+	g.CurrentMonthFinishDate = CurrentMonthFinishDate.Format("2006年01月02日 15时04分")
+
+	// 获取服务包当月已问诊次数
+	g.MonthInquiryCount, err = r.GetCurrentMonthInquiryCount(g.OrderServiceType, orderServicePackage.UserId, orderServicePackage.DoctorId, CurrentMonthStartDate, CurrentMonthFinishDate)
+	if err != nil {
+		return nil, err
+	}
+
+	// 获取服务包当月剩余问诊次数
+	g.RemainingInquiryCount = r.GetRemainingInquiryCount(orderServicePackageDetail.MonthlyFrequency, g.MonthInquiryCount)
+
+	// 健康包数据
+	if orderServicePackage.OrderServiceType == 1 {
+		if g.OrderServiceStatus == 3 || g.OrderServiceStatus == 4 || g.OrderServiceStatus == 5 {
+			// 获取用户某一类型优惠卷
+			userCouponDao := dao.UserCouponDao{}
+			userCoupon, _ := userCouponDao.GetUserAllObjectTypeCoupon(orderServicePackage.UserId, 7)
+
+			// 加载优惠卷数据
+			g.LoadUserCoupon(userCoupon)
+
+			// 获取健康包药品订单数据-周期内所有药品订单
+			orderServicePackageProductDao := dao.OrderServicePackageProductDao{}
+			orderServicePackageProduct, _ := orderServicePackageProductDao.GetOrderServicePackageProductPreloadByOrderServiceId(
+				orderServicePackage.OrderServiceId)
+
+			// 加载关联药品订单数据
+			g.LoadOrderServicePackageProduct(orderServicePackageProduct)
+
+			// 获取服务包内所有药品
+			healthPackageProductDao := dao.HealthPackageProductDao{}
+
+			maps := make(map[string]interface{})
+			maps["inquiry_type"] = 1
+			healthPackageProducts, err := healthPackageProductDao.GetHealthPackageProductByPackageId(orderServicePackageDetail.PackageId)
+			if err != nil {
+				return nil, err
+			}
+
+			for _, healthPackageProduct := range healthPackageProducts {
+				// 获取服务包内某一药品的剩余数量
+				remainingQuantity, err := r.GetOrderServiceProductCanUseQuantity(orderServicePackage.OrderServiceId, healthPackageProduct.ProductId, healthPackageProduct.Quantity)
+				if err != nil {
+					return nil, err
+				}
+
+				g.OrderServicePackageDetail.LoadRemainingQuantity(remainingQuantity)
+			}
+		}
+	}
+
+	return g, nil
+}
+
+// 获取服务包当前月时间区间
+func (r *OrderServicePackageService) getOrderServicePackageCurrentMonthDate(startTime model.LocalTime) (startDate, finishDate time.Time, err error) {
+	if startTime.IsEmpty() {
+		return time.Time{}, time.Time{}, err
+	}
+
+	// 获取当前时间
+	now := time.Now()
+
+	// 获取开启服务日期和今日的相差天数
+	diff := now.Sub(time.Time(startTime)).Hours() / 24
+	diffDays := int(diff)
+
+	// 获取当前月次
+	monthTime := (diffDays + 29) / 30 // 向上取整
+
+	days := monthTime * 30
+
+	// 当前所属月结束时间
+	currentMonthFinishDate := time.Time(startTime).AddDate(0, 0, days)
+
+	// 当前所属月开始时间
+	currentMonthStartDate := currentMonthFinishDate.AddDate(0, 0, -30)
+
+	return currentMonthStartDate, currentMonthFinishDate, nil
+}
+
+// 检测问诊是否服务包首次问诊
+func (r *OrderServicePackageService) isFirstInquiryServicePackage(orderNo string) (bool, error) {
+	orderServicePackageDao := dao.OrderServicePackageDao{}
+
+	maps := make(map[string]interface{})
+	maps["order_service_no"] = orderNo
+	orderServicePackage, err := orderServicePackageDao.GetOrderServicePackageList(maps)
+	if err != nil {
+		return false, err
+	}
+
+	if len(orderServicePackage) == 1 {
+		return true, nil
+	}
+
+	return false, err
+}
+
+// GetCurrentMonthInquiryCount 获取服务包当月已问诊次数
+func (r *OrderServicePackageService) GetCurrentMonthInquiryCount(orderServiceType int, userId, doctorId int64, startDate, endDate time.Time) (int, error) {
+	orderInquiryDao := dao.OrderInquiryDao{}
+
+	maps := make(map[string]interface{})
+	maps["inquiry_type"] = 1
+
+	if orderServiceType == 1 {
+		maps["inquiry_mode"] = 8
+	} else {
+		maps["inquiry_mode"] = 9
+	}
+
+	maps["user_id"] = userId
+	maps["doctor_id"] = doctorId
+	maps["inquiry_refund_status"] = 0
+	maps["inquiry_pay_status"] = 2
+	maps["inquiry_status"] = []int{1, 2, 3, 4, 5, 6}
+	orderInquirys, err := orderInquiryDao.GetOrderInquiryTimeList(maps, startDate.Format("2006-01-02 15:04"), endDate.Format("2006-01-02 15:04:05"))
+	if err != nil {
+		return 0, err
+	}
+
+	return len(orderInquirys), err
+}
+
+// GetRemainingInquiryCount 获取服务包当月剩余问诊次数
+func (r *OrderServicePackageService) GetRemainingInquiryCount(monthlyFrequency, monthInquiryCount int) string {
+	result := ""
+	if monthlyFrequency != 0 {
+		monthInquiryCount = monthlyFrequency - monthInquiryCount
+		if monthInquiryCount < 0 {
+			result = "0"
+		} else {
+			result = strconv.Itoa(monthInquiryCount)
+		}
+	} else {
+		result = "不限"
+	}
+	return result
+}
+
+// GetOrderServiceProductCanUseQuantity 获取服务包内某一药品的可使用数量
+func (r *OrderServicePackageService) GetOrderServiceProductCanUseQuantity(orderServiceId, productId int64, totalQuantity int) (int, error) {
+	orderServicePackageProductDao := dao.OrderServicePackageProductDao{}
+
+	maps := make(map[string]interface{})
+	maps["order_service_id"] = orderServiceId
+	maps["product_id"] = productId
+	orderServicePackageProducts, err := orderServicePackageProductDao.GetOrderServicePackageProductList(maps)
+	if err != nil {
+		return 0, err
+	}
+
+	// 订单使用数量
+	usedQuantity := 0
+	for _, product := range orderServicePackageProducts {
+		usedQuantity = usedQuantity + product.UsedQuantity
+	}
+
+	// 剩余数量 = 总数量-使用数量
+	remainingQuantity := totalQuantity - usedQuantity
+	if remainingQuantity < 0 {
+		remainingQuantity = 0
+	}
+
+	return remainingQuantity, err
+}