完成权限角色守卫

tone-page-server/src/role/entities/user-role.entity.ts

@@ -0,0 +1,23 @@
+import { Column, CreateDateColumn, Entity, Index, PrimaryGeneratedColumn } from "typeorm";
+
+@Entity()
+@Index(['userId', 'roleId'])
+export class UserRole {
+    @PrimaryGeneratedColumn('uuid')
+    id: string;
+
+    @Column('uuid')
+    roleId: string;
+
+    @Column('uuid')
+    userId: string
+
+    @Column()
+    isEnabled: boolean;
+
+    @CreateDateColumn({ precision: 3 })
+    createdAt: Date;
+
+    @Column({ nullable: true, precision: 3 })
+    expiredAt?: Date;
+}

tone-page-server/src/role/role.module.ts

@@ -3,8 +3,15 @@ import { TypeOrmModule } from '@nestjs/typeorm';
 import { Role } from './entities/role.entity';
 import { Permission } from './entities/permission.entity';
 import { RolePermission } from './entities/role-permission.entity';
+import { RolePermissionService } from './services/role-permission.service';
+import { RoleService } from './services/role.service';
+import { UserRoleService } from './services/user-role.service';
+import { UserRole } from './entities/user-role.entity';
+import { PermissionService } from './services/permission.service';
 
 @Module({
-    imports: [TypeOrmModule.forFeature([Role, Permission, RolePermission])]
+    imports: [TypeOrmModule.forFeature([Role, Permission, RolePermission, UserRole])],
+    providers: [RolePermissionService, RoleService, UserRoleService, PermissionService],
+    exports: [RolePermissionService, RoleService, UserRoleService, PermissionService],
 })
 export class RoleModule { }

tone-page-server/src/role/services/permission.service.ts

@@ -0,0 +1,26 @@
+import { Injectable } from "@nestjs/common";
+import { InjectRepository } from "@nestjs/typeorm";
+import { Permission } from "../entities/permission.entity";
+import { In, Repository } from "typeorm";
+
+@Injectable()
+export class PermissionService {
+
+    constructor(
+        @InjectRepository(Permission)
+        private readonly permissionRepository: Repository<Permission>,
+    ) { }
+
+    async findPermissionNamesByPermissionIds(permissionIds: string[]): Promise<string[]> {
+        const permissions = await this.findPermissionsByPermissionIds(permissionIds);
+        return permissions.map(permission => permission.name);
+    }
+
+    async findPermissionsByPermissionIds(permissionIds: string[]): Promise<Permission[]> {
+        return this.permissionRepository.find({
+            where: {
+                id: In(permissionIds),
+            }
+        })
+    }
+}

tone-page-server/src/role/services/role-permission.service.ts

@@ -0,0 +1,23 @@
+import { Injectable } from "@nestjs/common";
+import { InjectRepository } from "@nestjs/typeorm";
+import { RolePermission } from "../entities/role-permission.entity";
+import { In, Repository } from "typeorm";
+
+@Injectable()
+export class RolePermissionService {
+
+    constructor(
+        @InjectRepository(RolePermission)
+        private readonly rolePermissionRepository: Repository<RolePermission>,
+    ) { }
+
+    async findPermissionIdsByRoleIds(roleIds: string[]): Promise<string[]> {
+        const rolePermissions = await this.rolePermissionRepository.find({
+            where: {
+                roleId: In(roleIds),
+            }
+        });
+
+        return rolePermissions.map(rp => rp.permissionId);
+    }
+}

tone-page-server/src/role/services/role.service.ts

@@ -0,0 +1,26 @@
+import { Injectable } from "@nestjs/common";
+import { InjectRepository } from "@nestjs/typeorm";
+import { Role } from "../entities/role.entity";
+import { In, Repository } from "typeorm";
+
+@Injectable()
+export class RoleService {
+
+    constructor(
+        @InjectRepository(Role)
+        private readonly roleRepository: Repository<Role>,
+    ) { }
+
+    async findRoleNamesByRoleIds(roleIds: string[]): Promise<string[]> {
+        const roles = await this.findRolesByRoleIds(roleIds);
+        return roles.map(role => role.name);
+    }
+
+    async findRolesByRoleIds(roleIds: string[]): Promise<Role[]> {
+        return this.roleRepository.find({
+            where: {
+                id: In(roleIds),
+            }
+        })
+    }
+}

tone-page-server/src/role/services/user-role.service.ts

@@ -0,0 +1,35 @@
+import { Injectable } from "@nestjs/common";
+import { InjectRepository } from "@nestjs/typeorm";
+import { UserRole } from "src/role/entities/user-role.entity";
+import { IsNull, MoreThanOrEqual, Repository } from "typeorm";
+
+@Injectable()
+export class UserRoleService {
+    constructor(
+        @InjectRepository(UserRole)
+        private readonly userRoleRepository: Repository<UserRole>,
+    ) { }
+
+    async findValidRoleIdsByUserId(userId: string): Promise<string[]> {
+        return (await this.findValidRolesByUserId(userId)).map(ur => ur.roleId);
+    }
+
+    async findValidRolesByUserId(userId: string) {
+        const now = new Date();
+
+        return this.userRoleRepository.find({
+            where: [
+                {
+                    userId,
+                    isEnabled: true,
+                    expiredAt: MoreThanOrEqual(now),
+                },
+                {
+                    userId,
+                    isEnabled: true,
+                    expiredAt: IsNull(),
+                }
+            ]
+        })
+    }
+}