role module

src/modules/roles/controllers/roles.controller.ts

@@ -1,13 +1,11 @@
 import { Controller, Get, Post, Body, Param, Patch, Delete, UseGuards } from '@nestjs/common';
-import { ApiTags, ApiOperation, ApiBody, ApiBearerAuth, ApiHeader } from '@nestjs/swagger';
+import { ApiTags, ApiOperation, ApiBody, ApiBearerAuth } from '@nestjs/swagger';
 import { RolesService } from '../providers/roles.service';
 import { PermissionsService } from '../providers/permissions.service';
 import { CreateRoleDto } from '../dto/create-role.dto';
 import { UpdateRoleDto } from '../dto/update-role.dto';
 import { AdminAuthGuard } from 'src/modules/auth/guards/adminAuth.guard';
-import { SuperAdminAuthGuard } from 'src/modules/auth/guards/superAdminAuth.guard';
 import { Permissions } from 'src/common/decorators/permissions.decorator';
-import { } from 'src/common/decorators';
 import { AdminId } from 'src/common/decorators/admin-id.decorator';
 import { Permission } from 'src/common/enums/permission.enum';
 
@@ -21,13 +19,23 @@ export class RolesController {
     private readonly permissionService: PermissionsService,
   ) { }
 
+  @Post('admin/role')
+  @UseGuards(AdminAuthGuard)
+  @Permissions(Permission.MANAGE_ROLES)
+  @ApiBearerAuth()
+  @ApiOperation({ summary: 'Create a new role' })
+  @ApiBody({ type: CreateRoleDto })
+  create(@Body() dto: CreateRoleDto,) {
+    return this.roleService.create(dto);
+  }
+
   @Get('admin/roles')
   @UseGuards(AdminAuthGuard)
   @Permissions(Permission.MANAGE_ROLES)
   @ApiBearerAuth()
   @ApiOperation({ summary: 'Get all through restaurant roles with pagination and filters' })
   findAll() {
-    return this.roleService.findAllGeneralAndRestaurantRoles();
+    return this.roleService.findAll();
   }
 
   @Get('admin/roles/permissions')
