refactor(namespaces): restore private root

Author: ycdzj

src/namespaces/namespaces.service.ts

@@ -188,22 +188,19 @@ export class NamespacesService {
     await this.namespaceRepository.softDelete(id);
   }
 
-  async addMember(
-    namespaceId: string,
+  async createOrRestorePrivateRoot(
     userId: string,
-    role: NamespaceRole,
-    permission: ResourcePermission,
+    namespaceId: string,
+    namespaceMember: NamespaceMember | null,
     entityManager: EntityManager,
-  ) {
-    const count = await entityManager.count(NamespaceMember, {
-      where: {
+  ): Promise<string> {
+    if (namespaceMember) {
+      await this.resourcesService.restoreResource(
         namespaceId,
-        userId,
-        deletedAt: IsNull(),
-      },
-    });
-    if (count > 0) {
-      return;
+        namespaceMember.rootResourceId,
+        entityManager,
+      );
+      return namespaceMember.rootResourceId;
     }
     const privateRoot = await this.resourcesService.createResource(
       {
@@ -214,12 +211,45 @@ export class NamespacesService {
       },
       entityManager,
     );
+    await this.resourcesService.createResource(
+      {
+        namespaceId,
+        parentId: privateRoot.id,
+        userId,
+        resourceType: ResourceType.FOLDER,
+        name: await this.getUncategorizedName(userId, entityManager),
+      },
+      entityManager,
+    );
+    return privateRoot.id;
+  }
+
+  async addMember(
+    namespaceId: string,
+    userId: string,
+    role: NamespaceRole,
+    permission: ResourcePermission,
+    entityManager: EntityManager,
+  ) {
+    const namespaceMember = await entityManager.findOne(NamespaceMember, {
+      where: { namespaceId, userId },
+      withDeleted: true,
+    });
+    if (namespaceMember && !namespaceMember.deletedAt) {
+      return;
+    }
+    const privateRootId = await this.createOrRestorePrivateRoot(
+      userId,
+      namespaceId,
+      namespaceMember,
+      entityManager,
+    );
     await entityManager.save(
       entityManager.create(NamespaceMember, {
         namespaceId,
         userId,
         role,
-        rootResourceId: privateRoot.id,
+        rootResourceId: privateRootId,
       }),
     );
     const teamspaceRoot = await this.getTeamspaceRoot(
@@ -235,21 +265,11 @@ export class NamespacesService {
     );
     await this.permissionsService.updateUserPermission(
       namespaceId,
-      privateRoot.id,
+      privateRootId,
       userId,
       ResourcePermission.FULL_ACCESS,
       entityManager,
     );
-    await this.resourcesService.createResource(
-      {
-        namespaceId,
-        parentId: privateRoot.id,
-        userId,
-        resourceType: ResourceType.FOLDER,
-        name: await this.getUncategorizedName(userId, entityManager),
-      },
-      entityManager,
-    );
   }
 
   private async getUncategorizedName(
@@ -347,10 +367,11 @@ export class NamespacesService {
         return;
       }
       // Delete private root
-      await manager.softDelete(Resource, {
+      await this.resourcesService.deleteResource(
         namespaceId,
-        id: member.rootResourceId,
-      });
+        member.rootResourceId,
+        manager,
+      );
       // Clear user permissions
       await manager.softDelete(UserPermission, {
         namespaceId,

src/resources/resources.service.ts

@@ -327,4 +327,36 @@ export class ResourcesService {
 
     return resource;
   }
+
+  async restoreResource(
+    namespaceId: string,
+    resourceId: string,
+    entityManager?: EntityManager,
+  ): Promise<void> {
+    if (!entityManager) {
+      return await this.dataSource.transaction((entityManager) =>
+        this.restoreResource(namespaceId, resourceId, entityManager),
+      );
+    }
+    await entityManager.restore(Resource, {
+      namespaceId,
+      id: resourceId,
+    });
+  }
+
+  async deleteResource(
+    namespaceId: string,
+    resourceId: string,
+    entityManager?: EntityManager,
+  ): Promise<void> {
+    if (!entityManager) {
+      return await this.dataSource.transaction((entityManager) =>
+        this.restoreResource(namespaceId, resourceId, entityManager),
+      );
+    }
+    await entityManager.softDelete(Resource, {
+      namespaceId,
+      id: resourceId,
+    });
+  }
 }