Add device and user notification modules

libs/common/src/modules/device-notification/device.notification.module.ts

@@ -0,0 +1,10 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { DeviceNotificationEntity } from './entities';
+@Module({
+  providers: [],
+  exports: [],
+  controllers: [],
+  imports: [TypeOrmModule.forFeature([DeviceNotificationEntity])],
+})
+export class DeviceNotificationRepositoryModule {}

libs/common/src/modules/device-notification/dtos/device.notification.dto.ts

@@ -0,0 +1,15 @@
+import { IsNotEmpty, IsString } from 'class-validator';
+
+export class DeviceNotificationDto {
+  @IsString()
+  @IsNotEmpty()
+  public uuid: string;
+
+  @IsString()
+  @IsNotEmpty()
+  public userUuid: string;
+
+  @IsString()
+  @IsNotEmpty()
+  public deviceUuid: string;
+}

libs/common/src/modules/device-notification/dtos/index.ts

@@ -0,0 +1 @@
+export * from './device.notification.dto';

libs/common/src/modules/device-notification/entities/device.notification.entity.ts

@@ -0,0 +1,33 @@
+import { Column, Entity, ManyToOne, Unique } from 'typeorm';
+import { AbstractEntity } from '../../abstract/entities/abstract.entity';
+import { DeviceNotificationDto } from '../dtos';
+import { DeviceEntity } from '../../device/entities';
+import { UserEntity } from '../../user/entities';
+
+@Entity({ name: 'device-notification' })
+@Unique(['userUuid', 'deviceUuid'])
+export class DeviceNotificationEntity extends AbstractEntity<DeviceNotificationDto> {
+  @Column({
+    nullable: false,
+  })
+  public userUuid: string;
+
+  @Column({
+    nullable: false,
+  })
+  deviceUuid: string;
+
+  @ManyToOne(() => DeviceEntity, (device) => device.permission, {
+    nullable: false,
+  })
+  device: DeviceEntity;
+
+  @ManyToOne(() => UserEntity, (user) => user.userPermission, {
+    nullable: false,
+  })
+  user: UserEntity;
+  constructor(partial: Partial<DeviceNotificationEntity>) {
+    super();
+    Object.assign(this, partial);
+  }
+}

libs/common/src/modules/device-notification/entities/index.ts

@@ -0,0 +1 @@
+export * from './device.notification.entity';

libs/common/src/modules/device-notification/repositories/device.notification.repository.ts

@@ -0,0 +1,10 @@
+import { DataSource, Repository } from 'typeorm';
+import { Injectable } from '@nestjs/common';
+import { DeviceNotificationEntity } from '../entities';
+
+@Injectable()
+export class DeviceNotificationRepository extends Repository<DeviceNotificationEntity> {
+  constructor(private dataSource: DataSource) {
+    super(DeviceNotificationEntity, dataSource.createEntityManager());
+  }
+}

libs/common/src/modules/device-notification/repositories/index.ts

@@ -0,0 +1 @@
+export * from './device.notification.repository';

libs/common/src/modules/device/entities/device.entity.ts

@@ -5,6 +5,7 @@ import { GroupDeviceEntity } from '../../group-device/entities';
 import { SpaceEntity } from '../../space/entities';
 import { ProductEntity } from '../../product/entities';
 import { DeviceUserPermissionEntity } from '../../device-user-permission/entities';
+import { DeviceNotificationEntity } from '../../device-notification/entities';
 
 @Entity({ name: 'device' })
 @Unique(['spaceDevice', 'deviceTuyaUuid'])
@@ -28,7 +29,14 @@ export class DeviceEntity extends AbstractEntity<DeviceDto> {
     },
   )
   permission: DeviceUserPermissionEntity[];
