dy-admin-temp/internal/pcmserver/bus/service/cabinet.go

package service

import (
	"dy-admin/internal/pcmserver/bus/cabinet_pkg"
	"dy-admin/internal/pcmserver/bus/model"
	"dy-admin/internal/pcmserver/bus/model/request"
	"dy-admin/internal/pcmserver/common"
	"dy-admin/internal/pcmserver/global"
	"dy-admin/internal/pcmserver/pkg/code"
	systemService "dy-admin/internal/pcmserver/sys/service"
	"dy-admin/pkg/log"
	"dy-admin/pkg/rescode"
	"fmt"
	"go.uber.org/zap"
	"gorm.io/gorm"
)

type CabinetService struct {
}

func (cs *CabinetService) initCabinets() {
	// 已经创建的手机柜,初始化到内存并
	var list []model.Cabinet
	err := global.DB.Order("Sort asc").Find(&list).Error
	if err != nil {
		panic(err)
	}

	cabIds := make([]int, 0, len(list))
	for _, cab := range list {
		cabIds = append(cabIds, cab.ID)

		channels := cabinetMapChannel.setCabinetChannel(cab.ID)
		cab.Connected = "断开"
		err = cabinet_pkg.AddCabinet(cab, channels.cabinetConnectChan, channels.gridStatusChan, channels.openStatusChan)
		if err != nil {
			panic(err)
		}
		log.Info("init cabinet to memory", zap.Int("cabinetId", cab.ID))
	}

	// 批量将连接重置为未连接
	err = global.DB.Model(&model.Cabinet{}).Where("id in (?)", cabIds).Update("connected", "断开").Error
	if err != nil {
		panic(err)
	}

	return
}

// CreateCabinet 增加柜子
func (cs *CabinetService) CreateCabinet(cabinet model.Cabinet) (err error) {

	if cabinet.GridCount != 12 && cabinet.GridCount != 44 {
		return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrCabinetGridCountCode])
	}

	var ipCount int64
	err = global.DB.Model(&model.Cabinet{}).Where("ip = ?", cabinet.Ip).Count(&ipCount).Error
	if err != nil {
		return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrDatabaseCode])
	}
	if ipCount != 0 {
		return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrIPAlreadyExistsCode])
	}

	var numCount int64
	err = global.DB.Model(&model.Cabinet{}).Where("number = ?", cabinet.Number).Count(&ipCount).Error
	if err != nil {
		return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrDatabaseCode])
	}
	if numCount != 0 {
		return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrNumberAlreadyExistsCode])
	}

	tx := global.DB.Begin()
	defer func() {
		if err != nil {
			tx.Rollback()
		} else {
			tx.Commit()
		}
	}()
	cabinet.Connected = "断开"
	cabinet.AllowOpen = "允许开启"

	err = tx.Create(&cabinet).Error
	if err != nil {
		return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrDatabaseCode])
	}

	err = ServicesGroupApp.GridService.CreateGridBatch(cabinet.ID, cabinet.GridCount)
	if err != nil {
		return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrDatabaseCode])
	}

	// 创建监听
	channels := cabinetMapChannel.setCabinetChannel(cabinet.ID)
	err = cabinet_pkg.AddCabinet(cabinet, channels.cabinetConnectChan, channels.gridStatusChan, channels.openStatusChan)
	if err != nil {
		return err
	}

	return
}

// UpdateCabinet 更新柜子
func (cs *CabinetService) UpdateCabinet(cabinet model.Cabinet) (err error) {
	// ip 格子数量 创建后不允许修改。修改牵扯到的逻辑修改太多。
	err = global.DB.Updates(&cabinet).Error
	if err != nil {
		return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrDatabaseCode])
	}

	info, err := cs.GetCabinet(cabinet.ID)
	if err != nil {
		return
	}

	fmt.Println(info)
	return
}

// DeleteCabinet 删除柜子
func (cs *CabinetService) DeleteCabinet(cabinetId int) (err error) {
	// 找到柜子所有格子
	var girds []model.Grid
	err = global.DB.Where("cabinet_id = ?", cabinetId).Find(&girds).Error
	if err != nil {
		return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrDatabaseCode])
	}

	var staffs []model.Staff
	err = global.DB.Where("cabinet_id = ?", cabinetId).Find(&staffs).Error
	if err != nil {
		return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrDatabaseCode])
	}
	if len(staffs) != 0 {
		return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrCabinetGridUsedCode])
	}

	// 找到所有占用格子的人员。置空
	deviceIds := make([]int, 0, len(girds))
	for _, grid := range girds {
		deviceIds = append(deviceIds, grid.DeviceGridID)
	}

	tx := global.DB.Begin()
	defer func() {
		if err != nil {
			tx.Rollback()
		} else {
			tx.Commit()
		}
	}()

	// 人员占用的格子，清空
	staff := model.Staff{CabinetID: 0, GridDeviceID: 0}
	err = tx.Model(&model.Staff{}).Where("cabinet_id = ?", cabinetId).Where("grid_device_id in (?)", deviceIds).
		Updates(&staff).Error
	if err != nil {
		return
	}
	// 删除格子
	err = tx.Model(&model.Grid{}).Delete(&girds).Error
	if err != nil {
		return
	}
	// 删除柜子
	err = tx.Delete(&model.Cabinet{Model: common.Model{ID: cabinetId}}).Error
	if err != nil {
		return
	}

	//删除内存中柜子
	err = cabinet_pkg.DelCabinet(cabinetId)
	if err != nil {
		return err
	}

	// 删除消息通道
	cabinetMapChannel.deleteCabinetChannel(cabinetId)

	return
}

