608 lines
19 KiB
Go
608 lines
19 KiB
Go
package service
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"gorm.io/gorm"
|
|
"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 PharmacyService struct{}
|
|
|
|
// AddPharmacy 新增药房
|
|
func (r *PharmacyService) AddPharmacy(req requests.AddPharmacy) (bool, error) {
|
|
pharmacyDao := dao.PharmacyDao{}
|
|
|
|
// 检测药房代码是否已存在
|
|
existPharmacy, err := pharmacyDao.GetPharmacyByCode(req.PharmacyCode)
|
|
if err == nil && existPharmacy != nil {
|
|
return false, errors.New("药房代码已存在，请勿重复添加")
|
|
}
|
|
|
|
var province string
|
|
var city string
|
|
var county string
|
|
|
|
areaDao := dao.AreaDao{}
|
|
if req.ProvinceId != 0 {
|
|
area, err := areaDao.GetAreaById(req.ProvinceId)
|
|
if err != nil || area == nil {
|
|
return false, errors.New("省份数据错误")
|
|
}
|
|
province = area.AreaName
|
|
}
|
|
|
|
if req.CityId != 0 {
|
|
area, err := areaDao.GetAreaById(req.CityId)
|
|
if err != nil || area == nil {
|
|
return false, errors.New("城市数据错误")
|
|
}
|
|
city = area.AreaName
|
|
}
|
|
|
|
if req.CountyId != 0 {
|
|
area, err := areaDao.GetAreaById(req.CountyId)
|
|
if err != nil || area == nil {
|
|
return false, errors.New("区县数据错误")
|
|
}
|
|
county = area.AreaName
|
|
}
|
|
|
|
status := 1
|
|
if req.Status != nil {
|
|
status = *req.Status
|
|
}
|
|
|
|
// 开启事务
|
|
tx := global.Db.Begin()
|
|
defer func() {
|
|
if rec := recover(); rec != nil {
|
|
tx.Rollback()
|
|
}
|
|
}()
|
|
|
|
pharmacy := &model.Pharmacy{
|
|
PharmacyName: req.PharmacyName,
|
|
PharmacyCode: req.PharmacyCode,
|
|
Postage: *req.Postage,
|
|
FreeShippingThreshold: *req.FreeShippingThreshold,
|
|
IsPickup: *req.IsPickup,
|
|
Telephone: req.Telephone,
|
|
ProvinceId: req.ProvinceId,
|
|
Province: province,
|
|
CityId: req.CityId,
|
|
City: city,
|
|
CountyId: req.CountyId,
|
|
County: county,
|
|
Address: req.Address,
|
|
Status: status,
|
|
}
|
|
|
|
pharmacy, err = pharmacyDao.AddPharmacy(tx, pharmacy)
|
|
if err != nil || pharmacy == nil {
|
|
tx.Rollback()
|
|
return false, errors.New(err.Error())
|
|
}
|
|
|
|
tx.Commit()
|
|
return true, nil
|
|
}
|
|
|
|
// PutPharmacy 修改药房
|
|
func (r *PharmacyService) PutPharmacy(pharmacyId int64, req requests.PutPharmacy) (bool, error) {
|
|
pharmacyDao := dao.PharmacyDao{}
|
|
pharmacy, err := pharmacyDao.GetPharmacyById(pharmacyId)
|
|
if err != nil || pharmacy == nil {
|
|
return false, errors.New("药房不存在或已删除")
|
|
}
|
|
|
|
// 如果修改了代码，需检查新代码是否被其他药房占用
|
|
if req.PharmacyCode != pharmacy.PharmacyCode {
|
|
exist, err := pharmacyDao.GetPharmacyByCode(req.PharmacyCode)
|
|
if err == nil && exist != nil && exist.PharmacyId != pharmacyId {
|
|
return false, errors.New("药房代码已被占用")
|
|
}
|
|
}
|
|
|
|
// 若修改为禁用，校验是否有医生设为默认药房
|
|
if req.Status != nil && *req.Status == 0 && pharmacy.Status == 1 {
|
|
doctorPharmacyDao := dao.DoctorPharmacyDao{}
|
|
totalCount, defaultCount, err := doctorPharmacyDao.GetDoctorPharmacyCountsByPharmacyId(pharmacyId)
|
|
if err != nil {
|
|
return false, errors.New("查询药房关联医生失败")
|
|
}
|
|
if defaultCount > 0 {
|
|
return false, fmt.Errorf("该药房已被 %d 位医生设为默认药房（共 %d 位医生绑定），无法禁用。请先在【药房关联医生】中调整默认药房或解除绑定后再试", defaultCount, totalCount)
|
|
}
|
|
}
|
|
|
|
tx := global.Db.Begin()
|
|
defer func() {
|
|
if rec := recover(); rec != nil {
|
|
tx.Rollback()
|
|
fmt.Println(rec)
|
|
}
|
|
}()
|
|
|
|
pharmacyData := make(map[string]interface{})
|
|
|
|
if req.PharmacyName != pharmacy.PharmacyName {
|
|
pharmacyData["pharmacy_name"] = req.PharmacyName
|
|
}
|
|
|
|
if req.PharmacyCode != pharmacy.PharmacyCode {
|
|
pharmacyData["pharmacy_code"] = req.PharmacyCode
|
|
}
|
|
|
|
if *req.Postage != pharmacy.Postage {
|
|
pharmacyData["postage"] = *req.Postage
|
|
}
|
|
|
|
if *req.FreeShippingThreshold != pharmacy.FreeShippingThreshold {
|
|
pharmacyData["free_shipping_threshold"] = *req.FreeShippingThreshold
|
|
}
|
|
|
|
if *req.IsPickup != pharmacy.IsPickup {
|
|
pharmacyData["is_pickup"] = *req.IsPickup
|
|
}
|
|
|
|
if req.Telephone != pharmacy.Telephone {
|
|
pharmacyData["telephone"] = req.Telephone
|
|
}
|
|
|
|
if req.ProvinceId != 0 && req.ProvinceId != pharmacy.ProvinceId {
|
|
areaDao := dao.AreaDao{}
|
|
area, err := areaDao.GetAreaById(req.ProvinceId)
|
|
if err != nil || area == nil {
|
|
return false, errors.New("省份数据错误")
|
|
}
|
|
pharmacyData["province_id"] = req.ProvinceId
|
|
pharmacyData["province"] = area.AreaName
|
|
}
|
|
|
|
if req.CityId != 0 && req.CityId != pharmacy.CityId {
|
|
areaDao := dao.AreaDao{}
|
|
area, err := areaDao.GetAreaById(req.CityId)
|
|
if err != nil || area == nil {
|
|
return false, errors.New("城市数据错误")
|
|
}
|
|
pharmacyData["city_id"] = req.CityId
|
|
pharmacyData["city"] = area.AreaName
|
|
}
|
|
|
|
if req.CountyId != 0 && req.CountyId != pharmacy.CountyId {
|
|
areaDao := dao.AreaDao{}
|
|
area, err := areaDao.GetAreaById(req.CountyId)
|
|
if err != nil || area == nil {
|
|
return false, errors.New("区县数据错误")
|
|
}
|
|
pharmacyData["county_id"] = req.CountyId
|
|
pharmacyData["county"] = area.AreaName
|
|
}
|
|
|
|
if req.Address != pharmacy.Address {
|
|
pharmacyData["address"] = req.Address
|
|
}
|
|
|
|
if req.Status != nil && *req.Status != pharmacy.Status {
|
|
pharmacyData["status"] = *req.Status
|
|
}
|
|
|
|
if len(pharmacyData) > 0 {
|
|
err = pharmacyDao.EditPharmacyById(tx, pharmacyId, pharmacyData)
|
|
if err != nil {
|
|
tx.Rollback()
|
|
return false, errors.New(err.Error())
|
|
}
|
|
}
|
|
|
|
tx.Commit()
|
|
return true, nil
|
|
}
|
|
|
|
// PutPharmacyStatus 修改药房状态
|
|
func (r *PharmacyService) PutPharmacyStatus(pharmacyId int64, req requests.PutPharmacyStatus) (bool, error) {
|
|
pharmacyDao := dao.PharmacyDao{}
|
|
pharmacy, err := pharmacyDao.GetPharmacyById(pharmacyId)
|
|
if err != nil || pharmacy == nil {
|
|
return false, errors.New("药房不存在或已删除")
|
|
}
|
|
|
|
// 若修改为禁用，校验是否有医生设为默认药房
|
|
if req.Status != nil && *req.Status == 0 {
|
|
doctorPharmacyDao := dao.DoctorPharmacyDao{}
|
|
totalCount, defaultCount, err := doctorPharmacyDao.GetDoctorPharmacyCountsByPharmacyId(pharmacyId)
|
|
if err != nil {
|
|
return false, errors.New("查询药房关联医生失败")
|
|
}
|
|
if defaultCount > 0 {
|
|
return false, fmt.Errorf("该药房已被 %d 位医生设为默认药房（共 %d 位医生绑定），无法禁用。请先在【药房关联医生】中调整默认药房或解除绑定后再试", defaultCount, totalCount)
|
|
}
|
|
}
|
|
|
|
data := map[string]interface{}{
|
|
"status": *req.Status,
|
|
}
|
|
|
|
tx := global.Db.Begin()
|
|
defer func() {
|
|
if rec := recover(); rec != nil {
|
|
tx.Rollback()
|
|
}
|
|
}()
|
|
|
|
err = pharmacyDao.EditPharmacyById(tx, pharmacyId, data)
|
|
if err != nil {
|
|
tx.Rollback()
|
|
return false, errors.New(err.Error())
|
|
}
|
|
|
|
tx.Commit()
|
|
return true, nil
|
|
}
|
|
|
|
// DeletePharmacy 软删除药房
|
|
func (r *PharmacyService) DeletePharmacy(pharmacyId int64) (bool, error) {
|
|
pharmacyDao := dao.PharmacyDao{}
|
|
pharmacy, err := pharmacyDao.GetPharmacyById(pharmacyId)
|
|
if err != nil || pharmacy == nil {
|
|
return false, errors.New("药房不存在或已删除")
|
|
}
|
|
|
|
// 删除药房前校验：若有关联医生（特别是默认药房），拦截禁止删除
|
|
doctorPharmacyDao := dao.DoctorPharmacyDao{}
|
|
totalCount, defaultCount, err := doctorPharmacyDao.GetDoctorPharmacyCountsByPharmacyId(pharmacyId)
|
|
if err != nil {
|
|
return false, errors.New("查询药房关联医生失败")
|
|
}
|
|
if defaultCount > 0 {
|
|
return false, fmt.Errorf("该药房已被 %d 位医生设为默认药房（共 %d 位医生绑定），无法删除。请先在【药房关联医生】中调整默认药房或解除绑定后再试", defaultCount, totalCount)
|
|
}
|
|
if totalCount > 0 {
|
|
return false, fmt.Errorf("该药房仍有 %d 位医生绑定，无法删除。请先在【药房关联医生】中解除绑定后再试", totalCount)
|
|
}
|
|
|
|
tx := global.Db.Begin()
|
|
defer func() {
|
|
if rec := recover(); rec != nil {
|
|
tx.Rollback()
|
|
}
|
|
}()
|
|
|
|
err = pharmacyDao.DeletePharmacyById(tx, pharmacyId)
|
|
if err != nil {
|
|
tx.Rollback()
|
|
return false, errors.New(err.Error())
|
|
}
|
|
|
|
tx.Commit()
|
|
return true, nil
|
|
}
|
|
|
|
// GetPharmacy 药房详情
|
|
func (r *PharmacyService) GetPharmacy(pharmacyId int64) (*dto.PharmacyDto, error) {
|
|
pharmacyDao := dao.PharmacyDao{}
|
|
pharmacy, err := pharmacyDao.GetPharmacyById(pharmacyId)
|
|
if err != nil || pharmacy == nil {
|
|
if errors.Is(err, gorm.ErrRecordNotFound) || pharmacy == nil {
|
|
return nil, errors.New("未找到相关药房信息")
|
|
}
|
|
return nil, err
|
|
}
|
|
|
|
return dto.GetPharmacyDto(pharmacy), nil
|
|
}
|
|
|
|
// GetPharmacyDoctorPage 获取药房绑定的医生列表-分页
|
|
func (r *PharmacyService) GetPharmacyDoctorPage(req requests.GetPharmacyDoctorPage) (map[string]interface{}, error) {
|
|
pharmacyId, err := strconv.ParseInt(req.PharmacyId, 10, 64)
|
|
if err != nil || pharmacyId < 0 {
|
|
return nil, errors.New("药房id无效")
|
|
}
|
|
|
|
pharmacyDao := dao.PharmacyDao{}
|
|
pharmacy, err := pharmacyDao.GetPharmacyById(pharmacyId)
|
|
if err != nil || pharmacy == nil {
|
|
return nil, errors.New("药房不存在或已被删除")
|
|
}
|
|
|
|
if req.Page <= 0 {
|
|
req.Page = 1
|
|
}
|
|
if req.PageSize <= 0 {
|
|
req.PageSize = 20
|
|
}
|
|
|
|
doctorPharmacyDao := dao.DoctorPharmacyDao{}
|
|
list, total, err := doctorPharmacyDao.GetPharmacyDoctorPageSearch(pharmacyId, req, req.Page, req.PageSize)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
resList := dto.GetPharmacyDoctorListDto(list)
|
|
|
|
result := make(map[string]interface{})
|
|
result["page"] = req.Page
|
|
result["page_size"] = req.PageSize
|
|
result["total"] = total
|
|
result["data"] = resList
|
|
return result, nil
|
|
}
|
|
|
|
// GetPharmacyDoctorList 获取药房绑定的全部医生列表
|
|
func (r *PharmacyService) GetPharmacyDoctorList(pharmacyId int64) ([]dto.PharmacyDoctorDto, error) {
|
|
pharmacyDao := dao.PharmacyDao{}
|
|
pharmacy, err := pharmacyDao.GetPharmacyById(pharmacyId)
|
|
if err != nil || pharmacy == nil {
|
|
return nil, errors.New("药房不存在或已被删除")
|
|
}
|
|
|
|
doctorPharmacyDao := dao.DoctorPharmacyDao{}
|
|
list, err := doctorPharmacyDao.GetPharmacyDoctorListByPharmacyId(pharmacyId)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return dto.GetPharmacyDoctorListDto(list), nil
|
|
}
|
|
|
|
// GetAffectedDoctors 获取药房下线受影响医生列表（预检接口）
|
|
func (r *PharmacyService) GetAffectedDoctors(pharmacyId int64) (*dto.PharmacyAffectedDoctorsDto, error) {
|
|
pharmacyDao := dao.PharmacyDao{}
|
|
pharmacy, err := pharmacyDao.GetPharmacyById(pharmacyId)
|
|
if err != nil || pharmacy == nil {
|
|
return nil, errors.New("药房不存在或已删除")
|
|
}
|
|
|
|
doctorPharmacyDao := dao.DoctorPharmacyDao{}
|
|
totalCount, defaultCount, err := doctorPharmacyDao.GetDoctorPharmacyCountsByPharmacyId(pharmacyId)
|
|
if err != nil {
|
|
return nil, errors.New("查询药房关联医生数量失败")
|
|
}
|
|
|
|
// 获取将当前药房设为默认药房的受影响医生列表（仅默认药房受影响的医生需要重新指定默认药房）
|
|
list, err := doctorPharmacyDao.GetDefaultPharmacyDoctorListByPharmacyId(pharmacyId)
|
|
if err != nil {
|
|
return nil, errors.New("查询受影响医生列表失败")
|
|
}
|
|
|
|
// 收集所有医生ID
|
|
doctorIds := make([]int64, 0, len(list))
|
|
for _, dp := range list {
|
|
doctorIds = append(doctorIds, dp.DoctorId)
|
|
}
|
|
|
|
// 批量查询这些医生绑定的其他有效药房
|
|
otherMap := make(map[int64][]dto.BoundPharmacySimpleDto)
|
|
if len(doctorIds) > 0 {
|
|
otherList, err := doctorPharmacyDao.GetOtherPharmaciesByDoctorIds(doctorIds, pharmacyId)
|
|
if err == nil {
|
|
for _, dp := range otherList {
|
|
if dp.Pharmacy != nil && dp.Pharmacy.Status == 1 {
|
|
otherMap[dp.DoctorId] = append(otherMap[dp.DoctorId], dto.BoundPharmacySimpleDto{
|
|
PharmacyId: strconv.FormatInt(dp.Pharmacy.PharmacyId, 10),
|
|
PharmacyName: dp.Pharmacy.PharmacyName,
|
|
PharmacyCode: dp.Pharmacy.PharmacyCode,
|
|
IsDefault: dp.IsDefault,
|
|
})
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
doctorItems := make([]dto.AffectedDoctorItemDto, 0, len(list))
|
|
for _, dp := range list {
|
|
item := dto.AffectedDoctorItemDto{
|
|
DoctorId: strconv.FormatInt(dp.DoctorId, 10),
|
|
DoctorPharmacyId: strconv.FormatInt(dp.DoctorPharmacyId, 10),
|
|
IsDefault: dp.IsDefault,
|
|
}
|
|
if dp.UserDoctor != nil {
|
|
item.UserId = strconv.FormatInt(dp.UserDoctor.UserId, 10)
|
|
item.UserName = dp.UserDoctor.UserName
|
|
item.DoctorTitleName = dto.GetDoctorTitleName(dp.UserDoctor.DoctorTitle)
|
|
item.HospitalId = strconv.FormatInt(dp.UserDoctor.HospitalID, 10)
|
|
if dp.UserDoctor.Hospital != nil {
|
|
item.HospitalName = dp.UserDoctor.Hospital.HospitalName
|
|
}
|
|
item.DepartmentCustomId = strconv.FormatInt(dp.UserDoctor.DepartmentCustomId, 10)
|
|
item.DepartmentCustomName = dp.UserDoctor.DepartmentCustomName
|
|
if dp.UserDoctor.User != nil {
|
|
item.Mobile = dp.UserDoctor.User.Mobile
|
|
}
|
|
}
|
|
if others, ok := otherMap[dp.DoctorId]; ok {
|
|
item.OtherBoundPharmacies = others
|
|
} else {
|
|
item.OtherBoundPharmacies = []dto.BoundPharmacySimpleDto{}
|
|
}
|
|
doctorItems = append(doctorItems, item)
|
|
}
|
|
|
|
res := &dto.PharmacyAffectedDoctorsDto{
|
|
PharmacyId: strconv.FormatInt(pharmacy.PharmacyId, 10),
|
|
PharmacyName: pharmacy.PharmacyName,
|
|
PharmacyCode: pharmacy.PharmacyCode,
|
|
Status: pharmacy.Status,
|
|
DefaultDoctorCount: defaultCount,
|
|
TotalDoctorCount: totalCount,
|
|
DoctorList: doctorItems,
|
|
}
|
|
return res, nil
|
|
}
|
|
|
|
// BatchTransferAndAction 批量迁移医生默认药房并执行药房操作（禁用/删除）
|
|
func (r *PharmacyService) BatchTransferAndAction(req requests.BatchTransferAndAction) (bool, error) {
|
|
sourcePharmacyId, err := strconv.ParseInt(req.SourcePharmacyId, 10, 64)
|
|
if err != nil || sourcePharmacyId < 0 {
|
|
return false, errors.New("原药房id无效")
|
|
}
|
|
|
|
if req.Action != "disable" && req.Action != "delete" {
|
|
return false, errors.New("操作类型仅支持 disable(禁用) 或 delete(删除)")
|
|
}
|
|
|
|
pharmacyDao := dao.PharmacyDao{}
|
|
sourcePharmacy, err := pharmacyDao.GetPharmacyById(sourcePharmacyId)
|
|
if err != nil || sourcePharmacy == nil {
|
|
return false, errors.New("原药房不存在或已删除")
|
|
}
|
|
|
|
// 查询当前以原药房为默认药房的所有医生
|
|
doctorPharmacyDao := dao.DoctorPharmacyDao{}
|
|
var defaultDoctorPharmacies []*model.DoctorPharmacy
|
|
err = global.Db.Where("pharmacy_id = ? AND status = 1 AND is_default = 1", sourcePharmacyId).Find(&defaultDoctorPharmacies).Error
|
|
if err != nil {
|
|
return false, errors.New("查询受影响医生失败")
|
|
}
|
|
|
|
defaultDoctorMap := make(map[int64]bool)
|
|
for _, dp := range defaultDoctorPharmacies {
|
|
defaultDoctorMap[dp.DoctorId] = true
|
|
}
|
|
|
|
// 校验 transfers
|
|
transferDoctorMap := make(map[int64]int64) // doctorId -> targetPharmacyId
|
|
targetPharmacyIdSet := make(map[int64]bool)
|
|
|
|
for _, item := range req.Transfers {
|
|
docId, err := strconv.ParseInt(item.DoctorId, 10, 64)
|
|
if err != nil || docId <= 0 {
|
|
return false, errors.New("迁移配置中包含无效的医生id: " + item.DoctorId)
|
|
}
|
|
targetPharId, err := strconv.ParseInt(item.TargetPharmacyId, 10, 64)
|
|
if err != nil || targetPharId < 0 {
|
|
return false, errors.New("迁移配置中包含无效的目标药房id: " + item.TargetPharmacyId)
|
|
}
|
|
if targetPharId == sourcePharmacyId {
|
|
return false, errors.New("目标药房不能是当前待下线的药房自身")
|
|
}
|
|
if _, exists := transferDoctorMap[docId]; exists {
|
|
return false, fmt.Errorf("医生(ID: %d)存在重复迁移配置，每位医生只能指定一个默认药房", docId)
|
|
}
|
|
transferDoctorMap[docId] = targetPharId
|
|
targetPharmacyIdSet[targetPharId] = true
|
|
}
|
|
|
|
// 强校验：原药房名下所有默认医生必须全部指定了替代药房
|
|
for docId := range defaultDoctorMap {
|
|
if _, ok := transferDoctorMap[docId]; !ok {
|
|
return false, fmt.Errorf("医生(ID: %d)当前以此药房为默认药房，必须为其指定替代药房", docId)
|
|
}
|
|
}
|
|
|
|
// 校验所有目标药房必须存在且处于正常状态 (status = 1)
|
|
if len(targetPharmacyIdSet) > 0 {
|
|
var targetPharIds []int64
|
|
for id := range targetPharmacyIdSet {
|
|
targetPharIds = append(targetPharIds, id)
|
|
}
|
|
|
|
var targetPharmacies []*model.Pharmacy
|
|
err = global.Db.Where("pharmacy_id IN (?)", targetPharIds).Find(&targetPharmacies).Error
|
|
if err != nil {
|
|
return false, errors.New("查询目标药房信息失败")
|
|
}
|
|
|
|
targetMap := make(map[int64]*model.Pharmacy)
|
|
for _, ph := range targetPharmacies {
|
|
targetMap[ph.PharmacyId] = ph
|
|
}
|
|
|
|
for _, targetId := range targetPharIds {
|
|
ph, exists := targetMap[targetId]
|
|
if !exists || ph == nil {
|
|
return false, fmt.Errorf("目标药房(ID: %d)不存在或已被删除", targetId)
|
|
}
|
|
if ph.Status != 1 {
|
|
return false, fmt.Errorf("目标药房【%s】处于禁用状态，无法作为替代药房", ph.PharmacyName)
|
|
}
|
|
}
|
|
}
|
|
|
|
// 开启事务执行迁移与药房操作
|
|
tx := global.Db.Begin()
|
|
defer func() {
|
|
if rec := recover(); rec != nil {
|
|
tx.Rollback()
|
|
}
|
|
}()
|
|
|
|
// 逐个医生处理目标药房绑定与默认设置
|
|
for docId, targetPharId := range transferDoctorMap {
|
|
// 1. 重置该医生名下现有的所有药房为非默认
|
|
if err := doctorPharmacyDao.ResetDoctorDefaultPharmacy(tx, docId); err != nil {
|
|
tx.Rollback()
|
|
return false, errors.New("重置医生默认药房失败")
|
|
}
|
|
|
|
// 2. 检查该医生是否已绑定目标药房
|
|
existTarget, _ := doctorPharmacyDao.GetDoctorPharmacyByDoctorAndPharmacy(docId, targetPharId)
|
|
if existTarget != nil {
|
|
// 更新为 status = 1, is_default = 1
|
|
err = tx.Model(&model.DoctorPharmacy{}).
|
|
Where("doctor_pharmacy_id = ?", existTarget.DoctorPharmacyId).
|
|
Updates(map[string]interface{}{
|
|
"is_default": 1,
|
|
"status": 1,
|
|
}).Error
|
|
if err != nil {
|
|
tx.Rollback()
|
|
return false, errors.New("更新目标药房绑定关系失败")
|
|
}
|
|
} else {
|
|
// 新增绑定记录
|
|
newBinding := &model.DoctorPharmacy{
|
|
DoctorId: docId,
|
|
PharmacyId: targetPharId,
|
|
IsDefault: 1,
|
|
Status: 1,
|
|
}
|
|
_, err = doctorPharmacyDao.AddDoctorPharmacy(tx, newBinding)
|
|
if err != nil {
|
|
tx.Rollback()
|
|
return false, errors.New("新增目标药房绑定关系失败: " + err.Error())
|
|
}
|
|
}
|
|
|
|
// 3. 处理医生与原药房关系
|
|
if req.Action == "delete" || (req.UnbindSource != nil && *req.UnbindSource == 1) {
|
|
_ = doctorPharmacyDao.DeleteDoctorPharmacyByDoctorAndPharmacy(tx, docId, sourcePharmacyId)
|
|
}
|
|
}
|
|
|
|
// 执行原药房下线操作
|
|
if req.Action == "disable" {
|
|
// 若选择了解绑原药房，清空原药房所有绑定记录
|
|
if req.UnbindSource != nil && *req.UnbindSource == 1 {
|
|
_ = doctorPharmacyDao.DeleteDoctorPharmacy(tx, map[string]interface{}{"pharmacy_id": sourcePharmacyId})
|
|
}
|
|
|
|
data := map[string]interface{}{
|
|
"status": 0,
|
|
}
|
|
err = pharmacyDao.EditPharmacyById(tx, sourcePharmacyId, data)
|
|
if err != nil {
|
|
tx.Rollback()
|
|
return false, errors.New("修改药房状态失败: " + err.Error())
|
|
}
|
|
} else if req.Action == "delete" {
|
|
// 删除药房必须清空所有关联记录，防止外键孤儿数据
|
|
_ = doctorPharmacyDao.DeleteDoctorPharmacy(tx, map[string]interface{}{"pharmacy_id": sourcePharmacyId})
|
|
|
|
err = pharmacyDao.DeletePharmacyById(tx, sourcePharmacyId)
|
|
if err != nil {
|
|
tx.Rollback()
|
|
return false, errors.New("删除药房失败: " + err.Error())
|
|
}
|
|
}
|
|
|
|
tx.Commit()
|
|
return true, nil
|
|
}
|