lighting_control/server/service/item/device.go

package item

import (
	"fmt"
	"net"
	"server/dao"
	"server/global"
	"server/modbus"
	"server/model"
	"server/model/item/request"
	"server/utils"
)

type DeviceService struct{}

func (ds *DeviceService) QueryAllDevices() ([]dao.Device, error) {
	return dao.QueryAllDevices()
}

// GetOnlineDevice 获取在线设备 总共设备  在线率
func (ds *DeviceService) GetOnlineDevice() (total, online int) {
	devices, err := dao.GetOnlineDevices()
	if err != nil {
		global.GVA_LOG.Error(fmt.Sprintf("GetOnlineDevices err = %s\n", err.Error()))
		return
	}
	allDevices, err := dao.QueryAllDevices()
	if err != nil {
		global.GVA_LOG.Error(fmt.Sprintf("GetAllDevices err = %s\n", err.Error()))
		return
	}
	return len(allDevices), len(devices)
}

func (ds *DeviceService) QueryDeviceList(info request.SearchDeviceList) ([]dao.Device, int64, error) {
	limit := info.PageSize
	offset := info.PageSize * (info.Page - 1)
	devs, total, err := dao.QueryDeviceList(info.Name, info.Sn, info.RegionId, limit, offset)
	for i, dev := range devs {
		status, _ := dao.QueryDeviceLoopsByDeviceId(int(dev.ID))
		var relayStatus []int
		for _, loop := range status {
			relayStatus = append(relayStatus, loop.State)
		}

		devs[i].RelayStatus = relayStatus
		devs[i].RelayTimeStr = ds.GetDeviceRelayTimeStrByDevId(int(dev.ID), dev.LoopNumber)
	}
	return devs, total, err
}

func (ds *DeviceService) GetDeviceRelayTimeStrByDevId(id int, circuitNum int) (statusArr []string) {
	deviceRelays, err := dao.QueryDeviceLoopsByDeviceId(id)
	if err != nil {
		return
	}

	statusMap := make(map[int]dao.DeviceLoop)
	for _, relay := range deviceRelays {
		statusMap[relay.RelayId] = relay
	}
	for i := 1; i <= circuitNum; i++ {
		relayInfo, _ := statusMap[i]
		timeStr := "未设定时"
		if relayInfo.TimeCondition1OnTime == "" && relayInfo.TimeCondition1OffTime == "" && relayInfo.TimeCondition2OnTime == "" && relayInfo.TimeCondition2OffTime == "" {
			//timeStr := ""
		} else {
			timeStr = fmt.Sprintf("时控1[%v]-[%v]， 时控2[%v]-[%v]", relayInfo.TimeCondition1OnTime, relayInfo.TimeCondition1OffTime, relayInfo.TimeCondition2OnTime, relayInfo.TimeCondition2OffTime)
		}

		statusArr = append(statusArr, timeStr)
	}
	return
}

func (ds *DeviceService) CreateDevice(device dao.Device) error {
	if device.LoopNumber <= 0 {
		return fmt.Errorf("device.LoopNumber 必须大于0")
	}

	tx := global.GVA_DB.Begin()
	if tx.Error != nil {
		return tx.Error
	}
	defer func() {
		if r := recover(); r != nil {
			_ = tx.Rollback()
		}
	}()

	// 创建设备
	if err := tx.Create(&device).Error; err != nil {
		_ = tx.Rollback()
		return fmt.Errorf("创建设备失败: %w", err)
	}

	deviceID := int(device.ID)
	for i := 1; i <= device.LoopNumber; i++ {
		loop := dao.DeviceLoop{
			DeviceId: deviceID,
			RelayId:  i,
			Name:     fmt.Sprintf("回路 %d", i),
		}
		if err := tx.Create(&loop).Error; err != nil {
			_ = tx.Rollback()
			return fmt.Errorf("创建回路%d失败: %w", i, err)
		}
	}

	// 全部成功提交
	if err := tx.Commit().Error; err != nil {
		_ = tx.Rollback()
		return err
	}
	return nil
}

func (ds *DeviceService) UpdateDevice(device dao.Device) error {
	return device.UpdateDevice()
}

func (ds *DeviceService) DeviceLoopSwitch(deviceLoop dao.DeviceLoop) error {
	data := modbus.DeviceLoopSwitch(deviceLoop.RelayId, deviceLoop.State)
	dev1, _ := dao.QueryDeviceById(deviceLoop.DeviceId)
	if conn1, ok := model.ConnectionMap1.Load(dev1.Ip); ok {
		// 成功找到连接
		netConn := conn1.(net.Conn)
		if dev1.State == 0 {
			return fmt.Errorf("设备离线无法操作")
		}

		err := utils.WriteDevice(data, netConn)
		if err != nil {
			global.GVA_LOG.Error(fmt.Sprintf("设备回路开关 写命令错误: %s -- conn: %v", err, netConn.RemoteAddr().String()))
			return err
		}
	} else {
		// 没有找到对应的连接
		global.GVA_LOG.Warn(fmt.Sprintf("设备回路开关Connection for key %s not found", dev1.Ip))
	}
	return nil
}

func (ds *DeviceService) RegionSwitch(req model.RegionRequest) error {
	devices, err := dao.QueryDevicesByRegionId(req.RegionId)
	if err != nil {
		return err
	}
	for _, device := range devices {
		data := modbus.DeviceSwitch(device.LoopNumber, req.State)
		if conn1, ok := model.ConnectionMap1.Load(device.Ip); ok {
			// 成功找到连接
			netConn := conn1.(net.Conn)
			modbus.OperationCommand = data
			err := utils.WriteDevice(data, netConn)
			if err != nil {
				global.GVA_LOG.Error(fmt.Sprintf("设备回路开关 写命令错误: %s -- conn: %v", err, netConn.RemoteAddr().String()))
				return err
			}
		} else {
			// 没有找到对应的连接
			global.GVA_LOG.Warn(fmt.Sprintf("设备开关Connection for key %s not found", device.Ip))
		}

	}
	return nil

}

func (ds *DeviceService) DeviceBatchSwitch(req model.DevicesRequest) error {
	devices, err := dao.QueryDeviceByIds(req.IDs)
	if err != nil {
		return err
	}
	for _, device := range devices {
		if device.State == 0 {
			continue
		}
		data := modbus.DeviceSwitch(device.LoopNumber, req.State)
		modbus.OperationCommand = data
		if conn1, ok := model.ConnectionMap1.Load(device.Ip); ok {
			// 成功找到连接
			netConn := conn1.(net.Conn)
			err := utils.WriteDevice(data, netConn)
			if err != nil {
				global.GVA_LOG.Error(fmt.Sprintf("设备批量控制 写命令错误: %s -- conn: %v", err, netConn.RemoteAddr().String()))
			}
		} else {
			// 没有找到对应的连接
			global.GVA_LOG.Warn(fmt.Sprintf("设备批量控制Connection for key %s not found", device.Ip))
		}
	}
	return nil
}

func (ds *DeviceService) BatchUpdateDeviceTime(req request.UpdateDeviceTimeData) error {
	return dao.BatchUpdateDeviceTime(req.Ids, req.TimeCondition1OnTime, req.TimeCondition1OffTime, req.TimeCondition2OnTime, req.TimeCondition2OffTime)
}

func (ds *DeviceService) BatchUpdateRegionTime(req request.UpdateRegionTimeData) error {
	return dao.BatchUpdateRegionTime(req.RegionId, req.TimeCondition1OnTime, req.TimeCondition1OffTime, req.TimeCondition2OnTime, req.TimeCondition2OffTime)
}