gdxz/hospital-admin-api
4
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

新增：获取服务包订单列表-分页

Browse Source
This commit is contained in:
wucongxing8150 2024-05-24 10:20:17 +08:00
parent 22e50153de
commit 626542394d
18 changed files with 1034 additions and 3 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
api/controller/base.go
View File

@ -48,6 +48,7 @@ type order struct {
Order // 订单 Order // 订单
OrderInquiry // 问诊订单 OrderInquiry // 问诊订单
OrderProduct // 药品订单 OrderProduct // 药品订单
OrderServicePackage // 服务包订单
} }
// 患者管理 // 患者管理

58
api/controller/orderServicePackage.go Normal file
View File

@ -0,0 +1,58 @@
package controller
import (
"github.com/gin-gonic/gin"
"hospital-admin-api/api/dao"
"hospital-admin-api/api/dto"
"hospital-admin-api/api/requests"
"hospital-admin-api/api/responses"
"hospital-admin-api/global"
"hospital-admin-api/utils"
)
type OrderServicePackage struct{}
// GetOrderServicePackagePage 获取服务包订单列表-分页
func (r *OrderServicePackage) GetOrderServicePackagePage(c *gin.Context) {
orderServicePackageRequest := requests.OrderServicePackageRequest{}
req := orderServicePackageRequest.GetOrderServicePackagePage
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
}
orderServicePackageDao := dao.OrderServicePackageDao{}
orderServicePackage, total, err := orderServicePackageDao.GetOrderServicePackagePageSearch(req, req.Page, req.PageSize)
if err != nil {
responses.FailWithMessage(err.Error(), c)
return
}
// 处理返回值
GetOrderInquiryPageResponses := dto.GetOrderServicePackageListDto(orderServicePackage)
if err != nil {
responses.FailWithMessage(err.Error(), c)
return
}
result := make(map[string]interface{})
result["page"] = req.Page
result["page_size"] = req.PageSize
result["total"] = total
result["data"] = GetOrderInquiryPageResponses
responses.OkWithData(result, c)
}

293
api/dao/orderServicePackage.go Normal file
View File

