feat(user): expose username field to permissions

src/auth/auth.controller.ts

@@ -67,18 +67,25 @@ export class AuthController {
     @Body('inviteUrl') inviteUrl: string,
     @Body('registerUrl') registerUrl: string,
     @Body('namespace') namespaceId: string,
-    @Body('email') email: string,
     @Body('role') role: NamespaceRole,
     @Body('resourceId') resourceId: string,
     @Body('permissionLevel') permissionLevel: PermissionLevel,
     @Body('groupId') groupId: string,
+    @Body('emails') emails: Array<string>,
+    @Body('groupTitles') groupTitles: Array<string>,
   ) {
-    const actions: Array<Promise<any>> = [];
-    const userEmails = email.split(',');
-    userEmails.forEach((userEmail) => {
-      if (userEmail) {
-        actions.push(
-          this.authService.invite(req.user.id, userEmail, {
+    if (groupTitles && groupTitles.length > 0) {
+      await this.authService.inviteGroup(
+        namespaceId,
+        resourceId,
+        groupTitles,
+        permissionLevel,
+      );
+    }
+    if (emails && emails.length > 0) {
+      await Promise.all(
+        emails.map((email) =>
+          this.authService.invite(req.user.id, email, {
             role,
             inviteUrl,
             registerUrl,
@@ -87,10 +94,9 @@ export class AuthController {
             permissionLevel,
             groupId,
           }),
-        );
-      }
-    });
-    return await Promise.all(actions);
+        ),
+      );
+    }
   }
 
   @Post('invite/confirm')

src/auth/auth.service.ts

@@ -185,6 +185,16 @@ export class AuthService {
     };
     const account = await this.userService.findByEmail(email);
     if (account) {
+      const namespaceMembers = await this.namespaceService.listMembers(
+        data.namespaceId,
+      );
+      const userInNamespace = namespaceMembers.find(
+        (member) => `${member.id}` === account.id,
+      );
+      if (userInNamespace) {
+        // User already in namespace
+        return;
+      }
       const payload: InvitePayloadDto = {
         userId: account.id,
         invitation,
@@ -221,6 +231,47 @@ export class AuthService {
     });
   }
 
+  async inviteGroup(
+    namespaceId: string,
+    resourceId: string,
+    groupTitles: string[],
+    permissionLevel: PermissionLevel,
+  ) {
+    await Promise.all(
+      groupTitles.map((title) =>
+        this.groupsService
+          .getGroupsByTitle(namespaceId, title)
+          .then((groups) => {
+            if (groups.length <= 0) {
+              return Promise.resolve([]);
+            }
+            return Promise.all(
+              groups.map((group) =>
+                this.permissionsService
+                  .getGroupPermission(
+                    namespaceId,
+                    resourceId,
+                    group.id,
+                    permissionLevel,
+                  )
+                  .then((groupPermissionExists) => {
+                    if (groupPermissionExists) {
+                      return Promise.resolve();
+                    }
+                    return this.permissionsService.createGroupPermission(
+                      namespaceId,
+                      resourceId,
+                      group.id,
+                      permissionLevel,
+                    );
+                  }),
+              ),
+            );
+          }),
+      ),
+    );
+  }
+
   async handleInvitation(
     userId: string,
     invitation: InvitationDto,

src/groups/groups.service.ts

@@ -48,6 +48,14 @@ export class GroupsService {
     );
   }
 
+  async getGroupsByTitle(namespaceId: string, title: string): Promise<Group[]> {
+    const groups = await this.groupRepository.findBy({
+      namespace: { id: namespaceId },
+      title,
+    });
+    return groups;
+  }
+
   async userInGroup(
     namespaceId: string,
     groupId: string,

src/namespaces/dto/namespace-member.dto.ts

@@ -1,6 +1,10 @@
+import { PermissionLevel } from 'src/permissions/permission-level.enum';
+
 export class NamespaceMemberDto {
-  id: string;
+  id: number;
+  userId: string;
   email: string;
   role: string;
   username: string;
+  level: PermissionLevel;
 }

src/namespaces/namespaces.controller.ts

@@ -1,4 +1,5 @@
 import { NamespacesService } from 'src/namespaces/namespaces.service';
+import { NamespaceRole } from './entities/namespace-member.entity';
 import {
   Req,
   Get,
@@ -9,6 +10,7 @@ import {
   Delete,
   Controller,
   Query,
+  ParseIntPipe,
 } from '@nestjs/common';
 import { SpaceType } from './entities/namespace.entity';
 
@@ -31,6 +33,32 @@ export class NamespacesController {
     return await this.namespacesService.listMembers(namespaceId);
   }
 
+  @Get(':namespaceId/members/user/:userId')
+  async getMemberByUserId(
+    @Param('namespaceId') namespaceId: string,
+    @Param('userId') userId: string,
+  ) {
+    return await this.namespacesService.getMemberByUserId(namespaceId, userId);
+  }
+
+  @Patch(':namespaceId/members/:memberId')
+  async UpdateMemberRole(
+    @Param('namespaceId') namespaceId: string,
+    @Param('memberId', ParseIntPipe) memberId: number,
+    @Body('role') role: NamespaceRole,
+  ) {
+    return await this.namespacesService.updateMemberRole(
+      namespaceId,
+      memberId,
+      role,
+    );
+  }
+
+  @Delete(':namespaceId/members/:memberId')
+  async deleteMember(@Param('memberId', ParseIntPipe) memberId: number) {
+    return await this.namespacesService.deleteMember(memberId);
+  }
+
   @Get(':namespaceId/root')
   async getRoot(
     @Param('namespaceId') namespaceId: string,

src/namespaces/namespaces.service.ts

@@ -179,6 +179,17 @@ export class NamespacesService {
     );
   }
 
+  async updateMemberRole(
+    namespaceId: string,
+    memberId: number,
+    role: NamespaceRole,
+  ) {
+    await this.namespaceMemberRepository.update(memberId, {
+      role,
+      namespace: { id: namespaceId },
+    });
+  }
+
   async getPrivateRoot(userId: string, namespaceId: string): Promise<Resource> {
     const member = await this.namespaceMemberRepository.findOne({
       where: {
@@ -203,21 +214,55 @@ export class NamespacesService {
     return namespaces.map((v) => v.namespace);
   }
 
-  async listMembers(namespaceId: string): Promise<NamespaceMemberDto[]> {
+  async listMembers(
+    namespaceId: string,
+    manager?: EntityManager,
+  ): Promise<NamespaceMemberDto[]> {
     const members = await this.namespaceMemberRepository.find({
       where: { namespace: { id: namespaceId } },
       relations: ['user'],
     });
-    return members.map((member) => {
-      return {
-        role: member.role,
-        id: member.user.id,
-        email: member.user.email,
-        username: member.user.username,
-      };
+    if (members.length <= 0) {
+      return [];
+    }
+    return await Promise.all(
+      members.map((member) =>
+        this.getTeamspaceRoot(namespaceId, manager)
+          .then((teamspaceRoot) =>
+            this.permissionsService.getUserLevel(
+              namespaceId,
+              teamspaceRoot.id,
+              member.user.id,
+            ),
+          )
+          .then((userLevel) =>
+            Promise.resolve({
+              id: member.id,
+              level: userLevel,
+              role: member.role,
+              userId: member.user.id,
+              email: member.user.email,
+              username: member.user.username,
+            }),
+          ),
+      ),
+    );
+  }
+
+  async getMemberByUserId(namespaceId: string, userId: string) {
+    return await this.namespaceMemberRepository.findOne({
+      where: {
+        namespace: { id: namespaceId },
+        user: { id: userId },
+        deletedAt: IsNull(),
+      },
     });
   }
 
+  async deleteMember(memberId: number) {
+    await this.namespaceMemberRepository.delete(memberId);
+  }
+
   async getRoot(namespace: string, spaceType: SpaceType, userId: string) {
     let resource: Resource | null;
     if (spaceType === SpaceType.TEAMSPACE) {
@@ -245,6 +290,6 @@ export class NamespacesService {
     if (!user) {
       return false;
     }
-    return user.role === 'owner';
+    return user.role === NamespaceRole.OWNER;
   }
 }

src/permissions/dto/list-resp.dto.ts

@@ -31,6 +31,11 @@ export class UserDto {
   @IsString()
   @IsNotEmpty()
   email: string;
+
+  @Expose()
+  @IsString()
+  @IsNotEmpty()
+  username: string;
 }
 
 @Exclude()

src/permissions/permissions.service.ts

@@ -108,6 +108,37 @@ export class PermissionsService {
     );
   }
 
+  async getGroupPermission(
+    namespaceId: string,
+    resourceId: string,
+    groupId: string,
+    permissionLevel: PermissionLevel,
+  ) {
+    return await this.groupPermiRepo.findOne({
+      where: {
+        level: permissionLevel,
+        namespace: { id: namespaceId },
+        resource: { id: resourceId },
+        group: { id: groupId },
+      },
+    });
+  }
+
+  async createGroupPermission(
+    namespaceId: string,
+    resourceId: string,
+    groupId: string,
+    permissionLevel: PermissionLevel,
+  ) {
+    const groupPermission = this.groupPermiRepo.create({
+      level: permissionLevel,
+      namespace: { id: namespaceId },
+      resource: { id: resourceId },
+      group: { id: groupId },
+    });
+    await this.groupPermiRepo.save(groupPermission);
+  }
+
   async updateGroupPermission(
     namespaceId: string,
     resourceId: string,
@@ -247,6 +278,17 @@ export class PermissionsService {
     });
   }
 
+  async getUserLevel(namespaceId: string, resourceId: string, userId: string) {
+    const userPermission = await this.userPermiRepo.findOne({
+      where: {
+        namespace: { id: namespaceId },
+        resource: { id: resourceId },
+        user: { id: userId },
+      },
+    });
+    return userPermission ? userPermission.level : PermissionLevel.NO_ACCESS;
+  }
+
   async updateUserLevel(
     namespaceId: string,
     resourceId: string,