feat: create real timereaction to permission and feature changes (#155)

Author: YanaYestr

apps/gauzy/src/app/app.component.ts

@@ -17,11 +17,13 @@ import {
 	DEFAULT_DATE_PICKER_CONFIG,
 	DEFAULT_SELECTOR_VISIBILITY,
 	DateRangePickerBuilderService,
+	FeatureSocketService,
 	IDatePickerConfig,
 	ISelectorVisibility,
 	JitsuService,
 	LanguagesService,
 	NavigationService,
+	RolePermissionSocketService,
 	SelectorBuilderService,
 	SeoService,
 	Store,
@@ -52,7 +54,9 @@ export class AppComponent implements OnInit, AfterViewInit {
 		private readonly _selectorBuilderService: SelectorBuilderService,
 		private readonly _dateRangePickerBuilderService: DateRangePickerBuilderService,
 		private readonly _navigationService: NavigationService,
-		private readonly _usersSocketService: UsersSocketService
+		private readonly _usersSocketService: UsersSocketService,
+		private readonly rolePermissionSocketService: RolePermissionSocketService,
+		private readonly _featureSocketService: FeatureSocketService
 	) {
 		this.getActivateRouterDataEvent();
 		this.getPreferredLanguage();
@@ -115,6 +119,26 @@ export class AppComponent implements OnInit, AfterViewInit {
 		if (Number(this._store.serverConnection) === 0) {
 			this.loading = false;
 		}
+
+		this.rolePermissionSocketService.permissionChanged$
+			.pipe(
+				filter(Boolean),
+				tap(() => {
+					window.location.reload();
+				}),
+				untilDestroyed(this)
+			)
+			.subscribe();
+
+		this._featureSocketService.featureChanged$
+			.pipe(
+				filter(Boolean),
+				tap(() => {
+					window.location.reload();
+				}),
+				untilDestroyed(this)
+			)
+			.subscribe();
 	}
 
 	/**

packages/core/src/lib/auth/auth.service.ts

@@ -405,6 +405,7 @@ export class AuthService extends SocialAuthService {
 	private generateToken(user: IUser, code: string): string {
 		const payload: JwtPayload = {
 			userId: user.id,
+			roleId: user.role ? user.role.id : null,
 			email: user.email,
 			tenantId: user.tenant ? user.tenantId : null,
 			code
@@ -976,6 +977,7 @@ export class AuthService extends SocialAuthService {
 				id: user.id,
 				tenantId: user.tenantId ?? null,
 				employeeId: employee ? employee.id : null,
+				roleId: user.role ? user.role.id : null,
 				role: user.role ? user.role.name : null,
 				permissions: user.role?.rolePermissions?.filter((rp) => rp.enabled).map((rp) => rp.permission) ?? null
 			};
@@ -1011,7 +1013,8 @@ export class AuthService extends SocialAuthService {
 				id: user.id,
 				email: user.email,
 				tenantId: user.tenantId || null,
-				role: user.role ? user.role.name : null
+				role: user.role ? user.role.name : null,
+				roleId: user.role ? user.role.id : null
 			};
 
 			// Generate the JWT refresh token

packages/core/src/lib/core/entities/index.ts

@@ -0,0 +1,23 @@
+import { EventsHandler, IEventHandler } from '@nestjs/cqrs';
+import { EmployeeSocketEvent } from '../../../event-bus';
+import { SocketService } from '../../../socket';
+import { EmployeeService } from '../../employee.service';
+
+@EventsHandler(EmployeeSocketEvent)
+export class EmployeeSocketEventHandler implements IEventHandler<EmployeeSocketEvent> {
+	constructor(private readonly _socketService: SocketService, private readonly _employeeService: EmployeeService) {}
+
+	/**
+	 * Handles EmployeeSocketEvent.
+	 * The event contains employee IDs, socket event name and payload.
+	 * This handler resolves related users and emits a socket event to each connected user.
+	 */
+	async handle(event: EmployeeSocketEvent) {
+		const employees = await this._employeeService.findByIds(event.employeeIds);
+
+		employees
+			.map((e) => e.user?.id)
+			.filter(Boolean)
+			.forEach((userId) => this._socketService.emitToClient(userId, event.event, event.payload));
+	}
+}

packages/core/src/lib/employee/commands/handlers/employee.socket.handler.ts

@@ -48,8 +48,8 @@ export class EmployeeUpdateHandler implements ICommandHandler<EmployeeUpdateComm
 
 			// Send a real-time event to the specified user via socket.
 			// No error is thrown if the user is not currently connected.
-			this._socketService.sendTimerChanged(employee?.id);
-			this._socketService.emitToClient(employee?.id, 'employee:changed', existingEmployee);
+			this._socketService.notifyEmployee(employee?.id, 'timer:changed');
+			this._socketService.notifyEmployee(employee?.id, 'employee:changed', existingEmployee);
 
 			return employee;
 		} catch (error) {

packages/core/src/lib/employee/commands/handlers/employee.update.handler.ts

@@ -1,6 +1,7 @@
 import { EmployeeBulkCreateHandler } from './employee.bulk.create.handler';
 import { EmployeeCreateHandler } from './employee.create.handler';
 import { EmployeeGetHandler } from './employee.get.handler';
+import { EmployeeSocketEventHandler } from './employee.socket.handler';
 import { EmployeeUpdateHandler } from './employee.update.handler';
 import { WorkingEmployeeGetHandler } from './working-employee.get.handler';
 
@@ -9,5 +10,6 @@ export const CommandHandlers = [
 	EmployeeBulkCreateHandler,
 	EmployeeGetHandler,
 	EmployeeUpdateHandler,
-	WorkingEmployeeGetHandler
+	WorkingEmployeeGetHandler,
+	EmployeeSocketEventHandler
 ];

packages/core/src/lib/employee/commands/handlers/index.ts

@@ -26,7 +26,7 @@ import { SocketModule } from '../socket/socket.module';
 		forwardRef(() => UserModule),
 		forwardRef(() => AuthModule),
 		SocketModule,
-		RoleModule,
+		forwardRef(() => RoleModule),
 		CqrsModule
 	],
 	controllers: [EmployeeController],

packages/core/src/lib/employee/employee.module.ts

@@ -469,6 +469,7 @@ export class EmployeeService extends TenantAwareCrudService<Employee> {
 
 			// Tables joins with relations
 			query.leftJoin(`${query.alias}.user`, 'user');
+			query.leftJoin('user.organizations', 'userOrganization');
 			query.leftJoin(`${query.alias}.tags`, 'tags');
 			query.leftJoinAndSelect(`${query.alias}.organizationEmploymentTypes`, 'organizationEmploymentTypes');
 
@@ -511,8 +512,9 @@ export class EmployeeService extends TenantAwareCrudService<Employee> {
 						web.andWhere(p(`"${qb.alias}"."tenantId" = :tenantId`), { tenantId });
 
 						if (isNotEmpty(where?.organizationId)) {
-							const organizationId = where.organizationId;
-							web.andWhere(p(`"${qb.alias}"."organizationId" = :organizationId`), { organizationId });
+							web.andWhere(`"userOrganization"."organizationId" = :organizationId`, {
+								organizationId: where.organizationId
+							});
 						}
 					})
 				);
