新增了医生随访包配置

api/controller/base.go

@@ -73,6 +73,7 @@ type inquiryManage struct {
 	InquiryConfig             // 问诊配置
 	HealthPackage             // 系统健康包配置
 	DoctorConfigHealthPackage // 医生健康包配置
+	DoctorConfigFollowPackage // 医生随访包配置
 }
 
 // ca管理

api/controller/doctorConfigFollowPackage.go

@@ -0,0 +1,159 @@
+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/api/service"
+	"hospital-admin-api/global"
+	"hospital-admin-api/utils"
+	"strconv"
+)
+
+type DoctorConfigFollowPackage struct{}
+
+// GetDoctorFollowPage 获取开启随访包服务的医生-分页
+func (r *DoctorConfigFollowPackage) GetDoctorFollowPage(c *gin.Context) {
+	DoctorConfigFollowPackageRequest := requests.DoctorConfigFollowPackageRequest{}
+	req := DoctorConfigFollowPackageRequest.GetDoctorFollowPage
+	if err := c.ShouldBind(&req); err != nil {
+		responses.FailWithMessage(err.Error(), c)
+		return
+	}
+
+	// 参数验证
+	if err := global.Validate.Struct(req); err != nil {
+		responses.FailWithMessage(utils.Translate(err), c)
+		return
+	}
+
+	if req.Page == 0 {
+		req.Page = 1
+	}
+
+	if req.PageSize == 0 {
+		req.PageSize = 20
+	}
+
+	doctorConfigFollowPackageDao := dao.DoctorConfigFollowPackageDao{}
+	DoctorConfigFollowPackage, total, err := doctorConfigFollowPackageDao.GetDoctorFollowPageSearch(req, req.Page, req.PageSize)
+	if err != nil {
+		responses.FailWithMessage(err.Error(), c)
+		return
+	}
+
+	// 处理返回值
+	res := dto.GetDoctorConfigFollowPackageListDto(DoctorConfigFollowPackage)
+
+	doctorInquiryConfigDao := dao.DoctorInquiryConfigDao{}
+	for _, v := range res {
+		maps := make(map[string]interface{})
+		maps["doctor_id"] = v.DoctorId
+		maps["inquiry_type"] = 1
+		maps["inquiry_mode"] = 9
+		doctorInquiryConfig, _ := doctorInquiryConfigDao.GetDoctorInquiryConfig(maps)
+		if doctorInquiryConfig != nil {
+			v.LoadDoctorInquiryConfig(doctorInquiryConfig)
+		}
+	}
+
+	result := make(map[string]interface{})
+	result["page"] = req.Page
+	result["page_size"] = req.PageSize
+	result["total"] = total
+	result["data"] = res
+	responses.OkWithData(result, c)
+}
+
+// GetDoctorFollow 医生随访包配置详情
+func (r *DoctorConfigFollowPackage) GetDoctorFollow(c *gin.Context) {
+	id := c.Param("follow_package_id")
+	if id == "" {
+		responses.FailWithMessage("缺少参数", c)
+		return
+	}
+
+	// 将 id 转换为 int64 类型
+	followPackageId, err := strconv.ParseInt(id, 10, 64)
+	if err != nil {
+		responses.Fail(c)
+		return
+	}
+
+	// 业务处理
+	DoctorConfigFollowPackageService := service.DoctorConfigFollowPackageService{}
+	getUserDoctorResponses, err := DoctorConfigFollowPackageService.GetDoctorFollow(followPackageId)
+	if err != nil {
+		responses.FailWithMessage(err.Error(), c)
+		return
+	}
+
+	responses.OkWithData(getUserDoctorResponses, c)
+}
+
+// PutDoctorFollow 修改医生随访包配置
+func (r *DoctorConfigFollowPackage) PutDoctorFollow(c *gin.Context) {
+	DoctorConfigFollowPackageRequest := requests.DoctorConfigFollowPackageRequest{}
+	req := DoctorConfigFollowPackageRequest.PutDoctorFollow
+	if err := c.ShouldBindJSON(&req); err != nil {
+		responses.FailWithMessage(err.Error(), c)
+		return
+	}
+
+	// 参数验证
+	if err := global.Validate.Struct(req); err != nil {
+		responses.FailWithMessage(utils.Translate(err), c)
+		return
+	}
+
+	id := c.Param("follow_package_id")
+	if id == "" {
+		responses.FailWithMessage("缺少参数", c)
+		return
+	}
+
+	// 将 id 转换为 int64 类型
+	followPackageId, err := strconv.ParseInt(id, 10, 64)
+	if err != nil {
+		responses.Fail(c)
+		return
+	}
+
+	// 业务处理
+	DoctorConfigFollowPackageService := service.DoctorConfigFollowPackageService{}
+	_, err = DoctorConfigFollowPackageService.PutDoctorFollow(followPackageId, req)
+	if err != nil {
+		responses.FailWithMessage(err.Error(), c)
+		return
+	}
+
+	responses.Ok(c)
+}
+
+// AddDoctorFollow 新增医生随访包配置
+func (r *DoctorConfigFollowPackage) AddDoctorFollow(c *gin.Context) {
+	DoctorConfigFollowPackageRequest := requests.DoctorConfigFollowPackageRequest{}
+	req := DoctorConfigFollowPackageRequest.AddDoctorFollow
+	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
+	}
+
+	// 业务处理
+	DoctorConfigFollowPackageService := service.DoctorConfigFollowPackageService{}
+	_, err := DoctorConfigFollowPackageService.AddDoctorFollow(req)
+	if err != nil {
+		responses.FailWithMessage(err.Error(), c)
+		return
+	}
+
+	responses.Ok(c)
+}

