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

resolve conflicts

Browse Source
This commit is contained in:
unknown
2024-10-08 10:59:31 +03:00
parent 9a868c5757 972e1423f5
commit 11759d8112
53 changed files with 1009 additions and 1535 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
.env.example
View File

@ -90,3 +90,6 @@ FIREBASE_DATABASE_URL=
OTP_LIMITER= OTP_LIMITER=
GOOGLE_CLIENT_ID=
GOOGLE_CLIENT_SECRET=

38
libs/common/src/auth/services/auth.service.ts
View File

@ -1,4 +1,8 @@
import { BadRequestException, Injectable } from '@nestjs/common'; import {
BadRequestException,
Injectable,
UnauthorizedException,
} from '@nestjs/common';
import { JwtService } from '@nestjs/jwt'; import { JwtService } from '@nestjs/jwt';
import * as argon2 from 'argon2'; import * as argon2 from 'argon2';
import { HelperHashService } from '../../helper/services'; import { HelperHashService } from '../../helper/services';
@ -6,16 +10,20 @@ import { UserRepository } from '../../../../common/src/modules/user/repositories
import { UserSessionRepository } from '../../../../common/src/modules/session/repositories/session.repository'; import { UserSessionRepository } from '../../../../common/src/modules/session/repositories/session.repository';
import { UserSessionEntity } from '../../../../common/src/modules/session/entities'; import { UserSessionEntity } from '../../../../common/src/modules/session/entities';
import { ConfigService } from '@nestjs/config'; import { ConfigService } from '@nestjs/config';
import { OAuth2Client } from 'google-auth-library';
@Injectable() @Injectable()
export class AuthService { export class AuthService {
private client: OAuth2Client;
constructor( constructor(
private jwtService: JwtService, private jwtService: JwtService,
private readonly userRepository: UserRepository, private readonly userRepository: UserRepository,
private readonly sessionRepository: UserSessionRepository, private readonly sessionRepository: UserSessionRepository,
private readonly helperHashService: HelperHashService, private readonly helperHashService: HelperHashService,
private readonly configService: ConfigService, private readonly configService: ConfigService,
) {} ) {
this.client = new OAuth2Client(this.configService.get('GOOGLE_CLIENT_ID'));
}
async validateUser( async validateUser(
email: string, email: string,
@ -80,8 +88,17 @@ export class AuthService {
type: user.type, type: user.type,
sessionId: user.sessionId, sessionId: user.sessionId,
roles: user?.roles, roles: user?.roles,
googleCode: user.googleCode,
}; };
if (payload.googleCode) {
const profile = await this.getProfile(payload.googleCode);
user = await this.userRepository.findOne({
where: { email: profile.email },
});
if (!user) {
return { profile };
}
}
const tokens = await this.getTokens(payload); const tokens = await this.getTokens(payload);
await this.updateRefreshToken(user.uuid, tokens.refreshToken); await this.updateRefreshToken(user.uuid, tokens.refreshToken);
return tokens; return tokens;
@ -100,4 +117,19 @@ export class AuthService {
hashData(data: string) { hashData(data: string) {
return argon2.hash(data); return argon2.hash(data);
} }
async getProfile(googleCode: string) {
try {
const ticket = await this.client.verifyIdToken({
idToken: googleCode,
audience: this.configService.get('GOOGLE_CLIENT_ID'),
});
const payload = ticket.getPayload();
return {
...payload,
};
} catch (error) {
throw new UnauthorizedException('Google login failed');
}
}
} }

12
libs/common/src/common.module.ts
View File

@ -6,10 +6,16 @@ import { AuthModule } from './auth/auth.module';
import { ConfigModule } from '@nestjs/config'; import { ConfigModule } from '@nestjs/config';
import config from './config'; import config from './config';
import { EmailService } from './util/email.service'; import { EmailService } from './util/email.service';
import { ErrorMessageService } from 'src/error-message/error-message.service';
@Module({ @Module({
providers: [CommonService, EmailService], providers: [CommonService, EmailService, ErrorMessageService],
exports: [CommonService, HelperModule, AuthModule, EmailService], exports: [
CommonService,
HelperModule,
AuthModule,
EmailService,
ErrorMessageService,
],
imports: [ imports: [
ConfigModule.forRoot({ ConfigModule.forRoot({
load: config, load: config,

2
libs/common/src/constants/product-type.enum.ts
View File

@ -13,4 +13,6 @@ export enum ProductType {
TWO_2TG = '2GT', TWO_2TG = '2GT',
ONE_1TG = '1GT', ONE_1TG = '1GT',
WL = 'WL', WL = 'WL',
GD = 'GD',
CUR = 'CUR',
} }

2
libs/common/src/firebase/devices-status/services/devices-status.service.ts
View File

@ -85,6 +85,7 @@ export class DeviceStatusFirebaseService {
return await this.deviceRepository.findOne({ return await this.deviceRepository.findOne({
where: { where: {
deviceTuyaUuid, deviceTuyaUuid,
isActive: true,
}, },
relations: ['productDevice'], relations: ['productDevice'],
}); });
@ -139,6 +140,7 @@ export class DeviceStatusFirebaseService {
return await this.deviceRepository.findOne({ return await this.deviceRepository.findOne({
where: { where: {
uuid: deviceUuid, uuid: deviceUuid,
isActive: true,
}, },
...(withProductDevice && { relations: ['productDevice'] }), ...(withProductDevice && { relations: ['productDevice'] }),
}); });

3
libs/common/src/modules/device/entities/device.entity.ts
View File

@ -18,8 +18,9 @@ export class DeviceEntity extends AbstractEntity<DeviceDto> {
@Column({ @Column({
nullable: true, nullable: true,
default: true, default: true,
type: 'boolean',
}) })
isActive: true; isActive: boolean;
@ManyToOne(() => UserEntity, (user) => user.userSpaces, { nullable: false }) @ManyToOne(() => UserEntity, (user) => user.userSpaces, { nullable: false })
user: UserEntity; user: UserEntity;

164
package-lock.json generated
View File

@ -20,13 +20,14 @@
"@nestjs/websockets": "^10.3.8", "@nestjs/websockets": "^10.3.8",
"@tuya/tuya-connector-nodejs": "^2.1.2", "@tuya/tuya-connector-nodejs": "^2.1.2",
"argon2": "^0.40.1", "argon2": "^0.40.1",
"axios": "^1.6.7", "axios": "^1.7.7",
"bcryptjs": "^2.4.3", "bcryptjs": "^2.4.3",
"class-transformer": "^0.5.1", "class-transformer": "^0.5.1",
"class-validator": "^0.14.1", "class-validator": "^0.14.1",
"crypto-js": "^4.2.0", "crypto-js": "^4.2.0",
"express-rate-limit": "^7.1.5", "express-rate-limit": "^7.1.5",
"firebase": "^10.12.5", "firebase": "^10.12.5",
"google-auth-library": "^9.14.1",
"helmet": "^7.1.0", "helmet": "^7.1.0",
"ioredis": "^5.3.2", "ioredis": "^5.3.2",
"morgan": "^1.10.0", "morgan": "^1.10.0",
@ -3564,6 +3565,18 @@
"node": ">=0.4.0" "node": ">=0.4.0"
} }
}, },
"node_modules/agent-base": {
"version": "7.1.1",
"resolved": "https://registry.npmjs.org/agent-base/-/agent-base-7.1.1.tgz",
"integrity": "sha512-H0TSyFNDMomMNJQBn8wFV5YC/2eJ+VXECwOadZJT554xP6cODZHPX3H9QMQECxvrgiSOP1pHjy1sMWQVYJOUOA==",
"license": "MIT",
"dependencies": {
"debug": "^4.3.4"
},
"engines": {
"node": ">= 14"
}
},
"node_modules/ajv": { "node_modules/ajv": {
"version": "8.12.0", "version": "8.12.0",
"resolved": "https://registry.npmjs.org/ajv/-/ajv-8.12.0.tgz", "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.12.0.tgz",
@ -3784,11 +3797,12 @@
"integrity": "sha512-3AungXC4I8kKsS9PuS4JH2nc+0bVY/mjgrephHTIi8fpEeGsTHBUJeosp0Wc1myYMElmD0B3Oc4XL/HVJ4PV2g==" "integrity": "sha512-3AungXC4I8kKsS9PuS4JH2nc+0bVY/mjgrephHTIi8fpEeGsTHBUJeosp0Wc1myYMElmD0B3Oc4XL/HVJ4PV2g=="
}, },
"node_modules/axios": { "node_modules/axios": {
"version": "1.6.7", "version": "1.7.7",
"resolved": "https://registry.npmjs.org/axios/-/axios-1.6.7.tgz", "resolved": "https://registry.npmjs.org/axios/-/axios-1.7.7.tgz",
"integrity": "sha512-/hDJGff6/c7u0hDkvkGxR/oy6CbCs8ziCsC7SqmhjfozqiJGc8Z11wrv9z9lYfY4K8l+H9TpjcMDX0xOZmx+RA==", "integrity": "sha512-S4kL7XrjgBmvdGut0sN3yJxqYzrDOnivkBiN0OFs6hLiUam3UPvswUo0kqGyhqUZGEOytHyumEdXsAkgCOUf3Q==",
"license": "MIT",
"dependencies": { "dependencies": {
"follow-redirects": "^1.15.4", "follow-redirects": "^1.15.6",
"form-data": "^4.0.0", "form-data": "^4.0.0",
"proxy-from-env": "^1.1.0" "proxy-from-env": "^1.1.0"
} }
@ -3962,6 +3976,15 @@
"resolved": "https://registry.npmjs.org/bcryptjs/-/bcryptjs-2.4.3.tgz", "resolved": "https://registry.npmjs.org/bcryptjs/-/bcryptjs-2.4.3.tgz",
"integrity": "sha512-V/Hy/X9Vt7f3BbPJEi8BdVFMByHi+jNXrYkW3huaybV/kQ0KJg0Y6PkEMbn+zeT+i+SiKZ/HMqJGIIt4LZDqNQ==" "integrity": "sha512-V/Hy/X9Vt7f3BbPJEi8BdVFMByHi+jNXrYkW3huaybV/kQ0KJg0Y6PkEMbn+zeT+i+SiKZ/HMqJGIIt4LZDqNQ=="
}, },
"node_modules/bignumber.js": {
"version": "9.1.2",
"resolved": "https://registry.npmjs.org/bignumber.js/-/bignumber.js-9.1.2.tgz",
"integrity": "sha512-2/mKyZH9K85bzOEfhXDBFZTGd1CTs+5IHpeFQo9luiBG7hghdC851Pj2WAhb6E3R6b9tZj/XKhbg4fum+Kepug==",
"license": "MIT",
"engines": {
"node": "*"
}
},
"node_modules/binary-extensions": { "node_modules/binary-extensions": {
"version": "2.2.0", "version": "2.2.0",
"resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.2.0.tgz", "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.2.0.tgz",
@ -5887,15 +5910,16 @@
"dev": true "dev": true
}, },
"node_modules/follow-redirects": { "node_modules/follow-redirects": {
"version": "1.15.5", "version": "1.15.9",
"resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.5.tgz", "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.9.tgz",
"integrity": "sha512-vSFWUON1B+yAw1VN4xMfxgn5fTUiaOzAJCKBwIIgT/+7CuGy9+r+5gITvP62j3RmaD5Ph65UaERdOSRGUzZtgw==", "integrity": "sha512-gew4GsXizNgdoRyqmyfMHyAmXsZDk6mHkSxZFCzW9gwlbtOW44CDtYavM+y+72qD/Vq2l550kMF52DT8fOLJqQ==",
"funding": [ "funding": [
{ {
"type": "individual", "type": "individual",
"url": "https://github.com/sponsors/RubenVerborgh" "url": "https://github.com/sponsors/RubenVerborgh"
} }
], ],
"license": "MIT",
"engines": { "engines": {
"node": ">=4.0" "node": ">=4.0"
}, },
@ -6056,6 +6080,35 @@
"url": "https://github.com/sponsors/ljharb" "url": "https://github.com/sponsors/ljharb"
} }
}, },
"node_modules/gaxios": {
"version": "6.7.1",
"resolved": "https://registry.npmjs.org/gaxios/-/gaxios-6.7.1.tgz",
"integrity": "sha512-LDODD4TMYx7XXdpwxAVRAIAuB0bzv0s+ywFonY46k126qzQHT9ygyoa9tncmOiQmmDrik65UYsEkv3lbfqQ3yQ==",
"license": "Apache-2.0",
"dependencies": {
"extend": "^3.0.2",
"https-proxy-agent": "^7.0.1",
"is-stream": "^2.0.0",
"node-fetch": "^2.6.9",
"uuid": "^9.0.1"
},
"engines": {
"node": ">=14"
}
},
"node_modules/gcp-metadata": {
"version": "6.1.0",
"resolved": "https://registry.npmjs.org/gcp-metadata/-/gcp-metadata-6.1.0.tgz",
"integrity": "sha512-Jh/AIwwgaxan+7ZUUmRLCjtchyDiqh4KjBJ5tW3plBZb5iL/BPcso8A5DlzeD9qlw0duCamnNdpFjxwaT0KyKg==",
"license": "Apache-2.0",
"dependencies": {
"gaxios": "^6.0.0",
"json-bigint": "^1.0.0"
},
"engines": {
"node": ">=14"
}
},
"node_modules/gensync": { "node_modules/gensync": {
"version": "1.0.0-beta.2", "version": "1.0.0-beta.2",
"resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz", "resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz",
@ -6194,6 +6247,44 @@
"url": "https://github.com/sponsors/sindresorhus" "url": "https://github.com/sponsors/sindresorhus"
} }
}, },
"node_modules/google-auth-library": {
"version": "9.14.1",
"resolved": "https://registry.npmjs.org/google-auth-library/-/google-auth-library-9.14.1.tgz",
"integrity": "sha512-Rj+PMjoNFGFTmtItH7gHfbHpGVSb3vmnGK3nwNBqxQF9NoBpttSZI/rc0WiM63ma2uGDQtYEkMHkK9U6937NiA==",
"license": "Apache-2.0",
"dependencies": {
"base64-js": "^1.3.0",
"ecdsa-sig-formatter": "^1.0.11",
"gaxios": "^6.1.1",
"gcp-metadata": "^6.1.0",
"gtoken": "^7.0.0",
"jws": "^4.0.0"
},
"engines": {
"node": ">=14"
}
},
"node_modules/google-auth-library/node_modules/jwa": {
"version": "2.0.0",
"resolved": "https://registry.npmjs.org/jwa/-/jwa-2.0.0.tgz",
"integrity": "sha512-jrZ2Qx916EA+fq9cEAeCROWPTfCwi1IVHqT2tapuqLEVVDKFDENFw1oL+MwrTvH6msKxsd1YTDVw6uKEcsrLEA==",
"license": "MIT",
"dependencies": {
"buffer-equal-constant-time": "1.0.1",
"ecdsa-sig-formatter": "1.0.11",
"safe-buffer": "^5.0.1"
}
},
"node_modules/google-auth-library/node_modules/jws": {
"version": "4.0.0",
"resolved": "https://registry.npmjs.org/jws/-/jws-4.0.0.tgz",
"integrity": "sha512-KDncfTmOZoOMTFG4mBlG0qUIOlc03fmzH+ru6RgYVZhPkyiy/92Owlt/8UEN+a4TXR1FQetfIpJE8ApdvdVxTg==",
"license": "MIT",
"dependencies": {
"jwa": "^2.0.0",
"safe-buffer": "^5.0.1"
}
},
"node_modules/gopd": { "node_modules/gopd": {
"version": "1.0.1", "version": "1.0.1",
"resolved": "https://registry.npmjs.org/gopd/-/gopd-1.0.1.tgz", "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.0.1.tgz",
@ -6217,6 +6308,40 @@
"integrity": "sha512-EtKwoO6kxCL9WO5xipiHTZlSzBm7WLT627TqC/uVRd0HKmq8NXyebnNYxDoBi7wt8eTWrUrKXCOVaFq9x1kgag==", "integrity": "sha512-EtKwoO6kxCL9WO5xipiHTZlSzBm7WLT627TqC/uVRd0HKmq8NXyebnNYxDoBi7wt8eTWrUrKXCOVaFq9x1kgag==",
"dev": true "dev": true
}, },
"node_modules/gtoken": {
"version": "7.1.0",
"resolved": "https://registry.npmjs.org/gtoken/-/gtoken-7.1.0.tgz",
"integrity": "sha512-pCcEwRi+TKpMlxAQObHDQ56KawURgyAf6jtIY046fJ5tIv3zDe/LEIubckAO8fj6JnAxLdmWkUfNyulQ2iKdEw==",
"license": "MIT",
"dependencies": {
"gaxios": "^6.0.0",
"jws": "^4.0.0"
},
"engines": {
"node": ">=14.0.0"
}
},
"node_modules/gtoken/node_modules/jwa": {
"version": "2.0.0",
"resolved": "https://registry.npmjs.org/jwa/-/jwa-2.0.0.tgz",
"integrity": "sha512-jrZ2Qx916EA+fq9cEAeCROWPTfCwi1IVHqT2tapuqLEVVDKFDENFw1oL+MwrTvH6msKxsd1YTDVw6uKEcsrLEA==",
"license": "MIT",
"dependencies": {
"buffer-equal-constant-time": "1.0.1",
"ecdsa-sig-formatter": "1.0.11",
"safe-buffer": "^5.0.1"
}
},
"node_modules/gtoken/node_modules/jws": {
"version": "4.0.0",
"resolved": "https://registry.npmjs.org/jws/-/jws-4.0.0.tgz",
"integrity": "sha512-KDncfTmOZoOMTFG4mBlG0qUIOlc03fmzH+ru6RgYVZhPkyiy/92Owlt/8UEN+a4TXR1FQetfIpJE8ApdvdVxTg==",
"license": "MIT",
"dependencies": {
"jwa": "^2.0.0",
"safe-buffer": "^5.0.1"
}
},
"node_modules/har-schema": { "node_modules/har-schema": {
"version": "2.0.0", "version": "2.0.0",
"resolved": "https://registry.npmjs.org/har-schema/-/har-schema-2.0.0.tgz", "resolved": "https://registry.npmjs.org/har-schema/-/har-schema-2.0.0.tgz",
@ -6384,6 +6509,19 @@
"npm": ">=1.3.7" "npm": ">=1.3.7"
} }
}, },
"node_modules/https-proxy-agent": {
"version": "7.0.5",
"resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-7.0.5.tgz",
"integrity": "sha512-1e4Wqeblerz+tMKPIq2EMGiiWW1dIjZOksyHWSUm1rmuvw/how9hBHZ38lAGj5ID4Ik6EdkOw7NmWPy6LAwalw==",
"license": "MIT",
"dependencies": {
"agent-base": "^7.0.2",
"debug": "4"
},
"engines": {
"node": ">= 14"
}
},
"node_modules/human-signals": { "node_modules/human-signals": {
"version": "2.1.0", "version": "2.1.0",
"resolved": "https://registry.npmjs.org/human-signals/-/human-signals-2.1.0.tgz", "resolved": "https://registry.npmjs.org/human-signals/-/human-signals-2.1.0.tgz",
@ -6689,7 +6827,6 @@
"version": "2.0.1", "version": "2.0.1",
"resolved": "https://registry.npmjs.org/is-stream/-/is-stream-2.0.1.tgz", "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-2.0.1.tgz",
"integrity": "sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==", "integrity": "sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==",
"dev": true,
"engines": { "engines": {
"node": ">=8" "node": ">=8"
}, },
@ -7533,6 +7670,15 @@
"node": ">=4" "node": ">=4"
} }
}, },
"node_modules/json-bigint": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/json-bigint/-/json-bigint-1.0.0.tgz",
"integrity": "sha512-SiPv/8VpZuWbvLSMtTDU8hEfrZWg/mH/nV/b4o0CYbSxu1UIQPLdwKOCIyLQX+VIPO5vrLX3i8qtqFyhdPSUSQ==",
"license": "MIT",
"dependencies": {
"bignumber.js": "^9.0.0"
}
},
"node_modules/json-buffer": { "node_modules/json-buffer": {
"version": "3.0.1", "version": "3.0.1",
"resolved": "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.1.tgz", "resolved": "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.1.tgz",

3
package.json
View File

@ -31,13 +31,14 @@
"@nestjs/websockets": "^10.3.8", "@nestjs/websockets": "^10.3.8",
"@tuya/tuya-connector-nodejs": "^2.1.2", "@tuya/tuya-connector-nodejs": "^2.1.2",
"argon2": "^0.40.1", "argon2": "^0.40.1",
"axios": "^1.6.7", "axios": "^1.7.7",
"bcryptjs": "^2.4.3", "bcryptjs": "^2.4.3",
"class-transformer": "^0.5.1", "class-transformer": "^0.5.1",
"class-validator": "^0.14.1", "class-validator": "^0.14.1",
"crypto-js": "^4.2.0", "crypto-js": "^4.2.0",
"express-rate-limit": "^7.1.5", "express-rate-limit": "^7.1.5",
"firebase": "^10.12.5", "firebase": "^10.12.5",
"google-auth-library": "^9.14.1",
"helmet": "^7.1.0", "helmet": "^7.1.0",
"ioredis": "^5.3.2", "ioredis": "^5.3.2",
"morgan": "^1.10.0", "morgan": "^1.10.0",

2
src/app.module.ts
View File

@ -2,7 +2,6 @@ import { Module } from '@nestjs/common';
import { ConfigModule } from '@nestjs/config'; import { ConfigModule } from '@nestjs/config';
import config from './config'; import config from './config';
import { AuthenticationModule } from './auth/auth.module'; import { AuthenticationModule } from './auth/auth.module';
import { AuthenticationController } from './auth/controllers/authentication.controller';
import { UserModule } from './users/user.module'; import { UserModule } from './users/user.module';
import { RoomModule } from './room/room.module'; import { RoomModule } from './room/room.module';
import { GroupModule } from './group/group.module'; import { GroupModule } from './group/group.module';
@ -53,7 +52,6 @@ import { ScheduleModule } from './schedule/schedule.module';
VisitorPasswordModule, VisitorPasswordModule,
ScheduleModule, ScheduleModule,
], ],
controllers: [AuthenticationController],
providers: [ providers: [
{ {
provide: APP_INTERCEPTOR, provide: APP_INTERCEPTOR,

7
src/auth/auth.module.ts
View File

@ -1,6 +1,4 @@
import { Module } from '@nestjs/common'; import { Module } from '@nestjs/common';
import { AuthenticationController } from './controllers/authentication.controller';
import { AuthenticationService } from './services/authentication.service';
import { ConfigModule } from '@nestjs/config'; import { ConfigModule } from '@nestjs/config';
import { UserRepositoryModule } from '@app/common/modules/user/user.repository.module'; import { UserRepositoryModule } from '@app/common/modules/user/user.repository.module';
import { CommonModule } from '../../libs/common/src'; import { CommonModule } from '../../libs/common/src';
@ -16,9 +14,8 @@ import { RoleTypeRepository } from '@app/common/modules/role-type/repositories';
@Module({ @Module({
imports: [ConfigModule, UserRepositoryModule, CommonModule], imports: [ConfigModule, UserRepositoryModule, CommonModule],
controllers: [AuthenticationController, UserAuthController], controllers: [UserAuthController],
providers: [ providers: [
AuthenticationService,
UserAuthService, UserAuthService,
UserRepository, UserRepository,
UserSessionRepository, UserSessionRepository,
@ -26,6 +23,6 @@ import { RoleTypeRepository } from '@app/common/modules/role-type/repositories';
UserRoleRepository, UserRoleRepository,
RoleTypeRepository, RoleTypeRepository,
], ],
exports: [AuthenticationService, UserAuthService], exports: [UserAuthService],
}) })
export class AuthenticationModule {} export class AuthenticationModule {}

17
src/auth/controllers/authentication.controller.ts
View File

@ -1,17 +0,0 @@
import { Controller, Post } from '@nestjs/common';
import { AuthenticationService } from '../services/authentication.service';
import { ApiTags } from '@nestjs/swagger';
import { EnableDisableStatusEnum } from '@app/common/constants/days.enum';
@Controller({
version: EnableDisableStatusEnum.ENABLED,
path: 'authentication',
})
@ApiTags('Tuya Auth')
export class AuthenticationController {
constructor(private readonly authenticationService: AuthenticationService) {}
@Post('auth2')
async Authentication() {
return await this.authenticationService.main();
}
}

1
src/auth/controllers/index.ts
View File

@ -1,2 +1 @@
export * from './authentication.controller';
export * from './user-auth.controller'; export * from './user-auth.controller';

2
src/auth/controllers/user-auth.controller.ts
View File

@ -84,7 +84,7 @@ export class UserAuthController {
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(SuperAdminRoleGuard) @UseGuards(SuperAdminRoleGuard)
@Get('user/list') @Get('user')
async userList() { async userList() {
const userList = await this.userAuthService.userList(); const userList = await this.userAuthService.userList();
return { return {

2
src/auth/dtos/user-auth.dto.ts
View File

@ -41,5 +41,5 @@ export class UserSignUpDto {
@IsString() @IsString()
@IsOptional() @IsOptional()
public regionUuid: string; public regionUuid?: string;
} }

12
src/auth/dtos/user-login.dto.ts
View File

@ -1,19 +1,23 @@
import { ApiProperty } from '@nestjs/swagger'; import { ApiProperty } from '@nestjs/swagger';
import { IsEmail, IsNotEmpty, IsOptional, IsString } from 'class-validator'; import { IsEmail, IsOptional, IsString } from 'class-validator';
export class UserLoginDto { export class UserLoginDto {
@ApiProperty() @ApiProperty()
@IsEmail() @IsEmail()
@IsNotEmpty() @IsOptional()
email: string; email?: string;
@ApiProperty() @ApiProperty()
@IsString() @IsString()
@IsOptional() @IsOptional()
password: string; password?: string;
@ApiProperty() @ApiProperty()
@IsString() @IsString()
@IsOptional() @IsOptional()
regionUuid?: string; regionUuid?: string;
@IsOptional()
@IsString()
googleCode?: string;
} }

120
src/auth/services/authentication.service.ts
View File

@ -1,120 +0,0 @@
import { Injectable } from '@nestjs/common';
import * as qs from 'qs';
import * as crypto from 'crypto';
import { ConfigService } from '@nestjs/config';
import axios from 'axios';
@Injectable()
export class AuthenticationService {
private token: string;
private deviceId: string;
private accessKey: string;
private secretKey: string;
constructor(private readonly configService: ConfigService) {
(this.deviceId = this.configService.get<string>('auth-config.DEVICE_ID')),
(this.accessKey = this.configService.get<string>(
'auth-config.ACCESS_KEY',
)),
(this.secretKey = this.configService.get<string>(
'auth-config.SECRET_KEY',
));
}
async main() {
await this.getToken();
const data = await this.getDeviceInfo(this.deviceId);
console.log('fetch success: ', JSON.stringify(data));
return JSON.stringify(data);
}
async getToken() {
const method = 'GET';
const timestamp = Date.now().toString();
const signUrl = 'https://openapi.tuyaeu.com/v1.0/token?grant_type=1';
const contentHash = crypto.createHash('sha256').update('').digest('hex');
const stringToSign = [method, contentHash, '', signUrl].join('\n');
const signStr = this.accessKey + timestamp + stringToSign;
const headers = {
t: timestamp,
sign_method: 'HMAC-SHA256',
client_id: this.accessKey,
sign: await this.encryptStr(signStr, this.secretKey),
};
const { data: login } = await axios.get(
'https://openapi.tuyaeu.com/v1.0/token',
{
params: {
grant_type: 1,
},
headers,
},
);
if (!login || !login.success) {
throw new Error(`fetch failed: ${login.msg}`);
}
this.token = login.result.access_token;
}
async getDeviceInfo(deviceId: string) {
const query = {};
const method = 'POST';
const url = `https://openapi.tuyaeu.com/v1.0/devices/${deviceId}/commands`;
const reqHeaders: { [k: string]: string } = await this.getRequestSign(
url,
method,
{},
query,
);
const { data } = await axios.post(url, {}, reqHeaders);
if (!data || !data.success) {
throw new Error(`request api failed: ${data.msg}`);
}
return data;
}
async encryptStr(str: string, secret: string): Promise<string> {
return crypto
.createHmac('sha256', secret)
.update(str, 'utf8')
.digest('hex')
.toUpperCase();
}
async getRequestSign(
path: string,
method: string,
query: { [k: string]: any } = {},
body: { [k: string]: any } = {},
) {
const t = Date.now().toString();
const [uri, pathQuery] = path.split('?');
const queryMerged = Object.assign(query, qs.parse(pathQuery));
const sortedQuery: { [k: string]: string } = {};
Object.keys(queryMerged)
.sort()
.forEach((i) => (sortedQuery[i] = query[i]));
const querystring = decodeURIComponent(qs.stringify(sortedQuery));
const url = querystring ? `${uri}?${querystring}` : uri;
const contentHash = crypto
.createHash('sha256')
.update(JSON.stringify(body))
.digest('hex');
const stringToSign = [method, contentHash, '', url].join('\n');
const signStr = this.accessKey + this.token + t + stringToSign;
return {
t,
path: url,
client_id: 'this.accessKey',
sign: await this.encryptStr(signStr, this.secretKey),
sign_method: 'HMAC-SHA256',
access_token: this.token,
};
}
}

1
src/auth/services/index.ts
View File

@ -1,2 +1 @@
export * from './authentication.service';
export * from './user-auth.service'; export * from './user-auth.service';

44
src/auth/services/user-auth.service.ts
View File

@ -3,7 +3,6 @@ import {
BadRequestException, BadRequestException,
ForbiddenException, ForbiddenException,
Injectable, Injectable,
UnauthorizedException,
} from '@nestjs/common'; } from '@nestjs/common';
import { UserSignUpDto } from '../dtos/user-auth.dto'; import { UserSignUpDto } from '../dtos/user-auth.dto';
import { HelperHashService } from '../../../libs/common/src/helper/services'; import { HelperHashService } from '../../../libs/common/src/helper/services';
@ -19,6 +18,7 @@ import * as argon2 from 'argon2';
import { differenceInSeconds } from '@app/common/helper/differenceInSeconds'; import { differenceInSeconds } from '@app/common/helper/differenceInSeconds';
import { LessThan, MoreThan } from 'typeorm'; import { LessThan, MoreThan } from 'typeorm';
import { ConfigService } from '@nestjs/config'; import { ConfigService } from '@nestjs/config';
import { UUID } from 'typeorm/driver/mongodb/bson.typings';
@Injectable() @Injectable()
export class UserAuthService { export class UserAuthService {
@ -89,13 +89,38 @@ export class UserAuthService {
async userLogin(data: UserLoginDto) { async userLogin(data: UserLoginDto) {
try { try {
const user = await this.authService.validateUser( let user;
data.email, if (data.googleCode) {
data.password, const googleUserData = await this.authService.login({
data.regionUuid, googleCode: data.googleCode,
); });
if (!user) { const userExists = await this.userRepository.exists({
throw new UnauthorizedException('Invalid login credentials.'); where: {
email: googleUserData['email'],
},
});
user = await this.userRepository.findOne({
where: {
email: googleUserData['email'],
},
});
if (!userExists) {
await this.signUp({
email: googleUserData['email'],
firstName: googleUserData['given_name'],
lastName: googleUserData['family_name'],
password: googleUserData['email'],
});
}
data.email = googleUserData['email'];
data.password = googleUserData['password'];
}
if (!data.googleCode) {
user = await this.authService.validateUser(
data.email,
data.password,
data.regionUuid,
);
} }
const session = await Promise.all([ const session = await Promise.all([
await this.sessionRepository.update( await this.sessionRepository.update(
@ -110,7 +135,7 @@ export class UserAuthService {
isLoggedOut: false, isLoggedOut: false,
}), }),
]); ]);
return await this.authService.login({ const res = await this.authService.login({
email: user.email, email: user.email,
userId: user.uuid, userId: user.uuid,
uuid: user.uuid, uuid: user.uuid,
@ -119,6 +144,7 @@ export class UserAuthService {
}), }),
sessionId: session[1].uuid, sessionId: session[1].uuid,
}); });
return res;
} catch (error) { } catch (error) {
throw new BadRequestException('Invalid credentials'); throw new BadRequestException('Invalid credentials');
} }

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

@ -4,7 +4,6 @@ import {
Controller, Controller,
Delete, Delete,
Get, Get,
HttpException,
HttpStatus, HttpStatus,
Param, Param,
Post, Post,
@ -32,52 +31,30 @@ export class AutomationController {
@UseGuards(JwtAuthGuard) @UseGuards(JwtAuthGuard)
@Post() @Post()
async addAutomation(@Body() addAutomationDto: AddAutomationDto) { async addAutomation(@Body() addAutomationDto: AddAutomationDto) {
try { const automation =
const automation = await this.automationService.addAutomation(addAutomationDto);
await this.automationService.addAutomation(addAutomationDto); return {
return { statusCode: HttpStatus.CREATED,
statusCode: HttpStatus.CREATED, success: true,
success: true, message: 'Automation added successfully',
message: 'Automation added successfully', data: automation,
data: automation, };
};
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(JwtAuthGuard) @UseGuards(JwtAuthGuard)
@Get(':unitUuid') @Get(':unitUuid')
async getAutomationByUnit(@Param('unitUuid') unitUuid: string) { async getAutomationByUnit(@Param('unitUuid') unitUuid: string) {
try { const automation =
const automation = await this.automationService.getAutomationByUnit(unitUuid);
await this.automationService.getAutomationByUnit(unitUuid); return automation;
return automation;
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(JwtAuthGuard) @UseGuards(JwtAuthGuard)
@Get('details/:automationId') @Get('details/:automationId')
async getAutomationDetails(@Param('automationId') automationId: string) { async getAutomationDetails(@Param('automationId') automationId: string) {
try { const automation =
const automation = await this.automationService.getAutomationDetails(automationId);
await this.automationService.getAutomationDetails(automationId); return automation;
return automation;
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
``;
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(JwtAuthGuard) @UseGuards(JwtAuthGuard)
@ -86,18 +63,11 @@ export class AutomationController {
@Param('unitUuid') unitUuid: string, @Param('unitUuid') unitUuid: string,
@Param('automationId') automationId: string, @Param('automationId') automationId: string,
) { ) {
try { await this.automationService.deleteAutomation(unitUuid, automationId);
await this.automationService.deleteAutomation(unitUuid, automationId); return {
return { statusCode: HttpStatus.OK,
statusCode: HttpStatus.OK, message: 'Automation Deleted Successfully',
message: 'Automation Deleted Successfully', };
};
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(JwtAuthGuard) @UseGuards(JwtAuthGuard)
@ -106,23 +76,16 @@ export class AutomationController {
@Body() updateAutomationDto: UpdateAutomationDto, @Body() updateAutomationDto: UpdateAutomationDto,
@Param('automationId') automationId: string, @Param('automationId') automationId: string,
) { ) {
try { const automation = await this.automationService.updateAutomation(
const automation = await this.automationService.updateAutomation( updateAutomationDto,
updateAutomationDto, automationId,
automationId, );
); return {
return { statusCode: HttpStatus.CREATED,
statusCode: HttpStatus.CREATED, success: true,
success: true, message: 'Automation updated successfully',
message: 'Automation updated successfully', data: automation,
data: automation, };
};
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(JwtAuthGuard) @UseGuards(JwtAuthGuard)
@ -131,21 +94,14 @@ export class AutomationController {
@Body() updateAutomationStatusDto: UpdateAutomationStatusDto, @Body() updateAutomationStatusDto: UpdateAutomationStatusDto,
@Param('automationId') automationId: string, @Param('automationId') automationId: string,
) { ) {
try { await this.automationService.updateAutomationStatus(
await this.automationService.updateAutomationStatus( updateAutomationStatusDto,
updateAutomationStatusDto, automationId,
automationId, );
); return {
return { statusCode: HttpStatus.CREATED,
statusCode: HttpStatus.CREATED, success: true,
success: true, message: 'Automation status updated successfully',
message: 'Automation status updated successfully', };
};
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
} }

111
src/building/controllers/building.controller.ts
View File

@ -3,7 +3,6 @@ import {
Body, Body,
Controller, Controller,
Get, Get,
HttpException,
HttpStatus, HttpStatus,
Param, Param,
Post, Post,
@ -35,36 +34,21 @@ export class BuildingController {
@UseGuards(JwtAuthGuard, CheckCommunityTypeGuard) @UseGuards(JwtAuthGuard, CheckCommunityTypeGuard)
@Post() @Post()
async addBuilding(@Body() addBuildingDto: AddBuildingDto) { async addBuilding(@Body() addBuildingDto: AddBuildingDto) {
try { const building = await this.buildingService.addBuilding(addBuildingDto);
const building = await this.buildingService.addBuilding(addBuildingDto); return {
return { statusCode: HttpStatus.CREATED,
statusCode: HttpStatus.CREATED, success: true,
success: true, message: 'Building added successfully',
message: 'Building added successfully', data: building,
data: building, };
};
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(JwtAuthGuard, BuildingPermissionGuard) @UseGuards(JwtAuthGuard, BuildingPermissionGuard)
@Get(':buildingUuid') @Get(':buildingUuid')
async getBuildingByUuid(@Param('buildingUuid') buildingUuid: string) { async getBuildingByUuid(@Param('buildingUuid') buildingUuid: string) {
try { const building = await this.buildingService.getBuildingByUuid(buildingUuid);
const building = return building;
await this.buildingService.getBuildingByUuid(buildingUuid);
return building;
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@ -74,84 +58,49 @@ export class BuildingController {
@Param('buildingUuid') buildingUuid: string, @Param('buildingUuid') buildingUuid: string,
@Query() query: GetBuildingChildDto, @Query() query: GetBuildingChildDto,
) { ) {
try { const building = await this.buildingService.getBuildingChildByUuid(
const building = await this.buildingService.getBuildingChildByUuid( buildingUuid,
buildingUuid, query,
query, );
); return building;
return building;
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(JwtAuthGuard, BuildingPermissionGuard) @UseGuards(JwtAuthGuard, BuildingPermissionGuard)
@Get('parent/:buildingUuid') @Get('parent/:buildingUuid')
async getBuildingParentByUuid(@Param('buildingUuid') buildingUuid: string) { async getBuildingParentByUuid(@Param('buildingUuid') buildingUuid: string) {
try { const building =
const building = await this.buildingService.getBuildingParentByUuid(buildingUuid);
await this.buildingService.getBuildingParentByUuid(buildingUuid); return building;
return building;
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(AdminRoleGuard, CheckUserBuildingGuard) @UseGuards(AdminRoleGuard, CheckUserBuildingGuard)
@Post('user') @Post('user')
async addUserBuilding(@Body() addUserBuildingDto: AddUserBuildingDto) { async addUserBuilding(@Body() addUserBuildingDto: AddUserBuildingDto) {
try { await this.buildingService.addUserBuilding(addUserBuildingDto);
await this.buildingService.addUserBuilding(addUserBuildingDto); return {
return { statusCode: HttpStatus.CREATED,
statusCode: HttpStatus.CREATED, success: true,
success: true, message: 'user building added successfully',
message: 'user building added successfully', };
};
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(JwtAuthGuard) @UseGuards(JwtAuthGuard)
@Get('user/:userUuid') @Get('user/:userUuid')
async getBuildingsByUserId(@Param('userUuid') userUuid: string) { async getBuildingsByUserId(@Param('userUuid') userUuid: string) {
try { return await this.buildingService.getBuildingsByUserId(userUuid);
return await this.buildingService.getBuildingsByUserId(userUuid);
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(JwtAuthGuard, BuildingPermissionGuard) @UseGuards(JwtAuthGuard, BuildingPermissionGuard)
@Put('rename/:buildingUuid') @Put(':buildingUuid')
async renameBuildingByUuid( async renameBuildingByUuid(
@Param('buildingUuid') buildingUuid: string, @Param('buildingUuid') buildingUuid: string,
@Body() updateBuildingDto: UpdateBuildingNameDto, @Body() updateBuildingDto: UpdateBuildingNameDto,
) { ) {
try { const building = await this.buildingService.renameBuildingByUuid(
const building = await this.buildingService.renameBuildingByUuid( buildingUuid,
buildingUuid, updateBuildingDto,
updateBuildingDto, );
); return building;
return building;
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
} }

7
src/common/filters/http-exception/http-exception.filter.spec.ts Normal file
View File

@ -0,0 +1,7 @@
import { HttpExceptionFilter } from './http-exception.filter';
describe('HttpExceptionFilter', () => {
it('should be defined', () => {
expect(new HttpExceptionFilter()).toBeDefined();
});
});

38
src/common/filters/http-exception/http-exception.filter.ts Normal file
View File

@ -0,0 +1,38 @@
import {
ExceptionFilter,
Catch,
ArgumentsHost,
HttpException,
HttpStatus,
} from '@nestjs/common';
import { Response } from 'express';
@Catch()
export class HttpExceptionFilter implements ExceptionFilter {
catch(exception: unknown, host: ArgumentsHost) {
const ctx = host.switchToHttp();
const response = ctx.getResponse<Response>();
const request = ctx.getRequest<Request>();
const status =
exception instanceof HttpException
? exception.getStatus()
: HttpStatus.INTERNAL_SERVER_ERROR;
const message =
exception instanceof HttpException
? exception.getResponse()
: 'Internal server error';
const errorResponse = {
statusCode: status,
timestamp: new Date().toISOString(),
path: request.url,
error: message,
};
// Optionally log the exception
console.error(`Error occurred:`, exception);
response.status(status).json(errorResponse);
}
}

112
src/community/controllers/community.controller.ts
View File

@ -3,7 +3,6 @@ import {
Body, Body,
Controller, Controller,
Get, Get,
HttpException,
HttpStatus, HttpStatus,
Param, Param,
Post, Post,
@ -18,7 +17,6 @@ import {
} from '../dtos/add.community.dto'; } from '../dtos/add.community.dto';
import { GetCommunityChildDto } from '../dtos/get.community.dto'; import { GetCommunityChildDto } from '../dtos/get.community.dto';
import { UpdateCommunityNameDto } from '../dtos/update.community.dto'; import { UpdateCommunityNameDto } from '../dtos/update.community.dto';
// import { CheckUserCommunityGuard } from 'src/guards/user.community.guard';
import { AdminRoleGuard } from 'src/guards/admin.role.guard'; import { AdminRoleGuard } from 'src/guards/admin.role.guard';
import { JwtAuthGuard } from '@app/common/guards/jwt.auth.guard'; import { JwtAuthGuard } from '@app/common/guards/jwt.auth.guard';
import { EnableDisableStatusEnum } from '@app/common/constants/days.enum'; import { EnableDisableStatusEnum } from '@app/common/constants/days.enum';
@ -37,51 +35,29 @@ export class CommunityController {
@UseGuards(JwtAuthGuard) @UseGuards(JwtAuthGuard)
@Post() @Post()
async addCommunity(@Body() addCommunityDto: AddCommunityDto) { async addCommunity(@Body() addCommunityDto: AddCommunityDto) {
try { const community = await this.communityService.addCommunity(addCommunityDto);
const community = return {
await this.communityService.addCommunity(addCommunityDto); statusCode: HttpStatus.CREATED,
return { success: true,
statusCode: HttpStatus.CREATED, message: 'Community added successfully',
success: true, data: community,
message: 'Community added successfully', };
data: community,
};
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(JwtAuthGuard) @UseGuards(JwtAuthGuard)
@Get(':communityUuid') @Get(':communityUuid')
async getCommunityByUuid(@Param('communityUuid') communityUuid: string) { async getCommunityByUuid(@Param('communityUuid') communityUuid: string) {
try { const community =
const community = await this.communityService.getCommunityByUuid(communityUuid);
await this.communityService.getCommunityByUuid(communityUuid); return community;
return community;
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(JwtAuthGuard) @UseGuards(JwtAuthGuard)
@Get() @Get()
async getCommunities() { async getCommunities() {
try { const communities = await this.communityService.getCommunities();
const communities = await this.communityService.getCommunities(); return communities;
return communities;
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(JwtAuthGuard) @UseGuards(JwtAuthGuard)
@ -90,69 +66,41 @@ export class CommunityController {
@Param('communityUuid') communityUuid: string, @Param('communityUuid') communityUuid: string,
@Query() query: GetCommunityChildDto, @Query() query: GetCommunityChildDto,
) { ) {
try { const community = await this.communityService.getCommunityChildByUuid(
const community = await this.communityService.getCommunityChildByUuid( communityUuid,
communityUuid, query,
query, );
); return community;
return community;
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(JwtAuthGuard) @UseGuards(JwtAuthGuard)
@Get('user/:userUuid') @Get('user/:userUuid')
async getCommunitiesByUserId(@Param('userUuid') userUuid: string) { async getCommunitiesByUserId(@Param('userUuid') userUuid: string) {
try { return await this.communityService.getCommunitiesByUserId(userUuid);
return await this.communityService.getCommunitiesByUserId(userUuid);
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(AdminRoleGuard) @UseGuards(AdminRoleGuard)
@Post('user') @Post('user')
async addUserCommunity(@Body() addUserCommunityDto: AddUserCommunityDto) { async addUserCommunity(@Body() addUserCommunityDto: AddUserCommunityDto) {
try { await this.communityService.addUserCommunity(addUserCommunityDto);
await this.communityService.addUserCommunity(addUserCommunityDto); return {
return { statusCode: HttpStatus.CREATED,
statusCode: HttpStatus.CREATED, success: true,
success: true, message: 'user community added successfully',
message: 'user community added successfully', };
};
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(JwtAuthGuard) @UseGuards(JwtAuthGuard)
@Put('rename/:communityUuid') @Put(':communityUuid')
async renameCommunityByUuid( async renameCommunityByUuid(
@Param('communityUuid') communityUuid: string, @Param('communityUuid') communityUuid: string,
@Body() updateCommunityDto: UpdateCommunityNameDto, @Body() updateCommunityDto: UpdateCommunityNameDto,
) { ) {
try { const community = await this.communityService.renameCommunityByUuid(
const community = await this.communityService.renameCommunityByUuid( communityUuid,
communityUuid, updateCommunityDto,
updateCommunityDto, );
); return community;
return community;
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
} }

70
src/device-messages/controllers/device-messages.controller.ts
View File

@ -3,7 +3,6 @@ import {
Controller, Controller,
Delete, Delete,
Get, Get,
HttpException,
HttpStatus, HttpStatus,
Param, Param,
Post, Post,
@ -32,22 +31,15 @@ export class DeviceMessagesSubscriptionController {
async addDeviceMessagesSubscription( async addDeviceMessagesSubscription(
@Body() deviceMessagesAddDto: DeviceMessagesAddDto, @Body() deviceMessagesAddDto: DeviceMessagesAddDto,
) { ) {
try { const addDetails =
const addDetails = await this.deviceMessagesSubscriptionService.addDeviceMessagesSubscription(
await this.deviceMessagesSubscriptionService.addDeviceMessagesSubscription( deviceMessagesAddDto,
deviceMessagesAddDto,
);
return {
statusCode: HttpStatus.CREATED,
message: 'Device Messages Subscription Added Successfully',
data: addDetails,
};
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
); );
} return {
statusCode: HttpStatus.CREATED,
message: 'Device Messages Subscription Added Successfully',
data: addDetails,
};
} }
@ApiBearerAuth() @ApiBearerAuth()
@ -57,23 +49,16 @@ export class DeviceMessagesSubscriptionController {
@Param('deviceUuid') deviceUuid: string, @Param('deviceUuid') deviceUuid: string,
@Param('userUuid') userUuid: string, @Param('userUuid') userUuid: string,
) { ) {
try { const deviceDetails =
const deviceDetails = await this.deviceMessagesSubscriptionService.getDeviceMessagesSubscription(
await this.deviceMessagesSubscriptionService.getDeviceMessagesSubscription( userUuid,
userUuid, deviceUuid,
deviceUuid,
);
return {
statusCode: HttpStatus.OK,
message: 'User Device Subscription fetched Successfully',
data: deviceDetails,
};
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
); );
} return {
statusCode: HttpStatus.OK,
message: 'User Device Subscription fetched Successfully',
data: deviceDetails,
};
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(JwtAuthGuard) @UseGuards(JwtAuthGuard)
@ -81,19 +66,12 @@ export class DeviceMessagesSubscriptionController {
async deleteDeviceMessagesSubscription( async deleteDeviceMessagesSubscription(
@Body() deviceMessagesAddDto: DeviceMessagesAddDto, @Body() deviceMessagesAddDto: DeviceMessagesAddDto,
) { ) {
try { await this.deviceMessagesSubscriptionService.deleteDeviceMessagesSubscription(
await this.deviceMessagesSubscriptionService.deleteDeviceMessagesSubscription( deviceMessagesAddDto,
deviceMessagesAddDto, );
); return {
return { statusCode: HttpStatus.OK,
statusCode: HttpStatus.OK, message: 'User subscription deleted Successfully',
message: 'User subscription deleted Successfully', };
};
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
} }

206
src/device/controllers/device.controller.ts
View File

@ -6,7 +6,6 @@ import {
Post, Post,
Query, Query,
Param, Param,
HttpException,
HttpStatus, HttpStatus,
UseGuards, UseGuards,
Req, Req,
@ -44,34 +43,20 @@ export class DeviceController {
@UseGuards(SuperAdminRoleGuard, CheckDeviceGuard) @UseGuards(SuperAdminRoleGuard, CheckDeviceGuard)
@Post() @Post()
async addDeviceUser(@Body() addDeviceDto: AddDeviceDto) { async addDeviceUser(@Body() addDeviceDto: AddDeviceDto) {
try { const device = await this.deviceService.addDeviceUser(addDeviceDto);
const device = await this.deviceService.addDeviceUser(addDeviceDto);
return { return {
statusCode: HttpStatus.CREATED, statusCode: HttpStatus.CREATED,
success: true, success: true,
message: 'device added successfully', message: 'device added successfully',
data: device, data: device,
}; };
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(JwtAuthGuard) @UseGuards(JwtAuthGuard)
@Get('user/:userUuid') @Get('user/:userUuid')
async getDevicesByUser(@Param('userUuid') userUuid: string) { async getDevicesByUser(@Param('userUuid') userUuid: string) {
try { return await this.deviceService.getDevicesByUser(userUuid);
return await this.deviceService.getDevicesByUser(userUuid);
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(JwtAuthGuard, CheckRoomGuard) @UseGuards(JwtAuthGuard, CheckRoomGuard)
@ -80,31 +65,17 @@ export class DeviceController {
@Query() getDeviceByRoomUuidDto: GetDeviceByRoomUuidDto, @Query() getDeviceByRoomUuidDto: GetDeviceByRoomUuidDto,
@Req() req: any, @Req() req: any,
) { ) {
try { const userUuid = req.user.uuid;
const userUuid = req.user.uuid; return await this.deviceService.getDevicesByRoomId(
return await this.deviceService.getDevicesByRoomId( getDeviceByRoomUuidDto,
getDeviceByRoomUuidDto, userUuid,
userUuid, );
);
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(JwtAuthGuard) @UseGuards(JwtAuthGuard)
@Get('unit/:unitUuid') @Get('unit/:unitUuid')
async getDevicesByUnitId(@Param('unitUuid') unitUuid: string) { async getDevicesByUnitId(@Param('unitUuid') unitUuid: string) {
try { return await this.deviceService.getDevicesByUnitId(unitUuid);
return await this.deviceService.getDevicesByUnitId(unitUuid);
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(JwtAuthGuard, CheckRoomGuard) @UseGuards(JwtAuthGuard, CheckRoomGuard)
@ -112,23 +83,16 @@ export class DeviceController {
async updateDeviceInRoom( async updateDeviceInRoom(
@Body() updateDeviceInRoomDto: UpdateDeviceInRoomDto, @Body() updateDeviceInRoomDto: UpdateDeviceInRoomDto,
) { ) {
try { const device = await this.deviceService.updateDeviceInRoom(
const device = await this.deviceService.updateDeviceInRoom( updateDeviceInRoomDto,
updateDeviceInRoomDto, );
);
return { return {
statusCode: HttpStatus.CREATED, statusCode: HttpStatus.CREATED,
success: true, success: true,
message: 'device updated in room successfully', message: 'device updated in room successfully',
data: device, data: device,
}; };
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@ -138,18 +102,11 @@ export class DeviceController {
@Param('deviceUuid') deviceUuid: string, @Param('deviceUuid') deviceUuid: string,
@Req() req: any, @Req() req: any,
) { ) {
try { const userUuid = req.user.uuid;
const userUuid = req.user.uuid; return await this.deviceService.getDeviceDetailsByDeviceId(
return await this.deviceService.getDeviceDetailsByDeviceId( deviceUuid,
deviceUuid, userUuid,
userUuid, );
);
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(JwtAuthGuard, CheckUserHavePermission) @UseGuards(JwtAuthGuard, CheckUserHavePermission)
@ -157,29 +114,13 @@ export class DeviceController {
async getDeviceInstructionByDeviceId( async getDeviceInstructionByDeviceId(
@Param('deviceUuid') deviceUuid: string, @Param('deviceUuid') deviceUuid: string,
) { ) {
try { return await this.deviceService.getDeviceInstructionByDeviceId(deviceUuid);
return await this.deviceService.getDeviceInstructionByDeviceId(
deviceUuid,
);
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(JwtAuthGuard, CheckUserHavePermission) @UseGuards(JwtAuthGuard, CheckUserHavePermission)
@Get(':deviceUuid/functions/status') @Get(':deviceUuid/functions/status')
async getDevicesInstructionStatus(@Param('deviceUuid') deviceUuid: string) { async getDevicesInstructionStatus(@Param('deviceUuid') deviceUuid: string) {
try { return await this.deviceService.getDevicesInstructionStatus(deviceUuid);
return await this.deviceService.getDevicesInstructionStatus(deviceUuid);
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@ -189,17 +130,7 @@ export class DeviceController {
@Body() controlDeviceDto: ControlDeviceDto, @Body() controlDeviceDto: ControlDeviceDto,
@Param('deviceUuid') deviceUuid: string, @Param('deviceUuid') deviceUuid: string,
) { ) {
try { return await this.deviceService.controlDevice(controlDeviceDto, deviceUuid);
return await this.deviceService.controlDevice(
controlDeviceDto,
deviceUuid,
);
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(JwtAuthGuard) @UseGuards(JwtAuthGuard)
@ -208,43 +139,22 @@ export class DeviceController {
@Param('deviceUuid') deviceUuid: string, @Param('deviceUuid') deviceUuid: string,
@Param('firmwareVersion') firmwareVersion: number, @Param('firmwareVersion') firmwareVersion: number,
) { ) {
try { return await this.deviceService.updateDeviceFirmware(
return await this.deviceService.updateDeviceFirmware( deviceUuid,
deviceUuid, firmwareVersion,
firmwareVersion, );
);
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(JwtAuthGuard) @UseGuards(JwtAuthGuard)
@Get('gateway/:gatewayUuid/devices') @Get('gateway/:gatewayUuid/devices')
async getDevicesInGateway(@Param('gatewayUuid') gatewayUuid: string) { async getDevicesInGateway(@Param('gatewayUuid') gatewayUuid: string) {
try { return await this.deviceService.getDevicesInGateway(gatewayUuid);
return await this.deviceService.getDevicesInGateway(gatewayUuid);
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(JwtAuthGuard) @UseGuards(JwtAuthGuard)
@Get() @Get()
async getAllDevices() { async getAllDevices() {
try { return await this.deviceService.getAllDevices();
return await this.deviceService.getAllDevices();
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(JwtAuthGuard) @UseGuards(JwtAuthGuard)
@ -253,14 +163,7 @@ export class DeviceController {
@Param('deviceUuid') deviceUuid: string, @Param('deviceUuid') deviceUuid: string,
@Query() query: GetDeviceLogsDto, @Query() query: GetDeviceLogsDto,
) { ) {
try { return await this.deviceService.getDeviceLogs(deviceUuid, query);
return await this.deviceService.getDeviceLogs(deviceUuid, query);
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(JwtAuthGuard) @UseGuards(JwtAuthGuard)
@ -268,16 +171,7 @@ export class DeviceController {
async batchControlDevices( async batchControlDevices(
@Body() batchControlDevicesDto: BatchControlDevicesDto, @Body() batchControlDevicesDto: BatchControlDevicesDto,
) { ) {
try { return await this.deviceService.batchControlDevices(batchControlDevicesDto);
return await this.deviceService.batchControlDevices(
batchControlDevicesDto,
);
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(JwtAuthGuard) @UseGuards(JwtAuthGuard)
@ -285,14 +179,7 @@ export class DeviceController {
async batchStatusDevices( async batchStatusDevices(
@Query() batchStatusDevicesDto: BatchStatusDevicesDto, @Query() batchStatusDevicesDto: BatchStatusDevicesDto,
) { ) {
try { return await this.deviceService.batchStatusDevices(batchStatusDevicesDto);
return await this.deviceService.batchStatusDevices(batchStatusDevicesDto);
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(JwtAuthGuard) @UseGuards(JwtAuthGuard)
@ -300,15 +187,8 @@ export class DeviceController {
async batchFactoryResetDevices( async batchFactoryResetDevices(
@Body() batchFactoryResetDevicesDto: BatchFactoryResetDevicesDto, @Body() batchFactoryResetDevicesDto: BatchFactoryResetDevicesDto,
) { ) {
try { return await this.deviceService.batchFactoryResetDevices(
return await this.deviceService.batchFactoryResetDevices( batchFactoryResetDevicesDto,
batchFactoryResetDevicesDto, );
);
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
} }

49
src/device/services/device.service.ts
View File

@ -64,6 +64,7 @@ export class DeviceService {
return await this.deviceRepository.findOne({ return await this.deviceRepository.findOne({
where: { where: {
uuid: deviceUuid, uuid: deviceUuid,
isActive: true,
}, },
...(withProductDevice && { relations: ['productDevice'] }), ...(withProductDevice && { relations: ['productDevice'] }),
}); });
@ -72,6 +73,7 @@ export class DeviceService {
return await this.deviceRepository.findOne({ return await this.deviceRepository.findOne({
where: { where: {
deviceTuyaUuid, deviceTuyaUuid,
isActive: true,
}, },
relations: ['productDevice'], relations: ['productDevice'],
}); });
@ -128,6 +130,7 @@ export class DeviceService {
const devices = await this.deviceRepository.find({ const devices = await this.deviceRepository.find({
where: { where: {
user: { uuid: userUuid }, user: { uuid: userUuid },
isActive: true,
permission: { permission: {
userUuid, userUuid,
permissionType: { permissionType: {
@ -174,6 +177,7 @@ export class DeviceService {
const devices = await this.deviceRepository.find({ const devices = await this.deviceRepository.find({
where: { where: {
spaceDevice: { uuid: getDeviceByRoomUuidDto.roomUuid }, spaceDevice: { uuid: getDeviceByRoomUuidDto.roomUuid },
isActive: true,
permission: { permission: {
userUuid, userUuid,
permissionType: { permissionType: {
@ -223,6 +227,7 @@ export class DeviceService {
const device = await this.deviceRepository.findOne({ const device = await this.deviceRepository.findOne({
where: { where: {
uuid: updateDeviceInRoomDto.deviceUuid, uuid: updateDeviceInRoomDto.deviceUuid,
isActive: true,
}, },
relations: ['spaceDevice', 'spaceDevice.parent'], relations: ['spaceDevice', 'spaceDevice.parent'],
}); });
@ -409,7 +414,7 @@ export class DeviceService {
} }
async checkAllDevicesHaveSameProductUuid(deviceUuids: string[]) { async checkAllDevicesHaveSameProductUuid(deviceUuids: string[]) {
const firstDevice = await this.deviceRepository.findOne({ const firstDevice = await this.deviceRepository.findOne({
where: { uuid: deviceUuids[0] }, where: { uuid: deviceUuids[0], isActive: true },
relations: ['productDevice'], relations: ['productDevice'],
}); });
@ -421,7 +426,7 @@ export class DeviceService {
for (let i = 1; i < deviceUuids.length; i++) { for (let i = 1; i < deviceUuids.length; i++) {
const device = await this.deviceRepository.findOne({ const device = await this.deviceRepository.findOne({
where: { uuid: deviceUuids[i] }, where: { uuid: deviceUuids[i], isActive: true },
relations: ['productDevice'], relations: ['productDevice'],
}); });
@ -465,6 +470,11 @@ export class DeviceService {
if (operationResult.success) { if (operationResult.success) {
// Add to success results if operationResult.success is true // Add to success results if operationResult.success is true
successResults.push({ deviceUuid, result: operationResult }); 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 { } else {
// Add to failed results if operationResult.success is false // Add to failed results if operationResult.success is false
failedResults.push({ deviceUuid, error: operationResult.msg }); failedResults.push({ deviceUuid, error: operationResult.msg });
@ -645,6 +655,7 @@ export class DeviceService {
const device = await this.deviceRepository.findOne({ const device = await this.deviceRepository.findOne({
where: { where: {
uuid: deviceUuid, uuid: deviceUuid,
isActive: true,
permission: { permission: {
userUuid: userUuid, userUuid: userUuid,
}, },
@ -669,19 +680,25 @@ export class DeviceService {
const devices = await Promise.all( const devices = await Promise.all(
response.map(async (device: any) => { response.map(async (device: any) => {
const deviceDetails = await this.getDeviceByDeviceTuyaUuid(device.id); try {
if (deviceDetails.deviceTuyaUuid) { const deviceDetails = await this.getDeviceByDeviceTuyaUuid(
// eslint-disable-next-line @typescript-eslint/no-unused-vars device.id,
const { id, ...rest } = device; );
return { if (deviceDetails.deviceTuyaUuid) {
...rest, // eslint-disable-next-line @typescript-eslint/no-unused-vars
tuyaUuid: deviceDetails.deviceTuyaUuid, const { id, ...rest } = device;
uuid: deviceDetails.uuid, return {
productUuid: deviceDetails.productDevice.uuid, ...rest,
productType: deviceDetails.productDevice.prodType, tuyaUuid: deviceDetails.deviceTuyaUuid,
}; uuid: deviceDetails.uuid,
productUuid: deviceDetails.productDevice.uuid,
productType: deviceDetails.productDevice.prodType,
};
}
return null;
} catch (error) {
return null;
} }
return null;
}), }),
); );
@ -770,6 +787,9 @@ export class DeviceService {
parent: { parent: {
uuid: unitUuid, uuid: unitUuid,
}, },
devicesSpaceEntity: {
isActive: true,
},
}, },
relations: ['devicesSpaceEntity', 'devicesSpaceEntity.productDevice'], relations: ['devicesSpaceEntity', 'devicesSpaceEntity.productDevice'],
}); });
@ -804,6 +824,7 @@ export class DeviceService {
async getAllDevices(): Promise<GetDeviceDetailsInterface[]> { async getAllDevices(): Promise<GetDeviceDetailsInterface[]> {
try { try {
const devices = await this.deviceRepository.find({ const devices = await this.deviceRepository.find({
where: { isActive: true },
relations: [ relations: [
'spaceDevice.parent', 'spaceDevice.parent',
'productDevice', 'productDevice',

199
src/door-lock/controllers/door.lock.controller.ts
View File

@ -4,7 +4,6 @@ import {
Controller, Controller,
Post, Post,
Param, Param,
HttpException,
HttpStatus, HttpStatus,
Get, Get,
Delete, Delete,
@ -32,27 +31,20 @@ export class DoorLockController {
@Body() addDoorLockDto: AddDoorLockOnlineDto, @Body() addDoorLockDto: AddDoorLockOnlineDto,
@Param('doorLockUuid') doorLockUuid: string, @Param('doorLockUuid') doorLockUuid: string,
) { ) {
try { const temporaryPassword =
const temporaryPassword = await this.doorLockService.addOnlineTemporaryPassword(
await this.doorLockService.addOnlineTemporaryPassword( addDoorLockDto,
addDoorLockDto, doorLockUuid,
doorLockUuid,
);
return {
statusCode: HttpStatus.CREATED,
success: true,
message: 'online temporary password added successfully',
data: {
id: temporaryPassword.id,
},
};
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
); );
}
return {
statusCode: HttpStatus.CREATED,
success: true,
message: 'online temporary password added successfully',
data: {
id: temporaryPassword.id,
},
};
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(JwtAuthGuard) @UseGuards(JwtAuthGuard)
@ -60,24 +52,17 @@ export class DoorLockController {
async addOfflineOneTimeTemporaryPassword( async addOfflineOneTimeTemporaryPassword(
@Param('doorLockUuid') doorLockUuid: string, @Param('doorLockUuid') doorLockUuid: string,
) { ) {
try { const temporaryPassword =
const temporaryPassword = await this.doorLockService.addOfflineOneTimeTemporaryPassword(
await this.doorLockService.addOfflineOneTimeTemporaryPassword( doorLockUuid,
doorLockUuid,
);
return {
statusCode: HttpStatus.CREATED,
success: true,
message: 'offline temporary password added successfully',
data: temporaryPassword,
};
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
); );
}
return {
statusCode: HttpStatus.CREATED,
success: true,
message: 'offline temporary password added successfully',
data: temporaryPassword,
};
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(JwtAuthGuard) @UseGuards(JwtAuthGuard)
@ -87,25 +72,18 @@ export class DoorLockController {
addDoorLockOfflineTempMultipleTimeDto: AddDoorLockOfflineTempMultipleTimeDto, addDoorLockOfflineTempMultipleTimeDto: AddDoorLockOfflineTempMultipleTimeDto,
@Param('doorLockUuid') doorLockUuid: string, @Param('doorLockUuid') doorLockUuid: string,
) { ) {
try { const temporaryPassword =
const temporaryPassword = await this.doorLockService.addOfflineMultipleTimeTemporaryPassword(
await this.doorLockService.addOfflineMultipleTimeTemporaryPassword( addDoorLockOfflineTempMultipleTimeDto,
addDoorLockOfflineTempMultipleTimeDto, doorLockUuid,
doorLockUuid,
);
return {
statusCode: HttpStatus.CREATED,
success: true,
message: 'offline temporary password added successfully',
data: temporaryPassword,
};
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
); );
}
return {
statusCode: HttpStatus.CREATED,
success: true,
message: 'offline temporary password added successfully',
data: temporaryPassword,
};
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(JwtAuthGuard) @UseGuards(JwtAuthGuard)
@ -113,16 +91,9 @@ export class DoorLockController {
async getOnlineTemporaryPasswords( async getOnlineTemporaryPasswords(
@Param('doorLockUuid') doorLockUuid: string, @Param('doorLockUuid') doorLockUuid: string,
) { ) {
try { return await this.doorLockService.getOnlineTemporaryPasswordsMultiple(
return await this.doorLockService.getOnlineTemporaryPasswordsMultiple( doorLockUuid,
doorLockUuid, );
);
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(JwtAuthGuard) @UseGuards(JwtAuthGuard)
@ -131,21 +102,11 @@ export class DoorLockController {
@Param('doorLockUuid') doorLockUuid: string, @Param('doorLockUuid') doorLockUuid: string,
@Param('passwordId') passwordId: string, @Param('passwordId') passwordId: string,
) { ) {
try { await this.doorLockService.deleteDoorLockPassword(doorLockUuid, passwordId);
await this.doorLockService.deleteDoorLockPassword( return {
doorLockUuid, statusCode: HttpStatus.OK,
passwordId, message: 'Temporary Password deleted Successfully',
); };
return {
statusCode: HttpStatus.OK,
message: 'Temporary Password deleted Successfully',
};
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(JwtAuthGuard) @UseGuards(JwtAuthGuard)
@ -153,16 +114,9 @@ export class DoorLockController {
async getOfflineOneTimeTemporaryPasswords( async getOfflineOneTimeTemporaryPasswords(
@Param('doorLockUuid') doorLockUuid: string, @Param('doorLockUuid') doorLockUuid: string,
) { ) {
try { return await this.doorLockService.getOfflineOneTimeTemporaryPasswords(
return await this.doorLockService.getOfflineOneTimeTemporaryPasswords( doorLockUuid,
doorLockUuid, );
);
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(JwtAuthGuard) @UseGuards(JwtAuthGuard)
@ -170,16 +124,9 @@ export class DoorLockController {
async getOfflineMultipleTimeTemporaryPasswords( async getOfflineMultipleTimeTemporaryPasswords(
@Param('doorLockUuid') doorLockUuid: string, @Param('doorLockUuid') doorLockUuid: string,
) { ) {
try { return await this.doorLockService.getOfflineMultipleTimeTemporaryPasswords(
return await this.doorLockService.getOfflineMultipleTimeTemporaryPasswords( doorLockUuid,
doorLockUuid, );
);
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@ -191,44 +138,30 @@ export class DoorLockController {
@Param('doorLockUuid') doorLockUuid: string, @Param('doorLockUuid') doorLockUuid: string,
@Param('passwordId') passwordId: string, @Param('passwordId') passwordId: string,
) { ) {
try { const temporaryPassword =
const temporaryPassword = await this.doorLockService.updateOfflineTemporaryPassword(
await this.doorLockService.updateOfflineTemporaryPassword( updateDoorLockOfflineTempDto,
updateDoorLockOfflineTempDto, doorLockUuid,
doorLockUuid, passwordId,
passwordId,
);
return {
statusCode: HttpStatus.CREATED,
success: true,
message: 'offline temporary password updated successfully',
data: temporaryPassword,
};
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
); );
}
return {
statusCode: HttpStatus.CREATED,
success: true,
message: 'offline temporary password updated successfully',
data: temporaryPassword,
};
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(JwtAuthGuard) @UseGuards(JwtAuthGuard)
@Post('open/:doorLockUuid') @Post('open/:doorLockUuid')
async openDoorLock(@Param('doorLockUuid') doorLockUuid: string) { async openDoorLock(@Param('doorLockUuid') doorLockUuid: string) {
try { await this.doorLockService.openDoorLock(doorLockUuid);
await this.doorLockService.openDoorLock(doorLockUuid);
return { return {
statusCode: HttpStatus.CREATED, statusCode: HttpStatus.CREATED,
success: true, success: true,
message: 'door lock opened successfully', message: 'door lock opened successfully',
}; };
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
} }

1
src/door-lock/services/door.lock.service.ts
View File

@ -859,6 +859,7 @@ export class DoorLockService {
return await this.deviceRepository.findOne({ return await this.deviceRepository.findOne({
where: { where: {
uuid: deviceUuid, uuid: deviceUuid,
isActive: true,
}, },
...(withProductDevice && { relations: ['productDevice'] }), ...(withProductDevice && { relations: ['productDevice'] }),
}); });

18
src/error-message/error-message.service.spec.ts Normal file
View File

@ -0,0 +1,18 @@
import { Test, TestingModule } from '@nestjs/testing';
import { ErrorMessageService } from './error-message.service';
describe('ErrorMessageService', () => {
let service: ErrorMessageService;
beforeEach(async () => {
const module: TestingModule = await Test.createTestingModule({
providers: [ErrorMessageService],
}).compile();
service = module.get<ErrorMessageService>(ErrorMessageService);
});
it('should be defined', () => {
expect(service).toBeDefined();
});
});

40
src/error-message/error-message.service.ts Normal file
View File

@ -0,0 +1,40 @@
// src/common/services/error-message.service.ts
import { Injectable } from '@nestjs/common';
type ErrorMessageKey = keyof typeof ErrorMessageService.prototype.messages;
@Injectable()
export class ErrorMessageService {
public readonly messages = {
NOT_FOUND: '{entity} not found', // Single key for "not found" errors
INVALID_MINUTES: 'Invalid minutes value',
INVALID_TIME_FORMAT: 'Invalid time format',
USER_NOT_FOUND: '{entity} not found', // Can reuse NOT_FOUND if desired
INTERNAL_SERVER_ERROR: 'Internal server error',
ERROR_ADDING_TEMP_PASSWORD:
'Error adding {type} temporary password from Tuya',
INVALID_UUID: 'Invalid {entity} UUID',
USER_ALREADY_BELONGS: 'This user already belongs to this {entity}',
USER_HAS_NO_ENTITIES: 'This user has no {entity}',
DEVICE_OPERATION_FAILED: 'All device operations failed',
REQUEST_FAILED: 'Error processing {operation} request',
COOLDOWN_ERROR:
'Please wait {time} more seconds before requesting a new OTP.',
};
getMessage(
key: ErrorMessageKey,
params?: Record<string, string | number>,
): string {
let message = this.messages[key] || 'Unknown error';
// Replace placeholders with provided params
if (params) {
Object.keys(params).forEach((param) => {
const regex = new RegExp(`{${param}}`, 'g');
message = message.replace(regex, params[param].toString());
});
}
return message;
}
}

105
src/floor/controllers/floor.controller.ts
View File

@ -3,7 +3,6 @@ import {
Body, Body,
Controller, Controller,
Get, Get,
HttpException,
HttpStatus, HttpStatus,
Param, Param,
Post, Post,
@ -35,35 +34,21 @@ export class FloorController {
@UseGuards(JwtAuthGuard, CheckBuildingTypeGuard) @UseGuards(JwtAuthGuard, CheckBuildingTypeGuard)
@Post() @Post()
async addFloor(@Body() addFloorDto: AddFloorDto) { async addFloor(@Body() addFloorDto: AddFloorDto) {
try { const floor = await this.floorService.addFloor(addFloorDto);
const floor = await this.floorService.addFloor(addFloorDto); return {
return { statusCode: HttpStatus.CREATED,
statusCode: HttpStatus.CREATED, success: true,
success: true, message: 'Floor added successfully',
message: 'Floor added successfully', data: floor,
data: floor, };
};
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(JwtAuthGuard, FloorPermissionGuard) @UseGuards(JwtAuthGuard, FloorPermissionGuard)
@Get(':floorUuid') @Get(':floorUuid')
async getFloorByUuid(@Param('floorUuid') floorUuid: string) { async getFloorByUuid(@Param('floorUuid') floorUuid: string) {
try { const floor = await this.floorService.getFloorByUuid(floorUuid);
const floor = await this.floorService.getFloorByUuid(floorUuid); return floor;
return floor;
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@ -73,85 +58,47 @@ export class FloorController {
@Param('floorUuid') floorUuid: string, @Param('floorUuid') floorUuid: string,
@Query() query: GetFloorChildDto, @Query() query: GetFloorChildDto,
) { ) {
try { const floor = await this.floorService.getFloorChildByUuid(floorUuid, query);
const floor = await this.floorService.getFloorChildByUuid( return floor;
floorUuid,
query,
);
return floor;
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(JwtAuthGuard, FloorPermissionGuard) @UseGuards(JwtAuthGuard, FloorPermissionGuard)
@Get('parent/:floorUuid') @Get('parent/:floorUuid')
async getFloorParentByUuid(@Param('floorUuid') floorUuid: string) { async getFloorParentByUuid(@Param('floorUuid') floorUuid: string) {
try { const floor = await this.floorService.getFloorParentByUuid(floorUuid);
const floor = await this.floorService.getFloorParentByUuid(floorUuid); return floor;
return floor;
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(AdminRoleGuard, CheckUserFloorGuard) @UseGuards(AdminRoleGuard, CheckUserFloorGuard)
@Post('user') @Post('user')
async addUserFloor(@Body() addUserFloorDto: AddUserFloorDto) { async addUserFloor(@Body() addUserFloorDto: AddUserFloorDto) {
try { await this.floorService.addUserFloor(addUserFloorDto);
await this.floorService.addUserFloor(addUserFloorDto); return {
return { statusCode: HttpStatus.CREATED,
statusCode: HttpStatus.CREATED, success: true,
success: true, message: 'user floor added successfully',
message: 'user floor added successfully', };
};
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(JwtAuthGuard) @UseGuards(JwtAuthGuard)
@Get('user/:userUuid') @Get('user/:userUuid')
async getFloorsByUserId(@Param('userUuid') userUuid: string) { async getFloorsByUserId(@Param('userUuid') userUuid: string) {
try { return await this.floorService.getFloorsByUserId(userUuid);
return await this.floorService.getFloorsByUserId(userUuid);
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(JwtAuthGuard, FloorPermissionGuard) @UseGuards(JwtAuthGuard, FloorPermissionGuard)
@Put('rename/:floorUuid') @Put(':floorUuid')
async renameFloorByUuid( async renameFloorByUuid(
@Param('floorUuid') floorUuid: string, @Param('floorUuid') floorUuid: string,
@Body() updateFloorNameDto: UpdateFloorNameDto, @Body() updateFloorNameDto: UpdateFloorNameDto,
) { ) {
try { const floor = await this.floorService.renameFloorByUuid(
const floor = await this.floorService.renameFloorByUuid( floorUuid,
floorUuid, updateFloorNameDto,
updateFloorNameDto, );
); return floor;
return floor;
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
} }

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

@ -1,13 +1,5 @@
import { GroupService } from '../services/group.service'; import { GroupService } from '../services/group.service';
import { import { Controller, Get, UseGuards, Param, Req } from '@nestjs/common';
Controller,
Get,
UseGuards,
Param,
HttpException,
HttpStatus,
Req,
} from '@nestjs/common';
import { ApiTags, ApiBearerAuth } from '@nestjs/swagger'; import { ApiTags, ApiBearerAuth } from '@nestjs/swagger';
import { JwtAuthGuard } from '@app/common/guards/jwt.auth.guard'; import { JwtAuthGuard } from '@app/common/guards/jwt.auth.guard';
import { UnitPermissionGuard } from 'src/guards/unit.permission.guard'; import { UnitPermissionGuard } from 'src/guards/unit.permission.guard';
@ -25,14 +17,7 @@ export class GroupController {
@UseGuards(JwtAuthGuard, UnitPermissionGuard) @UseGuards(JwtAuthGuard, UnitPermissionGuard)
@Get(':unitUuid') @Get(':unitUuid')
async getGroupsBySpaceUuid(@Param('unitUuid') unitUuid: string) { async getGroupsBySpaceUuid(@Param('unitUuid') unitUuid: string) {
try { return await this.groupService.getGroupsByUnitUuid(unitUuid);
return await this.groupService.getGroupsByUnitUuid(unitUuid);
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(JwtAuthGuard, UnitPermissionGuard) @UseGuards(JwtAuthGuard, UnitPermissionGuard)
@ -42,19 +27,12 @@ export class GroupController {
@Param('groupName') groupName: string, @Param('groupName') groupName: string,
@Req() req: any, @Req() req: any,
) { ) {
try { const userUuid = req.user.uuid;
const userUuid = req.user.uuid;
return await this.groupService.getUnitDevicesByGroupName( return await this.groupService.getUnitDevicesByGroupName(
unitUuid, unitUuid,
groupName, groupName,
userUuid, userUuid,
); );
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
} }

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

@ -7,6 +7,7 @@ import { convertKeysToCamelCase } from '@app/common/helper/camelCaseConverter';
import { ProductRepository } from '@app/common/modules/product/repositories'; import { ProductRepository } from '@app/common/modules/product/repositories';
import { PermissionType } from '@app/common/constants/permission-type.enum'; import { PermissionType } from '@app/common/constants/permission-type.enum';
import { In } from 'typeorm'; import { In } from 'typeorm';
import { ProductType } from '@app/common/constants/product-type.enum';
@Injectable() @Injectable()
export class GroupService { export class GroupService {
@ -44,8 +45,24 @@ export class GroupService {
}); });
const uniqueGroupNames = [...new Set(groupNames)]; const uniqueGroupNames = [...new Set(groupNames)];
const groups = uniqueGroupNames.map((groupName) => ({
return uniqueGroupNames.map((groupName) => ({ groupName })); groupName: groupName as ProductType,
}));
const allowedProductTypes = [
ProductType.ONE_1TG,
ProductType.TWO_2TG,
ProductType.THREE_3TG,
ProductType.THREE_G,
ProductType.TWO_G,
ProductType.ONE_G,
ProductType.GD,
ProductType.WH,
ProductType.AC,
ProductType.CUR,
];
return groups.filter((group) =>
allowedProductTypes.includes(group.groupName),
);
} catch (error) { } catch (error) {
throw new HttpException( throw new HttpException(
'This unit does not have any groups', 'This unit does not have any groups',

4
src/guards/device.product.guard.ts
View File

@ -28,7 +28,7 @@ export class CheckProductUuidForAllDevicesGuard implements CanActivate {
async checkAllDevicesHaveSameProductUuid(deviceUuids: string[]) { async checkAllDevicesHaveSameProductUuid(deviceUuids: string[]) {
const firstDevice = await this.deviceRepository.findOne({ const firstDevice = await this.deviceRepository.findOne({
where: { uuid: deviceUuids[0] }, where: { uuid: deviceUuids[0], isActive: true },
relations: ['productDevice'], relations: ['productDevice'],
}); });
@ -40,7 +40,7 @@ export class CheckProductUuidForAllDevicesGuard implements CanActivate {
for (let i = 1; i < deviceUuids.length; i++) { for (let i = 1; i < deviceUuids.length; i++) {
const device = await this.deviceRepository.findOne({ const device = await this.deviceRepository.findOne({
where: { uuid: deviceUuids[i] }, where: { uuid: deviceUuids[i], isActive: true },
relations: ['productDevice'], relations: ['productDevice'],
}); });

1
src/guards/room.guard.ts
View File

@ -56,6 +56,7 @@ export class CheckRoomGuard implements CanActivate {
const response = await this.deviceRepository.findOne({ const response = await this.deviceRepository.findOne({
where: { where: {
uuid: deviceUuid, uuid: deviceUuid,
isActive: true,
}, },
}); });

6
src/guards/user.device.controllable.permission.guard.ts
View File

@ -58,7 +58,11 @@ export class CheckUserHaveControllablePermission implements CanActivate {
deviceUuid: string, deviceUuid: string,
): Promise<string> { ): Promise<string> {
const device = await this.deviceRepository.findOne({ const device = await this.deviceRepository.findOne({
where: { uuid: deviceUuid, permission: { userUuid: userUuid } }, where: {
uuid: deviceUuid,
isActive: true,
permission: { userUuid: userUuid },
},
relations: ['permission', 'permission.permissionType'], relations: ['permission', 'permission.permissionType'],
}); });

6
src/guards/user.device.permission.guard.ts
View File

@ -59,7 +59,11 @@ export class CheckUserHavePermission implements CanActivate {
deviceUuid: string, deviceUuid: string,
): Promise<string> { ): Promise<string> {
const device = await this.deviceRepository.findOne({ const device = await this.deviceRepository.findOne({
where: { uuid: deviceUuid, permission: { userUuid: userUuid } }, where: {
uuid: deviceUuid,
permission: { userUuid: userUuid },
isActive: true,
},
relations: ['permission', 'permission.permissionType'], relations: ['permission', 'permission.permissionType'],
}); });

2
src/main.ts
View File

@ -6,6 +6,7 @@ import { setupSwaggerAuthentication } from '../libs/common/src/util/user-auth.sw
import { ValidationPipe } from '@nestjs/common'; import { ValidationPipe } from '@nestjs/common';
import { json, urlencoded } from 'body-parser'; import { json, urlencoded } from 'body-parser';
import { SeederService } from '@app/common/seed/services/seeder.service'; import { SeederService } from '@app/common/seed/services/seeder.service';
import { HttpExceptionFilter } from './common/filters/http-exception/http-exception.filter';
async function bootstrap() { async function bootstrap() {
const app = await NestFactory.create(AppModule); const app = await NestFactory.create(AppModule);
@ -15,6 +16,7 @@ async function bootstrap() {
// Set the body parser limit to 1 MB // Set the body parser limit to 1 MB
app.use(json({ limit: '1mb' })); app.use(json({ limit: '1mb' }));
app.use(urlencoded({ limit: '1mb', extended: true })); app.use(urlencoded({ limit: '1mb', extended: true }));
app.useGlobalFilters(new HttpExceptionFilter());
app.use( app.use(
rateLimit({ rateLimit({

11
src/region/controllers/region.controller.ts
View File

@ -1,4 +1,4 @@
import { Controller, Get, HttpException, HttpStatus } from '@nestjs/common'; import { Controller, Get } from '@nestjs/common';
import { RegionService } from '../services/region.service'; import { RegionService } from '../services/region.service';
import { ApiTags, ApiOperation } from '@nestjs/swagger'; import { ApiTags, ApiOperation } from '@nestjs/swagger';
import { ControllerRoute } from '@app/common/constants/controller-route'; import { ControllerRoute } from '@app/common/constants/controller-route';
@ -18,13 +18,6 @@ export class RegionController {
description: ControllerRoute.REGION.ACTIONS.GET_REGIONS_DESCRIPTION, description: ControllerRoute.REGION.ACTIONS.GET_REGIONS_DESCRIPTION,
}) })
async getAllRegions() { async getAllRegions() {
try { return await this.regionService.getAllRegions();
return await this.regionService.getAllRegions();
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
} }

3
src/region/region.module.ts
View File

@ -3,9 +3,10 @@ import { RegionService } from './services/region.service';
import { RegionController } from './controllers/region.controller'; import { RegionController } from './controllers/region.controller';
import { ConfigModule } from '@nestjs/config'; import { ConfigModule } from '@nestjs/config';
import { RegionRepository } from '@app/common/modules/region/repositories'; import { RegionRepository } from '@app/common/modules/region/repositories';
import { CommonModule } from '@app/common';
@Module({ @Module({
imports: [ConfigModule], imports: [ConfigModule, CommonModule],
controllers: [RegionController], controllers: [RegionController],
providers: [RegionService, RegionRepository], providers: [RegionService, RegionRepository],
exports: [RegionService], exports: [RegionService],

16
src/region/services/region.service.ts
View File

@ -2,23 +2,33 @@ import {
BadRequestException, BadRequestException,
HttpException, HttpException,
HttpStatus, HttpStatus,
Inject,
Injectable, Injectable,
} from '@nestjs/common'; } from '@nestjs/common';
import { RegionRepository } from '@app/common/modules/region/repositories'; import { RegionRepository } from '@app/common/modules/region/repositories';
import { ErrorMessageService } from 'src/error-message/error-message.service';
@Injectable() @Injectable()
export class RegionService { export class RegionService {
constructor(private readonly regionRepository: RegionRepository) {} constructor(
private readonly regionRepository: RegionRepository,
@Inject(ErrorMessageService)
private readonly errorMessageService: ErrorMessageService,
) {}
async getAllRegions() { async getAllRegions() {
try { try {
const regions = await this.regionRepository.find(); const regions = await this.regionRepository.find();
return regions; return regions;
} catch (err) { } catch (err) {
if (err instanceof BadRequestException) { if (err instanceof BadRequestException) {
throw err; // Re-throw BadRequestException throw err; // Re-throw BadRequestException
} else { } else {
throw new HttpException('Regions found', HttpStatus.NOT_FOUND); throw new HttpException(
this.errorMessageService.getMessage('NOT_FOUND', {
entity: 'Regions',
}),
HttpStatus.NOT_FOUND,
);
} }
} }
} }

34
src/role/controllers/role.controller.ts
View File

@ -2,7 +2,6 @@ import {
Body, Body,
Controller, Controller,
Get, Get,
HttpException,
HttpStatus, HttpStatus,
Post, Post,
UseGuards, UseGuards,
@ -24,32 +23,21 @@ export class RoleController {
@UseGuards(SuperAdminRoleGuard) @UseGuards(SuperAdminRoleGuard)
@Get('types') @Get('types')
async fetchRoleTypes() { async fetchRoleTypes() {
try { const roleTypes = await this.roleService.fetchRoleTypes();
const roleTypes = await this.roleService.fetchRoleTypes(); return {
return { statusCode: HttpStatus.OK,
statusCode: HttpStatus.OK, message: 'Role Types fetched Successfully',
message: 'Role Types fetched Successfully', data: roleTypes,
data: roleTypes, };
};
} catch (err) {
throw new Error(err);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(SuperAdminRoleGuard) @UseGuards(SuperAdminRoleGuard)
@Post() @Post()
async addUserRoleType(@Body() addUserRoleDto: AddUserRoleDto) { async addUserRoleType(@Body() addUserRoleDto: AddUserRoleDto) {
try { await this.roleService.addUserRoleType(addUserRoleDto);
await this.roleService.addUserRoleType(addUserRoleDto); return {
return { statusCode: HttpStatus.OK,
statusCode: HttpStatus.OK, message: 'User Role Added Successfully',
message: 'User Role Added Successfully', };
};
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
} }

91
src/room/controllers/room.controller.ts
View File

@ -3,7 +3,6 @@ import {
Body, Body,
Controller, Controller,
Get, Get,
HttpException,
HttpStatus, HttpStatus,
Param, Param,
Post, Post,
@ -33,101 +32,59 @@ export class RoomController {
@UseGuards(JwtAuthGuard, CheckUnitTypeGuard) @UseGuards(JwtAuthGuard, CheckUnitTypeGuard)
@Post() @Post()
async addRoom(@Body() addRoomDto: AddRoomDto) { async addRoom(@Body() addRoomDto: AddRoomDto) {
try { const room = await this.roomService.addRoom(addRoomDto);
const room = await this.roomService.addRoom(addRoomDto); return {
return { statusCode: HttpStatus.CREATED,
statusCode: HttpStatus.CREATED, success: true,
success: true, message: 'Room added successfully',
message: 'Room added successfully', data: room,
data: room, };
};
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(JwtAuthGuard, RoomPermissionGuard) @UseGuards(JwtAuthGuard, RoomPermissionGuard)
@Get(':roomUuid') @Get(':roomUuid')
async getRoomByUuid(@Param('roomUuid') roomUuid: string) { async getRoomByUuid(@Param('roomUuid') roomUuid: string) {
try { const room = await this.roomService.getRoomByUuid(roomUuid);
const room = await this.roomService.getRoomByUuid(roomUuid); return room;
return room;
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(JwtAuthGuard, RoomPermissionGuard) @UseGuards(JwtAuthGuard, RoomPermissionGuard)
@Get('parent/:roomUuid') @Get('parent/:roomUuid')
async getRoomParentByUuid(@Param('roomUuid') roomUuid: string) { async getRoomParentByUuid(@Param('roomUuid') roomUuid: string) {
try { const room = await this.roomService.getRoomParentByUuid(roomUuid);
const room = await this.roomService.getRoomParentByUuid(roomUuid); return room;
return room;
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(AdminRoleGuard, CheckUserRoomGuard) @UseGuards(AdminRoleGuard, CheckUserRoomGuard)
@Post('user') @Post('user')
async addUserRoom(@Body() addUserRoomDto: AddUserRoomDto) { async addUserRoom(@Body() addUserRoomDto: AddUserRoomDto) {
try { await this.roomService.addUserRoom(addUserRoomDto);
await this.roomService.addUserRoom(addUserRoomDto); return {
return { statusCode: HttpStatus.CREATED,
statusCode: HttpStatus.CREATED, success: true,
success: true, message: 'user room added successfully',
message: 'user room added successfully', };
};
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(JwtAuthGuard) @UseGuards(JwtAuthGuard)
@Get('user/:userUuid') @Get('user/:userUuid')
async getRoomsByUserId(@Param('userUuid') userUuid: string) { async getRoomsByUserId(@Param('userUuid') userUuid: string) {
try { return await this.roomService.getRoomsByUserId(userUuid);
return await this.roomService.getRoomsByUserId(userUuid);
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(JwtAuthGuard, RoomPermissionGuard) @UseGuards(JwtAuthGuard, RoomPermissionGuard)
@Put('rename/:roomUuid') @Put(':roomUuid')
async renameRoomByUuid( async renameRoomByUuid(
@Param('roomUuid') roomUuid: string, @Param('roomUuid') roomUuid: string,
@Body() updateRoomNameDto: UpdateRoomNameDto, @Body() updateRoomNameDto: UpdateRoomNameDto,
) { ) {
try { const room = await this.roomService.renameRoomByUuid(
const room = await this.roomService.renameRoomByUuid( roomUuid,
roomUuid, updateRoomNameDto,
updateRoomNameDto, );
); return room;
return room;
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
} }

114
src/scene/controllers/scene.controller.ts
View File

@ -4,7 +4,6 @@ import {
Controller, Controller,
Delete, Delete,
Get, Get,
HttpException,
HttpStatus, HttpStatus,
Param, Param,
Post, Post,
@ -28,36 +27,22 @@ export class SceneController {
@UseGuards(JwtAuthGuard) @UseGuards(JwtAuthGuard)
@Post('tap-to-run') @Post('tap-to-run')
async addTapToRunScene(@Body() addSceneTapToRunDto: AddSceneTapToRunDto) { async addTapToRunScene(@Body() addSceneTapToRunDto: AddSceneTapToRunDto) {
try { const tapToRunScene =
const tapToRunScene = await this.sceneService.addTapToRunScene(addSceneTapToRunDto);
await this.sceneService.addTapToRunScene(addSceneTapToRunDto); return {
return { statusCode: HttpStatus.CREATED,
statusCode: HttpStatus.CREATED, success: true,
success: true, message: 'Scene added successfully',
message: 'Scene added successfully', data: tapToRunScene,
data: tapToRunScene, };
};
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(JwtAuthGuard) @UseGuards(JwtAuthGuard)
@Get('tap-to-run/:unitUuid') @Get('tap-to-run/:unitUuid')
async getTapToRunSceneByUnit(@Param('unitUuid') unitUuid: string) { async getTapToRunSceneByUnit(@Param('unitUuid') unitUuid: string) {
try { const tapToRunScenes =
const tapToRunScenes = await this.sceneService.getTapToRunSceneByUnit(unitUuid);
await this.sceneService.getTapToRunSceneByUnit(unitUuid); return tapToRunScenes;
return tapToRunScenes;
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(JwtAuthGuard) @UseGuards(JwtAuthGuard)
@ -66,53 +51,31 @@ export class SceneController {
@Param('unitUuid') unitUuid: string, @Param('unitUuid') unitUuid: string,
@Param('sceneId') sceneId: string, @Param('sceneId') sceneId: string,
) { ) {
try { await this.sceneService.deleteTapToRunScene(unitUuid, sceneId);
await this.sceneService.deleteTapToRunScene(unitUuid, sceneId); return {
return { statusCode: HttpStatus.OK,
statusCode: HttpStatus.OK, message: 'Scene Deleted Successfully',
message: 'Scene Deleted Successfully', };
};
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(JwtAuthGuard) @UseGuards(JwtAuthGuard)
@Post('tap-to-run/trigger/:sceneId') @Post('tap-to-run/trigger/:sceneId')
async triggerTapToRunScene(@Param('sceneId') sceneId: string) { async triggerTapToRunScene(@Param('sceneId') sceneId: string) {
try { await this.sceneService.triggerTapToRunScene(sceneId);
await this.sceneService.triggerTapToRunScene(sceneId); return {
return { statusCode: HttpStatus.CREATED,
statusCode: HttpStatus.CREATED, success: true,
success: true, message: 'Scene trigger successfully',
message: 'Scene trigger successfully', };
};
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(JwtAuthGuard) @UseGuards(JwtAuthGuard)
@Get('tap-to-run/details/:sceneId') @Get('tap-to-run/details/:sceneId')
async getTapToRunSceneDetails(@Param('sceneId') sceneId: string) { async getTapToRunSceneDetails(@Param('sceneId') sceneId: string) {
try { const tapToRunScenes =
const tapToRunScenes = await this.sceneService.getTapToRunSceneDetails(sceneId);
await this.sceneService.getTapToRunSceneDetails(sceneId); return tapToRunScenes;
return tapToRunScenes;
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
``;
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(JwtAuthGuard) @UseGuards(JwtAuthGuard)
@ -121,22 +84,15 @@ export class SceneController {
@Body() updateSceneTapToRunDto: UpdateSceneTapToRunDto, @Body() updateSceneTapToRunDto: UpdateSceneTapToRunDto,
@Param('sceneId') sceneId: string, @Param('sceneId') sceneId: string,
) { ) {
try { const tapToRunScene = await this.sceneService.updateTapToRunScene(
const tapToRunScene = await this.sceneService.updateTapToRunScene( updateSceneTapToRunDto,
updateSceneTapToRunDto, sceneId,
sceneId, );
); return {
return { statusCode: HttpStatus.CREATED,
statusCode: HttpStatus.CREATED, success: true,
success: true, message: 'Scene updated successfully',
message: 'Scene updated successfully', data: tapToRunScene,
data: tapToRunScene, };
};
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
} }

114
src/schedule/controllers/schedule.controller.ts
View File

@ -5,7 +5,6 @@ import {
Get, Get,
Post, Post,
Param, Param,
HttpException,
HttpStatus, HttpStatus,
UseGuards, UseGuards,
Put, Put,
@ -37,24 +36,17 @@ export class ScheduleController {
@Param('deviceUuid') deviceUuid: string, @Param('deviceUuid') deviceUuid: string,
@Body() addScheduleDto: AddScheduleDto, @Body() addScheduleDto: AddScheduleDto,
) { ) {
try { const schedule = await this.scheduleService.addDeviceSchedule(
const schedule = await this.scheduleService.addDeviceSchedule( deviceUuid,
deviceUuid, addScheduleDto,
addScheduleDto, );
);
return { return {
statusCode: HttpStatus.CREATED, statusCode: HttpStatus.CREATED,
success: true, success: true,
message: 'schedule added successfully', message: 'schedule added successfully',
data: schedule, data: schedule,
}; };
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(JwtAuthGuard) @UseGuards(JwtAuthGuard)
@ -63,17 +55,10 @@ export class ScheduleController {
@Param('deviceUuid') deviceUuid: string, @Param('deviceUuid') deviceUuid: string,
@Query() query: GetScheduleDeviceDto, @Query() query: GetScheduleDeviceDto,
) { ) {
try { return await this.scheduleService.getDeviceScheduleByCategory(
return await this.scheduleService.getDeviceScheduleByCategory( deviceUuid,
deviceUuid, query.category,
query.category, );
);
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(JwtAuthGuard) @UseGuards(JwtAuthGuard)
@ -82,19 +67,12 @@ export class ScheduleController {
@Param('deviceUuid') deviceUuid: string, @Param('deviceUuid') deviceUuid: string,
@Param('scheduleId') scheduleId: string, @Param('scheduleId') scheduleId: string,
) { ) {
try { await this.scheduleService.deleteDeviceSchedule(deviceUuid, scheduleId);
await this.scheduleService.deleteDeviceSchedule(deviceUuid, scheduleId); return {
return { statusCode: HttpStatus.CREATED,
statusCode: HttpStatus.CREATED, success: true,
success: true, message: 'schedule deleted successfully',
message: 'schedule deleted successfully', };
};
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(JwtAuthGuard) @UseGuards(JwtAuthGuard)
@ -103,22 +81,15 @@ export class ScheduleController {
@Param('deviceUuid') deviceUuid: string, @Param('deviceUuid') deviceUuid: string,
@Body() enableScheduleDto: EnableScheduleDto, @Body() enableScheduleDto: EnableScheduleDto,
) { ) {
try { await this.scheduleService.enableDeviceSchedule(
await this.scheduleService.enableDeviceSchedule( deviceUuid,
deviceUuid, enableScheduleDto,
enableScheduleDto, );
); return {
return { statusCode: HttpStatus.CREATED,
statusCode: HttpStatus.CREATED, success: true,
success: true, message: 'schedule updated successfully',
message: 'schedule updated successfully', };
};
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(JwtAuthGuard) @UseGuards(JwtAuthGuard)
@ -127,23 +98,16 @@ export class ScheduleController {
@Param('deviceUuid') deviceUuid: string, @Param('deviceUuid') deviceUuid: string,
@Body() updateScheduleDto: UpdateScheduleDto, @Body() updateScheduleDto: UpdateScheduleDto,
) { ) {
try { const schedule = await this.scheduleService.updateDeviceSchedule(
const schedule = await this.scheduleService.updateDeviceSchedule( deviceUuid,
deviceUuid, updateScheduleDto,
updateScheduleDto, );
);
return { return {
statusCode: HttpStatus.CREATED, statusCode: HttpStatus.CREATED,
success: true, success: true,
message: 'schedule updated successfully', message: 'schedule updated successfully',
data: schedule, data: schedule,
}; };
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
} }

16
src/schedule/services/schedule.service.ts
View File

@ -56,7 +56,8 @@ export class ScheduleService {
deviceDetails.productDevice.prodType !== ProductType.WH && deviceDetails.productDevice.prodType !== ProductType.WH &&
deviceDetails.productDevice.prodType !== ProductType.ONE_1TG && deviceDetails.productDevice.prodType !== ProductType.ONE_1TG &&
deviceDetails.productDevice.prodType !== ProductType.TWO_2TG && deviceDetails.productDevice.prodType !== ProductType.TWO_2TG &&
deviceDetails.productDevice.prodType !== ProductType.THREE_3TG deviceDetails.productDevice.prodType !== ProductType.THREE_3TG &&
deviceDetails.productDevice.prodType !== ProductType.GD
) { ) {
throw new HttpException( throw new HttpException(
'This device is not supported for schedule', 'This device is not supported for schedule',
@ -113,7 +114,8 @@ export class ScheduleService {
deviceDetails.productDevice.prodType !== ProductType.WH && deviceDetails.productDevice.prodType !== ProductType.WH &&
deviceDetails.productDevice.prodType !== ProductType.ONE_1TG && deviceDetails.productDevice.prodType !== ProductType.ONE_1TG &&
deviceDetails.productDevice.prodType !== ProductType.TWO_2TG && deviceDetails.productDevice.prodType !== ProductType.TWO_2TG &&
deviceDetails.productDevice.prodType !== ProductType.THREE_3TG deviceDetails.productDevice.prodType !== ProductType.THREE_3TG &&
deviceDetails.productDevice.prodType !== ProductType.GD
) { ) {
throw new HttpException( throw new HttpException(
'This device is not supported for schedule', 'This device is not supported for schedule',
@ -166,7 +168,8 @@ export class ScheduleService {
deviceDetails.productDevice.prodType !== ProductType.WH && deviceDetails.productDevice.prodType !== ProductType.WH &&
deviceDetails.productDevice.prodType !== ProductType.ONE_1TG && deviceDetails.productDevice.prodType !== ProductType.ONE_1TG &&
deviceDetails.productDevice.prodType !== ProductType.TWO_2TG && deviceDetails.productDevice.prodType !== ProductType.TWO_2TG &&
deviceDetails.productDevice.prodType !== ProductType.THREE_3TG deviceDetails.productDevice.prodType !== ProductType.THREE_3TG &&
deviceDetails.productDevice.prodType !== ProductType.GD
) { ) {
throw new HttpException( throw new HttpException(
'This device is not supported for schedule', 'This device is not supported for schedule',
@ -233,7 +236,8 @@ export class ScheduleService {
deviceDetails.productDevice.prodType !== ProductType.WH && deviceDetails.productDevice.prodType !== ProductType.WH &&
deviceDetails.productDevice.prodType !== ProductType.ONE_1TG && deviceDetails.productDevice.prodType !== ProductType.ONE_1TG &&
deviceDetails.productDevice.prodType !== ProductType.TWO_2TG && deviceDetails.productDevice.prodType !== ProductType.TWO_2TG &&
deviceDetails.productDevice.prodType !== ProductType.THREE_3TG deviceDetails.productDevice.prodType !== ProductType.THREE_3TG &&
deviceDetails.productDevice.prodType !== ProductType.GD
) { ) {
throw new HttpException( throw new HttpException(
'This device is not supported for schedule', 'This device is not supported for schedule',
@ -294,6 +298,7 @@ export class ScheduleService {
return await this.deviceRepository.findOne({ return await this.deviceRepository.findOne({
where: { where: {
uuid: deviceUuid, uuid: deviceUuid,
isActive: true,
}, },
...(withProductDevice && { relations: ['productDevice'] }), ...(withProductDevice && { relations: ['productDevice'] }),
}); });
@ -317,7 +322,8 @@ export class ScheduleService {
deviceDetails.productDevice.prodType !== ProductType.WH && deviceDetails.productDevice.prodType !== ProductType.WH &&
deviceDetails.productDevice.prodType !== ProductType.ONE_1TG && deviceDetails.productDevice.prodType !== ProductType.ONE_1TG &&
deviceDetails.productDevice.prodType !== ProductType.TWO_2TG && deviceDetails.productDevice.prodType !== ProductType.TWO_2TG &&
deviceDetails.productDevice.prodType !== ProductType.THREE_3TG deviceDetails.productDevice.prodType !== ProductType.THREE_3TG &&
deviceDetails.productDevice.prodType !== ProductType.GD
) { ) {
throw new HttpException( throw new HttpException(
'This device is not supported for schedule', 'This device is not supported for schedule',

17
src/timezone/controllers/timezone.controller.ts
View File

@ -1,10 +1,4 @@
import { import { Controller, Get, UseGuards } from '@nestjs/common';
Controller,
Get,
HttpException,
HttpStatus,
UseGuards,
} from '@nestjs/common';
import { TimeZoneService } from '../services/timezone.service'; import { TimeZoneService } from '../services/timezone.service';
import { ApiTags, ApiBearerAuth } from '@nestjs/swagger'; import { ApiTags, ApiBearerAuth } from '@nestjs/swagger';
import { JwtAuthGuard } from '../../../libs/common/src/guards/jwt.auth.guard'; import { JwtAuthGuard } from '../../../libs/common/src/guards/jwt.auth.guard';
@ -22,13 +16,6 @@ export class TimeZoneController {
@UseGuards(JwtAuthGuard) @UseGuards(JwtAuthGuard)
@Get() @Get()
async getAllTimeZones() { async getAllTimeZones() {
try { return await this.timeZoneService.getAllTimeZones();
return await this.timeZoneService.getAllTimeZones();
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
} }

132
src/unit/controllers/unit.controller.ts
View File

@ -3,7 +3,6 @@ import {
Body, Body,
Controller, Controller,
Get, Get,
HttpException,
HttpStatus, HttpStatus,
Param, Param,
Post, Post,
@ -38,35 +37,21 @@ export class UnitController {
@UseGuards(JwtAuthGuard, CheckFloorTypeGuard) @UseGuards(JwtAuthGuard, CheckFloorTypeGuard)
@Post() @Post()
async addUnit(@Body() addUnitDto: AddUnitDto) { async addUnit(@Body() addUnitDto: AddUnitDto) {
try { const unit = await this.unitService.addUnit(addUnitDto);
const unit = await this.unitService.addUnit(addUnitDto); return {
return { statusCode: HttpStatus.CREATED,
statusCode: HttpStatus.CREATED, success: true,
success: true, message: 'Unit added successfully',
message: 'Unit added successfully', data: unit,
data: unit, };
};
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(JwtAuthGuard, UnitPermissionGuard) @UseGuards(JwtAuthGuard, UnitPermissionGuard)
@Get(':unitUuid') @Get(':unitUuid')
async getUnitByUuid(@Param('unitUuid') unitUuid: string) { async getUnitByUuid(@Param('unitUuid') unitUuid: string) {
try { const unit = await this.unitService.getUnitByUuid(unitUuid);
const unit = await this.unitService.getUnitByUuid(unitUuid); return unit;
return unit;
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@ -76,95 +61,53 @@ export class UnitController {
@Param('unitUuid') unitUuid: string, @Param('unitUuid') unitUuid: string,
@Query() query: GetUnitChildDto, @Query() query: GetUnitChildDto,
) { ) {
try { const unit = await this.unitService.getUnitChildByUuid(unitUuid, query);
const unit = await this.unitService.getUnitChildByUuid(unitUuid, query); return unit;
return unit;
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(JwtAuthGuard, UnitPermissionGuard) @UseGuards(JwtAuthGuard, UnitPermissionGuard)
@Get('parent/:unitUuid') @Get('parent/:unitUuid')
async getUnitParentByUuid(@Param('unitUuid') unitUuid: string) { async getUnitParentByUuid(@Param('unitUuid') unitUuid: string) {
try { const unit = await this.unitService.getUnitParentByUuid(unitUuid);
const unit = await this.unitService.getUnitParentByUuid(unitUuid); return unit;
return unit;
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(JwtAuthGuard, CheckUserUnitGuard) @UseGuards(JwtAuthGuard, CheckUserUnitGuard)
@Post('user') @Post('user')
async addUserUnit(@Body() addUserUnitDto: AddUserUnitDto) { async addUserUnit(@Body() addUserUnitDto: AddUserUnitDto) {
try { await this.unitService.addUserUnit(addUserUnitDto);
await this.unitService.addUserUnit(addUserUnitDto); return {
return { statusCode: HttpStatus.CREATED,
statusCode: HttpStatus.CREATED, success: true,
success: true, message: 'user unit added successfully',
message: 'user unit added successfully', };
};
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(JwtAuthGuard) @UseGuards(JwtAuthGuard)
@Get('user/:userUuid') @Get('user/:userUuid')
async getUnitsByUserId(@Param('userUuid') userUuid: string) { async getUnitsByUserId(@Param('userUuid') userUuid: string) {
try { return await this.unitService.getUnitsByUserId(userUuid);
return await this.unitService.getUnitsByUserId(userUuid);
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(JwtAuthGuard, UnitPermissionGuard) @UseGuards(JwtAuthGuard, UnitPermissionGuard)
@Put('rename/:unitUuid') @Put(':unitUuid')
async renameUnitByUuid( async renameUnitByUuid(
@Param('unitUuid') unitUuid: string, @Param('unitUuid') unitUuid: string,
@Body() updateUnitNameDto: UpdateUnitNameDto, @Body() updateUnitNameDto: UpdateUnitNameDto,
) { ) {
try { const unit = await this.unitService.renameUnitByUuid(
const unit = await this.unitService.renameUnitByUuid( unitUuid,
unitUuid, updateUnitNameDto,
updateUnitNameDto, );
); return unit;
return unit;
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(JwtAuthGuard, UnitPermissionGuard) @UseGuards(JwtAuthGuard, UnitPermissionGuard)
@Get(':unitUuid/invitation-code') @Get(':unitUuid/invitation-code')
async getUnitInvitationCode(@Param('unitUuid') unitUuid: string) { async getUnitInvitationCode(@Param('unitUuid') unitUuid: string) {
try { const unit = await this.unitService.getUnitInvitationCode(unitUuid);
const unit = await this.unitService.getUnitInvitationCode(unitUuid); return unit;
return unit;
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@ -173,18 +116,11 @@ export class UnitController {
async verifyCodeAndAddUserUnit( async verifyCodeAndAddUserUnit(
@Body() addUserUnitUsingCodeDto: AddUserUnitUsingCodeDto, @Body() addUserUnitUsingCodeDto: AddUserUnitUsingCodeDto,
) { ) {
try { await this.unitService.verifyCodeAndAddUserUnit(addUserUnitUsingCodeDto);
await this.unitService.verifyCodeAndAddUserUnit(addUserUnitUsingCodeDto); return {
return { statusCode: HttpStatus.CREATED,
statusCode: HttpStatus.CREATED, success: true,
success: true, message: 'user unit added successfully',
message: 'user unit added successfully', };
};
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
} }

93
src/user-device-permission/controllers/user-device-permission.controller.ts
View File

@ -3,7 +3,6 @@ import {
Controller, Controller,
Delete, Delete,
Get, Get,
HttpException,
HttpStatus, HttpStatus,
Param, Param,
Post, Post,
@ -29,67 +28,48 @@ export class UserDevicePermissionController {
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(AdminRoleGuard) @UseGuards(AdminRoleGuard)
@Post('add') @Post()
async addDevicePermission( async addDevicePermission(
@Body() userDevicePermissionDto: UserDevicePermissionAddDto, @Body() userDevicePermissionDto: UserDevicePermissionAddDto,
) { ) {
try { const addDetails = await this.userDevicePermissionService.addUserPermission(
const addDetails = userDevicePermissionDto,
await this.userDevicePermissionService.addUserPermission( );
userDevicePermissionDto, return {
); statusCode: HttpStatus.CREATED,
return { message: 'User Permission for Devices Added Successfully',
statusCode: HttpStatus.CREATED, data: addDetails,
message: 'User Permission for Devices Added Successfully', };
data: addDetails,
};
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(AdminRoleGuard) @UseGuards(AdminRoleGuard)
@Put('edit/:devicePermissionUuid') @Put(':devicePermissionUuid')
async editDevicePermission( async editDevicePermission(
@Param('devicePermissionUuid') devicePermissionUuid: string, @Param('devicePermissionUuid') devicePermissionUuid: string,
@Body() userDevicePermissionEditDto: UserDevicePermissionEditDto, @Body() userDevicePermissionEditDto: UserDevicePermissionEditDto,
) { ) {
try { await this.userDevicePermissionService.editUserPermission(
await this.userDevicePermissionService.editUserPermission( devicePermissionUuid,
devicePermissionUuid, userDevicePermissionEditDto,
userDevicePermissionEditDto, );
); return {
return { statusCode: HttpStatus.OK,
statusCode: HttpStatus.OK, message: 'User Permission for Devices Updated Successfully',
message: 'User Permission for Devices Updated Successfully', };
};
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(AdminRoleGuard) @UseGuards(AdminRoleGuard)
@Get(':deviceUuid/list') @Get(':deviceUuid')
async fetchDevicePermission(@Param('deviceUuid') deviceUuid: string) { async fetchDevicePermission(@Param('deviceUuid') deviceUuid: string) {
try { const deviceDetails =
const deviceDetails = await this.userDevicePermissionService.fetchUserPermission(deviceUuid);
await this.userDevicePermissionService.fetchUserPermission(deviceUuid); return {
return { statusCode: HttpStatus.OK,
statusCode: HttpStatus.OK, message: 'Device Details fetched Successfully',
message: 'Device Details fetched Successfully', data: deviceDetails,
data: deviceDetails, };
};
} catch (err) {
throw new Error(err);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(AdminRoleGuard) @UseGuards(AdminRoleGuard)
@ -97,19 +77,12 @@ export class UserDevicePermissionController {
async deleteDevicePermission( async deleteDevicePermission(
@Param('devicePermissionUuid') devicePermissionUuid: string, @Param('devicePermissionUuid') devicePermissionUuid: string,
) { ) {
try { await this.userDevicePermissionService.deleteDevicePermission(
await this.userDevicePermissionService.deleteDevicePermission( devicePermissionUuid,
devicePermissionUuid, );
); return {
return { statusCode: HttpStatus.OK,
statusCode: HttpStatus.OK, message: 'User Permission for Devices Deleted Successfully',
message: 'User Permission for Devices Deleted Successfully', };
};
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
} }

66
src/user-notification/controllers/user-notification.controller.ts
View File

@ -2,7 +2,6 @@ import {
Body, Body,
Controller, Controller,
Get, Get,
HttpException,
HttpStatus, HttpStatus,
Param, Param,
Post, Post,
@ -35,41 +34,27 @@ export class UserNotificationController {
async addUserSubscription( async addUserSubscription(
@Body() userNotificationAddDto: UserNotificationAddDto, @Body() userNotificationAddDto: UserNotificationAddDto,
) { ) {
try { const addDetails = await this.userNotificationService.addUserSubscription(
const addDetails = await this.userNotificationService.addUserSubscription( userNotificationAddDto,
userNotificationAddDto, );
); return {
return { statusCode: HttpStatus.CREATED,
statusCode: HttpStatus.CREATED, message: 'User Notification Added Successfully',
message: 'User Notification Added Successfully', data: addDetails,
data: addDetails, };
};
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(JwtAuthGuard) @UseGuards(JwtAuthGuard)
@Get(':userUuid') @Get(':userUuid')
async fetchUserSubscriptions(@Param('userUuid') userUuid: string) { async fetchUserSubscriptions(@Param('userUuid') userUuid: string) {
try { const userDetails =
const userDetails = await this.userNotificationService.fetchUserSubscriptions(userUuid);
await this.userNotificationService.fetchUserSubscriptions(userUuid); return {
return { statusCode: HttpStatus.OK,
statusCode: HttpStatus.OK, message: 'User Notification fetched Successfully',
message: 'User Notification fetched Successfully', data: { ...userDetails },
data: { ...userDetails }, };
};
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(JwtAuthGuard) @UseGuards(JwtAuthGuard)
@ -77,19 +62,12 @@ export class UserNotificationController {
async updateUserSubscription( async updateUserSubscription(
@Body() userNotificationUpdateDto: UserNotificationUpdateDto, @Body() userNotificationUpdateDto: UserNotificationUpdateDto,
) { ) {
try { await this.userNotificationService.updateUserSubscription(
await this.userNotificationService.updateUserSubscription( userNotificationUpdateDto,
userNotificationUpdateDto, );
); return {
return { statusCode: HttpStatus.OK,
statusCode: HttpStatus.OK, message: 'User subscription updated Successfully',
message: 'User subscription updated Successfully', };
};
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
} }

118
src/users/controllers/user.controller.ts
View File

@ -3,7 +3,6 @@ import {
Controller, Controller,
Delete, Delete,
Get, Get,
HttpException,
HttpStatus, HttpStatus,
Param, Param,
Put, Put,
@ -34,14 +33,7 @@ export class UserController {
@UseGuards(JwtAuthGuard) @UseGuards(JwtAuthGuard)
@Get(':userUuid') @Get(':userUuid')
async getUserDetailsByUserUuid(@Param('userUuid') userUuid: string) { async getUserDetailsByUserUuid(@Param('userUuid') userUuid: string) {
try { return await this.userService.getUserDetailsByUserUuid(userUuid);
return await this.userService.getUserDetailsByUserUuid(userUuid);
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(JwtAuthGuard, CheckProfilePictureGuard) @UseGuards(JwtAuthGuard, CheckProfilePictureGuard)
@ -50,23 +42,16 @@ export class UserController {
@Param('userUuid') userUuid: string, @Param('userUuid') userUuid: string,
@Body() updateProfilePictureDataDto: UpdateProfilePictureDataDto, @Body() updateProfilePictureDataDto: UpdateProfilePictureDataDto,
) { ) {
try { const userData = await this.userService.updateProfilePictureByUserUuid(
const userData = await this.userService.updateProfilePictureByUserUuid( userUuid,
userUuid, updateProfilePictureDataDto,
updateProfilePictureDataDto, );
); return {
return { statusCode: HttpStatus.CREATED,
statusCode: HttpStatus.CREATED, success: true,
success: true, message: 'profile picture updated successfully',
message: 'profile picture updated successfully', data: userData,
data: userData, };
};
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(JwtAuthGuard) @UseGuards(JwtAuthGuard)
@ -75,23 +60,16 @@ export class UserController {
@Param('userUuid') userUuid: string, @Param('userUuid') userUuid: string,
@Body() updateRegionDataDto: UpdateRegionDataDto, @Body() updateRegionDataDto: UpdateRegionDataDto,
) { ) {
try { const userData = await this.userService.updateRegionByUserUuid(
const userData = await this.userService.updateRegionByUserUuid( userUuid,
userUuid, updateRegionDataDto,
updateRegionDataDto, );
); return {
return { statusCode: HttpStatus.CREATED,
statusCode: HttpStatus.CREATED, success: true,
success: true, message: 'region updated successfully',
message: 'region updated successfully', data: userData,
data: userData, };
};
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(JwtAuthGuard) @UseGuards(JwtAuthGuard)
@ -100,23 +78,16 @@ export class UserController {
@Param('userUuid') userUuid: string, @Param('userUuid') userUuid: string,
@Body() updateTimezoneDataDto: UpdateTimezoneDataDto, @Body() updateTimezoneDataDto: UpdateTimezoneDataDto,
) { ) {
try { const userData = await this.userService.updateTimezoneByUserUuid(
const userData = await this.userService.updateTimezoneByUserUuid( userUuid,
userUuid, updateTimezoneDataDto,
updateTimezoneDataDto, );
); return {
return { statusCode: HttpStatus.CREATED,
statusCode: HttpStatus.CREATED, success: true,
success: true, message: 'timezone updated successfully',
message: 'timezone updated successfully', data: userData,
data: userData, };
};
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(JwtAuthGuard) @UseGuards(JwtAuthGuard)
@ -125,23 +96,16 @@ export class UserController {
@Param('userUuid') userUuid: string, @Param('userUuid') userUuid: string,
@Body() updateNameDto: UpdateNameDto, @Body() updateNameDto: UpdateNameDto,
) { ) {
try { const userData = await this.userService.updateNameByUserUuid(
const userData = await this.userService.updateNameByUserUuid( userUuid,
userUuid, updateNameDto,
updateNameDto, );
); return {
return { statusCode: HttpStatus.CREATED,
statusCode: HttpStatus.CREATED, success: true,
success: true, message: 'name updated successfully',
message: 'name updated successfully', data: userData,
data: userData, };
};
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(SuperAdminRoleGuard) @UseGuards(SuperAdminRoleGuard)

127
src/vistor-password/controllers/visitor-password.controller.ts
View File

@ -3,7 +3,6 @@ import {
Body, Body,
Controller, Controller,
Post, Post,
HttpException,
HttpStatus, HttpStatus,
UseGuards, UseGuards,
Get, Get,
@ -35,24 +34,17 @@ export class VisitorPasswordController {
@Body() addDoorLockOnlineMultipleDto: AddDoorLockOnlineMultipleDto, @Body() addDoorLockOnlineMultipleDto: AddDoorLockOnlineMultipleDto,
@Req() req: any, @Req() req: any,
) { ) {
try { const userUuid = req.user.uuid;
const userUuid = req.user.uuid; const temporaryPasswords =
const temporaryPasswords = await this.visitorPasswordService.addOnlineTemporaryPasswordMultipleTime(
await this.visitorPasswordService.addOnlineTemporaryPasswordMultipleTime( addDoorLockOnlineMultipleDto,
addDoorLockOnlineMultipleDto, userUuid,
userUuid,
);
return {
statusCode: HttpStatus.CREATED,
data: temporaryPasswords,
};
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
); );
}
return {
statusCode: HttpStatus.CREATED,
data: temporaryPasswords,
};
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(JwtAuthGuard) @UseGuards(JwtAuthGuard)
@ -61,24 +53,17 @@ export class VisitorPasswordController {
@Body() addDoorLockOnlineOneTimeDto: AddDoorLockOnlineOneTimeDto, @Body() addDoorLockOnlineOneTimeDto: AddDoorLockOnlineOneTimeDto,
@Req() req: any, @Req() req: any,
) { ) {
try { const userUuid = req.user.uuid;
const userUuid = req.user.uuid; const temporaryPasswords =
const temporaryPasswords = await this.visitorPasswordService.addOnlineTemporaryPasswordOneTime(
await this.visitorPasswordService.addOnlineTemporaryPasswordOneTime( addDoorLockOnlineOneTimeDto,
addDoorLockOnlineOneTimeDto, userUuid,
userUuid,
);
return {
statusCode: HttpStatus.CREATED,
data: temporaryPasswords,
};
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
); );
}
return {
statusCode: HttpStatus.CREATED,
data: temporaryPasswords,
};
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(JwtAuthGuard) @UseGuards(JwtAuthGuard)
@ -87,24 +72,17 @@ export class VisitorPasswordController {
@Body() addDoorLockOfflineOneTimeDto: AddDoorLockOfflineOneTimeDto, @Body() addDoorLockOfflineOneTimeDto: AddDoorLockOfflineOneTimeDto,
@Req() req: any, @Req() req: any,
) { ) {
try { const userUuid = req.user.uuid;
const userUuid = req.user.uuid; const temporaryPassword =
const temporaryPassword = await this.visitorPasswordService.addOfflineOneTimeTemporaryPassword(
await this.visitorPasswordService.addOfflineOneTimeTemporaryPassword( addDoorLockOfflineOneTimeDto,
addDoorLockOfflineOneTimeDto, userUuid,
userUuid,
);
return {
statusCode: HttpStatus.CREATED,
data: temporaryPassword,
};
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
); );
}
return {
statusCode: HttpStatus.CREATED,
data: temporaryPassword,
};
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(JwtAuthGuard) @UseGuards(JwtAuthGuard)
@ -114,49 +92,28 @@ export class VisitorPasswordController {
addDoorLockOfflineMultipleDto: AddDoorLockOfflineMultipleDto, addDoorLockOfflineMultipleDto: AddDoorLockOfflineMultipleDto,
@Req() req: any, @Req() req: any,
) { ) {
try { const userUuid = req.user.uuid;
const userUuid = req.user.uuid; const temporaryPassword =
const temporaryPassword = await this.visitorPasswordService.addOfflineMultipleTimeTemporaryPassword(
await this.visitorPasswordService.addOfflineMultipleTimeTemporaryPassword( addDoorLockOfflineMultipleDto,
addDoorLockOfflineMultipleDto, userUuid,
userUuid,
);
return {
statusCode: HttpStatus.CREATED,
data: temporaryPassword,
};
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
); );
}
return {
statusCode: HttpStatus.CREATED,
data: temporaryPassword,
};
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(JwtAuthGuard) @UseGuards(JwtAuthGuard)
@Get() @Get()
async GetVisitorPassword() { async GetVisitorPassword() {
try { return await this.visitorPasswordService.getPasswords();
return await this.visitorPasswordService.getPasswords();
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
@ApiBearerAuth() @ApiBearerAuth()
@UseGuards(JwtAuthGuard) @UseGuards(JwtAuthGuard)
@Get('/devices') @Get('/devices')
async GetVisitorDevices() { async GetVisitorDevices() {
try { return await this.visitorPasswordService.getAllPassDevices();
return await this.visitorPasswordService.getAllPassDevices();
} catch (error) {
throw new HttpException(
error.message || 'Internal server error',
error.status || HttpStatus.INTERNAL_SERVER_ERROR,
);
}
} }
} }

3
src/vistor-password/services/visitor-password.service.ts
View File

@ -450,6 +450,7 @@ export class VisitorPasswordService {
productDevice: { productDevice: {
prodType: ProductType.DL, prodType: ProductType.DL,
}, },
isActive: true,
}, },
}); });
const data = []; const data = [];
@ -492,6 +493,7 @@ export class VisitorPasswordService {
productDevice: { productDevice: {
prodType: ProductType.DL, prodType: ProductType.DL,
}, },
isActive: true,
}, },
relations: ['productDevice'], relations: ['productDevice'],
}); });
@ -857,6 +859,7 @@ export class VisitorPasswordService {
return await this.deviceRepository.findOne({ return await this.deviceRepository.findOne({
where: { where: {
uuid: deviceUuid, uuid: deviceUuid,
isActive: true,
}, },
...(withProductDevice && { relations: ['productDevice'] }), ...(withProductDevice && { relations: ['productDevice'] }),
}); });