hospital-admin-api/api/service/doctorConfigFollowPackage.go

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.ServicePeriod != 30 && item.ServicePeriod != 90 && item.ServicePeriod != 180 && item.ServicePeriod != 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.ServicePeriod != 30 && item.ServicePeriod != 90 && item.ServicePeriod != 180 && item.ServicePeriod != 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
}