refactor: the whole role and permission flow

src/modules/users/DTO/create-admin.dto.ts

@@ -0,0 +1,29 @@
+import { ApiProperty, ApiPropertyOptional, PickType } from "@nestjs/swagger";
+import { IsEmail, IsNotEmpty, IsOptional, IsString, IsUUID, IsUrl, MinLength } from "class-validator";
+
+import { AdminMessage, AuthMessage } from "../../../common/enums/message.enum";
+import { CompleteRegistrationDto } from "../../auth/DTO/complete-register.dto";
+
+export class CreateAdminDto extends PickType(CompleteRegistrationDto, ["firstName", "lastName", "phone", "password"] as const) {
+  @IsNotEmpty({ message: AuthMessage.PASSWORD_NOT_EMPTY })
+  @IsString({ message: AuthMessage.PASSWORD_FORMAT_INVALID })
+  @ApiProperty({ description: "repeat password", example: "12345678" })
+  @MinLength(8, { message: AuthMessage.PASSWORD_LENGTH })
+  repeatPassword: string;
+
+  @IsNotEmpty({ message: AuthMessage.EMAIL_NOT_EMPTY })
+  @IsEmail({}, { message: AuthMessage.INVALID_EMAIL_FORMAT })
+  @ApiProperty({ description: "Email", example: "ma@gmail.com" })
+  email: string;
+
+  @IsNotEmpty({ message: AdminMessage.ROLE_REQUIRED })
+  @IsUUID("4", { message: AdminMessage.ROLE_ID_SHOULD_BE_UUID })
+  @ApiProperty({ description: "Role id", example: "123e4567-e89b-12d3-a456-426614174000" })
+  roleId: string;
+
+  @IsOptional()
+  @IsNotEmpty({ message: AdminMessage.PROFILE_PIC_REQUIRED })
+  @IsUrl({ protocols: ["http", "https"], require_protocol: true }, { message: AdminMessage.PROFILE_PIC_URL })
+  @ApiPropertyOptional({ description: "Profile picture", example: "https://www.google.com" })
+  profilePic: string;
+}

src/modules/users/DTO/create-role.dto.ts

@@ -0,0 +1,17 @@
+import { ApiProperty } from "@nestjs/swagger";
+import { IsNotEmpty, IsString, IsUUID, Length } from "class-validator";
+
+import { AdminMessage } from "../../../common/enums/message.enum";
+
+export class CreateRoleDto {
+  @IsNotEmpty({ message: AdminMessage.ROLE_NAME_REQUIRED })
+  @IsString({ message: AdminMessage.ROLE_NAME_STRING })
+  @Length(3, 150, { message: AdminMessage.ROLE_NAME_LENGTH })
+  @ApiProperty({ description: "Role name", example: "super-admin" })
+  name: string;
+
+  @IsNotEmpty({ message: AdminMessage.PERMISSIONS_REQUIRED })
+  @IsUUID("4", { each: true, message: AdminMessage.PERMISSIONS_ID_SHOULD_BE_UUID })
+  @ApiProperty({ description: "Permissions id", example: ["123e4567-e89b-12d3-a456-426614174000"] })
+  permissions: string[];
+}

src/modules/users/DTO/search-admins-query.dto.ts

@@ -0,0 +1,17 @@
+import { ApiPropertyOptional } from "@nestjs/swagger";
+import { IsEnum, IsOptional, IsString } from "class-validator";
+
+import { PaginationDto } from "../../../common/DTO/pagination.dto";
+import { PermissionEnum } from "../enums/permission.enum";
+
+export class SearchAdminQueryDto extends PaginationDto {
+  @IsOptional()
+  @IsString()
+  @ApiPropertyOptional({ description: "search query", example: "mahyar" })
+  q?: string;
+
+  @IsOptional()
+  @IsEnum(PermissionEnum)
+  @ApiPropertyOptional({ description: "permission", example: PermissionEnum.SERVICES })
+  permission?: PermissionEnum;
+}

