Added status for invited users

src/common/email/email.service.ts

@@ -122,7 +122,7 @@ export class EmailService {
   async sendInviteUserEmail(
     email: string,
     ownerEmail: string,
-    kbName: string,
+    kbId: string,
     userExist: boolean,
   ) {
     if (!this.isSgInitialized) return;
@@ -131,14 +131,16 @@ export class EmailService {
       ? `${this.clientUrl}/login`
       : `${this.clientUrl}/sign-up`;
 
+    const acceptUrl = `${this.clientUrl}/knowledgebase/kbId/accept_invite`;
+
     const msg = {
       to: email,
       from: { email: this.senderEmail, name: this.senderName },
       templateId: 'd-46f484fb64ae432aa8ca732e5ab2c1a9',
       dynamicTemplateData: {
         owner_email: ownerEmail,
         user_name: ownerEmail,
-        kb_name: kbName,
+        accept_url: acceptUrl,
         website_url: websiteUrl,
       },
     };

src/knowledgebase/knowledgebase-db.service.ts

@@ -147,6 +147,7 @@ export class KnowledgebaseDbService {
         {
           $match: {
             'participants.id': userId,
+            'participants.status': 'Active',
           },
         },
         {
@@ -687,4 +688,14 @@ export class KnowledgebaseDbService {
   async deletePrompt(id: ObjectId) {
     await this.promptCollection.deleteOne({ _id: id });
   }
+
+  async getAllTheParticipatedKnowledgeBaseForUser(userId: ObjectId) {
+    const query = { 'participants.id': userId };
+    const projection = { name: 1, 'participants.$': 1 };
+    const result = await this.knowledgebaseCollection
+      .find(query)
+      .project(projection)
+      .toArray();
+    return result;
+  }
 }

src/knowledgebase/knowledgebase-utils.ts

@@ -10,6 +10,11 @@ export enum UserPermissions {
   DELETE_USER = 'delete_user',
 }
 
+export enum InviteStatus {
+  PENDING = 'Pending',
+  ACTIVE = 'Active',
+}
+
 const rolePermissions = {
   [UserRoles.READER]: [UserPermissions.READ],
   [UserRoles.EDITOR]: [UserPermissions.READ, UserPermissions.EDIT],

src/knowledgebase/knowledgebase.controller.ts

@@ -326,6 +326,12 @@ export class KnowledgebaseController {
     return this.kbService.createKnowledgebase(user, data);
   }
 
+  @Get('/participant/list')
+  async getKnowledgeBasesForParticipants(@Req() req: RequestWithUser) {
+    const { user } = req;
+    return this.kbService.getKnowledgeBasesForParticipants(user);
+  }
+
   @Post('/:id/invite_user')
   async inviteUser(
     @Req() req: RequestWithUser,
@@ -347,4 +353,11 @@ export class KnowledgebaseController {
 
     return this.kbService.deleteUserFromKnowledgeBase(user, kbId, userId);
   }
+
+  @Get('/:id/accept_invite')
+  async acceptInvite(@Req() req: RequestWithUser, @Param('id') id: string) {
+    const { user } = req;
+
+    return this.kbService.inviteUserAccept(user, id);
+  }
 }

src/knowledgebase/knowledgebase.schema.ts

@@ -39,6 +39,7 @@ export interface ParticipantsData {
   id: ObjectId;
   role: UserRoles;
   email: string;
+  status: string;
 }
 
 export interface Knowledgebase {

src/knowledgebase/knowledgebase.service.ts

@@ -15,6 +15,7 @@ import { KnowledgebaseDbService } from './knowledgebase-db.service';
 import {
   checkUserPermissionForKb,
   UserPermissions,
+  InviteStatus,
 } from './knowledgebase-utils';
 import {
   CreateKnowledgebaseDTO,
@@ -163,6 +164,7 @@ export class KnowledgebaseService {
       id: user._id,
       role: UserRoles.ADMIN,
       email: user.email,
+      status: InviteStatus.ACTIVE,
     };
     // Create a new Kb in db
     const ts = new Date();
@@ -347,6 +349,21 @@ export class KnowledgebaseService {
     return kbs;
   }
 
+  /**
+   * Get all knowledgebases for a participant
+   * @param user
+   * @returns
+   */
+  async getKnowledgeBasesForParticipants(user: UserSparse) {
+    // Fetch all the knowledgebase for a user who participates
+    const kbs =
+      await this.kbDbService.getAllTheParticipatedKnowledgeBaseForUser(
+        user._id,
+      );
+
+    return kbs;
+  }
+
   /**
    * Get knowledgebase detail data
    * @param user
@@ -602,6 +619,7 @@ export class KnowledgebaseService {
     kbId: ObjectId,
     role: string,
     email: string,
+    status: string,
     kb,
   ) {
     let updatedParticipants;
@@ -614,6 +632,7 @@ export class KnowledgebaseService {
             id: userId,
             role: role,
             email: email,
+            status: status,
           };
         }
         return owner;
@@ -626,10 +645,17 @@ export class KnowledgebaseService {
         )
       ) {
         // Add the new invitation for the user
-        updatedParticipants.push({ id: userId, role: role, email: email });
+        updatedParticipants.push({
+          id: userId,
+          role: role,
+          email: email,
+          status: status,
+        });
       }
     } else {
-      updatedParticipants = [{ id: userId, role: role, email: email }];
+      updatedParticipants = [
+        { id: userId, role: role, email: email, status: status },
+      ];
     }
 
     if (updatedParticipants) {
@@ -668,6 +694,7 @@ export class KnowledgebaseService {
         kbId,
         data.role,
         data.email,
+        InviteStatus.PENDING,
         kb,
       );
       userExist = true;
@@ -684,7 +711,7 @@ export class KnowledgebaseService {
     await this.emailService.sendInviteUserEmail(
       data.email,
       user.email,
-      kb.name,
+      kb._id.toString(),
       userExist,
     );
 
@@ -705,6 +732,7 @@ export class KnowledgebaseService {
             kb._id,
             invitedData.role,
             email,
+            InviteStatus.PENDING,
             kb,
           );
           await this.userService.deleteFromInvitedEmail(email, kb._id);
@@ -741,4 +769,36 @@ export class KnowledgebaseService {
 
     return;
   }
+
+  async inviteUserAccept(user: UserSparse, id: string) {
+    const kbId = new ObjectId(id);
+    const kb = await this.kbDbService.getKnowledgebaseSparseById(kbId);
+
+    if (user._id.toString() === kb.owner.toString()) {
+      throw new HttpException(
+        'knowledgebase owner cannot accept the invite request!',
+        HttpStatus.BAD_REQUEST,
+      );
+    }
+
+    let updatedParticipants;
+    if (kb.participants && Array.isArray(kb.participants)) {
+      updatedParticipants = kb.participants.map((owner) => {
+        if (owner.id.toString() === user._id.toString()) {
+          // Update the existing invitation for the user
+          owner.status = InviteStatus.ACTIVE;
+        }
+        return owner;
+      });
+      if (updatedParticipants) {
+        await this.kbDbService.updateKnowledgebaseParticipants(
+          kbId,
+          updatedParticipants,
+        );
+      }
+    } else {
+      throw new HttpException('Invalid request!', HttpStatus.BAD_REQUEST);
+    }
+    return;
+  }
 }