-
+  @OneToMany(
+    () => DeviceNotificationEntity,
+    (deviceUserNotification) => deviceUserNotification.device,
+    {
+      nullable: true,
+    },
+  )
+  deviceUserNotification: DeviceNotificationEntity[];
   @OneToMany(
     () => GroupDeviceEntity,
     (userGroupDevices) => userGroupDevices.device,

libs/common/src/modules/user-notification/dtos/index.ts

@@ -0,0 +1 @@
+export * from './user.notification.dto';

libs/common/src/modules/user-notification/dtos/user.notification.dto.ts

@@ -0,0 +1,19 @@
+import { IsBoolean, IsNotEmpty, IsString } from 'class-validator';
+
+export class UserNotificationDto {
+  @IsString()
+  @IsNotEmpty()
+  public uuid: string;
+
+  @IsString()
+  @IsNotEmpty()
+  public userUuid: string;
+
+  @IsString()
+  @IsNotEmpty()
+  public subscriptionUuid: string;
+
+  @IsBoolean()
+  @IsNotEmpty()
+  public active: boolean;
+}

libs/common/src/modules/user-notification/entities/index.ts

@@ -0,0 +1 @@
+export * from './user.notification.entity';

libs/common/src/modules/user-notification/entities/user.notification.entity.ts

@@ -0,0 +1,27 @@
+import { Column, Entity, ManyToOne, Unique } from 'typeorm';
+import { AbstractEntity } from '../../abstract/entities/abstract.entity';
+import { UserNotificationDto } from '../dtos';
+import { UserEntity } from '../../user/entities';
+
+@Entity({ name: 'user-notification' })
+@Unique(['user', 'subscriptionUuid'])
+export class UserNotificationEntity extends AbstractEntity<UserNotificationDto> {
+  @ManyToOne(() => UserEntity, (user) => user.roles, {
+    nullable: false,
+  })
+  user: UserEntity;
+  @Column({
+    nullable: false,
+  })
+  subscriptionUuid: string;
+
+  @Column({
+    nullable: false,
+    default: true,
+  })
+  active: boolean;
+  constructor(partial: Partial<UserNotificationEntity>) {
+    super();
+    Object.assign(this, partial);
+  }
+}

libs/common/src/modules/user-notification/repositories/index.ts

@@ -0,0 +1 @@
+export * from './user.notification.repository';

libs/common/src/modules/user-notification/repositories/user.notification.repository.ts

@@ -0,0 +1,10 @@
+import { DataSource, Repository } from 'typeorm';
+import { Injectable } from '@nestjs/common';
+import { UserNotificationEntity } from '../entities';
+
+@Injectable()
+export class UserNotificationRepository extends Repository<UserNotificationEntity> {
+  constructor(private dataSource: DataSource) {
+    super(UserNotificationEntity, dataSource.createEntityManager());
+  }
+}

libs/common/src/modules/user-notification/user.notification.repository.module.ts

@@ -0,0 +1,10 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { UserNotificationEntity } from './entities';
+@Module({
+  providers: [],
+  exports: [],
+  controllers: [],
+  imports: [TypeOrmModule.forFeature([UserNotificationEntity])],
+})
+export class UserNotificationRepositoryModule {}

libs/common/src/modules/user/entities/user.entity.ts

@@ -4,6 +4,8 @@ import { UserDto } from '../dtos';
 import { AbstractEntity } from '../../abstract/entities/abstract.entity';
 import { UserSpaceEntity } from '../../user-space/entities';
 import { UserRoleEntity } from '../../user-role/entities';
+import { DeviceNotificationEntity } from '../../device-notification/entities';
+import { UserNotificationEntity } from '../../user-notification/entities';
 
 @Entity({ name: 'user' })
 export class UserEntity extends AbstractEntity<UserDto> {
@@ -53,12 +55,21 @@ export class UserEntity extends AbstractEntity<UserDto> {
   @OneToMany(() => UserSpaceEntity, (userSpace) => userSpace.user)
   userSpaces: UserSpaceEntity[];
 
+  @OneToMany(
+    () => UserNotificationEntity,
+    (userNotification) => userNotification.user,
+  )
+  userNotification: UserNotificationEntity[];
   @OneToMany(
     () => DeviceUserPermissionEntity,
     (userPermission) => userPermission.user,
   )
   userPermission: DeviceUserPermissionEntity[];
-
+  @OneToMany(
+    () => DeviceNotificationEntity,
+    (deviceUserNotification) => deviceUserNotification.user,
+  )
+  deviceUserNotification: DeviceNotificationEntity[];
   @OneToMany(() => UserRoleEntity, (role) => role.user, {
     nullable: true,
   })