src/modules/users/DTO/search-admins.dto.ts

@@ -1,12 +0,0 @@
-import { ApiPropertyOptional } from "@nestjs/swagger";
-import { IsOptional, IsString } from "class-validator";
-
-import { PaginationDto } from "../../../common/DTO/pagination.dto";
-import { FinancialMessage } from "../../../common/enums/message.enum";
-
-export class SearchAdminsDto extends PaginationDto {
-  @IsOptional()
-  @IsString({ message: FinancialMessage.SEARCH_QUERY_MUST_BE_A_STRING })
-  @ApiPropertyOptional({ description: "search query", example: "search query" })
-  q: string;
-}

src/modules/users/DTO/search-roles.dto.ts

@@ -0,0 +1,11 @@
+import { ApiPropertyOptional } from "@nestjs/swagger";
+import { IsOptional, IsString } from "class-validator";
+
+import { PaginationDto } from "../../../common/DTO/pagination.dto";
+
+export class SearchRolesQueryDto extends PaginationDto {
+  @IsOptional()
+  @IsString()
+  @ApiPropertyOptional({ description: "Search query", example: "admin" })
+  q?: string;
+}

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

@@ -1,15 +1,24 @@
 import { Column, Entity, JoinTable, ManyToMany } from "typeorm";
 
 import { Permission } from "./permission.entity";
+import { User } from "./user.entity";
 import { BaseEntity } from "../../../common/entities/base.entity";
-import { RoleEnum } from "../enums/role.enum";
 
 @Entity()
 export class Role extends BaseEntity {
-  @Column({ type: "enum", enum: RoleEnum, default: RoleEnum.USER, nullable: false, unique: true })
-  name: RoleEnum;
+  //   @Column({ type: "enum", enum: RoleEnum, default: RoleEnum.USER, nullable: false, unique: true })
+  //   name: RoleEnum;
+
+  @Column({ type: "varchar", length: 150, nullable: false, unique: true })
+  name: string;
+
+  @Column({ type: "boolean", default: false })
+  isAdmin: boolean;
 
   @ManyToMany(() => Permission, (permission) => permission.roles)
   @JoinTable({ name: "role_permission_relation" })
   permissions: Permission[];
+
+  @ManyToMany(() => User, (user) => user.roles)
+  users: User[];
 }

src/modules/users/entities/user-financial.entity.ts

@@ -0,0 +1,27 @@
+import { Column, Entity, ManyToOne, Unique } from "typeorm";
+
+import { User } from "./user.entity";
+import { BaseEntity } from "../../../common/entities/base.entity";
+import { FinancialType } from "../enums/financial-type.enum";
+
+@Unique(["user", "type"])
+@Entity()
+export class UserFinancial extends BaseEntity {
+  @Column({ type: "enum", enum: FinancialType, default: FinancialType.REAL })
+  type: FinancialType;
+
+  @Column({ nullable: true })
+  economicCode: string;
+
+  @Column({ nullable: true })
+  registrationId: string;
+
+  @Column({ nullable: true })
+  nationalId: string;
+
+  @Column({ nullable: true })
+  number: string;
+
+  @ManyToOne(() => User)
+  user: User;
+}

src/modules/users/entities/user.entity.ts