api/controller/doctorConfigHealthPackage.go

@@ -53,13 +53,10 @@ func (r *DoctorConfigHealthPackage) GetDoctorHealthPage(c *gin.Context) {
 		maps["doctor_id"] = v.DoctorId
 		maps["inquiry_type"] = 1
 		maps["inquiry_mode"] = 8
-		doctorInquiryConfig, err := doctorInquiryConfigDao.GetDoctorInquiryConfig(maps)
+		doctorInquiryConfig, _ := doctorInquiryConfigDao.GetDoctorInquiryConfig(maps)
-		if err != nil {
+		if doctorInquiryConfig != nil {
-			responses.FailWithMessage(err.Error(), c)
+			v.LoadDoctorInquiryConfig(doctorInquiryConfig)
-			return
 		}
-
-		v.LoadDoctorInquiryConfig(doctorInquiryConfig)
 	}
 
 	result := make(map[string]interface{})

api/dao/doctorConfigFollowPackage.go

@@ -0,0 +1,131 @@
+package dao
+
+import (
+	"gorm.io/gorm"
+	"hospital-admin-api/api/model"
+	"hospital-admin-api/api/requests"
+	"hospital-admin-api/global"
+)
+
+type DoctorConfigFollowPackageDao struct {
+}
+
+// GetDoctorConfigFollowPackageListByDoctorId 获取列表-医生id
+func (r *DoctorConfigFollowPackageDao) GetDoctorConfigFollowPackageListByDoctorId(doctorId int64) (m []*model.DoctorConfigFollowPackage, err error) {
+	err = global.Db.Where("doctor_id = ?", doctorId).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetDoctorConfigFollowPackageById 获取医生随访包配置数据-id
+func (r *DoctorConfigFollowPackageDao) GetDoctorConfigFollowPackageById(followPackageId int64) (m *model.DoctorConfigFollowPackage, err error) {
+	err = global.Db.First(&m, followPackageId).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// DeleteDoctorConfigFollowPackage 删除医生随访包配置
+func (r *DoctorConfigFollowPackageDao) DeleteDoctorConfigFollowPackage(tx *gorm.DB, maps interface{}) error {
+	err := tx.Where(maps).Delete(&model.DoctorConfigFollowPackage{}).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// EditDoctorConfigFollowPackageById 修改医生随访包配置-随访包配置id
+func (r *DoctorConfigFollowPackageDao) EditDoctorConfigFollowPackageById(tx *gorm.DB, followPackageId int64, data interface{}) error {
+	err := tx.Model(&model.DoctorConfigFollowPackage{}).Where("follow_package_id = ?", followPackageId).Updates(data).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// GetDoctorConfigFollowPackageList 获取医生随访包配置列表
+func (r *DoctorConfigFollowPackageDao) GetDoctorConfigFollowPackageList(maps interface{}) (m []*model.DoctorConfigFollowPackage, err error) {
+	err = global.Db.Where(maps).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// AddDoctorConfigFollowPackage 新增医生随访包配置
+func (r *DoctorConfigFollowPackageDao) AddDoctorConfigFollowPackage(tx *gorm.DB, model *model.DoctorConfigFollowPackage) (*model.DoctorConfigFollowPackage, error) {
+	if err := tx.Create(model).Error; err != nil {
+		return nil, err
+	}
+	return model, nil
+}
+
+// GetDoctorConfigFollowPackage 获取医生随访包配置
+func (r *DoctorConfigFollowPackageDao) GetDoctorConfigFollowPackage(maps interface{}) (m *model.DoctorConfigFollowPackage, err error) {
+	err = global.Db.Where(maps).First(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// GetDoctorFollowPageSearch 获取开启随访包服务的医生-分页
+func (r *DoctorConfigFollowPackageDao) GetDoctorFollowPageSearch(req requests.GetDoctorFollowPage, page, pageSize int) (m []*model.DoctorConfigFollowPackage, total int64, err error) {
+	var totalRecords int64
+
+	// 构建查询条件
+	query := global.Db.Model(&model.DoctorConfigFollowPackage{})
+
+	// 医生
+	query = query.Preload("UserDoctor", func(db *gorm.DB) *gorm.DB {
+		return db.Omit("open_id", "union_id", "wx_session_key")
+	})
+
+	// 明细
+	query = query.Preload("DoctorConfigFollowPackageItem")
+
+	// 用户表
+	query = query.Preload("UserDoctor.User", func(db *gorm.DB) *gorm.DB {
+		return db.Omit("user_password", "salt")
+	})
+
+	// 手机号
+	if 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("doctor_id IN (?)", doctorSubQuery)
+	}
+
+	// 医生姓名
+	if req.DoctorName != "" {
+		subQuery := global.Db.Model(&model.UserDoctor{}).
+			Select("doctor_id").
+			Where("user_name LIKE ?", "%"+req.DoctorName+"%")
+
+		query = query.Where("doctor_id IN (?)", subQuery)
+	}
+
+	// 排序
+	query = query.Order("created_at desc")
+
+	// 查询总数量
+	if err := query.Count(&totalRecords).Error; err != nil {
+		return nil, 0, err
+	}
+
+	err = query.Scopes(model.Paginate(page, pageSize)).Find(&m).Error
+	if err != nil {
+		return nil, 0, err
+	}
+	return m, totalRecords, nil
+}

api/dao/doctorConfigFollowPackageItem.go

@@ -0,0 +1,54 @@
+package dao
+
+import (
+	"gorm.io/gorm"
+	"hospital-admin-api/api/model"
+	"hospital-admin-api/global"
+)
+
+type DoctorConfigFollowPackageItemDao struct {
+}
+
+// GetDoctorConfigFollowPackageItemListByFollowPackageId 获取列表-id
+func (r *DoctorConfigFollowPackageItemDao) GetDoctorConfigFollowPackageItemListByFollowPackageId(followPackageId int64) (m []*model.DoctorConfigFollowPackageItem, err error) {
+	err = global.Db.Where("follow_package_id = ?", followPackageId).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// DeleteDoctorConfigFollowPackageItem 删除医生随访包列表配置
+func (r *DoctorConfigFollowPackageItemDao) DeleteDoctorConfigFollowPackageItem(tx *gorm.DB, maps interface{}) error {
+	err := tx.Where(maps).Delete(&model.DoctorConfigFollowPackageItem{}).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// EditDoctorConfigFollowPackageItemById 修改医生随访包列表配置-随访包列表配置id
+func (r *DoctorConfigFollowPackageItemDao) EditDoctorConfigFollowPackageItemById(tx *gorm.DB, followPackageItemId int64, data interface{}) error {
+	err := tx.Model(&model.DoctorConfigFollowPackageItem{}).Where("follow_package_item_id = ?", followPackageItemId).Updates(data).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// GetDoctorConfigFollowPackageItemList 获取医生随访包列表配置列表
+func (r *DoctorConfigFollowPackageItemDao) GetDoctorConfigFollowPackageItemList(maps interface{}) (m []*model.DoctorConfigFollowPackageItem, err error) {
+	err = global.Db.Where(maps).Find(&m).Error
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// AddDoctorConfigFollowPackageItem 新增医生随访包列表配置
+func (r *DoctorConfigFollowPackageItemDao) AddDoctorConfigFollowPackageItem(tx *gorm.DB, model *model.DoctorConfigFollowPackageItem) (*model.DoctorConfigFollowPackageItem, error) {
+	if err := tx.Create(model).Error; err != nil {
+		return nil, err
+	}
+	return model, nil
+}

api/dto/DoctorConfigFollowPackage.go

@@ -0,0 +1,89 @@
+package dto
+
+import (
+	"fmt"
+	"hospital-admin-api/api/model"
+)
+
+// DoctorConfigFollowPackageDto 医生配置-健康包
+type DoctorConfigFollowPackageDto struct {
+	FollowPackageId               string                              `json:"follow_package_id"`                 // 主键id
+	DoctorId                      string                              `json:"doctor_id"`                         // 医生id
+	MonthlyFrequency              int                                 `json:"monthly_frequency"`                 // 每月次数（0表示不限次）
+	ServiceRounds                 int                                 `json:"service_rounds"`                    // 服务回合数（0表示不限次）
+	CreatedAt                     model.LocalTime                     `json:"created_at"`                        // 创建时间
+	UpdatedAt                     model.LocalTime                     `json:"updated_at"`                        // 修改时间
+	UserDoctor                    *UserDoctorDto                      `json:"user_doctor"`                       // 医生数据
+	DoctorInquiryConfig           *DoctorInquiryConfigDto             `json:"doctor_inquiry_config"`             // 医生问诊配置数据
+	DoctorConfigFollowPackageItem []*DoctorConfigFollowPackageItemDto `json:"doctor_config_follow_package_item"` // 医生随访包配置明细数据
+}
+
+func GetDoctorConfigFollowPackageDto(m *model.DoctorConfigFollowPackage) *DoctorConfigFollowPackageDto {
+	return &DoctorConfigFollowPackageDto{
+		FollowPackageId:  fmt.Sprintf("%d", m.FollowPackageId),
+		DoctorId:         fmt.Sprintf("%d", m.DoctorId),
+		MonthlyFrequency: m.MonthlyFrequency,
+		ServiceRounds:    m.ServiceRounds,
+		CreatedAt:        m.CreatedAt,
+		UpdatedAt:        m.UpdatedAt,
+	}
+}
+
+func GetDoctorConfigFollowPackageListDto(m []*model.DoctorConfigFollowPackage) []*DoctorConfigFollowPackageDto {
+	// 处理返回值
+	responses := make([]*DoctorConfigFollowPackageDto, len(m))
+
+	if len(m) > 0 {
+		for i, v := range m {
+			response := &DoctorConfigFollowPackageDto{
+				FollowPackageId:  fmt.Sprintf("%d", v.FollowPackageId),
+				DoctorId:         fmt.Sprintf("%d", v.DoctorId),
+				MonthlyFrequency: v.MonthlyFrequency,
+				ServiceRounds:    v.ServiceRounds,
+				CreatedAt:        v.CreatedAt,
+				UpdatedAt:        v.UpdatedAt,
+			}
+
+			if v.UserDoctor != nil {
+				response.LoadUserDoctor(v.UserDoctor)
+			}
+
+			// 将转换后的结构体添加到新切片中
+			responses[i] = response
+		}
+	}
+
+	return responses
+}
+
+// LoadUserDoctor 加载医生数据
+func (r *DoctorConfigFollowPackageDto) LoadUserDoctor(m *model.UserDoctor) *DoctorConfigFollowPackageDto {
+	if m != nil {
+		r.UserDoctor = GetUserDoctorDto(m)
+	}
+	return r
+}
+
+// LoadUserDoctorHospital 加载医生医院数据
+func (r *DoctorConfigFollowPackageDto) LoadUserDoctorHospital(m *model.Hospital) *DoctorConfigFollowPackageDto {
+	if m != nil && r.UserDoctor != nil {
+		r.UserDoctor.Hospital = GetHospitalDto(m)
+	}
+	return r
+}
+
+// LoadDoctorInquiryConfig 加载医生问诊配置
+func (r *DoctorConfigFollowPackageDto) LoadDoctorInquiryConfig(m *model.DoctorInquiryConfig) *DoctorConfigFollowPackageDto {
+	if m != nil {
+		r.DoctorInquiryConfig = GetDoctorInquiryConfigDto(m)
+	}
+	return r
+}
+
+// LoadDoctorConfigFollowPackageItem 加载医生随访包列表配置
+func (r *DoctorConfigFollowPackageDto) LoadDoctorConfigFollowPackageItem(m []*model.DoctorConfigFollowPackageItem) *DoctorConfigFollowPackageDto {
+	if len(m) > 0 {
+		r.DoctorConfigFollowPackageItem = GetDoctorConfigFollowPackageItemListDto(m)
+	}
+	return r
+}

api/dto/DoctorConfigFollowPackageItem.go

@@ -0,0 +1,50 @@
+package dto
+
+import (
+	"fmt"
+	"hospital-admin-api/api/model"
+)
+
+// DoctorConfigFollowPackageItemDto 医生配置-随访包-明细
+type DoctorConfigFollowPackageItemDto struct {
+	FollowPackageItemId string          `json:"follow_package_item_id"` // 主键id
+	FollowPackageId     string          `json:"follow_package_id"`      // 医生随访包id
+	ServicePeriod       int             `json:"service_period"`         // 服务周期(天)
+	ServicePrice        float64         `json:"service_price"`          // 服务价格
+	CreatedAt           model.LocalTime `json:"created_at"`             // 创建时间
+	UpdatedAt           model.LocalTime `json:"updated_at"`             // 修改时间
+}
+
+func GetDoctorConfigFollowPackageItemDto(m *model.DoctorConfigFollowPackageItem) *DoctorConfigFollowPackageItemDto {
+	return &DoctorConfigFollowPackageItemDto{
+		FollowPackageItemId: fmt.Sprintf("%d", m.FollowPackageItemId),
+		FollowPackageId:     fmt.Sprintf("%d", m.FollowPackageId),
+		ServicePeriod:       m.ServicePeriod,
+		ServicePrice:        m.ServicePrice,
+		CreatedAt:           m.CreatedAt,
+		UpdatedAt:           m.UpdatedAt,
+	}
+}
+
+func GetDoctorConfigFollowPackageItemListDto(m []*model.DoctorConfigFollowPackageItem) []*DoctorConfigFollowPackageItemDto {
+	// 处理返回值
+	responses := make([]*DoctorConfigFollowPackageItemDto, len(m))
+
+	if len(m) > 0 {
+		for i, v := range m {
+			response := &DoctorConfigFollowPackageItemDto{
+				FollowPackageItemId: fmt.Sprintf("%d", v.FollowPackageItemId),
+				FollowPackageId:     fmt.Sprintf("%d", v.FollowPackageId),
+				ServicePeriod:       v.ServicePeriod,
+				ServicePrice:        v.ServicePrice,
+				CreatedAt:           v.CreatedAt,
+				UpdatedAt:           v.UpdatedAt,
+			}
+
+			// 将转换后的结构体添加到新切片中
+			responses[i] = response
+		}
+	}
+
+	return responses
+}

api/dto/DoctotInquiryConfig.go

@@ -14,7 +14,7 @@ type DoctorInquiryConfigDto struct {
 	IsEnable                   int                            `json:"is_enable"`                     // 是否启用（0:否 1:是）
 	LastEnableMethod           int                            `json:"last_enable_method"`            // 最后开启方式（1:自己 2:后台）
 	WorkNumDay                 int                            `json:"work_num_day"`                  // 每日接诊数量
-	InquiryPrice               float64                        `json:"inquiry_price"`                 // 接诊价格（专家问诊-公益问诊）
+	InquiryPrice               *float64                       `json:"inquiry_price"`                 // 接诊价格（专家问诊-公益问诊）
 	CreatedAt                  model.LocalTime                `json:"created_at"`                    // 创建时间
 	UpdatedAt                  model.LocalTime                `json:"updated_at"`                    // 修改时间
 	DoctorName                 string                         `json:"doctor_name"`                   // 医生姓名
@@ -36,7 +36,7 @@ func GetDoctorInquiryConfigDto(m *model.DoctorInquiryConfig) *DoctorInquiryConfi
 		IsEnable:         m.IsEnable,
 		LastEnableMethod: m.LastEnableMethod,
 		WorkNumDay:       m.WorkNumDay,
-		InquiryPrice:     *m.InquiryPrice,
+		InquiryPrice:     m.InquiryPrice,
 		CreatedAt:        m.CreatedAt,
 		UpdatedAt:        m.UpdatedAt,
 	}
@@ -56,7 +56,7 @@ func GetDoctorInquiryConfigListDto(m []*model.DoctorInquiryConfig) []*DoctorInqu
 				IsEnable:         v.IsEnable,
 				LastEnableMethod: v.LastEnableMethod,
 				WorkNumDay:       v.WorkNumDay,
-				InquiryPrice:     *v.InquiryPrice,
+				InquiryPrice:     v.InquiryPrice,
 				CreatedAt:        v.CreatedAt,
 				UpdatedAt:        v.UpdatedAt,
 			}

api/model/doctorConfigFollowPackage.go

@@ -13,6 +13,8 @@ type DoctorConfigFollowPackage struct {
 	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
+	UserDoctor                    *UserDoctor                      `gorm:"foreignKey:DoctorId;references:doctor_id" json:"user_doctor"`                                      // 医生
+	DoctorConfigFollowPackageItem []*DoctorConfigFollowPackageItem `gorm:"foreignKey:FollowPackageId;references:follow_package_id" json:"doctor_config_follow_package_item"` // 明细
 }
 
 func (m *DoctorConfigFollowPackage) TableName() string {

api/requests/DoctorConfigFollowPackageItem.go

@@ -0,0 +1,10 @@
+package requests
+
+type DoctorConfigFollowPackageItemRequest struct {
+	DoctorConfigFollowPackageItem
+}
+
+type DoctorConfigFollowPackageItem struct {
+	ServicePeriod int     `json:"service_period" form:"service_period" label:"服务周期(天)" validate:"required"`
+	ServicePrice  float64 `json:"service_price" form:"service_price" label:"服务价格" validate:"required,min=1"` // （0表示不限次）
+}

api/requests/doctorConfigFollowPackage.go

@@ -0,0 +1,32 @@
+package requests
+
+type DoctorConfigFollowPackageRequest struct {
+	GetDoctorFollowPage // 获取医生健康包列表-分页
+	PutDoctorFollow     // 修改医生健康包配置
+	AddDoctorFollow     // 新增医生健康包配置
+}
+
+// GetDoctorFollowPage 获取医生健康包列表-分页
+type GetDoctorFollowPage struct {
+	Page       int    `json:"page" form:"page" label:"页码"`
+	PageSize   int    `json:"page_size" form:"page_size" label:"每页个数"`
+	Mobile     string `json:"mobile" form:"mobile" label:"手机号"`
+	DoctorName string `json:"doctor_name" form:"doctor_name" label:"医生姓名"`
+}
+
+// PutDoctorFollow 修改医生健康包配置
+type PutDoctorFollow struct {
+	MonthlyFrequency              *int                             `json:"monthly_frequency" form:"monthly_frequency" label:"每月次数" validate:"required"`                                    // （0表示不限次）
+	ServiceRounds                 *int                             `json:"service_rounds" form:"service_rounds" label:"服务回合数" validate:"required"`                                         // （0表示不限次）
+	IsEnable                      *int                             `json:"is_enable" form:"is_enable" validate:"oneof=0 1" label:"是否启用" validate:"required"`                               // 0:否 1:是
+	DoctorConfigFollowPackageItem []*DoctorConfigFollowPackageItem `json:"doctor_config_follow_package_item" form:"doctor_config_follow_package_item" label:"医生健康包明细" validate:"required"` //
+}
+
+// AddDoctorFollow 新增医生健康包配置
+type AddDoctorFollow struct {
+	DoctorId                      string                           `json:"doctor_id" form:"doctor_id" label:"医生id" validate:"required"`
+	MonthlyFrequency              *int                             `json:"monthly_frequency" form:"monthly_frequency" label:"每月次数" validate:"required"`                                    // （0表示不限次）
+	ServiceRounds                 *int                             `json:"service_rounds" form:"service_rounds" label:"服务回合数" validate:"required"`                                         // （0表示不限次）
+	IsEnable                      *int                             `json:"is_enable" form:"is_enable" validate:"oneof=0 1" label:"是否启用" validate:"required"`                               // 0:否 1:是
+	DoctorConfigFollowPackageItem []*DoctorConfigFollowPackageItem `json:"doctor_config_follow_package_item" form:"doctor_config_follow_package_item" label:"医生健康包明细" validate:"required"` //
+}

api/requests/doctorConfigHealthPackage.go

@@ -1,12 +1,12 @@
 package requests
 
 type DoctorConfigHealthPackageRequest struct {
-	GetDoctorHealthPage // 获取医生账户列表-分页
+	GetDoctorHealthPage // 获取医生健康包列表-分页
 	PutDoctorHealth     // 修改医生健康包配置
 	AddDoctorHealth     // 新增医生健康包配置
 }
 
-// GetDoctorHealthPage 获取医生账户列表-分页
+// GetDoctorHealthPage 获取医生健康包列表-分页
 type GetDoctorHealthPage struct {
 	Page       int    `json:"page" form:"page" label:"页码"`
 	PageSize   int    `json:"page_size" form:"page_size" label:"每页个数"`

api/router/router.go

@@ -542,6 +542,22 @@ func privateRouter(r *gin.Engine, api controller.Api) {
 				// 新增医生健康包配置
 				healthGroup.POST("", api.DoctorConfigHealthPackage.AddDoctorHealth)
 			}
+
+			// 医生随访包配置
+			followGroup := doctorGroup.Group("/follow")
+			{
+				// 获取开启随访包服务的医生-分页
+				followGroup.GET("", api.DoctorConfigFollowPackage.GetDoctorFollowPage)
+
+				// 医生随访包配置详情
+				followGroup.GET("/:follow_package_id", api.DoctorConfigFollowPackage.GetDoctorFollow)
+
+				// 修改医生随访包配置
+				followGroup.PUT("/:follow_package_id", api.DoctorConfigFollowPackage.PutDoctorFollow)
+
+				// 新增医生随访包配置
+				followGroup.POST("", api.DoctorConfigFollowPackage.AddDoctorFollow)
+			}
 		}
 
 		// 系统问诊配置

api/service/doctorConfigFollowPackage.go

@@ -0,0 +1,326 @@
+package service
+
+import (
+	"errors"
+	"hospital-admin-api/api/dao"
+	"hospital-admin-api/api/dto"
+	"hospital-admin-api/api/model"
+	"hospital-admin-api/api/requests"
+	"hospital-admin-api/global"
+	"strconv"
+)
+
+type DoctorConfigFollowPackageService struct {
+}
+
+// GetDoctorFollow 医生随访包配置详情
+func (r *DoctorConfigFollowPackageService) GetDoctorFollow(followPackageId int64) (res *dto.DoctorConfigFollowPackageDto, err error) {
+	DoctorConfigFollowPackageDao := dao.DoctorConfigFollowPackageDao{}
+
+	DoctorConfigFollowPackage, err := DoctorConfigFollowPackageDao.GetDoctorConfigFollowPackageById(followPackageId)
+	if err != nil || DoctorConfigFollowPackage == nil {
+		return nil, errors.New("获取失败")
+	}
+
+	// 获取医生数据
+	userDoctorDao := dao.UserDoctorDao{}
+	userDoctor, err := userDoctorDao.GetUserDoctorById(DoctorConfigFollowPackage.DoctorId)
+	if err != nil || userDoctor == nil {
+		return nil, errors.New("获取失败")
+	}
+
+	// 获取医生医院数据
+	hospitalDao := dao.HospitalDao{}
+	hospital, err := hospitalDao.GetHospitalById(userDoctor.HospitalID)
+
+	// 获取随访包列表数据
+	doctorConfigFollowPackageItemDao := dao.DoctorConfigFollowPackageItemDao{}
+	doctorConfigFollowPackageItem, err := doctorConfigFollowPackageItemDao.GetDoctorConfigFollowPackageItemListByFollowPackageId(DoctorConfigFollowPackage.FollowPackageId)
+	if err != nil || doctorConfigFollowPackageItem == nil {
+		return nil, errors.New("获取失败")
+	}
+
+	// 获取医生问诊配置
+	doctorInquiryConfigDao := dao.DoctorInquiryConfigDao{}
+	maps := make(map[string]interface{})
+	maps["doctor_id"] = DoctorConfigFollowPackage.DoctorId
+	maps["inquiry_type"] = 1
+	maps["inquiry_mode"] = 9
+	doctorInquiryConfig, err := doctorInquiryConfigDao.GetDoctorInquiryConfig(maps)
+	if err != nil {
+		return nil, errors.New("获取失败")
+	}
+
+	// 处理返回值
+	res = dto.GetDoctorConfigFollowPackageDto(DoctorConfigFollowPackage)
+
+	// 加载医生数据
+	res.LoadUserDoctor(userDoctor)
+
+	// 加载医生医院
+	if hospital != nil {
+		res.LoadUserDoctorHospital(hospital)
+	}
+
+	// 加载医生随访包列表配置
+	res.LoadDoctorConfigFollowPackageItem(doctorConfigFollowPackageItem)
+
+	// 获取医生问诊配置
+	res.LoadDoctorInquiryConfig(doctorInquiryConfig)
+
+	return res, nil
+}
+
+// PutDoctorFollow 修改医生随访包配置
+func (r *DoctorConfigFollowPackageService) PutDoctorFollow(followPackageId int64, req requests.PutDoctorFollow) (bool, error) {
+	doctorConfigFollowPackageDao := dao.DoctorConfigFollowPackageDao{}
+	DoctorConfigFollowPackage, err := doctorConfigFollowPackageDao.GetDoctorConfigFollowPackageById(followPackageId)
+	if err != nil || DoctorConfigFollowPackage == nil {
+		return false, errors.New("修改失败")
+	}
+
+	// 获取医生数据
+	userDoctorDao := dao.UserDoctorDao{}
+	userDoctor, err := userDoctorDao.GetUserDoctorById(DoctorConfigFollowPackage.DoctorId)
+	if err != nil || userDoctor == nil {
+		return false, errors.New("医生错误")
+	}
+
+	if userDoctor.IdcardStatus != 1 {
+		return false, errors.New("请先进行实名认证")
+	}
+
+	if userDoctor.IdenAuthStatus != 1 {
+		return false, errors.New("请先进行身份认证")
+	}
+
+	if userDoctor.IsBindBank != 1 {
+		return false, errors.New("请先进行绑定结算银行卡")
+	}
+
+	// 开始事务
+	tx := global.Db.Begin()
+	defer func() {
+		if r := recover(); r != nil {
+			tx.Rollback()
+		}
+	}()
+
+	doctorConfigFollowPackageData := make(map[string]interface{})
+
+	if *req.MonthlyFrequency != DoctorConfigFollowPackage.MonthlyFrequency {
+		doctorConfigFollowPackageData["monthly_frequency"] = req.MonthlyFrequency
+	}
+
+	if *req.ServiceRounds != DoctorConfigFollowPackage.ServiceRounds {
+		doctorConfigFollowPackageData["service_rounds"] = req.ServiceRounds
+	}
+
+	if len(doctorConfigFollowPackageData) > 0 {
+		err := doctorConfigFollowPackageDao.EditDoctorConfigFollowPackageById(tx, followPackageId, doctorConfigFollowPackageData)
+		if err != nil {
+			tx.Rollback()
+			return false, errors.New("修改失败")
+		}
+	}
+
+	// 处理问诊配置
+	// 获取医生问诊配置
+	doctorInquiryConfigDao := dao.DoctorInquiryConfigDao{}
+	maps := make(map[string]interface{})
+	maps["doctor_id"] = DoctorConfigFollowPackage.DoctorId
+	maps["inquiry_type"] = 1
+	maps["inquiry_mode"] = 9
+	doctorInquiryConfig, _ := doctorInquiryConfigDao.GetDoctorInquiryConfig(maps)
+	if doctorInquiryConfig == nil {
+		// 新增医生问诊配置
+		doctorInquiryConfig = &model.DoctorInquiryConfig{
+			DoctorId:         DoctorConfigFollowPackage.DoctorId,
+			InquiryType:      1,
+			InquiryMode:      9,
+			IsEnable:         *req.IsEnable,
+			LastEnableMethod: 2,
+			WorkNumDay:       0,
+			InquiryPrice:     nil,
+		}
+
+		doctorInquiryConfig, err = doctorInquiryConfigDao.AddDoctorInquiryConfig(tx, doctorInquiryConfig)
+		if err != nil || doctorInquiryConfig == nil {
+			tx.Rollback()
+			return false, errors.New(err.Error())
+		}
+	} else {
+		// 修改医生问诊配置
+		doctorInquiryConfigData := make(map[string]interface{})
+		if *req.IsEnable != doctorInquiryConfig.IsEnable {
+			doctorInquiryConfigData["is_enable"] = req.IsEnable
+			if *req.IsEnable == 1 {
+				doctorInquiryConfigData["last_enable_method"] = 2
+			}
+		}
+
+		if len(doctorInquiryConfigData) > 0 {
+			err = doctorInquiryConfigDao.EditDoctorInquiryConfigById(tx, doctorInquiryConfig.InquiryConfigId, doctorInquiryConfigData)
+			if err != nil {
+				tx.Rollback()
+				return false, errors.New("修改失败")
+			}
+		}
+	}
+
+	// 删除随访包明细
+	maps = make(map[string]interface{})
+	maps["follow_package_id"] = DoctorConfigFollowPackage.FollowPackageId
+
+	doctorConfigFollowPackageItemDao := dao.DoctorConfigFollowPackageItemDao{}
+	err = doctorConfigFollowPackageItemDao.DeleteDoctorConfigFollowPackageItem(tx, maps)
+	if err != nil {
+		tx.Rollback()
+		return false, errors.New("修改失败")
+	}
+
+	// 处理随访包明细
+	for _, item := range req.DoctorConfigFollowPackageItem {
+		if item.ServicePrice < 10 || item.ServicePrice > 9999 {
+			tx.Rollback()
+			return false, errors.New("服务价格只允许设置在10-9999范围内")
+		}
+
+		if item.ServicePrice != 30 && item.ServicePrice != 90 && item.ServicePrice != 180 && item.ServicePrice != 360 {
+			tx.Rollback()
+			return false, errors.New("服务周期错误")
+		}
+
+		doctorConfigFollowPackageItem := &model.DoctorConfigFollowPackageItem{
+			FollowPackageId: DoctorConfigFollowPackage.FollowPackageId,
+			ServicePeriod:   item.ServicePeriod,
+			ServicePrice:    item.ServicePrice,
+		}
+
+		doctorConfigFollowPackageItem, err := doctorConfigFollowPackageItemDao.AddDoctorConfigFollowPackageItem(tx, doctorConfigFollowPackageItem)
+		if err != nil {
+			tx.Rollback()
+			return false, errors.New("修改失败")
+		}
+	}
+
+	tx.Commit()
+	return true, nil
+}
+
+// AddDoctorFollow 新增医生随访包配置
+func (r *DoctorConfigFollowPackageService) AddDoctorFollow(req requests.AddDoctorFollow) (bool, error) {
+	doctorId, err := strconv.ParseInt(req.DoctorId, 10, 64)
+	if err != nil {
+		return false, errors.New("修改失败")
+	}
+
+	// 获取医生数据
+	userDoctorDao := dao.UserDoctorDao{}
+	userDoctor, err := userDoctorDao.GetUserDoctorById(doctorId)
+	if err != nil || userDoctor == nil {
+		return false, errors.New("医生错误")
+	}
+
+	if userDoctor.IdcardStatus != 1 {
+		return false, errors.New("请先进行实名认证")
+	}
+
+	if userDoctor.IdenAuthStatus != 1 {
+		return false, errors.New("请先进行身份认证")
+	}
+
+	if userDoctor.IsBindBank != 1 {
+		return false, errors.New("请先进行绑定结算银行卡")
+	}
+
+	DoctorConfigFollowPackageDao := dao.DoctorConfigFollowPackageDao{}
+
+	maps := make(map[string]interface{})
+	maps["doctor_id"] = doctorId
+	DoctorConfigFollowPackage, err := DoctorConfigFollowPackageDao.GetDoctorConfigFollowPackage(maps)
+	if DoctorConfigFollowPackage != nil {
+		return false, errors.New("该医生存在随访包配置，请勿重复添加")
+	}
+
+	// 获取专家图文问诊价格
+	maps = make(map[string]interface{})
+	maps["doctor_id"] = req.DoctorId
+	maps["inquiry_type"] = 1
+	maps["inquiry_mode"] = 1
+
+	doctorInquiryConfigDao := dao.DoctorInquiryConfigDao{}
+	doctorInquiryConfig, err := doctorInquiryConfigDao.GetDoctorInquiryConfig(maps)
+	if err != nil && *req.IsEnable == 1 {
+		return false, errors.New("本服务需设置图文问诊的价格，才可开启")
+	}
+
+	// 开始事务
+	tx := global.Db.Begin()
+	defer func() {
+		if r := recover(); r != nil {
+			tx.Rollback()
+		}
+	}()
+
+	// 创建医生随访包
+	DoctorConfigFollowPackage = &model.DoctorConfigFollowPackage{
+		DoctorId:         doctorId,
+		MonthlyFrequency: *req.MonthlyFrequency,
+		ServiceRounds:    *req.ServiceRounds,
+	}
+
+	DoctorConfigFollowPackage, err = DoctorConfigFollowPackageDao.AddDoctorConfigFollowPackage(tx, DoctorConfigFollowPackage)
+	if err != nil || DoctorConfigFollowPackage == nil {
+		tx.Rollback()
+		return false, errors.New(err.Error())
+	}
+
+	// 处理随访包明细
+	doctorConfigFollowPackageItemDao := dao.DoctorConfigFollowPackageItemDao{}
+	for _, item := range req.DoctorConfigFollowPackageItem {
+		if item.ServicePrice < 10 || item.ServicePrice > 9999 {
+			tx.Rollback()
+			return false, errors.New("服务价格只允许设置在10-9999范围内")
+		}
+
+		if item.ServicePrice != 30 && item.ServicePrice != 90 && item.ServicePrice != 180 && item.ServicePrice != 360 {
+			tx.Rollback()
+			return false, errors.New("服务周期错误")
+		}
+
+		doctorConfigFollowPackageItem := &model.DoctorConfigFollowPackageItem{
+			FollowPackageId: DoctorConfigFollowPackage.FollowPackageId,
+			ServicePeriod:   item.ServicePeriod,
+			ServicePrice:    item.ServicePrice,
+		}
+
+		doctorConfigFollowPackageItem, err := doctorConfigFollowPackageItemDao.AddDoctorConfigFollowPackageItem(tx, doctorConfigFollowPackageItem)
+		if err != nil {
+			tx.Rollback()
+			return false, errors.New("修改失败")
+		}
+	}
+
+	// 增加医生问诊配置
+	if *req.IsEnable == 1 {
+		doctorInquiryConfig = &model.DoctorInquiryConfig{
+			DoctorId:         doctorId,
+			InquiryType:      1,
+			InquiryMode:      9,
+			IsEnable:         *req.IsEnable,
+			LastEnableMethod: 2,
+			WorkNumDay:       0,
+			InquiryPrice:     nil,
+		}
+
+		doctorInquiryConfig, err = doctorInquiryConfigDao.AddDoctorInquiryConfig(tx, doctorInquiryConfig)
+		if err != nil || doctorInquiryConfig == nil {
+			tx.Rollback()
+			return false, errors.New(err.Error())
+		}
+	}
+
+	tx.Commit()
+	return true, nil
+}