mirror of
https://github.com/SyncrowIOT/backend.git
synced 2025-11-26 08:14:55 +00:00
1396 lines
43 KiB
TypeScript
1396 lines
43 KiB
TypeScript
import { ProductRepository } from './../../../libs/common/src/modules/product/repositories/product.repository';
|
|
import {
|
|
Injectable,
|
|
HttpException,
|
|
HttpStatus,
|
|
NotFoundException,
|
|
BadRequestException,
|
|
forwardRef,
|
|
Inject,
|
|
} from '@nestjs/common';
|
|
import { TuyaContext } from '@tuya/tuya-connector-nodejs';
|
|
import { ConfigService } from '@nestjs/config';
|
|
import {
|
|
AddDeviceDto,
|
|
AddSceneToFourSceneDeviceDto,
|
|
UpdateDeviceDto,
|
|
UpdateDeviceInSpaceDto,
|
|
} from '../dtos/add.device.dto';
|
|
import {
|
|
DeviceInstructionResponse,
|
|
GetDeviceDetailsFunctionsInterface,
|
|
GetDeviceDetailsFunctionsStatusInterface,
|
|
GetDeviceDetailsInterface,
|
|
GetMacAddressInterface,
|
|
GetPowerClampFunctionsStatusInterface,
|
|
controlDeviceInterface,
|
|
getDeviceLogsInterface,
|
|
updateDeviceFirmwareInterface,
|
|
} from '../interfaces/get.device.interface';
|
|
import {
|
|
GetDeviceBySpaceUuidDto,
|
|
GetDeviceLogsDto,
|
|
} from '../dtos/get.device.dto';
|
|
import {
|
|
BatchControlDevicesDto,
|
|
BatchFactoryResetDevicesDto,
|
|
BatchStatusDevicesDto,
|
|
ControlDeviceDto,
|
|
GetSceneFourSceneDeviceDto,
|
|
} from '../dtos/control.device.dto';
|
|
import { convertKeysToCamelCase } from '@app/common/helper/camelCaseConverter';
|
|
import { DeviceRepository } from '@app/common/modules/device/repositories';
|
|
import { PermissionType } from '@app/common/constants/permission-type.enum';
|
|
import { In } from 'typeorm';
|
|
import { ProductType } from '@app/common/constants/product-type.enum';
|
|
import { SpaceRepository } from '@app/common/modules/space/repositories';
|
|
import { DeviceStatusFirebaseService } from '@app/common/firebase/devices-status/services/devices-status.service';
|
|
import { DeviceStatuses } from '@app/common/constants/device-status.enum';
|
|
import { CommonErrorCodes } from '@app/common/constants/error-codes.enum';
|
|
import { BatteryStatus } from '@app/common/constants/battery-status.enum';
|
|
import { SpaceEntity } from '@app/common/modules/space/entities';
|
|
import { SceneService } from 'src/scene/services';
|
|
import { AddAutomationDto } from 'src/automation/dtos';
|
|
import { TuyaService } from '@app/common/integrations/tuya/services/tuya.service';
|
|
import { SceneDeviceRepository } from '@app/common/modules/scene-device/repositories';
|
|
import { SceneSwitchesTypeEnum } from '@app/common/constants/scene-switch-type.enum';
|
|
import { AUTOMATION_CONFIG } from '@app/common/constants/automation.enum';
|
|
|
|
@Injectable()
|
|
export class DeviceService {
|
|
private tuya: TuyaContext;
|
|
constructor(
|
|
private readonly configService: ConfigService,
|
|
private readonly deviceRepository: DeviceRepository,
|
|
private readonly sceneDeviceRepository: SceneDeviceRepository,
|
|
private readonly productRepository: ProductRepository,
|
|
private readonly deviceStatusFirebaseService: DeviceStatusFirebaseService,
|
|
private readonly spaceRepository: SpaceRepository,
|
|
@Inject(forwardRef(() => SceneService))
|
|
private readonly sceneService: SceneService,
|
|
private readonly tuyaService: TuyaService,
|
|
) {
|
|
const accessKey = this.configService.get<string>('auth-config.ACCESS_KEY');
|
|
const secretKey = this.configService.get<string>('auth-config.SECRET_KEY');
|
|
const tuyaEuUrl = this.configService.get<string>('tuya-config.TUYA_EU_URL');
|
|
this.tuya = new TuyaContext({
|
|
baseUrl: tuyaEuUrl,
|
|
accessKey,
|
|
secretKey,
|
|
});
|
|
}
|
|
async getDeviceByDeviceUuid(
|
|
deviceUuid: string,
|
|
withProductDevice: boolean = true,
|
|
) {
|
|
const relations = ['subspace'];
|
|
|
|
if (withProductDevice) {
|
|
relations.push('productDevice');
|
|
}
|
|
|
|
return this.deviceRepository.findOne({
|
|
where: { uuid: deviceUuid },
|
|
relations,
|
|
});
|
|
}
|
|
|
|
async getDeviceByDeviceTuyaUuid(deviceTuyaUuid: string) {
|
|
return await this.deviceRepository.findOne({
|
|
where: {
|
|
deviceTuyaUuid,
|
|
},
|
|
relations: ['productDevice'],
|
|
});
|
|
}
|
|
|
|
async addDeviceUser(addDeviceDto: AddDeviceDto) {
|
|
try {
|
|
const device = await this.getDeviceDetailsByDeviceIdTuya(
|
|
addDeviceDto.deviceTuyaUuid,
|
|
);
|
|
|
|
if (!device.productUuid) {
|
|
throw new Error('Product UUID is missing for the device.');
|
|
}
|
|
const deviceSaved = await this.deviceRepository.save({
|
|
deviceTuyaUuid: addDeviceDto.deviceTuyaUuid,
|
|
productDevice: { uuid: device.productUuid },
|
|
user: {
|
|
uuid: addDeviceDto.userUuid,
|
|
},
|
|
});
|
|
if (deviceSaved.uuid) {
|
|
const deviceStatus = await this.getDevicesInstructionStatus(
|
|
deviceSaved.uuid,
|
|
);
|
|
if (deviceStatus.productUuid) {
|
|
await this.deviceStatusFirebaseService.addDeviceStatusToFirebase({
|
|
deviceUuid: deviceSaved.uuid,
|
|
deviceTuyaUuid: addDeviceDto.deviceTuyaUuid,
|
|
status: deviceStatus.status,
|
|
productUuid: deviceStatus.productUuid,
|
|
productType: deviceStatus.productType,
|
|
});
|
|
}
|
|
}
|
|
return deviceSaved;
|
|
} catch (error) {
|
|
if (error.code === CommonErrorCodes.DUPLICATE_ENTITY) {
|
|
throw new HttpException(
|
|
'Device already exists',
|
|
HttpStatus.BAD_REQUEST,
|
|
);
|
|
} else {
|
|
throw new HttpException(
|
|
error.message || 'Failed to add device in space',
|
|
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
async getDevicesByUser(
|
|
userUuid: string,
|
|
): Promise<GetDeviceDetailsInterface[]> {
|
|
try {
|
|
const devices = await this.deviceRepository.find({
|
|
where: {
|
|
user: { uuid: userUuid },
|
|
isActive: true,
|
|
permission: {
|
|
userUuid,
|
|
permissionType: {
|
|
type: In([PermissionType.READ, PermissionType.CONTROLLABLE]),
|
|
},
|
|
},
|
|
},
|
|
relations: [
|
|
'spaceDevice',
|
|
'productDevice',
|
|
'permission',
|
|
'permission.permissionType',
|
|
],
|
|
});
|
|
const devicesData = await Promise.all(
|
|
devices.map(async (device) => {
|
|
return {
|
|
haveRoom: device.spaceDevice ? true : false,
|
|
productUuid: device.productDevice.uuid,
|
|
productType: device.productDevice.prodType,
|
|
permissionType: device.permission[0].permissionType.type,
|
|
...(await this.getDeviceDetailsByDeviceIdTuya(
|
|
device.deviceTuyaUuid,
|
|
)),
|
|
uuid: device.uuid,
|
|
} as GetDeviceDetailsInterface;
|
|
}),
|
|
);
|
|
|
|
return devicesData;
|
|
} catch (error) {
|
|
// Handle the error here
|
|
throw new HttpException(
|
|
'User does not have any devices',
|
|
HttpStatus.NOT_FOUND,
|
|
);
|
|
}
|
|
}
|
|
|
|
async getDevicesBySpaceId(
|
|
getDeviceBySpaceUuidDto: GetDeviceBySpaceUuidDto,
|
|
userUuid: string,
|
|
): Promise<GetDeviceDetailsInterface[]> {
|
|
try {
|
|
const devices = await this.deviceRepository.find({
|
|
where: {
|
|
spaceDevice: { uuid: getDeviceBySpaceUuidDto.spaceUuid },
|
|
isActive: true,
|
|
permission: {
|
|
userUuid,
|
|
permissionType: {
|
|
type: In([PermissionType.READ, PermissionType.CONTROLLABLE]),
|
|
},
|
|
},
|
|
},
|
|
relations: [
|
|
'spaceDevice',
|
|
'productDevice',
|
|
'permission',
|
|
'permission.permissionType',
|
|
],
|
|
});
|
|
const devicesData = await Promise.all(
|
|
devices.map(async (device) => {
|
|
return {
|
|
haveRoom: device.spaceDevice ? true : false,
|
|
productUuid: device.productDevice.uuid,
|
|
productType: device.productDevice.prodType,
|
|
permissionType: device.permission[0].permissionType.type,
|
|
...(await this.getDeviceDetailsByDeviceIdTuya(
|
|
device.deviceTuyaUuid,
|
|
)),
|
|
uuid: device.uuid,
|
|
} as GetDeviceDetailsInterface;
|
|
}),
|
|
);
|
|
|
|
return devicesData;
|
|
} catch (error) {
|
|
// Handle the error here
|
|
throw new HttpException(
|
|
'Error fetching devices by space',
|
|
HttpStatus.INTERNAL_SERVER_ERROR,
|
|
);
|
|
}
|
|
}
|
|
async updateDeviceInSpace(updateDeviceInSpaceDto: UpdateDeviceInSpaceDto) {
|
|
try {
|
|
await this.deviceRepository.update(
|
|
{ uuid: updateDeviceInSpaceDto.deviceUuid },
|
|
{
|
|
spaceDevice: { uuid: updateDeviceInSpaceDto.spaceUuid },
|
|
},
|
|
);
|
|
const device = await this.deviceRepository.findOne({
|
|
where: {
|
|
uuid: updateDeviceInSpaceDto.deviceUuid,
|
|
},
|
|
relations: ['spaceDevice', 'spaceDevice.parent'],
|
|
});
|
|
if (device.spaceDevice.parent.spaceTuyaUuid) {
|
|
await this.transferDeviceInSpacesTuya(
|
|
device.deviceTuyaUuid,
|
|
device.spaceDevice.parent.spaceTuyaUuid,
|
|
);
|
|
}
|
|
|
|
return {
|
|
uuid: device.uuid,
|
|
spaceUuid: device.spaceDevice.uuid,
|
|
};
|
|
} catch (error) {
|
|
throw new HttpException(
|
|
'Failed to add device in space',
|
|
HttpStatus.INTERNAL_SERVER_ERROR,
|
|
);
|
|
}
|
|
}
|
|
|
|
async transferDeviceInSpacesTuya(
|
|
deviceId: string,
|
|
spaceId: string,
|
|
): Promise<controlDeviceInterface> {
|
|
try {
|
|
const path = `/v2.0/cloud/thing/${deviceId}/transfer`;
|
|
const response = await this.tuya.request({
|
|
method: 'POST',
|
|
path,
|
|
body: { space_id: spaceId },
|
|
});
|
|
|
|
return response as controlDeviceInterface;
|
|
} catch (error) {
|
|
throw new HttpException(
|
|
'Error transferring device in spaces from Tuya',
|
|
HttpStatus.INTERNAL_SERVER_ERROR,
|
|
);
|
|
}
|
|
}
|
|
async updateDeviceNameTuya(
|
|
deviceId: string,
|
|
deviceName: string,
|
|
): Promise<controlDeviceInterface> {
|
|
try {
|
|
const path = `/v2.0/cloud/thing/${deviceId}/attribute`;
|
|
const response = await this.tuya.request({
|
|
method: 'POST',
|
|
path,
|
|
body: { type: 1, data: deviceName },
|
|
});
|
|
|
|
return response as controlDeviceInterface;
|
|
} catch (error) {
|
|
throw new HttpException(
|
|
'Error updating device name from Tuya',
|
|
HttpStatus.INTERNAL_SERVER_ERROR,
|
|
);
|
|
}
|
|
}
|
|
async controlDevice(controlDeviceDto: ControlDeviceDto, deviceUuid: string) {
|
|
try {
|
|
const deviceDetails = await this.getDeviceByDeviceUuid(deviceUuid, false);
|
|
|
|
if (!deviceDetails || !deviceDetails.deviceTuyaUuid) {
|
|
throw new NotFoundException('Device Not Found');
|
|
}
|
|
const response = await this.controlDeviceTuya(
|
|
deviceDetails.deviceTuyaUuid,
|
|
controlDeviceDto,
|
|
);
|
|
|
|
if (response.success) {
|
|
return response;
|
|
} else {
|
|
throw new HttpException(
|
|
response.msg || 'Unknown error',
|
|
HttpStatus.BAD_REQUEST,
|
|
);
|
|
}
|
|
} catch (error) {
|
|
throw new HttpException(
|
|
error.message || 'Device Not Found',
|
|
error.status || HttpStatus.NOT_FOUND,
|
|
);
|
|
}
|
|
}
|
|
|
|
async factoryResetDeviceTuya(
|
|
deviceUuid: string,
|
|
): Promise<controlDeviceInterface> {
|
|
try {
|
|
const path = `/v2.0/cloud/thing/${deviceUuid}/reset`;
|
|
const response = await this.tuya.request({
|
|
method: 'POST',
|
|
path,
|
|
});
|
|
|
|
return response as controlDeviceInterface;
|
|
} catch (error) {
|
|
throw new HttpException(
|
|
'Error factory resetting device from Tuya',
|
|
HttpStatus.INTERNAL_SERVER_ERROR,
|
|
);
|
|
}
|
|
}
|
|
async controlDeviceTuya(
|
|
deviceUuid: string,
|
|
controlDeviceDto: ControlDeviceDto,
|
|
): Promise<controlDeviceInterface> {
|
|
try {
|
|
const path = `/v1.0/iot-03/devices/${deviceUuid}/commands`;
|
|
const response = await this.tuya.request({
|
|
method: 'POST',
|
|
path,
|
|
body: {
|
|
commands: [
|
|
{ code: controlDeviceDto.code, value: controlDeviceDto.value },
|
|
],
|
|
},
|
|
});
|
|
|
|
return response as controlDeviceInterface;
|
|
} catch (error) {
|
|
throw new HttpException(
|
|
'Error control device from Tuya',
|
|
HttpStatus.INTERNAL_SERVER_ERROR,
|
|
);
|
|
}
|
|
}
|
|
|
|
async batchControlDevices(batchControlDevicesDto: BatchControlDevicesDto) {
|
|
const { devicesUuid } = batchControlDevicesDto;
|
|
|
|
try {
|
|
// Check if all devices have the same product UUID
|
|
await this.checkAllDevicesHaveSameProductUuid(devicesUuid);
|
|
|
|
// Perform all operations concurrently
|
|
const results = await Promise.allSettled(
|
|
devicesUuid.map(async (deviceUuid) => {
|
|
const deviceDetails = await this.getDeviceByDeviceUuid(deviceUuid);
|
|
const result = await this.controlDeviceTuya(
|
|
deviceDetails.deviceTuyaUuid,
|
|
batchControlDevicesDto,
|
|
);
|
|
return { deviceUuid, result };
|
|
}),
|
|
);
|
|
|
|
// Separate successful and failed operations
|
|
const successResults = [];
|
|
const failedResults = [];
|
|
|
|
for (const result of results) {
|
|
if (result.status === DeviceStatuses.FULLFILLED) {
|
|
const { deviceUuid, result: operationResult } = result.value;
|
|
|
|
if (operationResult.success) {
|
|
// Add to success results if operationResult.success is true
|
|
successResults.push({ deviceUuid, result: operationResult });
|
|
} else {
|
|
// Add to failed results if operationResult.success is false
|
|
failedResults.push({ deviceUuid, error: operationResult.msg });
|
|
}
|
|
} else {
|
|
// Add to failed results if promise is rejected
|
|
failedResults.push({
|
|
deviceUuid: devicesUuid[results.indexOf(result)],
|
|
error: result.reason.message,
|
|
});
|
|
}
|
|
}
|
|
|
|
return { successResults, failedResults };
|
|
} catch (error) {
|
|
throw new HttpException(
|
|
error.message || 'Device Not Found',
|
|
error.status || HttpStatus.NOT_FOUND,
|
|
);
|
|
}
|
|
}
|
|
async batchStatusDevices(batchStatusDevicesDto: BatchStatusDevicesDto) {
|
|
const { devicesUuid } = batchStatusDevicesDto;
|
|
const devicesUuidArray = devicesUuid.split(',');
|
|
|
|
try {
|
|
await this.checkAllDevicesHaveSameProductUuid(devicesUuidArray);
|
|
const statuses = await Promise.all(
|
|
devicesUuidArray.map(async (deviceUuid) => {
|
|
const result = await this.getDevicesInstructionStatus(deviceUuid);
|
|
return { deviceUuid, result };
|
|
}),
|
|
);
|
|
return {
|
|
status: statuses[0].result,
|
|
devices: statuses,
|
|
};
|
|
} catch (error) {
|
|
throw new HttpException(
|
|
error.message || 'Device Not Found',
|
|
error.status || HttpStatus.NOT_FOUND,
|
|
);
|
|
}
|
|
}
|
|
async checkAllDevicesHaveSameProductUuid(deviceUuids: string[]) {
|
|
const firstDevice = await this.deviceRepository.findOne({
|
|
where: { uuid: deviceUuids[0], isActive: true },
|
|
relations: ['productDevice'],
|
|
});
|
|
|
|
if (!firstDevice) {
|
|
throw new BadRequestException('First device not found');
|
|
}
|
|
|
|
const firstProductType = firstDevice.productDevice.prodType;
|
|
|
|
for (let i = 1; i < deviceUuids.length; i++) {
|
|
const device = await this.deviceRepository.findOne({
|
|
where: { uuid: deviceUuids[i], isActive: true },
|
|
relations: ['productDevice'],
|
|
});
|
|
|
|
if (!device) {
|
|
throw new BadRequestException(`Device ${deviceUuids[i]} not found`);
|
|
}
|
|
|
|
if (device.productDevice.prodType !== firstProductType) {
|
|
throw new BadRequestException(`Devices have different product types`);
|
|
}
|
|
}
|
|
}
|
|
async batchFactoryResetDevices(
|
|
batchFactoryResetDevicesDto: BatchFactoryResetDevicesDto,
|
|
) {
|
|
const { devicesUuid } = batchFactoryResetDevicesDto;
|
|
|
|
try {
|
|
// Check if all devices have the same product UUID
|
|
await this.checkAllDevicesHaveSameProductUuid(devicesUuid);
|
|
|
|
// Perform all operations concurrently
|
|
const results = await Promise.allSettled(
|
|
devicesUuid.map(async (deviceUuid) => {
|
|
const deviceDetails = await this.getDeviceByDeviceUuid(deviceUuid);
|
|
const result = await this.factoryResetDeviceTuya(
|
|
deviceDetails.deviceTuyaUuid,
|
|
);
|
|
return { deviceUuid, result };
|
|
}),
|
|
);
|
|
|
|
// Separate successful and failed operations
|
|
const successResults = [];
|
|
const failedResults = [];
|
|
|
|
for (const result of results) {
|
|
if (result.status === DeviceStatuses.FULLFILLED) {
|
|
const { deviceUuid, result: operationResult } = result.value;
|
|
|
|
if (operationResult.success) {
|
|
// Add to success results if operationResult.success is true
|
|
successResults.push({ deviceUuid, result: operationResult });
|
|
// Update isActive to false in the repository for the successfully reset device
|
|
await this.deviceRepository.update(
|
|
{ uuid: deviceUuid },
|
|
{ isActive: false },
|
|
);
|
|
} else {
|
|
// Add to failed results if operationResult.success is false
|
|
failedResults.push({ deviceUuid, error: operationResult.msg });
|
|
}
|
|
} else {
|
|
// Add to failed results if promise is rejected
|
|
failedResults.push({
|
|
deviceUuid: devicesUuid[results.indexOf(result)],
|
|
error: result.reason.message,
|
|
});
|
|
}
|
|
}
|
|
|
|
return { successResults, failedResults };
|
|
} catch (error) {
|
|
throw new HttpException(
|
|
error.message || 'Device Not Found',
|
|
error.status || HttpStatus.NOT_FOUND,
|
|
);
|
|
}
|
|
}
|
|
async getDeviceDetailsByDeviceId(deviceUuid: string, userUuid: string) {
|
|
try {
|
|
const userDevicePermission = await this.getUserDevicePermission(
|
|
userUuid,
|
|
deviceUuid,
|
|
);
|
|
|
|
const deviceDetails = await this.getDeviceByDeviceUuid(deviceUuid);
|
|
|
|
if (!deviceDetails) {
|
|
throw new NotFoundException('Device Not Found');
|
|
}
|
|
|
|
const response = await this.getDeviceDetailsByDeviceIdTuya(
|
|
deviceDetails.deviceTuyaUuid,
|
|
);
|
|
const macAddress = await this.getMacAddressByDeviceIdTuya(
|
|
deviceDetails.deviceTuyaUuid,
|
|
);
|
|
|
|
return {
|
|
...response,
|
|
uuid: deviceDetails.uuid,
|
|
productUuid: deviceDetails.productDevice.uuid,
|
|
productType: deviceDetails.productDevice.prodType,
|
|
permissionType: userDevicePermission,
|
|
macAddress: macAddress.mac,
|
|
subspace: deviceDetails.subspace ? deviceDetails.subspace : {},
|
|
};
|
|
} catch (error) {
|
|
throw new HttpException(
|
|
error.message || 'Device Not Found',
|
|
HttpStatus.NOT_FOUND,
|
|
);
|
|
}
|
|
}
|
|
async updateDevice(deviceUuid: string, updateDeviceDto: UpdateDeviceDto) {
|
|
try {
|
|
const device = await this.getDeviceByDeviceUuid(deviceUuid);
|
|
if (device.deviceTuyaUuid) {
|
|
await this.updateDeviceNameTuya(
|
|
device.deviceTuyaUuid,
|
|
updateDeviceDto.deviceName,
|
|
);
|
|
}
|
|
|
|
return {
|
|
uuid: device.uuid,
|
|
deviceName: updateDeviceDto.deviceName,
|
|
};
|
|
} catch (error) {
|
|
throw new HttpException(
|
|
'Error updating device',
|
|
HttpStatus.INTERNAL_SERVER_ERROR,
|
|
);
|
|
}
|
|
}
|
|
async getDeviceDetailsByDeviceIdTuya(
|
|
deviceId: string,
|
|
): Promise<GetDeviceDetailsInterface> {
|
|
try {
|
|
const path = `/v1.1/iot-03/devices/${deviceId}`;
|
|
const response = await this.tuya.request({
|
|
method: 'GET',
|
|
path,
|
|
});
|
|
|
|
// Convert keys to camel case
|
|
const camelCaseResponse = convertKeysToCamelCase(response);
|
|
const product = await this.productRepository.findOne({
|
|
where: {
|
|
prodId: camelCaseResponse.result.productId,
|
|
},
|
|
});
|
|
|
|
// eslint-disable-next-line @typescript-eslint/no-unused-vars
|
|
const { productId, id, ...rest } = camelCaseResponse.result;
|
|
|
|
return {
|
|
...rest,
|
|
productUuid: product.uuid,
|
|
} as GetDeviceDetailsInterface;
|
|
} catch (error) {
|
|
throw new HttpException(
|
|
'Error fetching device details from Tuya',
|
|
HttpStatus.INTERNAL_SERVER_ERROR,
|
|
);
|
|
}
|
|
}
|
|
async getMacAddressByDeviceIdTuya(
|
|
deviceId: string,
|
|
): Promise<GetMacAddressInterface> {
|
|
try {
|
|
const path = `/v1.0/devices/factory-infos?device_ids=${deviceId}`;
|
|
const response = await this.tuya.request({
|
|
method: 'GET',
|
|
path,
|
|
});
|
|
|
|
return response.result[0];
|
|
} catch (error) {
|
|
throw new HttpException(
|
|
'Error fetching mac address device from Tuya',
|
|
HttpStatus.INTERNAL_SERVER_ERROR,
|
|
);
|
|
}
|
|
}
|
|
async getDeviceInstructionByDeviceId(
|
|
deviceUuid: string,
|
|
): Promise<DeviceInstructionResponse> {
|
|
const deviceDetails = await this.getDeviceByDeviceUuid(deviceUuid);
|
|
|
|
if (!deviceDetails) {
|
|
throw new NotFoundException('Device Not Found');
|
|
}
|
|
try {
|
|
const response = await this.getDeviceInstructionByDeviceIdTuya(
|
|
deviceDetails.deviceTuyaUuid,
|
|
);
|
|
|
|
return {
|
|
productUuid: deviceDetails.productDevice.uuid,
|
|
productType: deviceDetails.productDevice.prodType,
|
|
functions: response.result.functions.map((fun: any) => {
|
|
return {
|
|
code: fun.code,
|
|
values: fun.values,
|
|
dataType: fun.type,
|
|
};
|
|
}),
|
|
};
|
|
} catch (error) {
|
|
throw new HttpException('Device Not Found', HttpStatus.NOT_FOUND);
|
|
}
|
|
}
|
|
|
|
async getDeviceInstructionByDeviceIdTuya(
|
|
deviceId: string,
|
|
): Promise<GetDeviceDetailsFunctionsInterface> {
|
|
try {
|
|
const path = `/v1.0/iot-03/devices/${deviceId}/functions`;
|
|
const response = await this.tuya.request({
|
|
method: 'GET',
|
|
path,
|
|
});
|
|
return response as GetDeviceDetailsFunctionsInterface;
|
|
} catch (error) {
|
|
throw new HttpException(
|
|
'Error fetching device functions from Tuya',
|
|
HttpStatus.INTERNAL_SERVER_ERROR,
|
|
);
|
|
}
|
|
}
|
|
async getDevicesInstructionStatus(deviceUuid: string) {
|
|
try {
|
|
const deviceDetails = await this.getDeviceByDeviceUuid(deviceUuid);
|
|
|
|
if (!deviceDetails) {
|
|
throw new NotFoundException('Device Not Found');
|
|
}
|
|
const deviceStatus = await this.getDevicesInstructionStatusTuya(
|
|
deviceDetails.deviceTuyaUuid,
|
|
);
|
|
|
|
return {
|
|
productUuid: deviceDetails.productDevice.uuid,
|
|
productType: deviceDetails.productDevice.prodType,
|
|
status: deviceStatus.result[0].status,
|
|
};
|
|
} catch (error) {
|
|
throw new HttpException(
|
|
'Error fetching device functions status',
|
|
HttpStatus.INTERNAL_SERVER_ERROR,
|
|
);
|
|
}
|
|
}
|
|
|
|
async getDevicesInstructionStatusTuya(
|
|
deviceUuid: string,
|
|
): Promise<GetDeviceDetailsFunctionsStatusInterface> {
|
|
try {
|
|
const path = `/v1.0/iot-03/devices/status`;
|
|
const response = await this.tuya.request({
|
|
method: 'GET',
|
|
path,
|
|
query: {
|
|
device_ids: deviceUuid,
|
|
},
|
|
});
|
|
return response as GetDeviceDetailsFunctionsStatusInterface;
|
|
} catch (error) {
|
|
throw new HttpException(
|
|
'Error fetching device functions status from Tuya',
|
|
HttpStatus.INTERNAL_SERVER_ERROR,
|
|
);
|
|
}
|
|
}
|
|
private async getUserDevicePermission(userUuid: string, deviceUuid: string) {
|
|
const device = await this.deviceRepository.findOne({
|
|
where: {
|
|
uuid: deviceUuid,
|
|
permission: {
|
|
userUuid: userUuid,
|
|
},
|
|
},
|
|
relations: ['permission', 'permission.permissionType'],
|
|
});
|
|
return device.permission[0].permissionType.type;
|
|
}
|
|
async getDevicesInGateway(gatewayUuid: string) {
|
|
try {
|
|
const deviceDetails = await this.getDeviceByDeviceUuid(gatewayUuid);
|
|
|
|
if (!deviceDetails) {
|
|
throw new NotFoundException('Device Not Found');
|
|
} else if (deviceDetails.productDevice.prodType !== ProductType.GW) {
|
|
throw new BadRequestException('This is not a gateway device');
|
|
}
|
|
|
|
const response = await this.getDevicesInGatewayTuya(
|
|
deviceDetails.deviceTuyaUuid,
|
|
);
|
|
|
|
const devices = await Promise.all(
|
|
response.map(async (device: any) => {
|
|
try {
|
|
const deviceDetails = await this.getDeviceByDeviceTuyaUuid(
|
|
device.id,
|
|
);
|
|
if (deviceDetails.deviceTuyaUuid) {
|
|
// eslint-disable-next-line @typescript-eslint/no-unused-vars
|
|
const { id, ...rest } = device;
|
|
return {
|
|
...rest,
|
|
tuyaUuid: deviceDetails.deviceTuyaUuid,
|
|
uuid: deviceDetails.uuid,
|
|
productUuid: deviceDetails.productDevice.uuid,
|
|
productType: deviceDetails.productDevice.prodType,
|
|
};
|
|
}
|
|
return null;
|
|
} catch (error) {
|
|
return null;
|
|
}
|
|
}),
|
|
);
|
|
|
|
return {
|
|
uuid: deviceDetails.uuid,
|
|
productUuid: deviceDetails.productDevice.uuid,
|
|
productType: deviceDetails.productDevice.prodType,
|
|
devices: devices.filter((device) => device !== null),
|
|
};
|
|
} catch (error) {
|
|
throw new HttpException('Device Not Found', HttpStatus.NOT_FOUND);
|
|
}
|
|
}
|
|
|
|
async getDevicesInGatewayTuya(
|
|
deviceId: string,
|
|
): Promise<GetDeviceDetailsInterface[]> {
|
|
try {
|
|
const path = `/v1.0/devices/${deviceId}/sub-devices`;
|
|
const response: any = await this.tuya.request({
|
|
method: 'GET',
|
|
path,
|
|
});
|
|
const camelCaseResponse = response.result.map((device: any) => {
|
|
// eslint-disable-next-line @typescript-eslint/no-unused-vars
|
|
const { product_id, category, ...rest } = device;
|
|
const camelCaseDevice = convertKeysToCamelCase({ ...rest });
|
|
return camelCaseDevice as GetDeviceDetailsInterface[];
|
|
});
|
|
|
|
return camelCaseResponse;
|
|
} catch (error) {
|
|
throw new HttpException(
|
|
'Error fetching device details from Tuya',
|
|
HttpStatus.INTERNAL_SERVER_ERROR,
|
|
);
|
|
}
|
|
}
|
|
async updateDeviceFirmware(deviceUuid: string, firmwareVersion: number) {
|
|
try {
|
|
const deviceDetails = await this.getDeviceByDeviceUuid(deviceUuid, false);
|
|
|
|
if (!deviceDetails || !deviceDetails.deviceTuyaUuid) {
|
|
throw new NotFoundException('Device Not Found');
|
|
}
|
|
const response = await this.updateDeviceFirmwareTuya(
|
|
deviceDetails.deviceTuyaUuid,
|
|
firmwareVersion,
|
|
);
|
|
|
|
if (response.success) {
|
|
return response;
|
|
} else {
|
|
throw new HttpException(
|
|
response.msg || 'Unknown error',
|
|
HttpStatus.BAD_REQUEST,
|
|
);
|
|
}
|
|
} catch (error) {
|
|
throw new HttpException('Device Not Found', HttpStatus.NOT_FOUND);
|
|
}
|
|
}
|
|
async updateDeviceFirmwareTuya(
|
|
deviceUuid: string,
|
|
firmwareVersion: number,
|
|
): Promise<updateDeviceFirmwareInterface> {
|
|
try {
|
|
const path = `/v2.0/cloud/thing/${deviceUuid}/firmware/${firmwareVersion}`;
|
|
const response = await this.tuya.request({
|
|
method: 'POST',
|
|
path,
|
|
});
|
|
|
|
return response as updateDeviceFirmwareInterface;
|
|
} catch (error) {
|
|
throw new HttpException(
|
|
'Error updating device firmware from Tuya',
|
|
HttpStatus.INTERNAL_SERVER_ERROR,
|
|
);
|
|
}
|
|
}
|
|
async getDevicesBySpaceUuid(SpaceUuid: string) {
|
|
try {
|
|
const spaces = await this.spaceRepository.find({
|
|
where: {
|
|
parent: {
|
|
uuid: SpaceUuid,
|
|
},
|
|
devices: {
|
|
isActive: true,
|
|
},
|
|
},
|
|
relations: ['devices', 'devices.productDevice'],
|
|
});
|
|
|
|
const devices = spaces.flatMap((space) => {
|
|
return space.devices.map((device) => device);
|
|
});
|
|
|
|
const devicesData = await Promise.all(
|
|
devices.map(async (device) => {
|
|
return {
|
|
haveRoom: true,
|
|
productUuid: device.productDevice.uuid,
|
|
productType: device.productDevice.prodType,
|
|
permissionType: PermissionType.CONTROLLABLE,
|
|
...(await this.getDeviceDetailsByDeviceIdTuya(
|
|
device.deviceTuyaUuid,
|
|
)),
|
|
uuid: device.uuid,
|
|
} as GetDeviceDetailsInterface;
|
|
}),
|
|
);
|
|
|
|
return devicesData;
|
|
} catch (error) {
|
|
throw new HttpException(
|
|
'This space does not have any devices',
|
|
HttpStatus.NOT_FOUND,
|
|
);
|
|
}
|
|
}
|
|
async getAllDevices(): Promise<GetDeviceDetailsInterface[]> {
|
|
try {
|
|
const devices = await this.deviceRepository.find({
|
|
where: { isActive: true },
|
|
relations: [
|
|
'spaceDevice.parent',
|
|
'spaceDevice.community',
|
|
'productDevice',
|
|
'permission',
|
|
'permission.permissionType',
|
|
],
|
|
});
|
|
|
|
const devicesData = await Promise.allSettled(
|
|
devices.map(async (device) => {
|
|
let battery = null;
|
|
|
|
// Check if the device is a door lock (DL)
|
|
if (device.productDevice.prodType === ProductType.DL) {
|
|
const doorLockInstructionsStatus =
|
|
await this.getDevicesInstructionStatus(device.uuid);
|
|
|
|
const batteryStatus: any = doorLockInstructionsStatus.status.find(
|
|
(status: any) =>
|
|
status.code === BatteryStatus.RESIDUAL_ELECTRICITY,
|
|
);
|
|
|
|
if (batteryStatus) {
|
|
battery = batteryStatus.value;
|
|
}
|
|
}
|
|
// Check if the device is a door sensor (DS)
|
|
if (device.productDevice.prodType === ProductType.DS) {
|
|
const doorSensorInstructionsStatus =
|
|
await this.getDevicesInstructionStatus(device.uuid);
|
|
|
|
const batteryStatus: any = doorSensorInstructionsStatus.status.find(
|
|
(status: any) => status.code === BatteryStatus.BATTERY_PERCENTAGE,
|
|
);
|
|
|
|
if (batteryStatus) {
|
|
battery = batteryStatus.value;
|
|
}
|
|
}
|
|
// Check if the device is a water leak sensor (WL)
|
|
if (device.productDevice.prodType === ProductType.WL) {
|
|
const doorSensorInstructionsStatus =
|
|
await this.getDevicesInstructionStatus(device.uuid);
|
|
|
|
const batteryStatus: any = doorSensorInstructionsStatus.status.find(
|
|
(status: any) => status.code === BatteryStatus.BATTERY_PERCENTAGE,
|
|
);
|
|
|
|
if (batteryStatus) {
|
|
battery = batteryStatus.value;
|
|
}
|
|
}
|
|
|
|
const spaceHierarchy = await this.getFullSpaceHierarchy(
|
|
device?.spaceDevice,
|
|
);
|
|
const orderedHierarchy = spaceHierarchy.reverse();
|
|
|
|
return {
|
|
spaces: orderedHierarchy.map((space) => ({
|
|
uuid: space.uuid,
|
|
spaceName: space.spaceName,
|
|
})),
|
|
productUuid: device.productDevice.uuid,
|
|
productType: device.productDevice.prodType,
|
|
community: {
|
|
uuid: device.spaceDevice.community.uuid,
|
|
name: device.spaceDevice.community.name,
|
|
},
|
|
// permissionType: device.permission[0].permissionType.type,
|
|
...(await this.getDeviceDetailsByDeviceIdTuya(
|
|
device.deviceTuyaUuid,
|
|
)),
|
|
uuid: device.uuid,
|
|
...(battery && { battery }),
|
|
} as GetDeviceDetailsInterface;
|
|
}),
|
|
);
|
|
|
|
// Filter out rejected promises and extract the fulfilled values
|
|
const fulfilledDevices = devicesData
|
|
.filter((result) => result.status === DeviceStatuses.FULLFILLED)
|
|
.map(
|
|
(result) =>
|
|
(result as PromiseFulfilledResult<GetDeviceDetailsInterface>).value,
|
|
);
|
|
|
|
return fulfilledDevices;
|
|
} catch (error) {
|
|
throw new HttpException(
|
|
error.message || 'Internal server error',
|
|
HttpStatus.INTERNAL_SERVER_ERROR,
|
|
);
|
|
}
|
|
}
|
|
|
|
async getDeviceLogs(deviceUuid: string, query: GetDeviceLogsDto) {
|
|
try {
|
|
const deviceDetails = await this.getDeviceByDeviceUuid(deviceUuid);
|
|
|
|
if (!deviceDetails) {
|
|
throw new NotFoundException('Device Not Found');
|
|
}
|
|
|
|
const response = await this.getDeviceLogsTuya(
|
|
deviceDetails.deviceTuyaUuid,
|
|
query.code,
|
|
query.startTime,
|
|
query.endTime,
|
|
);
|
|
|
|
return {
|
|
deviceUuid,
|
|
...response,
|
|
};
|
|
} catch (error) {
|
|
throw new HttpException(
|
|
error.message || 'Device Not Found',
|
|
HttpStatus.NOT_FOUND,
|
|
);
|
|
}
|
|
}
|
|
async getDeviceLogsTuya(
|
|
deviceId: string,
|
|
code: string,
|
|
startTime: string = (Date.now() - 1 * 60 * 60 * 1000).toString(),
|
|
endTime: string = Date.now().toString(),
|
|
): Promise<getDeviceLogsInterface> {
|
|
try {
|
|
const path = `/v2.0/cloud/thing/${deviceId}/report-logs?start_time=${startTime}&end_time=${endTime}&codes=${code}&size=50`;
|
|
const response = await this.tuya.request({
|
|
method: 'GET',
|
|
path,
|
|
});
|
|
// Convert keys to camel case
|
|
const camelCaseResponse = convertKeysToCamelCase(response);
|
|
const logs = camelCaseResponse.result.logs ?? [];
|
|
return {
|
|
startTime,
|
|
endTime,
|
|
data: logs,
|
|
} as getDeviceLogsInterface;
|
|
} catch (error) {
|
|
throw new HttpException(
|
|
'Error fetching device logs from Tuya',
|
|
HttpStatus.INTERNAL_SERVER_ERROR,
|
|
);
|
|
}
|
|
}
|
|
|
|
async getFullSpaceHierarchy(
|
|
space: SpaceEntity,
|
|
): Promise<{ uuid: string; spaceName: string }[]> {
|
|
try {
|
|
// Fetch only the relevant spaces, starting with the target space
|
|
const targetSpace = await this.spaceRepository.findOne({
|
|
where: { uuid: space.uuid },
|
|
relations: ['parent', 'children'],
|
|
});
|
|
|
|
// Fetch only the ancestors of the target space
|
|
const ancestors = await this.fetchAncestors(targetSpace);
|
|
|
|
// Optionally, fetch descendants if required
|
|
const descendants = await this.fetchDescendants(targetSpace);
|
|
|
|
const fullHierarchy = [...ancestors, targetSpace, ...descendants].map(
|
|
(space) => ({
|
|
uuid: space.uuid,
|
|
spaceName: space.spaceName,
|
|
}),
|
|
);
|
|
|
|
return fullHierarchy;
|
|
} catch (error) {
|
|
console.error('Error fetching space hierarchy:', error.message);
|
|
throw new HttpException(
|
|
'Error fetching space hierarchy',
|
|
HttpStatus.INTERNAL_SERVER_ERROR,
|
|
);
|
|
}
|
|
}
|
|
|
|
async getPowerClampInstructionStatus(powerClampUuid: string) {
|
|
try {
|
|
const deviceDetails = await this.getDeviceByDeviceUuid(powerClampUuid);
|
|
if (!deviceDetails) {
|
|
throw new NotFoundException('Device Not Found');
|
|
} else if (deviceDetails.productDevice.prodType !== ProductType.PC) {
|
|
throw new BadRequestException('This is not a power clamp device');
|
|
}
|
|
const deviceStatus = await this.getPowerClampInstructionStatusTuya(
|
|
deviceDetails.deviceTuyaUuid,
|
|
);
|
|
const statusList = deviceStatus.result.properties as {
|
|
code: string;
|
|
value: any;
|
|
}[];
|
|
|
|
const groupedStatus = statusList.reduce(
|
|
(acc, currentStatus) => {
|
|
const { code } = currentStatus;
|
|
|
|
if (code.endsWith('A')) {
|
|
acc.phaseA.push(currentStatus);
|
|
} else if (code.endsWith('B')) {
|
|
acc.phaseB.push(currentStatus);
|
|
} else if (code.endsWith('C')) {
|
|
acc.phaseC.push(currentStatus);
|
|
} else {
|
|
acc.general.push(currentStatus);
|
|
}
|
|
return acc;
|
|
},
|
|
{
|
|
phaseA: [] as { code: string; value: any }[],
|
|
phaseB: [] as { code: string; value: any }[],
|
|
phaseC: [] as { code: string; value: any }[],
|
|
general: [] as { code: string; value: any }[],
|
|
},
|
|
);
|
|
|
|
return {
|
|
productUuid: deviceDetails.productDevice.uuid,
|
|
productType: deviceDetails.productDevice.prodType,
|
|
status: {
|
|
phaseA: groupedStatus.phaseA,
|
|
phaseB: groupedStatus.phaseB,
|
|
phaseC: groupedStatus.phaseC,
|
|
general: groupedStatus.general,
|
|
},
|
|
};
|
|
} catch (error) {
|
|
throw new HttpException(
|
|
error.message || 'Error fetching power clamp functions status',
|
|
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
|
|
);
|
|
}
|
|
}
|
|
async getPowerClampInstructionStatusTuya(
|
|
deviceUuid: string,
|
|
): Promise<GetPowerClampFunctionsStatusInterface> {
|
|
try {
|
|
const path = `/v2.0/cloud/thing/${deviceUuid}/shadow/properties`;
|
|
const response = await this.tuya.request({
|
|
method: 'GET',
|
|
path,
|
|
query: {
|
|
device_ids: deviceUuid,
|
|
},
|
|
});
|
|
const camelCaseResponse = convertKeysToCamelCase(response);
|
|
return camelCaseResponse as GetPowerClampFunctionsStatusInterface;
|
|
} catch (error) {
|
|
throw new HttpException(
|
|
'Error fetching power clamp functions status from Tuya',
|
|
HttpStatus.INTERNAL_SERVER_ERROR,
|
|
);
|
|
}
|
|
}
|
|
|
|
private async fetchAncestors(space: SpaceEntity): Promise<SpaceEntity[]> {
|
|
const ancestors: SpaceEntity[] = [];
|
|
|
|
let currentSpace = space;
|
|
while (currentSpace && currentSpace.parent) {
|
|
// Fetch the parent space
|
|
const parent = await this.spaceRepository.findOne({
|
|
where: { uuid: currentSpace.parent.uuid },
|
|
relations: ['parent'], // To continue fetching upwards
|
|
});
|
|
|
|
if (parent) {
|
|
ancestors.push(parent);
|
|
currentSpace = parent;
|
|
} else {
|
|
currentSpace = null;
|
|
}
|
|
}
|
|
|
|
// Return the ancestors in reverse order to have the root at the start
|
|
return ancestors.reverse();
|
|
}
|
|
|
|
private async fetchDescendants(space: SpaceEntity): Promise<SpaceEntity[]> {
|
|
const descendants: SpaceEntity[] = [];
|
|
|
|
// Fetch the immediate children of the current space
|
|
const children = await this.spaceRepository.find({
|
|
where: { parent: { uuid: space.uuid } },
|
|
relations: ['children'], // To continue fetching downwards
|
|
});
|
|
|
|
for (const child of children) {
|
|
// Add the child to the descendants list
|
|
descendants.push(child);
|
|
|
|
// Recursively fetch the child's descendants
|
|
const childDescendants = await this.fetchDescendants(child);
|
|
descendants.push(...childDescendants);
|
|
}
|
|
|
|
return descendants;
|
|
}
|
|
|
|
async addSceneToSceneDevice(
|
|
deviceUuid: string,
|
|
addSceneToFourSceneDeviceDto: AddSceneToFourSceneDeviceDto,
|
|
) {
|
|
try {
|
|
const { spaceUuid, sceneUuid, switchName } = addSceneToFourSceneDeviceDto;
|
|
|
|
if (!spaceUuid || !sceneUuid || !switchName) {
|
|
throw new BadRequestException('Missing required fields in DTO');
|
|
}
|
|
|
|
const [sceneData, spaceData, deviceData] = await Promise.all([
|
|
this.sceneService.findScene(sceneUuid),
|
|
this.sceneService.getSpaceByUuid(spaceUuid),
|
|
this.getDeviceByDeviceUuid(deviceUuid),
|
|
]);
|
|
|
|
const shortUuid = deviceUuid.slice(0, 6); // First 6 characters of the UUID
|
|
const timestamp = Math.floor(Date.now() / 1000); // Current timestamp in seconds
|
|
const automationName = `Auto_${shortUuid}_${timestamp}`;
|
|
|
|
const addAutomationData: AddAutomationDto = {
|
|
spaceUuid: spaceData.spaceTuyaUuid,
|
|
automationName,
|
|
decisionExpr: AUTOMATION_CONFIG.DECISION_EXPR,
|
|
effectiveTime: {
|
|
start: AUTOMATION_CONFIG.DEFAULT_START_TIME,
|
|
end: AUTOMATION_CONFIG.DEFAULT_END_TIME,
|
|
loops: AUTOMATION_CONFIG.DEFAULT_LOOPS,
|
|
},
|
|
conditions: [
|
|
{
|
|
code: 1,
|
|
entityId: deviceData.deviceTuyaUuid,
|
|
entityType: AUTOMATION_CONFIG.CONDITION_TYPE,
|
|
expr: {
|
|
comparator: AUTOMATION_CONFIG.COMPARATOR,
|
|
statusCode: switchName,
|
|
statusValue: AUTOMATION_CONFIG.SCENE_STATUS_VALUE,
|
|
},
|
|
},
|
|
],
|
|
actions: [
|
|
{
|
|
actionExecutor: AUTOMATION_CONFIG.ACTION_EXECUTOR,
|
|
entityId: sceneData.sceneTuyaUuid,
|
|
},
|
|
],
|
|
};
|
|
|
|
const automation = await this.tuyaService.createAutomation(
|
|
addAutomationData.spaceUuid,
|
|
addAutomationData.automationName,
|
|
addAutomationData.effectiveTime,
|
|
addAutomationData.decisionExpr,
|
|
addAutomationData.conditions,
|
|
addAutomationData.actions,
|
|
);
|
|
|
|
if (automation.success) {
|
|
const existingSceneDevice = await this.sceneDeviceRepository.findOne({
|
|
where: {
|
|
device: { uuid: deviceUuid },
|
|
switchName: switchName,
|
|
},
|
|
relations: ['scene', 'device'],
|
|
});
|
|
|
|
if (existingSceneDevice) {
|
|
await this.tuyaService.deleteAutomation(
|
|
spaceData.spaceTuyaUuid,
|
|
existingSceneDevice.automationTuyaUuid,
|
|
);
|
|
|
|
existingSceneDevice.automationTuyaUuid = automation.result.id;
|
|
existingSceneDevice.scene = sceneData;
|
|
existingSceneDevice.device = deviceData;
|
|
existingSceneDevice.switchName = switchName;
|
|
|
|
return await this.sceneDeviceRepository.save(existingSceneDevice);
|
|
} else {
|
|
const sceneDevice = await this.sceneDeviceRepository.save({
|
|
scene: sceneData,
|
|
device: deviceData,
|
|
automationTuyaUuid: automation.result.id,
|
|
switchName: switchName,
|
|
});
|
|
return sceneDevice;
|
|
}
|
|
}
|
|
} catch (err) {
|
|
const errorMessage = err.message || 'Error creating automation';
|
|
const errorStatus = err.status || HttpStatus.INTERNAL_SERVER_ERROR;
|
|
throw new HttpException(errorMessage, errorStatus);
|
|
}
|
|
}
|
|
|
|
async getScenesBySceneDevice(
|
|
deviceUuid: string,
|
|
getSceneFourSceneDeviceDto: GetSceneFourSceneDeviceDto,
|
|
): Promise<any> {
|
|
try {
|
|
if (getSceneFourSceneDeviceDto.switchName) {
|
|
// Query for a single record directly when switchName is provided
|
|
const sceneDevice = await this.sceneDeviceRepository.findOne({
|
|
where: {
|
|
device: { uuid: deviceUuid },
|
|
switchName:
|
|
getSceneFourSceneDeviceDto.switchName as SceneSwitchesTypeEnum,
|
|
},
|
|
relations: ['device', 'scene'],
|
|
});
|
|
|
|
if (!sceneDevice) {
|
|
throw new HttpException(
|
|
`No scene found for device with UUID ${deviceUuid} and switch name ${getSceneFourSceneDeviceDto.switchName}`,
|
|
HttpStatus.NOT_FOUND,
|
|
);
|
|
}
|
|
|
|
const sceneDetails = await this.sceneService.getSceneByUuid(
|
|
sceneDevice.scene.uuid,
|
|
);
|
|
|
|
return {
|
|
switchName: sceneDevice.switchName,
|
|
createdAt: sceneDevice.createdAt,
|
|
updatedAt: sceneDevice.updatedAt,
|
|
deviceUuid: sceneDevice.device.uuid,
|
|
scene: sceneDetails.data,
|
|
};
|
|
}
|
|
|
|
// Query for multiple records if switchName is not provided
|
|
const sceneDevices = await this.sceneDeviceRepository.find({
|
|
where: { device: { uuid: deviceUuid } },
|
|
relations: ['device', 'scene'],
|
|
});
|
|
|
|
if (!sceneDevices.length) {
|
|
throw new HttpException(
|
|
`No scenes found for device with UUID ${deviceUuid}`,
|
|
HttpStatus.NOT_FOUND,
|
|
);
|
|
}
|
|
|
|
const results = await Promise.all(
|
|
sceneDevices.map(async (sceneDevice) => {
|
|
const sceneDetails = await this.sceneService.getSceneByUuid(
|
|
sceneDevice.scene.uuid,
|
|
);
|
|
|
|
return {
|
|
switchName: sceneDevice.switchName,
|
|
createdAt: sceneDevice.createdAt,
|
|
updatedAt: sceneDevice.updatedAt,
|
|
deviceUuid: sceneDevice.device.uuid,
|
|
scene: sceneDetails.data,
|
|
};
|
|
}),
|
|
);
|
|
|
|
return results;
|
|
} catch (error) {
|
|
throw new HttpException(
|
|
error.message || 'Failed to fetch scenes for device',
|
|
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
|
|
);
|
|
}
|
|
}
|
|
}
|