@ -0,0 +1,293 @@
package dao
import (
"gorm.io/gorm"
"gorm.io/gorm/clause"
"hospital-admin-api/api/model"
"hospital-admin-api/api/requests"
"hospital-admin-api/global"
"strings"
"time"
)
type OrderServicePackageDao struct {
}
// GetOrderServicePackageById 获取数据-id
func (r *OrderServicePackageDao) GetOrderServicePackageById(orderServiceId int64) (m *model.OrderServicePackage, err error) {
err = global.Db.First(&m, orderServiceId).Error
if err != nil {
return nil, err
}
return m, nil
}
// GetOrderServicePackagePreloadById 获取数据-加载全部关联-id
func (r *OrderServicePackageDao) GetOrderServicePackagePreloadById(orderServiceId int64) (m *model.OrderServicePackage, err error) {
err = global.Db.Preload(clause.Associations).First(&m, orderServiceId).Error
if err != nil {
return nil, err
}
return m, nil
}
// GetOrderServicePackageByOrderProductId 获取数据-药品订单id
func (r *OrderServicePackageDao) GetOrderServicePackageByOrderProductId(orderId int64) (m *model.OrderServicePackage, err error) {
err = global.Db.Where("order_id = ?", orderId).First(&m).Error
if err != nil {
return nil, err
}
return m, nil
}
// DeleteOrderServicePackage 删除
func (r *OrderServicePackageDao) DeleteOrderServicePackage(tx *gorm.DB, maps interface{}) error {
err := tx.Where(maps).Delete(&model.OrderServicePackage{}).Error
if err != nil {
return err
}
return nil
}
// EditOrderServicePackage 修改
func (r *OrderServicePackageDao) EditOrderServicePackage(tx *gorm.DB, maps interface{}, data interface{}) error {
err := tx.Model(&model.OrderServicePackage{}).Where(maps).Updates(data).Error
if err != nil {
return err
}
return nil
}
// EditOrderServicePackageById 修改-药品订单id
func (r *OrderServicePackageDao) EditOrderServicePackageById(tx *gorm.DB, orderId int64, data interface{}) error {
err := tx.Model(&model.OrderServicePackage{}).Where("order_id = ?", orderId).Updates(data).Error
if err != nil {
return err
}
return nil
}
// GetOrderServicePackageList 获取列表
func (r *OrderServicePackageDao) GetOrderServicePackageList(maps interface{}) (m []*model.OrderServicePackage, err error) {
err = global.Db.Where(maps).Find(&m).Error
if err != nil {
return nil, err
}
return m, nil
}
// AddOrderServicePackage 新增
func (r *OrderServicePackageDao) AddOrderServicePackage(tx *gorm.DB, model *model.OrderServicePackage) (*model.OrderServicePackage, error) {
if err := tx.Create(model).Error; err != nil {
return nil, err
}
return model, nil
}
// GetOrderServicePackagePageSearch 获取问诊订单列表-分页
func (r *OrderServicePackageDao) GetOrderServicePackagePageSearch(req requests.GetOrderServicePackagePage, page, pageSize int) (m []*model.OrderServicePackage, total int64, err error) {
var totalRecords int64
// 构建查询条件
query := global.Db.Model(&model.OrderServicePackage{})
// 医生
query = query.Preload("UserDoctor", func(db *gorm.DB) *gorm.DB {
return db.Omit("open_id", "union_id", "wx_session_key")
})
// 医生姓名
if req.DoctorName != "" {
subQuery := global.Db.Model(&model.UserDoctor{}).
Select("doctor_id").
Where("user_name LIKE ?", "%"+req.DoctorName+"%")
query = query.Where(gorm.Expr("doctor_id IN (?)", subQuery))
}
// 用户
query = query.Preload("User", func(db *gorm.DB) *gorm.DB {
return db.Select("user_id", "user_name", "mobile")
})
// 主键id
if req.OrderServiceId != "" {
query = query.Where("order_service_id = ?", req.OrderServiceId)
}
// 订单id
if req.OrderId != "" {
query = query.Where("order_id = ?", req.OrderId)
}
// 服务包类型
if req.OrderServiceType != nil {
query = query.Where("order_service_type = ?", req.OrderServiceType)
}
// 订单状态
if req.OrderServiceStatus != nil {
query = query.Where("order_service_status = ?", req.OrderServiceStatus)
}
// 删除状态
if req.OrderServiceStatus != nil {
query = query.Where("order_service_status = ?", req.OrderServiceStatus)
}
// 订单退款状态
if req.RefundStatus != nil {
query = query.Where("refund_status = ?", req.RefundStatus)
}
// 支付渠道
if req.PayChannel != nil {
query = query.Where("pay_channel = ?", req.PayChannel)
}
// 支付状态
if req.PayStatus != nil {
query = query.Where("pay_status = ?", req.PayStatus)
}
// 系统订单编号
if req.OrderServiceNo != "" {
query = query.Where("order_service_no = ?", req.OrderServiceNo)
}
// 第三方支付流水号
if req.EscrowTradeNo != "" {
query = query.Where("escrow_trade_no = ?", req.EscrowTradeNo)
}
// 支付时间
if req.PayTime != "" {
payTime := strings.Split(req.PayTime, "&")
if len(payTime) == 2 {
startTime, _ := time.Parse("2006-01-02", payTime[0])
endTime, _ := time.Parse("2006-01-02", payTime[1])
endTime = endTime.Add(23*time.Hour + 59*time.Minute + 59*time.Second)
query = query.Where("pay_time BETWEEN ? AND ?", startTime, endTime)
}
}
// 开始服务时间
if req.StartTime != "" {
orderStartTime := strings.Split(req.StartTime, "&")
if len(orderStartTime) == 2 {
startTime, _ := time.Parse("2006-01-02", orderStartTime[0])
endTime, _ := time.Parse("2006-01-02", orderStartTime[1])
endTime = endTime.Add(23*time.Hour + 59*time.Minute + 59*time.Second)
query = query.Where("start_time BETWEEN ? AND ?", startTime, endTime)
}
}
// 结束服务时间
if req.FinishTime != "" {
finishTime := strings.Split(req.FinishTime, "&")
if len(finishTime) == 2 {
startTime, _ := time.Parse("2006-01-02", finishTime[0])
endTime, _ := time.Parse("2006-01-02", finishTime[1])
endTime = endTime.Add(23*time.Hour + 59*time.Minute + 59*time.Second)
query = query.Where("finish_time BETWEEN ? AND ?", startTime, endTime)
}
}
// 订单取消时间
if req.CancelTime != "" {
cancelTime := strings.Split(req.CancelTime, "&")
if len(cancelTime) == 2 {
startTime, _ := time.Parse("2006-01-02", cancelTime[0])
endTime, _ := time.Parse("2006-01-02", cancelTime[1])
endTime = endTime.Add(23*time.Hour + 59*time.Minute + 59*time.Second)
query = query.Where("cancel_time BETWEEN ? AND ?", startTime, endTime)
}
}
// 取消订单原因
if req.CancelReason != nil {
query = query.Where("cancel_reason = ?", req.CancelReason)
}
// 取消订单备注
if req.CancelRemarks != "" {
query = query.Where("cancel_remarks LIKE ?", "%"+req.CancelRemarks+"%")
}
// 添加完成订单延迟队列状态
if req.AddFinishStatus != nil {
query = query.Where("add_finish_status = ?", req.AddFinishStatus)
}
// 添加完成订单延迟队列时间
if req.AddFinishTime != "" {
addFinishTime := strings.Split(req.AddFinishTime, "&")
if len(addFinishTime) == 2 {
startTime, _ := time.Parse("2006-01-02", addFinishTime[0])
endTime, _ := time.Parse("2006-01-02", addFinishTime[1])
endTime = endTime.Add(23*time.Hour + 59*time.Minute + 59*time.Second)
query = query.Where("add_finish_time BETWEEN ? AND ?", startTime, endTime)
}
}
// 创建时间
if req.CreatedAt != "" {
createdAt := strings.Split(req.CreatedAt, "&")
if len(createdAt) == 2 {
startTime, _ := time.Parse("2006-01-02", createdAt[0])
endTime, _ := time.Parse("2006-01-02", createdAt[1])
endTime = endTime.Add(23*time.Hour + 59*time.Minute + 59*time.Second)
query = query.Where("created_at BETWEEN ? AND ?", startTime, endTime)
}
}
// 患者姓名-就诊人
if req.PatientName != "" {
query = query.Where("patient_name LIKE ?", "%"+req.PatientName+"%")
}
// 手机号-医生/患者
if req.Mobile != "" {
// 患者
patientSubQuery := global.Db.Model(&model.User{}).
Select("user_id").
Where("mobile = ?", req.Mobile)
// 医生
doctorUserSubQuery := global.Db.Model(&model.User{}).
Select("user_id").
Where("mobile = ?", req.Mobile)
doctorSubQuery := global.Db.Model(&model.UserDoctor{}).
Select("doctor_id").
Where(gorm.Expr("user_id IN (?)", doctorUserSubQuery))
query = query.Where("user_id IN (?)", patientSubQuery).Or("doctor_id IN (?)", doctorSubQuery)
}
// 排序
query = query.Order("created_at desc")
// 查询总数量
if err := query.Count(&totalRecords).Error; err != nil {
return nil, 0, err
}
err = query.Scopes(model.Paginate(page, pageSize)).Find(&m).Error
if err != nil {
return nil, 0, err
}
return m, totalRecords, nil
}

