lc_veterans/app/device/service/alarmTerminalService.go

package service

import (
	"fmt"
	"iot_manager_service/app/device/dao"
	"iot_manager_service/app/device/model"
	"iot_manager_service/app/system/service"
	"iot_manager_service/util"
	"time"
)

// 中间件管理服务
var AlarmTerminalService = new(alarmTerminalService)

type alarmTerminalService struct{}

func (s *alarmTerminalService) Get(id int) (*model.AlarmTerminalDetail, *util.Errors) {
	// 创建查询实例
	device := &dao.AlarmTerminal{
		ID: id,
	}
	err := device.GetDevice()
	if err != nil {
		return nil, util.FailResponse(err.Error(), nil)
	}
	endTime, state := util.GetDeviceState(device.TerminalSN)
	return &model.AlarmTerminalDetail{
		AlarmTerminal: *device,
		RunState:      state,
		NetworkState:  state,
		EndLineTime:   endTime,
	}, nil
}

func (s *alarmTerminalService) CreateOrUpdate(userId int64, tenantId int, req dao.AlarmTerminal) *util.Errors {
	device := req
	device.TenantId = tenantId
	device.UpdateUser = userId
	device.UpdateTime = time.Now()

	if req.ID == 0 {
		device.CreateTime = time.Now()
		device.CreateUser = userId

		if device.IsExistedBySN() {
			fmt.Printf("Create IsExistedBySN \n")
			return util.ParamsInvalidResponse(model.RepeatedName, nil)
		}
		if err := device.Create(); err != nil {
			fmt.Printf("Create err = %s \n", err.Error())
			return util.FailResponse(err.Error(), nil)
		}
		service.OperationHisService.Save(userId, tenantId, util.OperationCreate, util.ModuleTypeDevice,
			util.DeviceTypeAlarmTerminal, util.GetDeviceObject(device.ID, device.TerminalName), util.OperationSuccess)
		return util.SuccessResponse(util.Succeeded, nil)
	}

	if device.IsExistedByNameAndCode() {
		fmt.Printf("Update IsExistedByNameAndCode \n")
		return util.ParamsInvalidResponse(model.RepeatedName, nil)
	}

	if err := device.Update(); err != nil {
		fmt.Printf("Update err = %s \n", err.Error())
		return util.FailResponse(err.Error(), nil)
	}

	service.OperationHisService.Save(userId, tenantId, util.OperationUpdate, util.ModuleTypeDevice,
		util.DeviceTypeAlarmTerminal, util.GetDeviceObject(device.ID, device.TerminalName), util.OperationSuccess)
	return util.SuccessResponse(util.Succeeded, nil)
}

func (s *alarmTerminalService) List(poleGroupName string, current, size int) ([]model.AlarmTerminalDetail, *util.Errors) {
	// 创建查询实例
	device := &dao.AlarmTerminal{}
	offset := (current - 1) * size
	limit := size
	devices, err := device.GetDevices(offset, limit)
	if err != nil {
		return nil, util.FailResponse(err.Error(), nil)
	}
	var details []model.AlarmTerminalDetail
	for _, d := range devices {
		endTime, state := util.GetDeviceState(d.TerminalSN)
		details = append(details, model.AlarmTerminalDetail{
			AlarmTerminal: d,
			RunState:      state,
			NetworkState:  state,
			EndLineTime:   endTime,
		})
	}
	return details, nil
}

func (s *alarmTerminalService) Remove(userId int64, tenantId int, id int) *util.Errors {
	// 创建查询实例
	device := &dao.AlarmTerminal{
		ID:         id,
		IsDeleted:  1,
		UpdateUser: userId,
		UpdateTime: time.Now(),
	}
	err := device.Delete()
	if err != nil {
		return util.FailResponse(err.Error(), nil)
	}
	service.OperationHisService.Save(userId, tenantId, util.OperationRemove, util.ModuleTypeDevice,
		util.DeviceTypeAlarmTerminal, util.GetDeviceObject(device.ID, device.TerminalName), util.OperationSuccess)
	return nil
}

func (s *alarmTerminalService) GetByGateway(id int) []dao.AlarmTerminal {
	// 创建查询实例
	device := &dao.AlarmTerminal{
		GatewayId: id,
	}
	return device.GetDevicesByGateway()
}

func (s *alarmTerminalService) GetByLampPole(id int) []dao.AlarmTerminal {
	// 创建查询实例
	device := &dao.AlarmTerminal{
		LampPoleId: id,
	}
	return device.GetDevicesByLampPole()
}