hospital-admin-api/api/service/pharmacy.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("药房代码已被占用")
		}
	}

	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("药房不存在或已删除")
	}

	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("药房不存在或已删除")
	}

	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
}