158
api/dto/OrderServicePackage.go Normal file
View File

@ -0,0 +1,158 @@
package dto
import (
"fmt"
"hospital-admin-api/api/model"
)
// 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"` // 用户姓名（患者）
}
// GetOrderServicePackageDto 服务包订单详情
func GetOrderServicePackageDto(m *model.OrderServicePackage) *OrderServicePackageDto {
return &OrderServicePackageDto{
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,
RefundStatus: m.RefundStatus,
PayChannel: m.PayChannel,
PayStatus: m.PayStatus,
OrderServiceNo: m.OrderServiceNo,
EscrowTradeNo: m.EscrowTradeNo,
AmountTotal: m.AmountTotal,
CouponAmountTotal: m.CouponAmountTotal,
PaymentAmountTotal: m.PaymentAmountTotal,
PayTime: m.PayTime,
StartTime: m.StartTime,
FinishTime: m.FinishTime,
CancelTime: m.CancelTime,
CancelReason: m.CancelReason,
CancelRemarks: m.CancelRemarks,
AddFinishStatus: m.AddFinishStatus,
AddFinishTime: m.AddFinishTime,
AddFinishFailReason: m.AddFinishFailReason,
PatientName: m.PatientName,
PatientNameMask: m.PatientNameMask,
PatientSex: m.PatientSex,
PatientAge: m.PatientAge,
CreatedAt: m.CreatedAt,
UpdatedAt: m.UpdatedAt,
}
}
// GetOrderServicePackageListDto 服务包订单列表
func GetOrderServicePackageListDto(m []*model.OrderServicePackage) []*OrderServicePackageDto {
// 处理返回值
responses := make([]*OrderServicePackageDto, len(m))
if len(m) > 0 {
for i, v := range m {
response := &OrderServicePackageDto{
OrderServiceId: fmt.Sprintf("%d", v.OrderServiceId),
OrderId: fmt.Sprintf("%d", v.OrderId),
UserId: fmt.Sprintf("%d", v.UserId),
PatientId: fmt.Sprintf("%d", v.PatientId),
DoctorId: fmt.Sprintf("%d", v.DoctorId),
FamilyId: fmt.Sprintf("%d", v.FamilyId),
OrderServiceType: v.OrderServiceType,
OrderServiceStatus: v.OrderServiceStatus,
IsDelete: v.IsDelete,
RefundStatus: v.RefundStatus,
PayChannel: v.PayChannel,
PayStatus: v.PayStatus,
OrderServiceNo: v.OrderServiceNo,
EscrowTradeNo: v.EscrowTradeNo,
AmountTotal: v.AmountTotal,
CouponAmountTotal: v.CouponAmountTotal,
PaymentAmountTotal: v.PaymentAmountTotal,
PayTime: v.PayTime,
StartTime: v.StartTime,
FinishTime: v.FinishTime,
CancelTime: v.CancelTime,
CancelReason: v.CancelReason,
CancelRemarks: v.CancelRemarks,
AddFinishStatus: v.AddFinishStatus,
AddFinishTime: v.AddFinishTime,
AddFinishFailReason: v.AddFinishFailReason,
PatientName: v.PatientName,
PatientNameMask: v.PatientNameMask,
PatientSex: v.PatientSex,
PatientAge: v.PatientAge,
CreatedAt: v.CreatedAt,
UpdatedAt: v.UpdatedAt,
}
// 加载医生名称
if v.UserDoctor != nil {
response = response.LoadDoctorName(v.UserDoctor)
}
// 加载用户姓名（患者）
if v.User != nil {
response = response.LoadUserName(v.User)
}
// 将转换后的结构体添加到新切片中
responses[i] = response
}
}
return responses
}
// LoadDoctorName 加载医生名称
func (r *OrderServicePackageDto) LoadDoctorName(m *model.UserDoctor) *OrderServicePackageDto {
if m != nil {
r.DoctorName = m.UserName
}
return r
}
// LoadUserName 加载用户姓名（患者）
func (r *OrderServicePackageDto) LoadUserName(m *model.User) *OrderServicePackageDto {
if m != nil {
r.UserName = m.UserName
}
return r
}

36
api/model/doctorConfigDifficultConsultation.go Normal file
View File