@@ -43,14 +43,16 @@ export class User extends BaseEntity {
   @Column({ type: "varchar", length: 12, nullable: true })
   birthDate: string;
 
-  @Column({ type: "varchar", length: 100, unique: true, nullable: false })
-  nationalCode: string;
+  @Column({ type: "varchar", length: 100, unique: true, nullable: true })
+  nationalCode: string | null;
 
+  @Column({ type: "varchar", length: 100, nullable: true })
+  profilePic: string;
   //-----------------------------------------
   //   @ManyToOne(() => Role, { eager: true, onDelete: "RESTRICT", nullable: false })
   //   role: Role;
 
-  @ManyToMany(() => Role)
+  @ManyToMany(() => Role, (role) => role.users)
   @JoinTable({ name: "user_role_relation" })
   roles: Role[];
 

src/modules/users/enums/permission.enum.ts

@@ -16,4 +16,6 @@ export enum PermissionEnum {
   LEARNINGS = "learnings",
   LOGS = "logs",
   SETTINGS = "settings",
+  BANK_ACCOUNTS = "bank_accounts",
+  PAYMENTS = "payments",
 }

src/modules/users/enums/role.enum.ts

@@ -1,6 +1,4 @@
 export enum RoleEnum {
-  ADMIN = "admin",
+  SUPER_ADMIN = "super_admin",
   USER = "user",
-  DEVELOPER = "developer",
-  AGENT = "agent",
 }

src/modules/users/providers/users.service.ts

@@ -2,49 +2,40 @@ import { BadRequestException, Injectable } from "@nestjs/common";
 import slugify from "slugify";
 import { In, Not, QueryRunner } from "typeorm";
 
-import { CommonMessage, UserMessage } from "../../../common/enums/message.enum";
+// import { CreateFinancialDto } from "../DTO/create-legal-user.dto";
+import { AdminMessage, AdsMessage, CommonMessage, UserMessage } from "../../../common/enums/message.enum";
 import { CompleteRegistrationDto } from "../../auth/DTO/complete-register.dto";
 import { UserSettingsService } from "../../settings/providers/user-settings.service";
 import { PaginationUtils } from "../../utils/providers/pagination.utils";
+import { PasswordService } from "../../utils/providers/password.service";
 import { WalletsService } from "../../wallets/providers/wallets.service";
 import { CheckValidityDTO } from "../DTO/check-validity.dto";
-// import { CreateFinancialDto } from "../DTO/create-legal-user.dto";
-import { SearchAdminsDto } from "../DTO/search-admins.dto";
+import { CreateAdminDto } from "../DTO/create-admin.dto";
+import { CreateRoleDto } from "../DTO/create-role.dto";
+import { SearchAdminQueryDto } from "../DTO/search-admins-query.dto";
 import { SearchCustomersDto } from "../DTO/search-customers.dto";
+import { SearchRolesQueryDto } from "../DTO/search-roles.dto";
 import { UpdateProfileDto } from "../DTO/update-profile.dto";
 import { CreateUserGroupDto } from "../DTO/user-group.dto";
 import { Role } from "../entities/role.entity";
 import { User } from "../entities/user.entity";
 import { RoleEnum } from "../enums/role.enum";
 import { ValidityType } from "../enums/validity-type.enum";
-// import { LegalUserRepository } from "../repositories/legal-user.repository";
-// import { RealUserRepository } from "../repositories/real-user.repository";
+import { PermissionsRepository } from "../repositories/permissions.repository";
+import { RoleRepository } from "../repositories/roles.repository";
 import { UserGroupRepository } from "../repositories/user-group.repository";
 import { UserRepository } from "../repositories/users.repository";
 
 @Injectable()
 export class UsersService {
-  private readonly userSelect = {
-    id: true,
-    phone: true,
-    email: true,
-    userName: true,
-    firstName: true,
-    lastName: true,
-    nationalCode: true,
-    birthDate: true,
-    role: {
-      id: true,
-      name: true,
-    },
-  };
   constructor(
     private readonly userRepository: UserRepository,
     private readonly userGroupRepository: UserGroupRepository,
     private readonly userSettingsService: UserSettingsService,
     private readonly walletsService: WalletsService,
-    // private readonly realUserRepository: RealUserRepository,
-    // private readonly legalUserRepository: LegalUserRepository,
+    private readonly rolesRepository: RoleRepository,
+    private readonly permissionsRepository: PermissionsRepository,
+    private readonly passwordService: PasswordService,
   ) {}
 
   /************************************************************ */
@@ -65,7 +56,7 @@ export class UsersService {
   /************************************************************ */
 
   async getMe(userId: string) {
-    const user = await this.userRepository.findOne({ where: { id: userId }, select: this.userSelect });
+    const user = await this.userRepository.findOne({ where: { id: userId }, relations: { roles: true } });
     if (!user) throw new BadRequestException(UserMessage.USER_NOT_FOUND);
     return { user };
   }
@@ -74,6 +65,7 @@ export class UsersService {
 
   async updateProfile(userId: string, updateProfileDto: UpdateProfileDto) {
     if (updateProfileDto.userName) {
+      //
       updateProfileDto.userName = slugify(updateProfileDto.userName, { lower: true, trim: true });
       const existUserName = await this.userRepository.findOneBy({ userName: updateProfileDto.userName, id: Not(userId) });
       if (existUserName) throw new BadRequestException(UserMessage.USERNAME_EXIST);
@@ -81,12 +73,8 @@ export class UsersService {
     const user = await this.userRepository.findOneBy({ id: userId });
     if (!user) throw new BadRequestException(UserMessage.USER_NOT_FOUND);
 
-    // const { userName } = updateProfileDto;
-    // if (userName) user.userName = userName;
-    // if (firstName) user.firstName = firstName;
-    // if (lastName) user.lastName = lastName;
-
     await this.userRepository.save({ ...user, ...updateProfileDto });
+    //
     return {
       message: CommonMessage.UPDATE_SUCCESS,
     };
@@ -110,6 +98,9 @@ export class UsersService {
     const role = await queryRunner.manager.findOneBy(Role, { name: RoleEnum.USER });
     if (!role) throw new BadRequestException(UserMessage.ROLE_NOT_FOUND);
 
+    const existUser = await queryRunner.manager.findOneBy(User, { nationalCode: registerDto.nationalCode });
+    if (existUser) throw new BadRequestException(UserMessage.NATIONAL_CODE_EXIST);
+
     const user = queryRunner.manager.create(User, {
       ...registerDto,
       password: hashedPassword,
@@ -122,12 +113,47 @@ export class UsersService {
     await this.walletsService.createUserWallet(user.id, queryRunner);
 
     return user;
-    // const role = await this.roleRepository.findOneBy({ name: RoleEnum.USER });
-    // if (!role) throw new BadRequestException(UserMessage.ROLE_NOT_FOUND);
+  }
 
-    // const user = this.userRepository.create({ ...registerDto, password: hashedPassword, role });
-    // await this.userSettingsService.createUserSettings(user.id);
-    // return await this.userRepository.save(user);
+  /************************************************************ */
+
+  async createAdmin(createDto: CreateAdminDto) {
+    const existEmail = await this.userRepository.findOneBy({ email: createDto.email });
+    if (existEmail) throw new BadRequestException(UserMessage.EMAIL_EXIST);
+
+    const role = await this.rolesRepository.findOne({ where: { id: createDto.roleId }, relations: { permissions: true } });
+    if (!role) throw new BadRequestException(AdsMessage.ROLE_NOT_FOUND);
+
+    await this.rolesRepository.save(role);
+
+    if (createDto.password !== createDto.repeatPassword) throw new BadRequestException(AdminMessage.PASSWORD_NOT_MATCH);
+
+    const hashedPassword = await this.passwordService.hashPassword(createDto.password);
+
+    const userName = slugify(`${createDto.firstName} ${Date.now().toString().slice(-5)}`, { lower: true, trim: true });
+
+    const adminUser = this.userRepository.create({ ...createDto, roles: [role], password: hashedPassword, userName });
+    await this.userRepository.save(adminUser);
+    return {
+      message: AdminMessage.ADMIN_CREATED,
+      adminUser,
+    };
+  }
+  /************************************************************ */
+
+  async createRole(createDto: CreateRoleDto) {
+    const existRole = await this.rolesRepository.findOne({ where: { name: createDto.name } });
+    if (existRole) throw new BadRequestException(AdminMessage.ROLE_EXIST);
+
+    const permissions = await this.permissionsRepository.findBy({ id: In(createDto.permissions) });
+    if (permissions.length !== createDto.permissions.length) throw new BadRequestException(AdminMessage.PERMISSIONS_NOT_FOUND);
+
+    const role = this.rolesRepository.create({ ...createDto, permissions, isAdmin: true });
+    await this.rolesRepository.save(role);
+    return {
+      message: AdminMessage.ROLE_CREATED,
+      role,
+    };
   }
 
   /************************************************************ */
@@ -209,30 +235,6 @@ export class UsersService {
 
   /************************************************************ */
 
-  async findAllAdmins(queryDto: SearchAdminsDto) {
-    const { limit, skip } = PaginationUtils(queryDto);
-
-    const queryBuilder = this.userRepository
-      .createQueryBuilder("user")
-      .leftJoin("user.role", "role")
-      .where("role.name = :roleName", { roleName: RoleEnum.ADMIN })
-      .leftJoin("user.groups", "groups")
-      .addSelect(["groups.id", "groups.name"]);
-
-    if (queryDto.q) {
-      queryBuilder
-        .orWhere("user.firstName ILIKE :search", { search: `%${queryDto.q}%` })
-        .orWhere("user.lastName ILIKE :search", { search: `%${queryDto.q}%` })
-        .orWhere("user.userName ILIKE :search", { search: `%${queryDto.q}%` });
-    }
-
-    const [admins, count] = await queryBuilder.skip(skip).take(limit).getManyAndCount();
-
-    return { admins, count };
-  }
-
-  /************************************************************ */
-
   async findAllCustomers(queryDto: SearchCustomersDto) {
     const { limit, skip } = PaginationUtils(queryDto);
 
@@ -273,73 +275,77 @@ export class UsersService {
 
     return { customer };
   }
-
   /************************************************************ */
 
-  // async createRealUserData(createDto: CreateFinancialDto, user: User) {
-  //   const userExist = await this.userRepository.findOneBy({
-  //     id: user.role.name === RoleEnum.USER ? user.id : createDto.userId,
-  //   });
+  async getAdmins(queryDto: SearchAdminQueryDto) {
+    const { limit, skip } = PaginationUtils(queryDto);
+    const queryBuilder = this.userRepository.createQueryBuilder("user");
 
-  //   if (!userExist) throw new BadRequestException(UserMessage.USER_NOT_FOUND);
+    queryBuilder
+      .leftJoinAndSelect("user.roles", "role")
+      //   .addSelect(["role.id", "role.name"])
+      .where("role.isAdmin = :isAdmin", { isAdmin: true })
+      .leftJoinAndSelect("user.groups", "groups")
+      .leftJoinAndSelect("role.permissions", "permissions");
+    //   .where("permissions.name IN (:...adminPermissions)", {
+    //     adminPermissions: [PermissionEnum.ADMINS],
+    //   });
+    //   .addSelect(["permissions.id", "permissions.name"]);
 
-  //   const existingFinancial = await this.userFinancialRepository.findOne({
-  //     where: { user: { id: userExist.id }, type: createDto.type },
-  //   });
-  //   console.log(existingFinancial);
+    if (queryDto.q) {
+      queryBuilder.andWhere("user.firstName ILIKE :q OR user.lastName ILIKE :q OR user.userName ILIKE :q", {
+        q: `%${queryDto.q}%`,
+      });
+    }
 
-  //   if (existingFinancial) throw new BadRequestException(FinancialMessage.FINANCIAL_INFO_ALREADY_EXISTS);
+    if (queryDto.permission) {
+      queryBuilder.andWhere("permissions.name = :permName", { permName: queryDto.permission });
+    }
 
-  //   const userFinancial = this.userFinancialRepository.create({
-  //     ...createDto,
-  //     user: userExist,
-  //   });
+    queryBuilder.take(limit).skip(skip).orderBy("user.createdAt", "DESC");
 
-  //   await this.userFinancialRepository.save(userFinancial);
+    const [users, count] = await queryBuilder.getManyAndCount();
 
-  //   return {
-  //     message: CommonMessage.CREATED,
-  //     userFinancial,
-  //   };
-  // }
-
-  // /************************************************************ */
-
-  // async updateUserFinancial(updateDto: CreateFinancialDto, user: User, userFinancialId: string) {
-  //   const userExist = await this.userRepository.findOneBy({
-  //     id: user.role.name === RoleEnum.USER ? user.id : updateDto.userId,
-  //   });
-
-  //   if (!userExist) throw new BadRequestException(UserMessage.USER_NOT_FOUND);
-
-  //   const existingFinancial = await this.userFinancialRepository.findOne({
-  //     where: { id: userFinancialId, user: { id: userExist.id }, type: updateDto.type },
-  //   });
-
-  //   if (!existingFinancial) throw new BadRequestException(FinancialMessage.FINANCIAL_INFO_NOT_FOUND);
-
-  //   await this.userFinancialRepository.save({
-  //     ...existingFinancial,
-  //     updateDto,
-  //   });
-
-  //   return {
-  //     message: CommonMessage.UPDATE_SUCCESS,
-  //     userFinancial: existingFinancial,
-  //   };
-  // }
-
-  /************************************************************ */
-
-  async getUserFinancial(userId: string) {
-    const user = await this.userRepository.findOne({
-      where: {
-        id: userId,
-      },
-      relations: ["userFinancials"],
-    });
-    if (!user) throw new BadRequestException(UserMessage.USER_NOT_FOUND);
-
-    return { user };
+    return {
+      users,
+      count,
+      paginate: true,
+    };
   }
+
+  /************************************************************ */
+
+  async getPermissions() {
+    const permissions = await this.permissionsRepository.find({ select: { id: true, name: true } });
+    return {
+      permissions,
+    };
+  }
+  /************************************************************ */
+
+  async getRoles(queryDto: SearchRolesQueryDto) {
+    const { limit, skip } = PaginationUtils(queryDto);
+    const queryBuilder = this.rolesRepository.createQueryBuilder("role");
+
+    queryBuilder
+      .where("role.isAdmin = :isAdmin", { isAdmin: true })
+      //   .leftJoinAndSelect("role.permissions", "permissions")
+      .loadRelationCountAndMap("role.userCount", "role.users");
+
+    if (queryDto.q) {
+      queryBuilder.andWhere("role.name ILIKE :q", { q: `%${queryDto.q}%` });
+    }
+
+    queryBuilder.take(limit).skip(skip).orderBy("role.createdAt", "DESC");
+
+    const [roles, count] = await queryBuilder.getManyAndCount();
+
+    return {
+      roles,
+      count,
+      paginate: true,
+    };
+  }
+
+  /************************************************************ */
 }

src/modules/users/repositories/permissions.repository.ts

@@ -0,0 +1,12 @@
+import { Injectable } from "@nestjs/common";
+import { InjectRepository } from "@nestjs/typeorm";
+import { Repository } from "typeorm";
+
+import { Permission } from "../entities/permission.entity";
+
+@Injectable()
+export class PermissionsRepository extends Repository<Permission> {
+  constructor(@InjectRepository(Permission) permissionsRepository: Repository<Permission>) {
+    super(permissionsRepository.target, permissionsRepository.manager, permissionsRepository.queryRunner);
+  }
+}

src/modules/users/users.controller.ts

@@ -2,15 +2,18 @@ import { Body, Controller, Get, HttpCode, HttpStatus, Patch, Post, Query } from
 import { ApiOperation, ApiTags } from "@nestjs/swagger";
 
 import { CheckValidityDTO } from "./DTO/check-validity.dto";
-import { SearchAdminsDto } from "./DTO/search-admins.dto";
+import { CreateAdminDto } from "./DTO/create-admin.dto";
+import { CreateRoleDto } from "./DTO/create-role.dto";
+import { SearchAdminQueryDto } from "./DTO/search-admins-query.dto";
 import { SearchCustomersDto } from "./DTO/search-customers.dto";
+import { SearchRolesQueryDto } from "./DTO/search-roles.dto";
 import { UpdateProfileDto } from "./DTO/update-profile.dto";
 import { CreateUserGroupDto } from "./DTO/user-group.dto";
 import { User } from "./entities/user.entity";
-import { RoleEnum } from "./enums/role.enum";
+import { PermissionEnum } from "./enums/permission.enum";
 import { UsersService } from "./providers/users.service";
 import { AuthGuards } from "../../common/decorators/auth-guard.decorator";
-import { Roles } from "../../common/decorators/roles.decorator";
+import { PermissionsDec } from "../../common/decorators/permission.decorator";
 import { UserDec } from "../../common/decorators/user.decorator";
 
 @Controller("users")
@@ -49,9 +52,8 @@ export class UsersController {
   /************************************************************ */
 
   @AuthGuards()
-  @Roles(RoleEnum.ADMIN)
-  @ApiOperation({ summary: "Create user group" })
-  @HttpCode(HttpStatus.CREATED)
+  @ApiOperation({ summary: "Create user group ==> admin route" })
+  @PermissionsDec(PermissionEnum.ADMINS, PermissionEnum.CUSTOMERS)
   @Post("user-group")
   createUserGroup(@Body() createDto: CreateUserGroupDto) {
     return this.usersService.createUserGroup(createDto);
@@ -59,9 +61,9 @@ export class UsersController {
 
   /************************************************************ */
 
-  @ApiOperation({ summary: "get all user group" })
+  @ApiOperation({ summary: "get all user group ==> admin route" })
+  @PermissionsDec(PermissionEnum.ADMINS, PermissionEnum.CUSTOMERS)
   @AuthGuards()
-  @Roles(RoleEnum.ADMIN)
   @Get("user-group")
   UserGroups() {
     return this.usersService.getUserGroups();
@@ -69,50 +71,59 @@ export class UsersController {
 
   /************************************************************ */
 
-  @ApiOperation({ summary: "get all admins" })
+  @ApiOperation({ summary: "get all users ==> admin route" })
+  @PermissionsDec(PermissionEnum.ADMINS, PermissionEnum.CUSTOMERS)
   @AuthGuards()
-  @Roles(RoleEnum.ADMIN)
-  @Get("admins")
-  Users(@Query() queryDto: SearchAdminsDto) {
-    return this.usersService.findAllAdmins(queryDto);
+  @Get()
+  Users() {
+    return this.usersService.findAllUsers();
   }
 
-  /************************************************************ */
-
-  @ApiOperation({ summary: "get all customers" })
+  @ApiOperation({ summary: "get all customers ==> admin route" })
+  @PermissionsDec(PermissionEnum.ADMINS, PermissionEnum.CUSTOMERS)
   @AuthGuards()
-  @Roles(RoleEnum.ADMIN)
   @Get("customers")
   customers(@Query() queryDto: SearchCustomersDto) {
     return this.usersService.findAllCustomers(queryDto);
   }
 
-  /************************************************************ */
-
-  // @AuthGuards()
-  // @ApiOperation({ summary: "Create user financial" })
-  // @HttpCode(HttpStatus.CREATED)
-  // @Post("user-financial")
-  // createUserFinancial(@Body() createDto: CreateFinancialDto, @UserDec() user: User) {
-  //   return this.usersService.createUserFinancial(createDto, user);
-  // }
-
-  /************************************************************ */
-
-  // @AuthGuards()
-  // @ApiOperation({ summary: "update user financial" })
-  // @HttpCode(HttpStatus.CREATED)
-  // @Patch("user-financial/:id/update")
-  // updateUserFinancial(@Body() updateDto: CreateFinancialDto, @UserDec() user: User, @Param() paramDto: ParamDto) {
-  //   return this.usersService.updateUserFinancial(updateDto, user, paramDto.id);
-  // }
-
-  /************************************************************ */
-
-  @ApiOperation({ summary: "get all user financials" })
+  @ApiOperation({ summary: "get all admins ==> admin route" })
+  @PermissionsDec(PermissionEnum.ADMINS, PermissionEnum.CUSTOMERS)
   @AuthGuards()
-  @Get("user-financials")
-  userFinancials(@UserDec("id") userId: string) {
-    return this.usersService.getUserFinancial(userId);
+  @Get("admins")
+  getAdmins(@Query() queryDto: SearchAdminQueryDto) {
+    return this.usersService.getAdmins(queryDto);
+  }
+
+  @ApiOperation({ summary: "create admin ==> admin route" })
+  @AuthGuards()
+  @PermissionsDec(PermissionEnum.ADMINS, PermissionEnum.CUSTOMERS)
+  @Post("admins")
+  createAdmin(@Body() createDto: CreateAdminDto) {
+    return this.usersService.createAdmin(createDto);
+  }
+
+  @ApiOperation({ summary: "get all permissions ==> admin route" })
+  @AuthGuards()
+  @PermissionsDec(PermissionEnum.ADMINS, PermissionEnum.CUSTOMERS)
+  @Get("permissions")
+  getPermissions() {
+    return this.usersService.getPermissions();
+  }
+
+  @ApiOperation({ summary: "get all roles ==> admin route" })
+  @AuthGuards()
+  @PermissionsDec(PermissionEnum.ADMINS, PermissionEnum.CUSTOMERS)
+  @Get("roles")
+  getRoles(@Query() queryDto: SearchRolesQueryDto) {
+    return this.usersService.getRoles(queryDto);
+  }
+
+  @ApiOperation({ summary: "create role ==> admin route" })
+  @AuthGuards()
+  @PermissionsDec(PermissionEnum.ADMINS, PermissionEnum.CUSTOMERS)
+  @Post("roles")
+  createRole(@Body() createDto: CreateRoleDto) {
+    return this.usersService.createRole(createDto);
   }
 }

src/modules/users/users.module.ts

@@ -8,19 +8,21 @@ import { UserGroup } from "./entities/user-group.entity";
 import { User } from "./entities/user.entity";
 import { UsersService } from "./providers/users.service";
 import { LegalUserRepository } from "./repositories/legal-user.repository";
+import { PermissionsRepository } from "./repositories/permissions.repository";
 import { RoleRepository } from "./repositories/roles.repository";
 import { UserGroupRepository } from "./repositories/user-group.repository";
 import { UserRepository } from "./repositories/users.repository";
-import { UsersController } from "./users.controller";
 import { UserSetting } from "../settings/entities/user-setting.entity";
 import { UserSettingsService } from "../settings/providers/user-settings.service";
 import { UserSettingsRepository } from "../settings/repositories/user-settings.repository";
 import { WalletsModule } from "../wallets/wallets.module";
 import { RealUser } from "./entities/real-user.entity";
 import { RealUserRepository } from "./repositories/real-user.repository";
+import { UsersController } from "./users.controller";
+import { UtilsModule } from "../utils/utils.module";
 
 @Module({
-  imports: [TypeOrmModule.forFeature([User, Role, UserGroup, UserSetting, RealUser, LegalUser, Permission]), WalletsModule],
+  imports: [TypeOrmModule.forFeature([User, Role, UserGroup, UserSetting, RealUser, LegalUser, Permission]), WalletsModule, UtilsModule],
   providers: [
     UsersService,
     UserRepository,
@@ -28,10 +30,11 @@ import { RealUserRepository } from "./repositories/real-user.repository";
     UserGroupRepository,
     UserSettingsRepository,
     UserSettingsService,
+    PermissionsRepository,
     RealUserRepository,
     LegalUserRepository,
   ],
   controllers: [UsersController],
-  exports: [UsersService, TypeOrmModule, UserRepository],
+  exports: [UsersService, UserRepository],
 })
 export class UsersModule {}