@@ -36,30 +44,20 @@ export class RolesController {
   @ApiBearerAuth()
   @ApiOperation({ summary: 'Get all permissions that the admin has' })
   async findAllPermissions(@AdminId() adminId: string,) {
-    const adminPermissionNames = await this.permissionService.getAdminFullPermissions(adminId,);
+    const adminPermissionNames = await this.permissionService.getAdminPermissions(adminId);
 
     return adminPermissionNames;
   }
 
 
 
-  @Post('admin/roles')
-  @UseGuards(AdminAuthGuard)
-  @Permissions(Permission.MANAGE_ROLES)
-  @ApiBearerAuth()
-  @ApiOperation({ summary: 'Create a new role' })
-  @ApiBody({ type: CreateRoleDto })
-  create(@Body() dto: CreateRoleDto,) {
-    return this.roleService.createRestaurantRole(dto,);
-  }
-
   @Get('admin/roles/:id')
   @UseGuards(AdminAuthGuard)
   @Permissions(Permission.MANAGE_ROLES)
   @ApiBearerAuth()
   @ApiOperation({ summary: 'Get a specific role by ID' })
   findOne(@Param('id') id: string,) {
-    return this.roleService.findOne(, id);
+    return this.roleService.findOne( id);
   }
 
   @Patch('admin/roles/:id')
@@ -69,7 +67,7 @@ export class RolesController {
   @ApiOperation({ summary: 'Update a role' })
   @ApiBody({ type: UpdateRoleDto })
   update(@Param('id') id: string, @Body() dto: UpdateRoleDto,) {
-    return this.roleService.update(, id, dto);
+    return this.roleService.update(id, dto);
   }
 
   @Delete('admin/roles/:id')
@@ -78,16 +76,8 @@ export class RolesController {
   @ApiBearerAuth()
   @ApiOperation({ summary: 'Delete a role' })
   remove(@Param('id') id: string,) {
-    return this.roleService.remove(, id);
+    return this.roleService.remove( id);
   }
 
-  /** Super Admin Endpoints */
-  @UseGuards(SuperAdminAuthGuard)
-  @ApiBearerAuth()
-  @ApiOperation({ summary: 'Get all system roles for super-admin' })
-  @Get('super-admin/system-roles')
-  @ApiOperation({ summary: 'Get all system roles for super-admin' })
-  findAllSystemRoles() {
-    return this.roleService.findAllSystemRoles();
-  }
+
 }

src/modules/roles/dto/create-role.dto.ts

@@ -5,7 +5,12 @@ export class CreateRoleDto {
   @ApiProperty({ description: 'Role name' })
   @IsNotEmpty()
   @IsString()
-  name!: string;
+  name: string;
+
+  @ApiProperty({ description: 'farsi Role title' })
+  @IsNotEmpty()
+  @IsString()
+  title: string;
 
   @ApiProperty({ description: 'List of permission IDs', isArray: true, required: false })
   @IsOptional()

src/modules/roles/dto/update-role.dto.ts

@@ -1,14 +1,6 @@
-import { ApiProperty } from '@nestjs/swagger';
-import { IsOptional, IsString, IsArray } from 'class-validator';
+import {  PartialType } from '@nestjs/swagger';
+import { CreateRoleDto } from './create-role.dto';
 
-export class UpdateRoleDto {
-  @ApiProperty({ description: 'Role name', required: false })
-  @IsOptional()
-  @IsString()
-  name?: string;
+export class UpdateRoleDto extends PartialType(CreateRoleDto){
 
-  @ApiProperty({ description: 'List of permission IDs', isArray: true, required: false })
-  @IsOptional()
-  @IsArray()
-  permissionIds?: string[];
 }

src/modules/roles/entities/permission.entity.ts

@@ -1,17 +1,19 @@
-import { Entity, Property, Unique, ManyToMany, Collection } from '@mikro-orm/core';
+import { Entity, Property, Unique, ManyToMany, Collection, PrimaryKey } from '@mikro-orm/core';
 import { BaseEntity } from '../../../common/entities/base.entity';
 import { Role } from './role.entity';
+import { ulid } from 'ulid';
 
 @Entity({ tableName: 'permissions' })
 export class Permission extends BaseEntity {
-  @Property()
-  @Unique()
+  @PrimaryKey({ type: 'string', columnType: 'char(26)' })
+  id: string = ulid()
+
+  @Property({ unique: true })
   name!: string;
 
   @Property()
   title!: string;
 
-
   @ManyToMany({ entity: () => Role, mappedBy: 'permissions' })
   roles = new Collection<Role>(this);
 }

src/modules/roles/entities/role.entity.ts

@@ -1,15 +1,20 @@
-import { Collection, Entity, Index, ManyToMany, OneToMany, ManyToOne, Property } from '@mikro-orm/core';
+import { Collection, Entity, ManyToMany, OneToMany, PrimaryKey, Property } from '@mikro-orm/core';
 import { BaseEntity } from '../../../common/entities/base.entity';
 import { Permission } from './permission.entity';
-import { Restaurant } from '../../restaurants/entities/restaurant.entity';
 import { RolePermission } from './rolePermission.entity';
-import { AdminRole } from 'src/modules/admin/entities/adminRole.entity';
+import { Admin } from 'src/modules/admin/entities/admin.entity';
+import { ulid } from 'ulid';
 
 @Entity({ tableName: 'roles' })
-@Index({ properties: ['restaurant'] })
 export class Role extends BaseEntity {
+  @PrimaryKey({ type: 'string', columnType: 'char(26)' })
+  id: string = ulid()
+
+  @Property({ unique: true })
+  name: string;
+
   @Property()
-  name!: string;
+  title: string;
 
   @Property({ default: false })
   isSystem: boolean = false;
@@ -17,9 +22,6 @@ export class Role extends BaseEntity {
   @ManyToMany({ entity: () => Permission, pivotEntity: () => RolePermission, inversedBy: p => p.roles })
   permissions = new Collection<Permission>(this);
 
-  @ManyToOne(() => Restaurant, { nullable: true })
-  restaurant?: Restaurant;
-
-  @OneToMany(() => AdminRole, adminRole => adminRole.role)
-  admins = new Collection<AdminRole>(this);
+  @OneToMany(() => Admin, admin => admin.role)
+  admins = new Collection<Admin>(this);
 }

src/modules/roles/providers/permissions.service.ts

@@ -1,21 +1,17 @@
 import { Injectable } from '@nestjs/common';
 import { InjectRepository } from '@mikro-orm/nestjs';
-import { EntityManager, EntityRepository } from '@mikro-orm/core';
+import { EntityRepository } from '@mikro-orm/core';
 import { Permission } from '../entities/permission.entity';
-import { CacheService } from 'src/modules/util/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() {
@@ -23,83 +19,21 @@ export class PermissionsService {
     return permissions;
   }
 
-  /**
-   * Get admin permissions from cache or database
-   * @param adminId - The admin ID
-   * @param  - The restaurant ID
-   * @returns Array of permission names (string[])
-   */
-  async getAdminPermissions(adminId: string, : string): Promise<string[]> {
-    const cacheKey = `${this.ADMIN_PERMISSIONS_KEY}:${adminId}:${}`;
 
-    // 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
-      }
-    }
+  async getAdminPermissions(adminId: string) {
 
-    // If not in cache, fetch from database
     const admin = await this.adminRepository.findOne(
-      { id: adminId, roles: { restaurant: { id:  } } },
-      { populate: ['roles', 'roles.role', 'roles.role.permissions'] },
+      { id: adminId },
+      { populate: ['role', 'role.permissions'] },
     );
 
-    if (!admin || !admin.roles) {
+    if (!admin || !admin.role) {
       return [];
     }
 
-    // Ensure roles collection is loaded
-    await admin.roles.loadItems();
+    const permissions = admin.role.permissions.map(p => p)
 
-    // 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);
+    return permissions
   }
 
-  async getAdminFullPermissions(adminId: string, : string): Promise<Permission[]> {
-    const listOfPermissions = []
-    const adminRoles = await this.em.findOne(AdminRole, {
-      admin: {
-        id: adminId,
-      },
-      restaurant: {
-        id: ,
-      },
-    }, { 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  - The restaurant ID
-   */
-  async invalidateAdminPermissionsCache(adminId: string, : string): Promise<void> {
-    const cacheKey = `${this.ADMIN_PERMISSIONS_KEY}:${adminId}:${}`;
-    await this.cacheService.del(cacheKey);
-  }
 }

src/modules/roles/providers/roles.service.ts

@@ -3,42 +3,33 @@ 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';
+import { RoleRepository } from '../respository/role.repository';
 
 @Injectable()
 export class RolesService {
   constructor(
-    @InjectRepository(Role)
-    private readonly roleRepository: EntityRepository<Role>,
+    private readonly roleRepository: RoleRepository,
     @InjectRepository(Permission)
     private readonly permissionRepository: EntityRepository<Permission>,
     private readonly em: EntityManager,
   ) { }
 
-  async createRestaurantRole(dto: CreateRoleDto, : string) {
-    const { name, permissionIds } = dto;
+  async create(dto: CreateRoleDto) {
+    const { name, title, permissionIds } = dto;
 
     // Check if role already exists
-    const existing = await this.roleRepository.findOne({ name, restaurant:  ? { id:  } : null });
+    const existing = await this.roleRepository.findOne({ name });
     if (existing) {
-      throw new BadRequestException('Role with this name already exists for the restaurant');
-    }
-
-    let restaurant: Restaurant | null = null;
-    if () {
-      restaurant = await this.em.findOne(Restaurant, { id:  });
-      if (!restaurant) {
-        throw new NotFoundException('Restaurant not found');
-      }
+      throw new BadRequestException('Role with this key already exists');
     }
 
     const role = this.roleRepository.create({
       name,
-      restaurant,
+      title,
       isSystem: false,
     });
 
@@ -55,21 +46,21 @@ export class RolesService {
     return role;
   }
 
-  async findAllGeneralAndRestaurantRoles(: string) {
-    const where: FilterQuery<Role> = { $or: [{ restaurant:  }, { restaurant: null }], isSystem: false };
+  async findAll() {
+    const where: FilterQuery<Role> = { isSystem: false };
 
     const roles = await this.roleRepository.find(where, {
       orderBy: { createdAt: 'desc' },
-      populate: ['permissions', 'restaurant'],
+      populate: ['permissions'],
     });
 
     return roles;
   }
 
-  async findOne(: string, id: string) {
+  async findOne(id: string) {
     const role = await this.roleRepository.findOne(
-      { id, restaurant: { id:  } },
-      { populate: ['permissions', 'restaurant'] },
+      { id },
+      { populate: ['permissions'] },
     );
     if (!role) {
       throw new NotFoundException('Role not found');
@@ -77,10 +68,10 @@ export class RolesService {
     return role;
   }
 
-  async update(: string, id: string, dto: UpdateRoleDto) {
+  async update(id: string, dto: UpdateRoleDto) {
     const role = await this.roleRepository.findOne(
-      { id, restaurant: { id:  } },
-      { populate: ['permissions', 'restaurant'] },
+      { id },
+      { populate: ['permissions'] },
     );
     if (!role) {
       throw new NotFoundException('Role not found');
@@ -90,6 +81,10 @@ export class RolesService {
       role.name = dto.name;
     }
 
+    if (dto.title) {
+      role.title = dto.title;
+    }
+
     if (dto.permissionIds && dto.permissionIds.length >= 0) {
       // Clear existing permissions and add new ones
       role.permissions.removeAll();
@@ -104,22 +99,10 @@ export class RolesService {
     return role;
   }
 
-  async findAllSystemRoles() {
-    const roles = await this.roleRepository.find(
-      { isSystem: true },
-      {
-        orderBy: { createdAt: 'desc' },
-        populate: ['permissions', 'restaurant'],
-      },
-    );
-
-    return roles;
-  }
-
-  async remove(: string, id: string) {
+  async remove(id: string) {
     const role = await this.roleRepository.findOne(
-      { id, restaurant: { id:  } },
-      { populate: ['permissions', 'restaurant'] },
+      { id },
+      { populate: ['permissions'] },
     );
     if (!role) {
       throw new NotFoundException('Role not found');

src/modules/roles/respository/role.repository.ts

@@ -0,0 +1,13 @@
+import { EntityManager, EntityRepository } from '@mikro-orm/postgresql';
+ import { Injectable } from '@nestjs/common';
+import { Role } from '../entities/role.entity';
+
+@Injectable()
+export class RoleRepository extends EntityRepository<Role> {
+  constructor(
+    readonly em: EntityManager,
+  ) {
+    super(em, Role);
+  }
+
+}

src/modules/roles/roles.module.ts

@@ -9,12 +9,13 @@ import { RolePermission } from './entities/rolePermission.entity';
 import { JwtModule } from '@nestjs/jwt';
 import { UtilsModule } from '../util/utils.module';
 import { AdminModule } from '../admin/admin.module';
+import { RoleRepository } from './respository/role.repository';
 
 @Global()
 @Module({
   imports: [MikroOrmModule.forFeature([Role, Permission, RolePermission]), JwtModule, UtilsModule, AdminModule],
   controllers: [RolesController],
-  providers: [RolesService, PermissionsService],
-  exports: [RolesService, PermissionsService],
+  providers: [RolesService, PermissionsService, RoleRepository],
+  exports: [RolesService, PermissionsService, RoleRepository],
 })
 export class RolesModule { }