@ -0,0 +1,36 @@
package model
import (
"gorm.io/gorm"
"hospital-admin-api/global"
"time"
)
// DoctorConfigDifficultConsultation 医生配置-疑难会诊
type DoctorConfigDifficultConsultation struct {
DifficultConsultationId int64 `gorm:"column:difficult_consultation_id;type:bigint(19);primary_key;comment:主键id" json:"difficult_consultation_id"`
DoctorId int64 `gorm:"column:doctor_id;type:bigint(19);comment:医生id;NOT NULL" json:"doctor_id"`
ServiceContent string `gorm:"column:service_content;type:text;comment:服务内容" json:"service_content"`
ServiceProcess string `gorm:"column:service_process;type:text;comment:服务流程" json:"service_process"`
ServicePeriod uint `gorm:"column:service_period;type:int(10) unsigned;comment:服务周期;NOT NULL" json:"service_period"`
ServiceRounds uint `gorm:"column:service_rounds;type:int(1) unsigned;default:0;comment:服务回合数（0表示不限次）" json:"service_rounds"`
Model
}
func (m *DoctorConfigDifficultConsultation) TableName() string {
return "gdxz_doctor_config_difficult_consultation"
}
func (m *DoctorConfigDifficultConsultation) BeforeCreate(tx *gorm.DB) error {
if m.DifficultConsultationId == 0 {
m.DifficultConsultationId = 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
}

34
api/model/doctorConfigFollowPackage.go Normal file
View File

@ -0,0 +1,34 @@
package model
import (
"gorm.io/gorm"
"hospital-admin-api/global"
"time"
)
// DoctorConfigFollowPackage 医生配置-随访包
type DoctorConfigFollowPackage struct {
FollowPackageId int64 `gorm:"column:follow_package_id;type:bigint(19);primary_key;comment:主键id" json:"follow_package_id"`
DoctorId int64 `gorm:"column:doctor_id;type:bigint(19);comment:医生id" json:"doctor_id"`
MonthlyFrequency int `gorm:"column:monthly_frequency;type:int(1);default:0;comment:每月次数（0表示不限次）" json:"monthly_frequency"`
ServiceRounds int `gorm:"column:service_rounds;type:int(1);default:0;comment:服务回合数（0表示不限次）" json:"service_rounds"`
Model
}
func (m *DoctorConfigFollowPackage) TableName() string {
return "gdxz_doctor_config_follow_package"
}
func (m *DoctorConfigFollowPackage) BeforeCreate(tx *gorm.DB) error {
if m.FollowPackageId == 0 {
m.FollowPackageId = 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
}

34
api/model/doctorConfigFollowPackageItem.go Normal file
View File

@ -0,0 +1,34 @@
package model
import (
"gorm.io/gorm"
"hospital-admin-api/global"
"time"
)
// DoctorConfigFollowPackageItem 医生配置-随访包-明细
type DoctorConfigFollowPackageItem struct {
FollowPackageItemId int64 `gorm:"column:follow_package_item_id;type:bigint(19);primary_key;comment:主键id" json:"follow_package_item_id"`
FollowPackageId int64 `gorm:"column:follow_package_id;type:bigint(19);comment:医生随访包id;NOT NULL" json:"follow_package_id"`
ServicePeriod int `gorm:"column:service_period;type:int(5);comment:服务周期(天)" json:"service_period"`
ServicePrice float64 `gorm:"column:service_price;type:decimal(10,2);comment:服务价格" json:"service_price"`
Model
}
func (m *DoctorConfigFollowPackageItem) TableName() string {
return "gdxz_doctor_config_follow_package_item"
}
func (m *DoctorConfigFollowPackageItem) BeforeCreate(tx *gorm.DB) error {
if m.FollowPackageItemId == 0 {
m.FollowPackageItemId = 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
}

34
api/model/doctorConfigHealthPackage.go Normal file
View File

@ -0,0 +1,34 @@
package model
import (
"gorm.io/gorm"
"hospital-admin-api/global"
"time"
)
// DoctorConfigHealthPackage 医生配置-健康包
type DoctorConfigHealthPackage struct {
HealthPackageId int64 `gorm:"column:health_package_id;type:bigint(19);primary_key;comment:主键id" json:"health_package_id"`
DoctorId int64 `gorm:"column:doctor_id;type:bigint(19);comment:医生id;NOT NULL" json:"doctor_id"`
PackageId int64 `gorm:"column:package_id;type:bigint(19);comment:健康包配置id;NOT NULL" json:"package_id"`
ServicePrice float64 `gorm:"column:service_price;type:decimal(10,2);comment:服务价格（根据图文问诊价格计算）" json:"service_price"`
Model
}
func (m *DoctorConfigHealthPackage) TableName() string {
return "gdxz_doctor_config_health_package"
}
func (m *DoctorConfigHealthPackage) BeforeCreate(tx *gorm.DB) error {
if m.HealthPackageId == 0 {
m.HealthPackageId = 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
}

36
api/model/healthPackage.go Normal file
View File

@ -0,0 +1,36 @@
package model
import (
"gorm.io/gorm"
"hospital-admin-api/global"
"time"
)
// HealthPackage 健康包
type HealthPackage struct {
PackageId int64 `gorm:"column:package_id;type:bigint(20);primary_key;comment:主键id" json:"package_id"`
ServiceCount int `gorm:"column:service_count;type:int(1);comment:总服务次数" json:"service_count"`
MonthlyFrequency int `gorm:"column:monthly_frequency;type:int(1);comment:每月次数" json:"monthly_frequency"`
EffectiveDays string `gorm:"column:effective_days;type:varchar(20);comment:服务有效天数" json:"effective_days"`
ServiceRate string `gorm:"column:service_rate;type:varchar(20);comment:服务费率。100为满值，表示1，正常费率。" json:"service_rate"`
DiscountProductTotalAmount float64 `gorm:"column:discount_product_total_amount;type:decimal(10,2) unsigned;default:0.00;comment:折扣商品总价格" json:"discount_product_total_amount"`
Model
}
func (m *HealthPackage) TableName() string {
return "gdxz_health_package"
}
func (m *HealthPackage) BeforeCreate(tx *gorm.DB) error {
if m.PackageId == 0 {
m.PackageId = 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
}

36
api/model/healthPackageProduct.go Normal file
View File

@ -0,0 +1,36 @@
package model
import (
"gorm.io/gorm"
"hospital-admin-api/global"
"time"
)
// HealthPackageProduct 健康包-关联商品
type HealthPackageProduct struct {
PackageProductId int64 `gorm:"column:package_product_id;type:bigint(19);comment:主键id" json:"package_product_id"`
PackageId int64 `gorm:"column:package_id;type:bigint(19);comment:健康包id" json:"package_id"`
ProductId int64 `gorm:"column:product_id;type:bigint(19);primary_key;comment:商品id" json:"product_id"`
ProductName string `gorm:"column:product_name;type:varchar(255);comment:商品名称" json:"product_name"`
Quantity int `gorm:"column:quantity;type:int(1);default:1;comment:数量" json:"quantity"`
DiscountProductPrice float64 `gorm:"column:discount_product_price;type:decimal(10,2) unsigned;default:0.00;comment:折扣商品价格" json:"discount_product_price"`
Model
}
func (m *HealthPackageProduct) TableName() string {
return "gdxz_health_package_product"
}
func (m *HealthPackageProduct) BeforeCreate(tx *gorm.DB) error {
if m.PackageProductId == 0 {
m.PackageProductId = 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
}

62
api/model/orderServicePackage.go Normal file
View File

@ -0,0 +1,62 @@
package model
import (
"gorm.io/gorm"
"hospital-admin-api/global"
"time"
)
// OrderServicePackage 订单-服务包表
type OrderServicePackage struct {
OrderServiceId int64 `gorm:"column:order_service_id;type:bigint(19);primary_key;comment:主键id" json:"order_service_id"`
OrderId int64 `gorm:"column:order_id;type:bigint(19);comment:订单id;NOT NULL" json:"order_id"`
UserId int64 `gorm:"column:user_id;type:bigint(19);comment:用户id-患者;NOT NULL" json:"user_id"`
PatientId int64 `gorm:"column:patient_id;type:bigint(19);comment:患者id;NOT NULL" json:"patient_id"`
DoctorId int64 `gorm:"column:doctor_id;type:bigint(19);comment:医生id;NOT NULL" json:"doctor_id"`
FamilyId int64 `gorm:"column:family_id;type:bigint(19);comment:家庭成员id（就诊用户）;NOT NULL" json:"family_id"`
OrderServiceType int `gorm:"column:order_service_type;type:tinyint(1);comment:服务包类型（1:健康包 2:随访包）;NOT NULL" json:"order_service_type"`
OrderServiceStatus int `gorm:"column:order_service_status;type:tinyint(4);comment:订单状态（1:待支付 2:未开始 3:服务中 4:服务完成 5:服务取消）;NOT NULL" json:"order_service_status"`
IsDelete int `gorm:"column:is_delete;type:tinyint(1);default:0;comment:删除状态（0:否 1:是）" json:"is_delete"`
RefundStatus int `gorm:"column:refund_status;type:tinyint(1);default:0;comment:订单退款状态（0:无退款 1:申请退款 2:退款中 3:退款成功 4:拒绝退款 5:退款关闭 6:退款异常 7:部分退款）;NOT NULL" json:"refund_status"`
PayChannel int `gorm:"column:pay_channel;type:tinyint(1);comment:支付渠道（1:小程序支付 2:微信扫码支付 3:模拟支付）;NOT NULL" json:"pay_channel"`
PayStatus int `gorm:"column:pay_status;type:tinyint(1);default:1;comment:支付状态（1:未支付 2:已支付 3:支付中 4:支付失败 5:支付超时 6:支付关闭 7:已撤销 8:转入退款）;NOT NULL" json:"pay_status"`
OrderServiceNo string `gorm:"column:order_service_no;type:varchar(30);comment:系统订单编号;NOT NULL" json:"order_service_no"`
EscrowTradeNo string `gorm:"column:escrow_trade_no;type:varchar(100);comment:第三方支付流水号;NOT NULL" json:"escrow_trade_no"`
AmountTotal float64 `gorm:"column:amount_total;type:decimal(10,2);default:0.00;comment:订单金额" json:"amount_total"`
CouponAmountTotal float64 `gorm:"column:coupon_amount_total;type:decimal(10,2);default:0.00;comment:优惠卷总金额" json:"coupon_amount_total"`
PaymentAmountTotal float64 `gorm:"column:payment_amount_total;type:decimal(10,2);default:0.00;comment:实际付款金额" json:"payment_amount_total"`
PayTime LocalTime `gorm:"column:pay_time;type:datetime;comment:支付时间" json:"pay_time"`
StartTime LocalTime `gorm:"column:start_time;type:datetime;comment:开始服务时间" json:"start_time"`
FinishTime LocalTime `gorm:"column:finish_time;type:datetime;comment:结束服务时间" json:"finish_time"`
CancelTime LocalTime `gorm:"column:cancel_time;type:datetime;comment:订单取消时间" json:"cancel_time"`
CancelReason int `gorm:"column:cancel_reason;type:tinyint(1);comment:取消订单原因（1:医生未接受服务 2:主动取消 4:客服取消 5:支付超时）" json:"cancel_reason"`
CancelRemarks string `gorm:"column:cancel_remarks;type:varchar(255);comment:取消订单备注" json:"cancel_remarks"`
AddFinishStatus int `gorm:"column:add_finish_status;type:tinyint(1);default:0;comment:添加完成订单延迟队列状态（0:未添加 1:已添加 2:添加失败）" json:"add_finish_status"`
AddFinishTime LocalTime `gorm:"column:add_finish_time;type:datetime;comment:添加完成订单延迟队列时间" json:"add_finish_time"`
AddFinishFailReason string `gorm:"column:add_finish_fail_reason;type:varchar(255);comment:添加完成订单延迟队列失败原因" json:"add_finish_fail_reason"`
PatientName string `gorm:"column:patient_name;type:varchar(255);comment:患者姓名-就诊人" json:"patient_name"`
PatientNameMask string `gorm:"column:patient_name_mask;type:varchar(255);comment:患者姓名-就诊人(掩码)" json:"patient_name_mask"`
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"` // 患者
}
func (m *OrderServicePackage) TableName() string {
return "gdxz_order_service_package"
}
func (m *OrderServicePackage) BeforeCreate(tx *gorm.DB) error {
if m.OrderServiceId == 0 {
m.OrderServiceId = 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
}

51
api/model/orderServicePackageCase.go Normal file
View File

@ -0,0 +1,51 @@
package model
import (
"gorm.io/gorm"
"hospital-admin-api/global"
"time"
)
type OrderServicePackageCase struct {
OrderServiceCaseId int64 `gorm:"column:order_service_case_id;type:bigint(19);primary_key;comment:主键id" json:"order_service_case_id"`
UserId int64 `gorm:"column:user_id;type:bigint(19);comment:用户id;NOT NULL" json:"user_id"`
PatientId int64 `gorm:"column:patient_id;type:bigint(19);comment:患者id;NOT NULL" json:"patient_id"`
OrderId int64 `gorm:"column:order_id;type:bigint(19);comment:订单id;NOT NULL" json:"order_id"`
OrderServiceId int64 `gorm:"column:order_service_id;type:bigint(19);comment:订单-服务包id;NOT NULL" json:"order_service_id"`
FamilyId int64 `gorm:"column:family_id;type:bigint(19);comment:家庭成员id;NOT NULL" json:"family_id"`
DiseaseClassId int64 `gorm:"column:disease_class_id;type:bigint(19);comment:疾病分类id-系统" json:"disease_class_id"`
Relation int `gorm:"column:relation;type:tinyint(1);comment:与患者关系（1:本人 2:父母 3:爱人 4:子女 5:亲戚 6:其他 ）" json:"relation"`
Status int `gorm:"column:status;type:tinyint(1);default:1;comment:状态（1:正常 2:删除）" json:"status"`
Name string `gorm:"column:name;type:varchar(50);comment:患者名称" json:"name"`
Sex int `gorm:"column:sex;type:tinyint(1);default:0;comment:患者性别（0:未知 1:男 2:女）" json:"sex"`
Age int `gorm:"column:age;type:int(11);comment:患者年龄" json:"age"`
DiseaseClassName string `gorm:"column:disease_class_name;type:varchar(255);comment:疾病名称-系统" json:"disease_class_name"`
DiagnosisDate LocalTime `gorm:"column:diagnosis_date;type:datetime;comment:确诊日期" json:"diagnosis_date"`
DiseaseDesc string `gorm:"column:disease_desc;type:text;comment:病情描述（主诉）" json:"disease_desc"`
DiagnoseImages string `gorm:"column:diagnose_images;type:varchar(1000);comment:复诊凭证(多个使用逗号分隔)" json:"diagnose_images"`
IsAllergyHistory int `gorm:"column:is_allergy_history;type:tinyint(1);comment:是否存在过敏史（0:否 1:是）" json:"is_allergy_history"`
AllergyHistory string `gorm:"column:allergy_history;type:varchar(255);comment:过敏史描述" json:"allergy_history"`
IsFamilyHistory int `gorm:"column:is_family_history;type:tinyint(1);comment:是否存在家族病史（0:否 1:是）" json:"is_family_history"`
FamilyHistory string `gorm:"column:family_history;type:varchar(255);comment:家族病史描述" json:"family_history"`
IsPregnant int `gorm:"column:is_pregnant;type:tinyint(1);comment:是否备孕、妊娠、哺乳期（0:否 1:是）" json:"is_pregnant"`
Pregnant string `gorm:"column:pregnant;type:varchar(255);comment:备孕、妊娠、哺乳期描述" json:"pregnant"`
Model
}
func (m *OrderServicePackageCase) TableName() string {
return "gdxz_order_service_package_case"
}
func (m *OrderServicePackageCase) BeforeCreate(tx *gorm.DB) error {
if m.OrderServiceCaseId == 0 {
m.OrderServiceCaseId = 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
}

40
api/model/orderServicePackageDetail.go Normal file
View File

@ -0,0 +1,40 @@
package model
import (
"gorm.io/gorm"
"hospital-admin-api/global"
"time"
)
// OrderServicePackageDetail 订单-服务包详情表
type OrderServicePackageDetail struct {
OrderServiceDetailId int64 `gorm:"column:order_service_detail_id;type:bigint(19);primary_key;comment:主键id" json:"order_service_detail_id"`
OrderServiceId int64 `gorm:"column:order_service_id;type:bigint(19);comment:服务包订单id" json:"order_service_id"`
OrderId int64 `gorm:"column:order_id;type:bigint(19);comment:订单id" json:"order_id"`
PackageId int64 `gorm:"column:package_id;type:bigint(19);comment:健康包配置id（随访包时为空）" json:"package_id"`
OrderServiceNo string `gorm:"column:order_service_no;type:varchar(30);comment:系统订单编号" json:"order_service_no"`
ServicePeriod int `gorm:"column:service_period;type:int(1);comment:服务周期（天）" json:"service_period"`
ServiceCount int `gorm:"column:service_count;type:int(1);comment:总服务次数（0表示不限次）" json:"service_count"`
MonthlyFrequency int `gorm:"column:monthly_frequency;type:int(1);comment:每月次数（0表示不限次）" json:"monthly_frequency"`
SingleInquiryPrice float64 `gorm:"column:single_inquiry_price;type:decimal(10,2);default:0.00;comment:单次图文问诊价格" json:"single_inquiry_price"`
ServicePrice float64 `gorm:"column:service_price;type:decimal(10,2);default:0.00;comment:总服务价格" json:"service_price"`
Model
}
func (m *OrderServicePackageDetail) TableName() string {
return "gdxz_order_service_package_detail"
}
func (m *OrderServicePackageDetail) BeforeCreate(tx *gorm.DB) error {
if m.OrderServiceDetailId == 0 {
m.OrderServiceDetailId = 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
}

35
api/model/orderServicePackageInquiry.go Normal file
View File

@ -0,0 +1,35 @@
package model
import (
"gorm.io/gorm"
"hospital-admin-api/global"
"time"
)
// OrderServicePackageInquiry 服务包关联问诊订单表
type OrderServicePackageInquiry struct {
ServiceInquiryId int64 `gorm:"column:service_inquiry_id;type:bigint(19);primary_key;comment:主键id" json:"service_inquiry_id"`
OrderServiceId int64 `gorm:"column:order_service_id;type:bigint(19);comment:订单-服务包id;NOT NULL" json:"order_service_id"`
OrderInquiryId int64 `gorm:"column:order_inquiry_id;type:bigint(19);comment:订单-问诊id;NOT NULL" json:"order_inquiry_id"`
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
}
func (m *OrderServicePackageInquiry) TableName() string {
return "gdxz_order_service_package_inquiry"
}
func (m *OrderServicePackageInquiry) BeforeCreate(tx *gorm.DB) error {
if m.ServiceInquiryId == 0 {
m.ServiceInquiryId = 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
}

37
api/model/orderServicePackageProduct.go Normal file
View File

@ -0,0 +1,37 @@
package model
import (
"gorm.io/gorm"
"hospital-admin-api/global"
"time"
)
// OrderServicePackageProduct 订单-服务包-关联商品订单表
type OrderServicePackageProduct struct {
ServiceProductId int64 `gorm:"column:service_product_id;type:bigint(19);primary_key;comment:主键id" json:"service_product_id"`
OrderServiceId int64 `gorm:"column:order_service_id;type:bigint(19);comment:订单-服务包id;NOT NULL" json:"order_service_id"`
OrderProductId int64 `gorm:"column:order_product_id;type:bigint(19);comment:订单-商品id;NOT NULL" json:"order_product_id"`
OrderProductNo string `gorm:"column:order_product_no;type:varchar(100);comment:订单-商品系统编号;NOT NULL" json:"order_product_no"`
ProductItemId int64 `gorm:"column:product_item_id;type:bigint(19);comment:订单-商品明细id;NOT NULL" json:"product_item_id"`
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
}
func (m *OrderServicePackageProduct) TableName() string {
return "gdxz_order_service_package_product"
}
func (m *OrderServicePackageProduct) BeforeCreate(tx *gorm.DB) error {
if m.ServiceProductId == 0 {
m.ServiceProductId = 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
}

40
api/model/orderServicePackageRefund.go Normal file
View File

@ -0,0 +1,40 @@
package model
import (
"gorm.io/gorm"
"hospital-admin-api/global"
"time"
)
// OrderServicePackageRefund 订单-服务包-退款表
type OrderServicePackageRefund struct {
ServiceRefundId int64 `gorm:"column:service_refund_id;type:bigint(19);primary_key;comment:主键id" json:"service_refund_id"`
PatientId int64 `gorm:"column:patient_id;type:bigint(19);comment:患者id" json:"patient_id"`
OrderServiceId int64 `gorm:"column:order_service_id;type:bigint(19);comment:订单-服务包id" json:"order_service_id"`
OrderServiceNo string `gorm:"column:order_service_no;type:varchar(100);comment:系统订单编号" json:"order_service_no"`
ServiceRefundNo string `gorm:"column:service_refund_no;type:varchar(50);comment:系统退款编号" json:"service_refund_no"`
RefundId string `gorm:"column:refund_id;type:varchar(50);comment:第三方退款单号" json:"refund_id"`
RefundStatus int `gorm:"column:refund_status;type:tinyint(1);default:0;comment:订单退款状态（0:无退款 1:申请退款 2:退款中 3:退款成功 4:拒绝退款 5:退款关闭 6:退款异常 7:部分退款）" json:"refund_status"`
RefundTotal float64 `gorm:"column:refund_total;type:decimal(10,2);default:0.00;comment:退款金额" json:"refund_total"`
RefundReason string `gorm:"column:refund_reason;type:varchar(255);comment:退款原因" json:"refund_reason"`
SuccessTime LocalTime `gorm:"column:success_time;type:datetime;comment:退款成功时间" json:"success_time"`
Model
}
func (m *OrderServicePackageRefund) TableName() string {
return "gdxz_order_service_package_refund"
}
func (m *OrderServicePackageRefund) BeforeCreate(tx *gorm.DB) error {
if m.ServiceRefundId == 0 {
m.ServiceRefundId = 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
}

33
api/requests/OrderServicePackage.go Normal file
View File

@ -0,0 +1,33 @@
package requests
type OrderServicePackageRequest struct {
GetOrderServicePackagePage // 获取药品订单列表-分页
}
// GetOrderServicePackagePage 订单-服务包表
type GetOrderServicePackagePage struct {
Page int `json:"page" form:"page" label:"页码"`
PageSize int `json:"page_size" form:"page_size" label:"每页个数"`
OrderServiceId string `json:"order_service_id" form:"order_service_id" label:"主键id"` // 主键id
OrderId string `json:"order_id" form:"order_id" label:"订单id"` // 订单id
OrderServiceType *int `json:"order_service_type" form:"order_service_type" label:"服务包类型（1:健康包 2:随访包）"` // 服务包类型（1:健康包 2:随访包）
OrderServiceStatus *int `json:"order_service_status" form:"order_service_status" label:"订单状态（1:待支付 2:未开始 3:服务中 4:服务完成 5:服务取消）"` // 订单状态（1:待支付 2:未开始 3:服务中 4:服务完成 5:服务取消）
IsDelete *int `json:"is_delete" form:"is_delete" label:"删除状态（0:否 1:是）"` // 删除状态（0:否 1:是）
RefundStatus *int `json:"refund_status" form:"refund_status" label:"订单退款状态（0:无退款 1:申请退款 2:退款中 3:退款成功 4:拒绝退款 5:退款关闭 6:退款异常 7:部分退款）"` // 订单退款状态（0:无退款 1:申请退款 2:退款中 3:退款成功 4:拒绝退款 5:退款关闭 6:退款异常 7:部分退款）
PayChannel *int `json:"pay_channel" form:"pay_channel" label:"支付渠道（1:小程序支付 2:微信扫码支付 3:模拟支付）"` // 支付渠道（1:小程序支付 2:微信扫码支付 3:模拟支付）
PayStatus *int `json:"pay_status" form:"pay_status" label:"支付状态（1:未支付 2:已支付 3:支付中 4:支付失败 5:支付超时 6:支付关闭 7:已撤销 8:转入退款）"` // 支付状态（1:未支付 2:已支付 3:支付中 4:支付失败 5:支付超时 6:支付关闭 7:已撤销 8:转入退款）
OrderServiceNo string `json:"order_service_no" form:"order_service_no" label:"系统订单编号"` // 系统订单编号
EscrowTradeNo string `json:"escrow_trade_no" form:"escrow_trade_no" label:"第三方支付流水号"` // 第三方支付流水号
PayTime string `json:"pay_time" form:"pay_time" label:"支付时间"` // 支付时间
StartTime string `json:"start_time" form:"start_time" label:"开始服务时间"` // 开始服务时间
FinishTime string `json:"finish_time" form:"finish_time" label:"结束服务时间"` // 结束服务时间
CancelTime string `json:"cancel_time" form:"cancel_time" label:"订单取消时间"` // 订单取消时间
CancelReason *int `json:"cancel_reason" form:"cancel_reason" label:"取消订单原因（1:医生未接受服务 2:主动取消 4:客服取消 5:支付超时）"` // 取消订单原因（1:医生未接受服务 2:主动取消 4:客服取消 5:支付超时）
CancelRemarks string `json:"cancel_remarks" form:"cancel_remarks" label:"取消订单备注"` // 取消订单备注
AddFinishStatus *int `json:"add_finish_status" form:"add_finish_status" label:"添加完成订单延迟队列状态（0:未添加 1:已添加 2:添加失败）"` // 添加完成订单延迟队列状态（0:未添加 1:已添加 2:添加失败）
AddFinishTime string `json:"add_finish_time" form:"add_finish_time" label:"添加完成订单延迟队列时间"` // 添加完成订单延迟队列时间
PatientName string `json:"patient_name" form:"patient_name" label:"患者姓名-就诊人"` // 患者姓名-就诊人
CreatedAt string `json:"created_at" form:"created_at" label:"订单创建时间"` // 时间区间，数组形式，下标0为开始时间，下标1为结束时间
Mobile string `json:"mobile" form:"mobile" label:"手机号-医生/患者"`
DoctorName string `json:"doctor_name" form:"doctor_name" label:"医生姓名"`
}

13
api/router/router.go
View File

@ -448,6 +448,19 @@ func privateRouter(r *gin.Engine, api controller.Api) {
inquiryRecordGroup.GET("/:order_inquiry_id", api.OrderInquiry.GetOrderInquiryRecord) inquiryRecordGroup.GET("/:order_inquiry_id", api.OrderInquiry.GetOrderInquiryRecord)
} }
// 服务包订单
serviceGroup := orderGroup.Group("/service")
{
// 获取服务包订单列表-分页
serviceGroup.POST("/page", api.OrderServicePackage.GetOrderServicePackagePage)
// 问诊订单详情
serviceGroup.GET("/:order_inquiry_id", api.OrderInquiry.GetOrderInquiry)
// 取消问诊订单
serviceGroup.PUT("/cancel/:order_inquiry_id", api.OrderInquiry.CancelOrderInquiry)
}
} }
// 病例管理 // 病例管理