@@ -699,4 +701,47 @@ export class EmployeeService extends TenantAwareCrudService<Employee> {
 			return null;
 		}
 	}
+
+	async findByIds(employeeIds: string[], options?: FindManyOptions<Employee>): Promise<IEmployee[]> {
+		try {
+			if (!employeeIds.length) {
+				return [];
+			}
+
+			const where = {
+				id: In(employeeIds),
+				isActive: true,
+				isArchived: false
+			};
+
+			const queryOptions: FindManyOptions<Employee> = {
+				...options,
+				where: {
+					...where,
+					...(options?.where || {})
+				},
+				relations: {
+					user: true,
+					...(options?.relations || {})
+				}
+			};
+
+			switch (this.ormType) {
+				case MultiORMEnum.MikroORM: {
+					const { where: mikroWhere, mikroOptions } = parseTypeORMFindToMikroOrm<Employee>(queryOptions);
+					const employees = await this.mikroOrmRepository.find(mikroWhere, mikroOptions);
+					return employees.map((e) => this.serialize(e as Employee));
+				}
+
+				case MultiORMEnum.TypeORM:
+					return await this.typeOrmRepository.find(queryOptions);
+
+				default:
+					throw new Error(`Not implemented for ORM type: ${this.ormType}`);
+			}
+		} catch (error) {
+			this.logger.error('Error finding employees by IDs', error);
+			return [];
+		}
+	}
 }

packages/core/src/lib/employee/employee.service.ts

@@ -0,0 +1,3 @@
+export class EmployeeSocketEvent {
+	constructor(public readonly employeeIds: string[], public readonly event: string, public readonly payload?: any) {}
+}

packages/core/src/lib/event-bus/events/employee-socket.event.ts

@@ -3,3 +3,4 @@ export * from './account-verified.event';
 export * from './integration.event';
 export * from './task.event';
 export * from './screenshot.event';
+export * from './employee-socket.event';