init

2026-01-07 12:13:45 +03:30
parent 27ebf4a7b6
commit f2284c103d
235 changed files with 180468 additions and 1 deletions
@@ -0,0 +1,105 @@
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@mikro-orm/nestjs';
+import { EntityManager, EntityRepository } from '@mikro-orm/core';
+import { Permission } from '../entities/permission.entity';
+import { CacheService } from 'src/modules/utils/cache.service';
+import { AdminRepository } from 'src/modules/admin/repositories/admin.repository';
+import { AdminRole } from 'src/modules/admin/entities/adminRole.entity';
+
+@Injectable()
+export class PermissionsService {
+  private readonly ADMIN_PERMISSIONS_KEY = 'admin-perms';
+
+  constructor(
+    @InjectRepository(Permission)
+    private readonly permissionRepository: EntityRepository<Permission>,
+    private readonly cacheService: CacheService,
+    private readonly adminRepository: AdminRepository,
+    private readonly em: EntityManager,
+  ) { }
+
+  async findAll() {
+    const permissions = await this.permissionRepository.findAll();
+    return permissions;
+  }
+
+  /**
+   * Get admin permissions from cache or database
+   * @param adminId - The admin ID
+   * @param restId - The restaurant ID
+   * @returns Array of permission names (string[])
+   */
+  async getAdminPermissions(adminId: string, restId: string): Promise<string[]> {
+    const cacheKey = `${this.ADMIN_PERMISSIONS_KEY}:${adminId}:${restId}`;
+
+    // Try to get from cache first
+    const cachedPermissions = await this.cacheService.get<string>(cacheKey);
+    if (cachedPermissions) {
+      try {
+        const parsed: unknown = JSON.parse(cachedPermissions);
+        // Ensure it's an array of strings
+        if (Array.isArray(parsed) && parsed.every((p): p is string => typeof p === 'string')) {
+          return parsed;
+        }
+        // If invalid format, continue to fetch from DB
+      } catch {
+        // If parsing fails, continue to fetch from DB
+      }
+    }
+
+    // If not in cache, fetch from database
+    const admin = await this.adminRepository.findOne(
+      { id: adminId, roles: { restaurant: { id: restId } } },
+      { populate: ['roles', 'roles.role', 'roles.role.permissions'] },
+    );
+
+    if (!admin || !admin.roles) {
+      return [];
+    }
+
+    // Ensure roles collection is loaded
+    await admin.roles.loadItems();
+
+    // Extract permission names as array of strings
+    const permissions = await Promise.all(
+      admin.roles
+        .getItems()
+        .filter(r => r.role) // Filter out any null/undefined roles
+        .map(async r => {
+          // Ensure permissions collection is initialized
+          if (!r.role.permissions.isInitialized()) {
+            await r.role.permissions.loadItems();
+          }
+          return r.role.permissions.getItems();
+        }),
+    );
+
+    return permissions.flat().map(p => p.name);
+  }
+
+  async getAdminFullPermissions(adminId: string, restId: string): Promise<Permission[]> {
+    const listOfPermissions = []
+    const adminRoles = await this.em.findOne(AdminRole, {
+      admin: {
+        id: adminId,
+      },
+      restaurant: {
+        id: restId,
+      },
+    }, { populate: ['role', 'role.permissions'] });
+    if (adminRoles) {
+      listOfPermissions.push(...adminRoles.role.permissions.getItems());
+    }
+    return listOfPermissions.map(permission => permission);
+  }
+
+  /**
+   * Invalidate admin permissions cache
+   * @param adminId - The admin ID
+   * @param restId - The restaurant ID
+   */
+  async invalidateAdminPermissionsCache(adminId: string, restId: string): Promise<void> {
+    const cacheKey = `${this.ADMIN_PERMISSIONS_KEY}:${adminId}:${restId}`;
+    await this.cacheService.del(cacheKey);
+  }
+}
@@ -0,0 +1,138 @@
+import { Injectable, NotFoundException, BadRequestException } from '@nestjs/common';
+import { InjectRepository } from '@mikro-orm/nestjs';
+import { EntityRepository, FilterQuery } from '@mikro-orm/core';
+import { Role } from '../entities/role.entity';
+import { Permission } from '../entities/permission.entity';
+import { Restaurant } from '../../restaurants/entities/restaurant.entity';
+import { EntityManager } from '@mikro-orm/postgresql';
+import { CreateRoleDto } from '../dto/create-role.dto';
+import { UpdateRoleDto } from '../dto/update-role.dto';
+import { RolePermission } from '../entities/rolePermission.entity';
+
+@Injectable()
+export class RolesService {
+  constructor(
+    @InjectRepository(Role)
+    private readonly roleRepository: EntityRepository<Role>,
+    @InjectRepository(Permission)
+    private readonly permissionRepository: EntityRepository<Permission>,
+    private readonly em: EntityManager,
+  ) { }
+
+  async createRestaurantRole(dto: CreateRoleDto, restId: string) {
+    const { name, permissionIds } = dto;
+
+    // Check if role already exists
+    const existing = await this.roleRepository.findOne({ name, restaurant: restId ? { id: restId } : null });
+    if (existing) {
+      throw new BadRequestException('Role with this name already exists for the restaurant');
+    }
+
+    let restaurant: Restaurant | null = null;
+    if (restId) {
+      restaurant = await this.em.findOne(Restaurant, { id: restId });
+      if (!restaurant) {
+        throw new NotFoundException('Restaurant not found');
+      }
+    }
+
+    const role = this.roleRepository.create({
+      name,
+      restaurant,
+      isSystem: false,
+    });
+
+    // Add permissions if provided
+    if (permissionIds && permissionIds.length > 0) {
+      const permissions = await this.permissionRepository.find({ id: { $in: permissionIds } });
+      if (permissions.length !== permissionIds.length) {
+        throw new BadRequestException('One or more permissions not found');
+      }
+      permissions.forEach(p => role.permissions.add(p));
+    }
+
+    await this.em.persistAndFlush(role);
+    return role;
+  }
+
+  async findAllGeneralAndRestaurantRoles(restId: string) {
+    const where: FilterQuery<Role> = { $or: [{ restaurant: restId }, { restaurant: null }], isSystem: false };
+
+    const roles = await this.roleRepository.find(where, {
+      orderBy: { createdAt: 'desc' },
+      populate: ['permissions', 'restaurant'],
+    });
+
+    return roles;
+  }
+
+  async findOne(restId: string, id: string) {
+    const role = await this.roleRepository.findOne(
+      { id, restaurant: { id: restId } },
+      { populate: ['permissions', 'restaurant'] },
+    );
+    if (!role) {
+      throw new NotFoundException('Role not found');
+    }
+    return role;
+  }
+
+  async update(restId: string, id: string, dto: UpdateRoleDto) {
+    const role = await this.roleRepository.findOne(
+      { id, restaurant: { id: restId } },
+      { populate: ['permissions', 'restaurant'] },
+    );
+    if (!role) {
+      throw new NotFoundException('Role not found');
+    }
+
+    if (dto.name) {
+      role.name = dto.name;
+    }
+
+    if (dto.permissionIds && dto.permissionIds.length >= 0) {
+      // Clear existing permissions and add new ones
+      role.permissions.removeAll();
+      const permissions = await this.permissionRepository.find({ id: { $in: dto.permissionIds } });
+      if (permissions.length !== dto.permissionIds.length) {
+        throw new BadRequestException('One or more permissions not found');
+      }
+      permissions.forEach(p => role.permissions.add(p));
+    }
+
+    await this.em.persistAndFlush(role);
+    return role;
+  }
+
+  async findAllSystemRoles() {
+    const roles = await this.roleRepository.find(
+      { isSystem: true },
+      {
+        orderBy: { createdAt: 'desc' },
+        populate: ['permissions', 'restaurant'],
+      },
+    );
+
+    return roles;
+  }
+
+  async remove(restId: string, id: string) {
+    const role = await this.roleRepository.findOne(
+      { id, restaurant: { id: restId } },
+      { populate: ['permissions', 'restaurant'] },
+    );
+    if (!role) {
+      throw new NotFoundException('Role not found');
+    }
+    if (!role.admins.isEmpty()) {
+      throw new BadRequestException('Role has admins');
+    }
+
+    // Hard delete pivot table entries (role_permissions) before soft deleting the role
+    await this.em.nativeDelete(RolePermission, { role: { id: role.id } });
+
+    // Soft delete the role
+    role.deletedAt = new Date();
+    return this.em.persistAndFlush(role);
+  }
+}