ammar/backend
1
0
Fork 0
mirror of https://github.com/SyncrowIOT/backend.git synced 2025-11-26 17:54:54 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #139 from SyncrowIOT/feature/space-management

Browse Source 
Feature/space management
This commit is contained in:
faris Aljohari
2024-11-05 03:15:31 -06:00
committed by GitHub
parent f8057db8fa a39c28eeda
commit 1235f4cfa2
24 changed files with 595 additions and 208 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
libs/common/src/integrations/tuya/interfaces/automation.interface.ts Normal file
View File

@ -0,0 +1,9 @@
import { TuyaResponseInterface } from './tuya.response.interface';
export interface AddTuyaResponseInterface extends TuyaResponseInterface {
result: {
id: string;
};
t?: number;
tid?: string;
}

1
libs/common/src/integrations/tuya/interfaces/index.ts
View File

@ -1,2 +1,3 @@
export * from './tuya.response.interface';
export * from './tap-to-run-action.interface';
export * from './automation.interface';

2
libs/common/src/integrations/tuya/interfaces/tuya.response.interface.ts
View File

@ -1,5 +1,5 @@
export interface TuyaResponseInterface {
success: boolean;
msg?: string;
result: boolean;
result: boolean | { id: string };
}

76
libs/common/src/integrations/tuya/services/tuya.service.ts
View File

