refactor(resources): update listChildren

Author: ycdzj

src/api-key/api-key.service.ts

@@ -206,7 +206,9 @@ export class APIKeyService {
 
   async info(apiKey: APIKey): Promise<APIKeyInfoDto> {
     // Get the namespace
-    const namespace = await this.namespacesService.getNamespace(apiKey.namespaceId);
+    const namespace = await this.namespacesService.getNamespace(
+      apiKey.namespaceId,
+    );
 
     // Get the user
     const user = await this.userService.find(apiKey.userId);

src/namespace-resources/namespace-resources.service.ts

@@ -128,27 +128,26 @@ export class NamespaceResourcesService {
     return resources.map((resource) => resource.id);
   }
 
-  private async hasChildren(
-    namespaceId: string,
-    parents: ResourceMetaDto[],
-    userId: string,
-  ): Promise<boolean> {
-    const children = await this.resourcesService.getSubResources(
-      namespaceId,
-      parents[0].id,
-    );
-    for (const child of children) {
-      const permission = await this.permissionsService.getCurrentPermission(
-        namespaceId,
-        [child, ...parents],
-        userId,
-      );
-      if (permission !== ResourcePermission.NO_ACCESS) {
-        return true;
-      }
-    }
-    return false;
-  }
+  // private async hasChildren(
+  //   namespaceId: string,
+  //   parents: ResourceMetaDto[],
+  //   userId: string,
+  // ): Promise<boolean> {
+  //   const children = await this.resourcesService.getSubResources(namespaceId, [
+  //     parents[0].id,
+  //   ]);
+  //   for (const child of children) {
+  //     const permission = await this.permissionsService.getCurrentPermission(
+  //       namespaceId,
+  //       [child, ...parents],
+  //       userId,
+  //     );
+  //     if (permission !== ResourcePermission.NO_ACCESS) {
+  //       return true;
+  //     }
+  //   }
+  //   return false;
+  // }
 
   async create(
     userId: string,
@@ -403,10 +402,9 @@ export class NamespaceResourcesService {
     if (permission === ResourcePermission.NO_ACCESS) {
       return [];
     }
-    const children = await this.resourcesService.getSubResources(
-      namespaceId,
+    const children = await this.resourcesService.getSubResources(namespaceId, [
       parents[0].id,
-    );
+    ]);
     const filteredChildren: ResourceMetaDto[] = [];
     for (const child of children) {
       const permission = await this.permissionsService.getCurrentPermission(
@@ -430,21 +428,42 @@ export class NamespaceResourcesService {
       namespaceId,
       resourceId,
     );
-    const children = await this.getSubResourcesByParents(
+    const children = await this.resourcesService.getSubResources(namespaceId, [
+      resourceId,
+    ]);
+    const subChildren = await this.resourcesService.getSubResources(
+      namespaceId,
+      children.map((child) => child.id),
+    );
+    const resources = [...parents, ...children, ...subChildren];
+    const permissionMap = await this.permissionsService.getCurrentPermissions(
       namespaceId,
-      parents,
       userId,
+      resources,
     );
-    const resps: ChildrenMetaDto[] = [];
+
+    const hasChildrenMap = new Map<string, boolean>();
+    for (const subChild of subChildren) {
+      if (!subChild.parentId) {
+        continue;
+      }
+      const permission = permissionMap.get(subChild.id);
+      if (!permission || permission === ResourcePermission.NO_ACCESS) {
+        continue;
+      }
+      hasChildrenMap.set(subChild.parentId, true);
+    }
+
+    const childrenDtos: ChildrenMetaDto[] = [];
     for (const child of children) {
-      const hasChildren = await this.hasChildren(
-        namespaceId,
-        [child, ...parents],
-        userId,
-      );
-      resps.push(new ChildrenMetaDto(child, hasChildren));
+      const permission = permissionMap.get(child.id);
+      if (!permission || permission === ResourcePermission.NO_ACCESS) {
+        continue;
+      }
+      const hasChildren = hasChildrenMap.get(child.id) || false;
+      childrenDtos.push(new ChildrenMetaDto(child, hasChildren));
     }
-    return resps;
+    return childrenDtos;
   }
 
   async getSpaceType(

src/namespaces/namespaces.module.ts

@@ -8,6 +8,7 @@ import { Namespace } from './entities/namespace.entity';
 import { NamespaceMember } from './entities/namespace-member.entity';
 import { NamespaceResourcesModule } from 'omniboxd/namespace-resources/namespace-resources.module';
 import { PermissionsModule } from 'omniboxd/permissions/permissions.module';
+import { ResourcesModule } from 'omniboxd/resources/resources.module';
 
 @Module({
   exports: [NamespacesService],
@@ -16,6 +17,7 @@ import { PermissionsModule } from 'omniboxd/permissions/permissions.module';
   imports: [
     UserModule,
     NamespaceResourcesModule,
+    ResourcesModule,
     PermissionsModule,
     TypeOrmModule.forFeature([Resource]),
     TypeOrmModule.forFeature([Namespace]),

src/permissions/permissions.service.ts

@@ -167,7 +167,7 @@ export class PermissionsService {
     userId: string,
     resources: ResourceMetaDto[],
     entityManager?: EntityManager,
-  ): Promise<ResourcePermission[]> {
+  ): Promise<Map<string, ResourcePermission>> {
     if (!entityManager) {
       return await this.dataSource.transaction((entityManager) =>
         this.getCurrentPermissions(
@@ -277,22 +277,20 @@ export class PermissionsService {
       }
     };
 
-    const permissions: ResourcePermission[] = new Array(resources.length).fill(
-      ResourcePermission.NO_ACCESS,
-    );
+    const permissions: Map<string, ResourcePermission> = new Map();
     for (let i = 0; i < resources.length; i++) {
       const resource = resources[i];
       const userPermission = calcUserPermission(resource);
       const groupPermissions = groupIds.map((groupId) =>
         calcGroupPermission(resource, groupId),
       );
       const globalPermission = calcGlobalPermission(resource);
-      permissions[i] =
-        maxPermissions([
-          globalPermission,
-          userPermission,
-          ...groupPermissions,
-        ]) || ResourcePermission.NO_ACCESS;
+      const permission = maxPermissions([
+        globalPermission,
+        userPermission,
+        ...groupPermissions,
+      ]);
+      permissions.set(resource.id, permission || ResourcePermission.NO_ACCESS);
     }
     return permissions;
   }

src/resources/resources.service.ts

@@ -1,7 +1,7 @@
 import { Injectable, NotFoundException } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
 import { Resource, ResourceType } from './entities/resource.entity';
-import { DataSource, EntityManager, Repository } from 'typeorm';
+import { DataSource, EntityManager, In, Repository } from 'typeorm';
 import { ResourceMetaDto } from './dto/resource-meta.dto';
 import { WizardTaskService } from 'omniboxd/tasks/wizard-task.service';
 import { Task } from 'omniboxd/tasks/tasks.entity';
@@ -101,7 +101,7 @@ export class ResourcesService {
 
   async getSubResources(
     namespaceId: string,
-    resourceId: string,
+    parentIds: string[],
   ): Promise<ResourceMetaDto[]> {
     const children = await this.resourceRepository.find({
       select: [
@@ -116,7 +116,7 @@ export class ResourcesService {
       ],
       where: {
         namespaceId,
-        parentId: resourceId,
+        parentId: In(parentIds),
       },
       order: { updatedAt: 'DESC' },
     });