// GetCabinetList 分页获取柜子
func (cs *CabinetService) GetCabinetList(info request.CabinetSearch, dataPermission *BusPermission) (list []model.Cabinet, total int64, err error) {
	limit := info.PageSize
	offset := info.PageSize * (info.Page - 1)
	var cabinetModel model.Cabinet
	db := global.DB.Model(&cabinetModel).Scopes(Permission(cabinetModel.TableName(), dataPermission))

	if info.Name != "" {
		db = db.Where("name LIKE ?", "%"+info.Name+"%")
	}

	if info.DeptID != 0 {
		deptIds, err := systemService.ServicesGroupApp.DeptService.GetSonDeptIds(info.DeptID)
		if err != nil {
			log.Warn("get son deptIds err", zap.Error(err))
		} else {
			db = db.Where("department_id in (?)", deptIds)
		}
	}

	err = db.Count(&total).Error
	if err != nil {
		return
	}
	if err = db.Order("sort asc").Limit(limit).Offset(offset).Find(&list).Error; err != nil {
		return list, total, rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrDatabaseCode])
	}

	return
}

// GetCabinet 获取单个柜子
func (cs *CabinetService) GetCabinet(cabinetId int) (*model.Cabinet, error) {
	var cabinet model.Cabinet
	err := global.DB.Where("id = ?", cabinetId).First(&cabinet).Error
	if err != nil && err != gorm.ErrRecordNotFound {
		return &cabinet, rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrDatabaseCode])
	}

	return &cabinet, nil
}

func (cs *CabinetService) ChangeCabinetStatus(cabinetId int, status string) (err error) {
	tx := global.DB.Begin()
	defer func() {
		if err != nil {
			tx.Rollback()
		} else {
			tx.Commit()
		}
	}()
	updateCabinet := model.Cabinet{AllowOpen: status}
	err = tx.Where("id = ?", cabinetId).Updates(&updateCabinet).Error
	if err != nil {
		return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrDatabaseCode])
	}
	if status == "允许开启" {
		err = cabinet_pkg.EnableOpenDoor(cabinetId, true)
		if err != nil {
			return err
		}
	} else {
		err = cabinet_pkg.DisableOpenDoor(cabinetId)
		if err != nil {
			return err
		}
	}

	//推送到首页
	go func() {
		memInfo := cabinet_pkg.GetCabinet(cabinetId)
		err = sendUpdateCabinetOpenStatus(memInfo.DeptID, cabinetId, status, true)
		if err != nil {
			log.Error("sendUpdateCabinetOpenStatus", zap.Error(err))
		}
	}()

	return
}

func (cs *CabinetService) ChangeCabinetConnectStatus(cabinetId int, connectStatus string) (err error) {
	updateCabinet := model.Cabinet{Connected: connectStatus}
	err = global.DB.Where("id = ?", cabinetId).Updates(&updateCabinet).Error
	if err != nil {
		return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrDatabaseCode])
	}

	// 推送到首页
	go func() {
		memInfo := cabinet_pkg.GetCabinet(cabinetId)
		// 连接状态推送
		err = sendUpdateCabinetConnect(memInfo.DeptID, memInfo.CabinetID, connectStatus, true)
		if err != nil {
			log.Error("sendUpdateCabinetConnect", zap.Error(err))
		}
		// 部门下的柜子连接数推送
		err = sendCabinetConnect(memInfo.DeptID, true, nil)
		if err != nil {
			log.Error("sendCabinetConnect", zap.Error(err))
		}
	}()

	return
}

func (cs *CabinetService) GetCabinetWithGrids(cabinetId int) (cabinet *model.Cabinet, grids []model.Grid, err error) {
	cabinet, err = cs.GetCabinet(cabinetId)
	if err != nil {
		return cabinet, grids, rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrDatabaseCode])
	}

	grids, err = ServicesGroupApp.GridService.GetGridListByCabinetID(cabinetId)
	if err != nil {
		return cabinet, grids, rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrDatabaseCode])
	}
	return
}

func (cs *CabinetService) GetCabinetsByDeptID(deptId int) (cabinets []model.Cabinet, err error) {
	err = global.DB.Model(&model.Cabinet{}).Where("department_id = ?", deptId).Find(&cabinets).Order("sort asc").Error
	if err != nil && err != gorm.ErrRecordNotFound {
		return cabinets, rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrDatabaseCode])
	}
	return
}

func (cs *CabinetService) GetCabinetIDsByDeptID(deptId int) (ids []int, err error) {
	var cabinets []model.Cabinet
	err = global.DB.Model(&model.Cabinet{}).Where("department_id = ?", deptId).Find(&cabinets).Order("sort asc").Error
	if err != nil && err != gorm.ErrRecordNotFound {
		return ids, rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrDatabaseCode])
	}
	for _, cabinet := range cabinets {
		ids = append(ids, cabinet.ID)
	}
	return
}

func (cs *CabinetService) GetCabinetConnectByDeptID(deptId int) (connect int64, noConnect int64, err error) {
	err = global.DB.Model(&model.Cabinet{}).Where("department_id = ?", deptId).Where("connected = ?", "连接").Count(&connect).Error
	if err != nil {
		return connect, noConnect, rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrDatabaseCode])
	}
	err = global.DB.Model(&model.Cabinet{}).Where("department_id = ?", deptId).Where("connected = ?", "断开").Count(&noConnect).Error
	if err != nil {
		return connect, noConnect, rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrDatabaseCode])
	}
	return
}