Merge pull request #208 from import-ai/fix/bug

fix(bug): bug fix

Author: hewenguang

src/auth/google/google.service.ts

@@ -7,6 +7,7 @@ import { NamespacesService } from 'omniboxd/namespaces/namespaces.service';
 import { CreateUserBindingDto } from 'omniboxd/user/dto/create-user-binding.dto';
 import {
   BadRequestException,
+  ForbiddenException,
   Injectable,
   Logger,
   UnauthorizedException,
@@ -235,6 +236,10 @@ export class GoogleService extends SocialService {
   }
 
   async unbind(userId: string) {
+    const canDo = await this.canUnBinding(userId);
+    if (!canDo) {
+      throw new ForbiddenException('Unbinding is not allowed');
+    }
     await this.userService.unbindByLoginType(userId, 'google');
   }
 }

src/auth/social.service.ts

@@ -82,4 +82,13 @@ export class SocialService {
       'Unable to generate a valid username',
     );
   }
+
+  protected async canUnBinding(userId: string) {
+    const user = await this.userService.find(userId);
+    if (user.email) {
+      return true;
+    }
+    const binding = await this.userService.listBinding(userId);
+    return binding.length > 1;
+  }
 }

src/auth/wechat/wechat.service.ts

@@ -8,6 +8,7 @@ import { CreateUserBindingDto } from 'omniboxd/user/dto/create-user-binding.dto'
 import {
   Logger,
   Injectable,
+  ForbiddenException,
   BadRequestException,
   UnauthorizedException,
 } from '@nestjs/common';
@@ -271,6 +272,10 @@ export class WechatService extends SocialService {
   }
 
   async unbind(userId: string) {
+    const canDo = await this.canUnBinding(userId);
+    if (!canDo) {
+      throw new ForbiddenException('Unbinding is not allowed');
+    }
     await this.userService.unbindByLoginType(userId, 'wechat');
   }
 }

src/namespace-resources/namespace-resources.controller.ts

@@ -13,10 +13,8 @@ import {
   Patch,
   Post,
   Query,
-  Req,
 } from '@nestjs/common';
 import { UserId } from 'omniboxd/decorators/user-id.decorator';
-import { Request } from 'express';
 import { ResourceMetaDto } from 'omniboxd/resources/dto/resource-meta.dto';
 import { ChildrenMetaDto } from './dto/list-children-resp.dto';
 