@ -1,7 +1,11 @@
import { HttpException, HttpStatus, Injectable } from '@nestjs/common';
import { ConfigService } from '@nestjs/config';
import { TuyaContext } from '@tuya/tuya-connector-nodejs';
import { ConvertedAction, TuyaResponseInterface } from '../interfaces';
import {
AddTuyaResponseInterface,
ConvertedAction,
TuyaResponseInterface,
} from '../interfaces';
@Injectable()
export class TuyaService {
@ -144,32 +148,72 @@ export class TuyaService {
) {
const path = `/v2.0/cloud/scene/rule`;
const response: AddTuyaResponseInterface = await this.tuya.request({
method: 'POST',
path,
body: {
space_id: spaceId,
name: automationName,
effective_time: {
...effectiveTime,
timezone_id: 'Asia/Dubai',
},
type: 'automation',
decision_expr: decisionExpr,
conditions: conditions,
actions: actions,
},
});
if (!response.success) {
throw new HttpException(response.msg, HttpStatus.BAD_REQUEST);
}
return response;
}
async deleteAutomation(spaceId: string, automationUuid: string) {
const path = `/v2.0/cloud/scene/rule?ids=${automationUuid}&space_id=${spaceId}`;
const response = await this.tuya.request({
method: 'DELETE',
path,
});
if (!response.success) {
throw new HttpException(
'Failed to delete automation',
HttpStatus.NOT_FOUND,
);
}
return response;
}
async updateAutomationState(
spaceId: string,
automationUuid: string,
isEnable: boolean,
) {
const path = `/v2.0/cloud/scene/rule/state?space_id=${spaceId}`;
try {
const response = await this.tuya.request({
method: 'POST',
const response: TuyaResponseInterface = await this.tuya.request({
method: 'PUT',
path,
body: {
space_id: spaceId,
name: automationName,
effective_time: {
...effectiveTime,
timezone_id: 'Asia/Dubai',
},
type: 'automation',
decision_expr: decisionExpr,
conditions: conditions,
actions: actions,
ids: automationUuid,
is_enable: isEnable,
},
});
if (!response.success) {
throw new HttpException(response.msg, HttpStatus.BAD_REQUEST);
throw new HttpException('Automation not found', HttpStatus.NOT_FOUND);
}
return response.result;
return response;
} catch (error) {
throw new HttpException(
error.message || 'Failed to create automation in Tuya',
error.message || 'Failed to update automation state',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}

16
src/automation/controllers/automation.controller.ts
View File

@ -18,11 +18,7 @@ import {
} from '../dtos/automation.dto';
import { JwtAuthGuard } from '@app/common/guards/jwt.auth.guard';
import { EnableDisableStatusEnum } from '@app/common/constants/days.enum';
import {
AutomationParamDto,
DeleteAutomationParamDto,
SpaceParamDto,
} from '../dtos';
import { AutomationParamDto, SpaceParamDto } from '../dtos';
@ApiTags('Automation Module')
@Controller({
@ -45,6 +41,7 @@ export class AutomationController {
data: automation,
};
}
@ApiBearerAuth()
@UseGuards(JwtAuthGuard)
@Get(':spaceUuid')
@ -67,17 +64,18 @@ export class AutomationController {
@ApiBearerAuth()
@UseGuards(JwtAuthGuard)
@Delete(':unitUuid/:automationId')
async deleteAutomation(@Param() param: DeleteAutomationParamDto) {
@Delete(':automationUuid')
async deleteAutomation(@Param() param: AutomationParamDto) {
await this.automationService.deleteAutomation(param);
return {
statusCode: HttpStatus.OK,
message: 'Automation Deleted Successfully',
};
}
@ApiBearerAuth()
@UseGuards(JwtAuthGuard)
@Put(':automationId')
@Put(':automationUuid')
async updateAutomation(
@Body() updateAutomationDto: UpdateAutomationDto,
@Param() param: AutomationParamDto,
@ -96,7 +94,7 @@ export class AutomationController {
@ApiBearerAuth()
@UseGuards(JwtAuthGuard)
@Put('status/:automationId')
@Put('status/:automationUuid')
async updateAutomationStatus(
@Body() updateAutomationStatusDto: UpdateAutomationStatusDto,
@Param() param: AutomationParamDto,

2
src/automation/dtos/automation.dto.ts
View File

@ -10,7 +10,7 @@ import {
} from 'class-validator';
import { Type } from 'class-transformer';
class EffectiveTime {
export class EffectiveTime {
@ApiProperty({ description: 'Start time', required: true })
@IsString()
@IsNotEmpty()

9
src/automation/dtos/automation.param.dto.ts
View File

@ -1,11 +1,12 @@
import { ApiProperty } from '@nestjs/swagger';
import { IsUUID } from 'class-validator';
import { IsNotEmpty, IsString } from 'class-validator';
export class AutomationParamDto {
@ApiProperty({
description: 'UUID of the automation',
example: 'd290f1ee-6c54-4b01-90e6-d701748f0851',
description: 'TuyaId of the automation',
example: 'SfFi2Tbn09btes84',
})
@IsUUID()
@IsString()
@IsNotEmpty()
automationUuid: string;
}

9
src/automation/dtos/delete.automation.param.dto.ts
View File

@ -1,5 +1,5 @@
import { ApiProperty } from '@nestjs/swagger';
import { IsUUID } from 'class-validator';
import { IsNotEmpty, IsString, IsUUID } from 'class-validator';
export class DeleteAutomationParamDto {
@ApiProperty({
@ -10,9 +10,10 @@ export class DeleteAutomationParamDto {
spaceUuid: string;
@ApiProperty({
description: 'UUID of the Automation',
example: 'd290f1ee-6c54-4b01-90e6-d701748f0851',
description: 'TuyaId of the automation',
example: 'SfFi2Tbn09btes84',
})
@IsUUID()
@IsString()
@IsNotEmpty()
automationUuid: string;
}

11
src/automation/interface/automation.interface.ts
View File

@ -1,3 +1,5 @@
import { EffectiveTime } from '../dtos';
export interface AddAutomationInterface {
success: boolean;
msg?: string;
@ -48,3 +50,12 @@ export interface AutomationDetailsResult {
name: string;
type: string;
}
export interface AddAutomationParams {
actions: Action[];
conditions: Condition[];
automationName: string;
effectiveTime: EffectiveTime;
decisionExpr: string;
spaceTuyaId: string;
}

248
src/automation/services/automation.service.ts
View File

@ -7,7 +7,7 @@ import {
import { SpaceRepository } from '@app/common/modules/space/repositories';
import {
AddAutomationDto,
DeleteAutomationParamDto,
AutomationParamDto,
UpdateAutomationDto,
UpdateAutomationStatusDto,
} from '../dtos';
@ -17,11 +17,10 @@ import { convertKeysToSnakeCase } from '@app/common/helper/snakeCaseConverter';
import { DeviceService } from 'src/device/services';
import {
Action,
AddAutomationInterface,
AddAutomationParams,
AutomationDetailsResult,
AutomationResponseData,
Condition,
DeleteAutomationInterface,
GetAutomationBySpaceInterface,
} from '../interface/automation.interface';
import { convertKeysToCamelCase } from '@app/common/helper/camelCaseConverter';
@ -30,6 +29,7 @@ import {
EntityTypeEnum,
} from '@app/common/constants/automation.enum';
import { TuyaService } from '@app/common/integrations/tuya/services/tuya.service';
import { ConvertedAction } from '@app/common/integrations/tuya/interfaces';
@Injectable()
export class AutomationService {
@ -50,39 +50,26 @@ export class AutomationService {
});
}
async addAutomation(addAutomationDto: AddAutomationDto, spaceTuyaId = null) {
async addAutomation(addAutomationDto: AddAutomationDto) {
try {
const { automationName, effectiveTime, decisionExpr } = addAutomationDto;
const space = await this.getSpaceByUuid(addAutomationDto.spaceUuid);
const actions = await this.processEntities<Action>(
addAutomationDto.actions,
'actionExecutor',
{ [ActionExecutorEnum.DEVICE_ISSUE]: true },
this.deviceService,
);
const conditions = await this.processEntities<Condition>(
addAutomationDto.conditions,
'entityType',
{ [EntityTypeEnum.DEVICE_REPORT]: true },
this.deviceService,
);
const response = (await this.tuyaService.createAutomation(
space.spaceTuyaUuid,
const {
automationName,
effectiveTime,
decisionExpr,
conditions,
actions,
)) as AddAutomationInterface;
return {
id: response?.result.id,
};
conditions,
} = addAutomationDto;
const space = await this.getSpaceByUuid(addAutomationDto.spaceUuid);
const response = await this.add({
automationName,
effectiveTime,
decisionExpr,
actions,
conditions,
spaceTuyaId: space.spaceTuyaUuid,
});
return response;
} catch (err) {
console.log(err);
if (err instanceof BadRequestException) {
throw err;
} else {
@ -94,6 +81,33 @@ export class AutomationService {
}
}
async add(params: AddAutomationParams) {
try {
const formattedActions = await this.prepareActions(params.actions);
const formattedCondition = await this.prepareConditions(
params.conditions,
);
const response = await this.tuyaService.createAutomation(
params.spaceTuyaId,
params.automationName,
params.effectiveTime,
params.decisionExpr,
formattedCondition,
formattedActions,
);
return {
id: response?.result.id,
};
} catch (error) {
throw new HttpException(
error.message || 'Failed to add automation',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
}
async getSpaceByUuid(spaceUuid: string) {
try {
const space = await this.spaceRepository.findOne({
@ -120,6 +134,7 @@ export class AutomationService {
}
}
}
async getAutomationBySpace(spaceUuid: string) {
try {
const space = await this.getSpaceByUuid(spaceUuid);
@ -277,34 +292,45 @@ export class AutomationService {
}
}
async deleteAutomation(param: DeleteAutomationParamDto, spaceTuyaId = null) {
async deleteAutomation(param: AutomationParamDto) {
try {
const { automationUuid, spaceUuid } = param;
let tuyaSpaceId;
if (!spaceTuyaId) {
const space = await this.getSpaceByUuid(spaceUuid);
tuyaSpaceId = space.spaceTuyaUuid;
if (!tuyaSpaceId) {
throw new BadRequestException(`Invalid space UUID ${spaceUuid}`);
}
} else {
tuyaSpaceId = spaceTuyaId;
const { automationUuid } = param;
const automation = await this.getAutomationDetails(automationUuid, true);
if (!automation && !automation.spaceId) {
throw new HttpException(
`Invalid automationid ${automationUuid}`,
HttpStatus.BAD_REQUEST,
);
}
const path = `/v2.0/cloud/scene/rule?ids=${automationUuid}&space_id=${tuyaSpaceId}`;
const response: DeleteAutomationInterface = await this.tuya.request({
method: 'DELETE',
path,
});
if (!response.success) {
throw new HttpException('Automation not found', HttpStatus.NOT_FOUND);
}
const response = this.tuyaService.deleteAutomation(
automation.spaceId,
automationUuid,
);
return response;
} catch (err) {
if (err instanceof BadRequestException) {
throw err; // Re-throw BadRequestException
if (err instanceof HttpException) {
throw err;
} else {
throw new HttpException(
err.message || 'Automation not found',
err.status || HttpStatus.NOT_FOUND,
);
}
}
}
async delete(tuyaSpaceId: string, automationUuid: string) {
try {
const response = await this.tuyaService.deleteAutomation(
tuyaSpaceId,
automationUuid,
);
return response;
} catch (err) {
if (err instanceof HttpException) {
throw err;
} else {
throw new HttpException(
err.message || 'Automation not found',
@ -318,28 +344,28 @@ export class AutomationService {
updateAutomationDto: UpdateAutomationDto,
automationUuid: string,
) {
const { actions, conditions, automationName, effectiveTime, decisionExpr } =
updateAutomationDto;
try {
const spaceTuyaId = await this.getAutomationDetails(automationUuid, true);
if (!spaceTuyaId.spaceId) {
const automation = await this.getAutomationDetails(automationUuid, true);
if (!automation.spaceId) {
throw new HttpException(
"Automation doesn't exist",
HttpStatus.NOT_FOUND,
);
}
const addAutomation = {
...updateAutomationDto,
spaceUuid: null,
};
const newAutomation = await this.addAutomation(
addAutomation,
spaceTuyaId.spaceId,
);
const params: DeleteAutomationParamDto = {
spaceUuid: spaceTuyaId.spaceId,
automationUuid: automationUuid,
};
const newAutomation = await this.add({
actions,
conditions,
automationName,
effectiveTime,
decisionExpr,
spaceTuyaId: automation.spaceId,
});
if (newAutomation.id) {
await this.deleteAutomation(null, params);
await this.delete(automation.spaceId, automationUuid);
return newAutomation;
}
} catch (err) {
@ -357,29 +383,21 @@ export class AutomationService {
updateAutomationStatusDto: UpdateAutomationStatusDto,
automationUuid: string,
) {
const { isEnable, spaceUuid } = updateAutomationStatusDto;
try {
const space = await this.getSpaceByUuid(
updateAutomationStatusDto.spaceUuid,
);
const space = await this.getSpaceByUuid(spaceUuid);
if (!space.spaceTuyaUuid) {
throw new BadRequestException(
`Invalid space UUID ${updateAutomationStatusDto.spaceUuid}`,
throw new HttpException(
`Invalid space UUID ${spaceUuid}`,
HttpStatus.NOT_FOUND,
);
}
const path = `/v2.0/cloud/scene/rule/state?space_id=${space.spaceTuyaUuid}`;
const response: DeleteAutomationInterface = await this.tuya.request({
method: 'PUT',
path,
body: {
ids: automationUuid,
is_enable: updateAutomationStatusDto.isEnable,
},
});
if (!response.success) {
throw new HttpException('Automation not found', HttpStatus.NOT_FOUND);
}
const response = await this.tuyaService.updateAutomationState(
space.spaceTuyaUuid,
automationUuid,
isEnable,
);
return response;
} catch (err) {
@ -394,41 +412,41 @@ export class AutomationService {
}
}
async processEntities<T extends Action | Condition>(
entities: T[], // Accepts either Action[] or Condition[]
lookupKey: keyof T, // The key to look up, specific to T
entityTypeOrExecutorMap: {
[key in ActionExecutorEnum | EntityTypeEnum]?: boolean;
},
deviceService: {
getDeviceByDeviceUuid: (
id: string,
flag: boolean,
) => Promise<{ deviceTuyaUuid: string } | null>;
},
): Promise<T[]> {
// Returns the same type as provided in the input
return Promise.all(
entities.map(async (entity) => {
// Convert keys to snake case (assuming a utility function exists)
const processedEntity = convertKeysToSnakeCase(entity) as T;
private async prepareActions(actions: Action[]): Promise<ConvertedAction[]> {
const convertedData = convertKeysToSnakeCase(actions) as ConvertedAction[];
// Check if entity needs device UUID lookup
const key = processedEntity[lookupKey];
if (
entityTypeOrExecutorMap[key as ActionExecutorEnum | EntityTypeEnum]
) {
const device = await deviceService.getDeviceByDeviceUuid(
processedEntity.entityId,
await Promise.all(
convertedData.map(async (action) => {
if (action.action_executor === ActionExecutorEnum.DEVICE_ISSUE) {
const device = await this.deviceService.getDeviceByDeviceUuid(
action.entity_id,
false,
);
if (device) {
processedEntity.entityId = device.deviceTuyaUuid;
action.entity_id = device.deviceTuyaUuid;
}
}
return processedEntity;
}),
);
return convertedData;
}
private async prepareConditions(conditions: Condition[]) {
const convertedData = convertKeysToSnakeCase(conditions);
await Promise.all(
convertedData.map(async (condition) => {
if (condition.entity_type === EntityTypeEnum.DEVICE_REPORT) {
const device = await this.deviceService.getDeviceByDeviceUuid(
condition.entity_id,
false,
);
if (device) {
condition.entity_id = device.deviceTuyaUuid;
}
}
}),
);
return convertedData;
}
}

13
src/group/controllers/group.controller.ts
View File

@ -2,7 +2,6 @@ import { GroupService } from '../services/group.service';
import { Controller, Get, UseGuards, Param, Req } from '@nestjs/common';
import { ApiTags, ApiBearerAuth } from '@nestjs/swagger';
import { JwtAuthGuard } from '@app/common/guards/jwt.auth.guard';
import { UnitPermissionGuard } from 'src/guards/unit.permission.guard';
import { EnableDisableStatusEnum } from '@app/common/constants/days.enum';
@ApiTags('Group Module')
@ -17,21 +16,21 @@ export class GroupController {
@UseGuards(JwtAuthGuard)
@Get(':spaceUuid')
async getGroupsBySpaceUuid(@Param('spaceUuid') spaceUuid: string) {
return await this.groupService.getGroupsByUnitUuid(spaceUuid);
return await this.groupService.getGroupsBySpaceUuid(spaceUuid);
}
@ApiBearerAuth()
@UseGuards(JwtAuthGuard)
@Get(':unitUuid/devices/:groupName')
@Get(':spaceUuid/devices/:groupName')
async getUnitDevicesByGroupName(
@Param('unitUuid') unitUuid: string,
@Param('spaceUuid') spaceUuid: string,
@Param('groupName') groupName: string,
@Req() req: any,
) {
const userUuid = req.user.uuid;
return await this.groupService.getUnitDevicesByGroupName(
unitUuid,
return await this.groupService.getSpaceDevicesByGroupName(
spaceUuid,
groupName,
userUuid,
);

17
src/group/services/group.service.ts
View File

@ -27,11 +27,11 @@ export class GroupService {
});
}
async getGroupsByUnitUuid(unitUuid: string) {
async getGroupsBySpaceUuid(spaceUuid: string) {
try {
const spaces = await this.spaceRepository.find({
where: {
uuid: unitUuid,
uuid: spaceUuid,
},
relations: ['devices', 'devices.productDevice'],
});
@ -61,23 +61,21 @@ export class GroupService {
);
} catch (error) {
throw new HttpException(
'This unit does not have any groups',
'This space does not have any groups',
HttpStatus.NOT_FOUND,
);
}
}
async getUnitDevicesByGroupName(
unitUuid: string,
async getSpaceDevicesByGroupName(
spaceUuid: string,
groupName: string,
userUuid: string,
) {
try {
const spaces = await this.spaceRepository.find({
where: {
parent: {
uuid: unitUuid,
},
uuid: spaceUuid,
devices: {
productDevice: {
prodType: groupName,
@ -122,8 +120,9 @@ export class GroupService {
throw new HttpException('No devices found', HttpStatus.NOT_FOUND);
return devices.flat(); // Flatten the array since flatMap was used
} catch (error) {
console.log(error);
throw new HttpException(
'This unit does not have any devices for the specified group name',
'This space does not have any devices for the specified group name',
HttpStatus.NOT_FOUND,
);
}

8
src/scene/services/scene.service.ts
View File

@ -157,7 +157,7 @@ export class SceneService {
);
} else {
throw new HttpException(
'An Internal error has been occured',
`An Internal error has been occured ${err}`,
HttpStatus.INTERNAL_SERVER_ERROR,
);
}
@ -172,13 +172,13 @@ export class SceneService {
const scenesData = await this.sceneRepository.find({
where: {
spaceUuid,
...(showInHomePage !== undefined ? { showInHomePage } : {}),
...(showInHomePage ? { showInHomePage } : {}),
},
});
if (!scenesData.length) {
throw new HttpException(
`No scenes found for space UUID ${spaceUuid}`,
`No scenes found for space UUID ${spaceUuid} with showInHomePage ${showInHomePage} `,
HttpStatus.NOT_FOUND,
);
}
@ -199,7 +199,7 @@ export class SceneService {
err.message,
);
if (err instanceof BadRequestException) {
if (err instanceof HttpException) {
throw err;
} else {
throw new HttpException(

3
src/space/controllers/space.controller.ts
View File

@ -111,6 +111,7 @@ export class SpaceController {
return this.spaceService.getSpacesHierarchyForSpace(params.spaceUuid);
}
//should it be post?
@ApiBearerAuth()
@UseGuards(JwtAuthGuard)
@ApiOperation({
@ -118,7 +119,7 @@ export class SpaceController {
description:
ControllerRoute.SPACE.ACTIONS.CREATE_INVITATION_CODE_SPACE_DESCRIPTION,
})
@Post(':spaceUuid/invitation-code')
@Get(':spaceUuid/invitation-code')
async generateSpaceInvitationCode(
@Param() params: GetSpaceParam,
): Promise<BaseResponseDto> {

15
src/space/controllers/subspace/subspace-device.controller.ts
View File

@ -1,6 +1,13 @@
import { ControllerRoute } from '@app/common/constants/controller-route';
import { JwtAuthGuard } from '@app/common/guards/jwt.auth.guard';
import { Controller, Get, Param, Post, UseGuards } from '@nestjs/common';
import {
Controller,
Delete,
Get,
Param,
Post,
UseGuards,
} from '@nestjs/common';
import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
import { DeviceSubSpaceParam, GetSubSpaceParam } from '../../dtos';
import { SubspaceDeviceService } from 'src/space/services';
@ -55,10 +62,12 @@ export class SubSpaceDeviceController {
ControllerRoute.SUBSPACE_DEVICE.ACTIONS
.DISASSOCIATE_SUBSPACE_DEVICE_DESCRIPTION,
})
@Post('/:deviceUuid')
@Delete('/:deviceUuid')
async disassociateDeviceFromSubspace(
@Param() params: DeviceSubSpaceParam,
): Promise<BaseResponseDto> {
return await this.subspaceDeviceService.associateDeviceToSubspace(params);
return await this.subspaceDeviceService.disassociateDeviceFromSubspace(
params,
);
}
}

40
src/space/dtos/add.space.dto.ts
View File

@ -33,3 +33,43 @@ export class AddSpaceDto {
@IsBoolean()
isPrivate: boolean;
}
export class AddUserSpaceDto {
@ApiProperty({
description: 'spaceUuid',
required: true,
})
@IsString()
@IsNotEmpty()
public spaceUuid: string;
@ApiProperty({
description: 'userUuid',
required: true,
})
@IsString()
@IsNotEmpty()
public userUuid: string;
constructor(dto: Partial<AddUserSpaceDto>) {
Object.assign(this, dto);
}
}
export class AddUserSpaceUsingCodeDto {
@ApiProperty({
description: 'userUuid',
required: true,
})
@IsString()
@IsNotEmpty()
public userUuid: string;
@ApiProperty({
description: 'inviteCode',
required: true,
})
@IsString()
@IsNotEmpty()
public inviteCode: string;
constructor(dto: Partial<AddUserSpaceDto>) {
Object.assign(this, dto);
}
}

3
src/space/services/space-device.service.ts
View File

@ -100,7 +100,8 @@ export class SpaceDeviceService {
});
// Exclude specific keys and add `productUuid`
const { ...rest } = camelCaseResponse;
// eslint-disable-next-line @typescript-eslint/no-unused-vars
const { uuid, ...rest } = camelCaseResponse;
return {
...rest,
productUuid: product?.uuid,

11
src/space/services/space-scene.service.ts
View File

@ -1,9 +1,4 @@
import {
BadRequestException,
HttpException,
HttpStatus,
Injectable,
} from '@nestjs/common';
import { HttpException, HttpStatus, Injectable } from '@nestjs/common';
import { GetSpaceParam } from '../dtos';
import { BaseResponseDto } from '@app/common/dto/base.response.dto';
import { SpaceService } from './space.service';
@ -42,8 +37,8 @@ export class SpaceSceneService {
} catch (error) {
console.error('Error retrieving scenes:', error);
if (error instanceof BadRequestException) {
throw new HttpException(error.message, HttpStatus.BAD_REQUEST);
if (error instanceof HttpException) {
throw error;
} else {
throw new HttpException(
'An error occurred while retrieving scenes',

77
src/space/services/subspace/subspace-device.service.ts
View File

@ -57,40 +57,72 @@ export class SubspaceDeviceService {
message: 'Successfully retrieved list of devices',
});
}
async associateDeviceToSubspace(params: DeviceSubSpaceParam) {
async associateDeviceToSubspace(
params: DeviceSubSpaceParam,
): Promise<BaseResponseDto> {
const { subSpaceUuid, deviceUuid, spaceUuid, communityUuid } = params;
try {
await this.validateCommunityAndSpace(communityUuid, spaceUuid);
await this.validateCommunityAndSpace(communityUuid, spaceUuid);
const subspace = await this.findSubspace(subSpaceUuid);
const device = await this.findDevice(deviceUuid);
const subspace = await this.findSubspace(subSpaceUuid);
const device = await this.findDevice(deviceUuid);
device.subspace = subspace;
device.subspace = subspace;
await this.deviceRepository.save(device);
const newDevice = await this.deviceRepository.save(device);
return new SuccessResponseDto({
data: device,
message: 'Successfully associated device to subspace',
});
return new SuccessResponseDto({
data: newDevice,
message: 'Successfully associated device to subspace',
});
} catch (error) {
if (error instanceof HttpException) {
throw error;
} else {
throw new HttpException(
'Failed to associate device to subspace',
HttpStatus.INTERNAL_SERVER_ERROR,
);
}
}
}
async disassociateDeviceFromSubspace(params: DeviceSubSpaceParam) {
async disassociateDeviceFromSubspace(
params: DeviceSubSpaceParam,
): Promise<BaseResponseDto> {
const { subSpaceUuid, deviceUuid, spaceUuid, communityUuid } = params;
try {
await this.validateCommunityAndSpace(communityUuid, spaceUuid);
await this.validateCommunityAndSpace(communityUuid, spaceUuid);
const subspace = await this.findSubspace(subSpaceUuid);
const device = await this.findDevice(deviceUuid);
await this.findSubspace(subSpaceUuid);
const device = await this.findDevice(deviceUuid);
if (!device.subspace || device.subspace.uuid !== subspace.uuid) {
throw new HttpException(
`Device ${deviceUuid} is not associated with the specified subspace ${subSpaceUuid} `,
HttpStatus.BAD_REQUEST,
);
}
device.subspace = null;
await this.deviceRepository.save(device);
device.subspace = null;
const updatedDevice = await this.deviceRepository.save(device);
return new SuccessResponseDto({
data: device,
message: 'Successfully dissociated device from subspace',
});
return new SuccessResponseDto({
data: updatedDevice,
message: 'Successfully dissociated device from subspace',
});
} catch (error) {
if (error instanceof HttpException) {
throw error;
} else {
throw new HttpException(
'Failed to dissociate device from subspace',
HttpStatus.INTERNAL_SERVER_ERROR,
);
}
}
}
// Helper method to validate community and space
private async validateCommunityAndSpace(
communityUuid: string,
@ -137,6 +169,7 @@ export class SubspaceDeviceService {
private async findDevice(deviceUuid: string) {
const device = await this.deviceRepository.findOne({
where: { uuid: deviceUuid },
relations: ['subspace'],
});
if (!device) {
this.throwNotFound('Device', deviceUuid);
@ -173,7 +206,7 @@ export class SubspaceDeviceService {
} as GetDeviceDetailsInterface;
} catch (error) {
throw new HttpException(
'Error fetching device details from Tuya',
`Error fetching device details from Tuya for device uuid ${deviceId}.`,
HttpStatus.INTERNAL_SERVER_ERROR,
);
}

38
src/users/controllers/user-space.controller.ts
View File

@ -1,11 +1,20 @@
import { ControllerRoute } from '@app/common/constants/controller-route';
import { EnableDisableStatusEnum } from '@app/common/constants/days.enum';
import { Controller, Get, Param, UseGuards } from '@nestjs/common';
import {
Body,
Controller,
Get,
HttpException,
HttpStatus,
Param,
Post,
UseGuards,
} from '@nestjs/common';
import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
import { UserSpaceService } from '../services';
import { JwtAuthGuard } from '@app/common/guards/jwt.auth.guard';
import { BaseResponseDto } from '@app/common/dto/base.response.dto';
import { UserParamDto } from '../dtos';
import { AddUserSpaceUsingCodeDto, UserParamDto } from '../dtos';
@ApiTags('User Module')
@Controller({
@ -27,4 +36,29 @@ export class UserSpaceController {
): Promise<BaseResponseDto> {
return this.userSpaceService.getSpacesForUser(params.userUuid);
}
@ApiBearerAuth()
@UseGuards(JwtAuthGuard)
@Post('/verify-code')
async verifyCodeAndAddUserSpace(
@Body() dto: AddUserSpaceUsingCodeDto,
@Param() params: UserParamDto,
) {
try {
await this.userSpaceService.verifyCodeAndAddUserSpace(
dto,
params.userUuid,
);
return {
statusCode: HttpStatus.CREATED,
success: true,
message: 'user space added successfully',
};
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
}
}

68
src/users/dtos/add.space.dto.ts Normal file
View File

@ -0,0 +1,68 @@
import { ApiProperty } from '@nestjs/swagger';
import {
IsBoolean,
IsNotEmpty,
IsOptional,
IsString,
IsUUID,
} from 'class-validator';
export class AddSpaceDto {
@ApiProperty({
description: 'Name of the space (e.g., Floor 1, Unit 101)',
example: 'Unit 101',
})
@IsString()
@IsNotEmpty()
spaceName: string;
@ApiProperty({
description: 'UUID of the parent space (if any, for hierarchical spaces)',
example: 'f5d7e9c3-44bc-4b12-88f1-1b3cda84752e',
required: false,
})
@IsUUID()
@IsOptional()
parentUuid?: string;
@ApiProperty({
description: 'Indicates whether the space is private or public',
example: false,
default: false,
})
@IsBoolean()
isPrivate: boolean;
}
export class AddUserSpaceDto {
@ApiProperty({
description: 'spaceUuid',
required: true,
})
@IsString()
@IsNotEmpty()
public spaceUuid: string;
@ApiProperty({
description: 'userUuid',
required: true,
})
@IsString()
@IsNotEmpty()
public userUuid: string;
constructor(dto: Partial<AddUserSpaceDto>) {
Object.assign(this, dto);
}
}
export class AddUserSpaceUsingCodeDto {
@ApiProperty({
description: 'inviteCode',
required: true,
})
@IsString()
@IsNotEmpty()
public inviteCode: string;
constructor(dto: Partial<AddUserSpaceDto>) {
Object.assign(this, dto);
}
}

1
src/users/dtos/index.ts
View File

@ -1,3 +1,4 @@
export * from './update.user.dto';
export * from './user-community-param.dto';
export * from './user-param.dto';
export * from './add.space.dto';

118
src/users/services/user-space.service.ts
View File

@ -2,10 +2,20 @@ import { HttpException, HttpStatus, Injectable } from '@nestjs/common';
import { UserSpaceRepository } from '@app/common/modules/user/repositories';
import { SuccessResponseDto } from '@app/common/dto/success.response.dto';
import { BaseResponseDto } from '@app/common/dto/base.response.dto';
import { AddUserSpaceDto, AddUserSpaceUsingCodeDto } from '../dtos';
import { SpaceRepository } from '@app/common/modules/space/repositories';
import { CommonErrorCodes } from '@app/common/constants/error-codes.enum';
import { UserDevicePermissionService } from 'src/user-device-permission/services';
import { PermissionType } from '@app/common/constants/permission-type.enum';
import { SpaceEntity } from '@app/common/modules/space/entities';
@Injectable()
export class UserSpaceService {
constructor(private readonly userSpaceRepository: UserSpaceRepository) {}
constructor(
private readonly userSpaceRepository: UserSpaceRepository,
private readonly spaceRepository: SpaceRepository,
private readonly userDevicePermissionService: UserDevicePermissionService,
) {}
async getSpacesForUser(userUuid: string): Promise<BaseResponseDto> {
const userSpaces = await this.userSpaceRepository.find({
@ -25,4 +35,110 @@ export class UserSpaceService {
message: `Spaces for user ${userUuid} retrieved successfully`,
});
}
async verifyCodeAndAddUserSpace(
params: AddUserSpaceUsingCodeDto,
userUuid: string,
) {
try {
const space = await this.findUnitByInviteCode(params.inviteCode);
await this.addUserToSpace(userUuid, space.uuid);
await this.clearUnitInvitationCode(space.uuid);
const deviceUUIDs = await this.getDeviceUUIDsForSpace(space.uuid);
await this.addUserPermissionsToDevices(userUuid, deviceUUIDs);
} catch (err) {
throw new HttpException(
'Invalid invitation code',
HttpStatus.BAD_REQUEST,
);
}
}
private async findUnitByInviteCode(inviteCode: string): Promise<SpaceEntity> {
const space = await this.spaceRepository.findOneOrFail({
where: {
invitationCode: inviteCode,
},
});
return space;
}
private async addUserToSpace(userUuid: string, spaceUuid: string) {
const user = await this.addUserSpace({ userUuid, spaceUuid });
if (user.uuid) {
return user;
} else {
throw new HttpException(
'Failed to add user to unit',
HttpStatus.INTERNAL_SERVER_ERROR,
);
}
}
async addUserSpace(addUserSpaceDto: AddUserSpaceDto) {
try {
return await this.userSpaceRepository.save({
user: { uuid: addUserSpaceDto.userUuid },
space: { uuid: addUserSpaceDto.spaceUuid },
});
} catch (err) {
if (err.code === CommonErrorCodes.DUPLICATE_ENTITY) {
throw new HttpException(
'User already belongs to this unit',
HttpStatus.BAD_REQUEST,
);
}
throw new HttpException(
err.message || 'Internal Server Error',
HttpStatus.INTERNAL_SERVER_ERROR,
);
}
}
private async clearUnitInvitationCode(spaceUuid: string) {
await this.spaceRepository.update(
{ uuid: spaceUuid },
{ invitationCode: null },
);
}
private async getDeviceUUIDsForSpace(
unitUuid: string,
): Promise<{ uuid: string }[]> {
const devices = await this.spaceRepository.find({
where: { uuid: unitUuid },
relations: ['devicesSpaceEntity', 'devicesSpaceEntity.productDevice'],
});
const allDevices = devices.flatMap((space) => space.devices);
return allDevices.map((device) => ({ uuid: device.uuid }));
}
private async addUserPermissionsToDevices(
userUuid: string,
deviceUUIDs: { uuid: string }[],
): Promise<void> {
const permissionPromises = deviceUUIDs.map(async (device) => {
try {
await this.userDevicePermissionService.addUserPermission({
userUuid,
deviceUuid: device.uuid,
permissionType: PermissionType.CONTROLLABLE,
});
} catch (error) {
console.error(
`Failed to add permission for device ${device.uuid}: ${error.message}`,
);
}
});
await Promise.all(permissionPromises);
}
}

8
src/users/user.module.ts
View File

@ -12,6 +12,10 @@ import { UserSpaceController } from './controllers';
import { CommunityModule } from 'src/community/community.module';
import { UserSpaceService } from './services';
import { CommunityRepository } from '@app/common/modules/community/repositories';
import { SpaceRepository } from '@app/common/modules/space/repositories';
import { UserDevicePermissionService } from 'src/user-device-permission/services';
import { DeviceUserPermissionRepository } from '@app/common/modules/device/repositories';
import { PermissionTypeRepository } from '@app/common/modules/permission/repositories';
@Module({
imports: [ConfigModule, CommunityModule],
@ -20,9 +24,13 @@ import { CommunityRepository } from '@app/common/modules/community/repositories'
UserService,
UserRepository,
RegionRepository,
SpaceRepository,
TimeZoneRepository,
UserSpaceRepository,
CommunityRepository,
UserDevicePermissionService,
DeviceUserPermissionRepository,
PermissionTypeRepository,
UserSpaceService,
],
exports: [UserService],