@@ -29,7 +27,7 @@ export class NamespaceResourcesController {
 
   @Get()
   async findById(
-    @Req() req: Request,
+    @UserId() userId: string,
     @Param('namespaceId') namespaceId: string,
     @Query('id') id: string,
   ) {
@@ -40,11 +38,23 @@ export class NamespaceResourcesController {
     if (ids.length <= 0) {
       return [];
     }
-    return await this.namespaceResourcesService.findByIds(
+    const resources = await this.namespaceResourcesService.findByIds(
       namespaceId,
-      req.user!.id,
+      userId,
       ids,
     );
+    return Promise.all(
+      resources.map((resource) =>
+        this.namespaceResourcesService
+          .hasChildren(userId, namespaceId, resource.id)
+          .then((hasChildren) =>
+            Promise.resolve({
+              ...resource,
+              hasChildren,
+            }),
+          ),
+      ),
+    );
   }
 
   @Post()
@@ -62,33 +72,33 @@ export class NamespaceResourcesController {
 
   @Post(':resourceId/duplicate')
   async duplicate(
-    @Req() req: Request,
+    @UserId() userId: string,
     @Param('namespaceId') namespaceId: string,
     @Param('resourceId') resourceId: string,
   ) {
     const newResource = await this.namespaceResourcesService.duplicate(
-      req.user!.id,
+      userId,
       namespaceId,
       resourceId,
     );
     return await this.namespaceResourcesService.getResource({
       namespaceId,
-      userId: req.user!.id,
+      userId,
       resourceId: newResource.id,
     });
   }
 
   @Get('query')
   async query(
-    @Req() req: Request,
+    @UserId() userId: string,
     @Param('namespaceId') namespaceId: string,
     @Query('parentId') parentId: string,
     @Query('tags') tags: string,
   ) {
     return await this.namespaceResourcesService.query(
       namespaceId,
       parentId,
-      req.user!.id,
+      userId,
       tags,
     );
   }
@@ -108,15 +118,15 @@ export class NamespaceResourcesController {
 
   @Post(':resourceId/move/:targetId')
   async move(
-    @Req() req: Request,
+    @UserId() userId: string,
     @Param('namespaceId') namespaceId: string,
     @Param('resourceId') resourceId: string,
     @Param('targetId') targetId: string,
   ) {
     return await this.namespaceResourcesService.move(
       namespaceId,
       resourceId,
-      req.user!.id,
+      userId,
       targetId,
     );
   }
@@ -138,74 +148,83 @@ export class NamespaceResourcesController {
 
   @Get(':resourceId')
   async get(
-    @Req() req: Request,
+    @UserId() userId: string,
     @Param('namespaceId') namespaceId: string,
     @Param('resourceId') resourceId: string,
   ) {
     return await this.namespaceResourcesService.getResource({
       namespaceId,
       resourceId,
-      userId: req.user!.id,
+      userId,
     });
   }
 
   @Patch(':resourceId')
   async update(
-    @Req() req: Request,
+    @UserId() userId: string,
     @Param('namespaceId') namespaceId: string,
     @Param('resourceId') resourceId: string,
     @Body() data: UpdateResourceDto,
   ) {
     const hasPermission = await this.permissionsService.userHasPermission(
       namespaceId,
       resourceId,
-      req.user!.id,
+      userId,
       ResourcePermission.CAN_EDIT,
     );
     if (!hasPermission) {
       throw new ForbiddenException('Not authorized');
     }
-    await this.namespaceResourcesService.update(req.user!.id, resourceId, data);
+    await this.namespaceResourcesService.update(userId, resourceId, data);
     return await this.namespaceResourcesService.getResource({
       namespaceId,
       resourceId,
-      userId: req.user!.id,
+      userId,
     });
   }
 
   @Delete(':resourceId')
   async delete(
-    @Req() req: Request,
+    @UserId() userId: string,
     @Param('namespaceId') namespaceId: string,
     @Param('resourceId') resourceId: string,
   ) {
     const hasPermission = await this.permissionsService.userHasPermission(
       namespaceId,
       resourceId,
-      req.user!.id,
+      userId,
       ResourcePermission.CAN_EDIT,
     );
     if (!hasPermission) {
       throw new ForbiddenException('Not authorized');
     }
     return await this.namespaceResourcesService.delete(
-      req.user!.id,
+      userId,
       namespaceId,
       resourceId,
     );
   }
 
   @Post(':resourceId/restore')
   async restore(
-    @Req() req: Request,
+    @UserId() userId: string,
     @Param('namespaceId') namespaceId: string,
     @Param('resourceId') resourceId: string,
   ) {
-    await this.namespaceResourcesService.restore(req.user!.id, resourceId);
-    return await this.namespaceResourcesService.getResource({
+    await this.namespaceResourcesService.restore(userId, resourceId);
+    const resource = await this.namespaceResourcesService.getResource({
       namespaceId,
       resourceId,
-      userId: req.user!.id,
+      userId,
     });
+    const hasChildren = await this.namespaceResourcesService.hasChildren(
+      userId,
+      namespaceId,
+      resourceId,
+    );
+    return {
+      ...resource,
+      hasChildren,
+    };
   }
 }

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

@@ -449,6 +449,19 @@ export class NamespaceResourcesService {
     });
   }
 
+  async hasChildren(
+    userId: string,
+    namespaceId: string,
+    resourceId: string,
+  ): Promise<boolean> {
+    const children = await this.getSubResourcesByUser(
+      userId,
+      namespaceId,
+      resourceId,
+    );
+    return children.length > 0;
+  }
+
   async listChildren(
     namespaceId: string,
     resourceId: string,
@@ -666,8 +679,8 @@ export class NamespaceResourcesService {
     parentId?: string,
     resourceId?: string,
   ) {
-    const originalName = getOriginalFileName(fileName);
-    const encodedName = encodeFileName(fileName);
+    const originalName = decodeURIComponent(fileName);
+    const encodedName = encodeFileName(originalName);
 
     let resource: Resource;
     if (resourceId) {