integrate audit system to lead applciation

Author: snebo

src/notifications/notifications.service.spec.ts

@@ -6,6 +6,7 @@ describe('NotificationsService', () => {
   let service: NotificationsService;
   let userModel: any;
   let notificationModel: any;
+  let notificationAuditModel: any;
 
   beforeEach(async () => {
     // mokcingi model functions for testing
@@ -18,12 +19,16 @@ describe('NotificationsService', () => {
         },
       }),
     };
+    notificationAuditModel = {
+      create: jest.fn(),
+    };
 
     const module: TestingModule = await Test.createTestingModule({
       providers: [
         NotificationsService,
         { provide: 'NotificationInfo', useValue: notificationModel },
         { provide: 'User', useValue: userModel },
+        { provide: 'NotificationAuditInfo', useValue: notificationAuditModel },
       ],
     }).compile();
 

src/notifications/notifications.service.ts

@@ -6,7 +6,11 @@ import {
 } from '@nestjs/common';
 import { Model, Types } from 'mongoose';
 import { NotificationDto } from 'src/shared/dtos/notificatoin.dto';
-import { NotificationInfo, User } from 'src/shared/schema';
+import {
+  NotificationAuditInfo,
+  NotificationInfo,
+  User,
+} from 'src/shared/schema';
 
 @Injectable()
 export class NotificationsService {
@@ -15,6 +19,8 @@ export class NotificationsService {
     private readonly notificationModel: Model<NotificationInfo>,
     @Inject(User.name)
     private readonly userModel: Model<User>,
+    @Inject(NotificationAuditInfo.name)
+    private readonly notificationAuditModel: Model<NotificationAuditInfo>,
   ) {}
 
   async getNotifications(userId: string): Promise<string[]> {
@@ -53,6 +59,21 @@ export class NotificationsService {
     };
   }
 
+  async getNotificationByUserId(userId: string, entityId: string) {
+    const notification = await this.notificationModel.findOne({
+      receiverId: userId,
+      entityId,
+    });
+
+    if (!notification) {
+      throw new NotFoundException(
+        'No unread notifications found for this entity',
+      );
+    }
+
+    return notification;
+  }
+
   async getUnreadNotificationsByEntity(entityId: string): Promise<any[]> {
     const notifications = await this.notificationModel
       .find({ entityId })
@@ -146,9 +167,10 @@ export class NotificationsService {
   }
 
   async resolveNotification(
+    notification_id: string,
     admin_id: string,
     message: string,
-    notification_id: string,
+    status: string,
   ): Promise<string> {
     // Fetch the notification to copy its data
     const notification = await this.notificationModel
@@ -158,14 +180,23 @@ export class NotificationsService {
     if (!notification) {
       throw new NotFoundException('Notification not found');
     }
+    const notificationToAudit = {
+      actorId: admin_id,
+      notificationSummary: notification.message,
+      resolutionMessage: message,
+      resolutionStatus: status,
+      entityType: notification.notification_type,
+      entityId: notification.entityId,
+    };
 
     // Delete the notification
     const deleted = await this.deleteNotification(notification_id);
     if (!deleted) {
       throw new InternalServerErrorException('Error deleting notification');
     }
-    // TODO: use notification to create audit file with admin id
 
-    return '';
+    await this.notificationAuditModel.create(notificationToAudit);
+
+    return 'Notification resolved successfully';
   }
 }

src/shared/schema/index.ts

@@ -6,6 +6,10 @@ import { ContactInfo, ContactInfoSchema } from './contact.info.schema';
 import { DataLog, DataLogSchema } from './data.log.schema';
 import { EventSchema } from './events.schema';
 import { InviteToken, InviteTokenSchema } from './invite-tokens.schema';
+import {
+  NotificationAuditInfo,
+  NotificationAuditSchema,
+} from './notificationAudit.schema';
 import { NotificationInfo, NotificationSchema } from './notifications.schema';
 import { Post, PostSchema } from './post.schema';
 import {
@@ -20,6 +24,7 @@ export * from './contact.info.schema';
 export * from './data.log.schema';
 export * from './events.schema';
 export * from './invite-tokens.schema';
+export * from './notificationAudit.schema';
 export * from './notifications.schema';
 export * from './post.schema';
 export * from './professional.info.schema';
@@ -39,6 +44,11 @@ const SCHEMA_LIST = [
   },
   { name: ContactInfo.name, schema: ContactInfoSchema, dbPrefix: 'APP' },
   { name: NotificationInfo.name, schema: NotificationSchema, dbPrefix: 'APP' },
+  {
+    name: NotificationAuditInfo.name,
+    schema: NotificationAuditSchema,
+    dbPrefix: 'LOG',
+  },
 ];
 
 export const CONNECTION = SCHEMA_LIST.reduce((result, data) => {

src/shared/schema/notificationAudit.schema.ts

@@ -0,0 +1,30 @@
+import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
+import { HydratedDocument } from 'mongoose';
+import { NotificationType } from '../interfaces';
+
+export type NotificationAuditInfoDoc = HydratedDocument<NotificationAuditInfo>;
+
+@Schema({ collection: 'notification_audit', timestamps: true })
+export class NotificationAuditInfo {
+  @Prop({ required: true })
+  actorId: string; // id of the admin who made the change
+
+  @Prop({ required: true })
+  resolutionMessage: string;
+
+  @Prop({ required: true, type: String, enum: ['REJECTED', 'APPROVED'] })
+  resolutionStatus: string;
+
+  @Prop({ required: true, type: String, enum: NotificationType })
+  entityType: NotificationType;
+
+  @Prop({ required: true })
+  entityId: string;
+
+  @Prop({ required: true })
+  notificationSummary: string;
+}
+
+export const NotificationAuditSchema = SchemaFactory.createForClass(
+  NotificationAuditInfo,
+);

src/users/users.admin.controller.ts

@@ -9,6 +9,7 @@ import {
   Post,
   Put,
   Query,
+  Req,
   Request,
   UseGuards,
 } from '@nestjs/common';
@@ -236,8 +237,12 @@ export class UsersAdminsController {
       'finds a pending lead application using the email query param and approve that pending application on that account',
   })
   @Patch('lead/:email/approve')
-  async approveApplication(@Param('email') email: string): Promise<string> {
-    return await this.usersService.approveTempApplication(email);
+  async approveApplication(
+    @Param('email') email: string,
+    @Request() req: ApiReq,
+  ): Promise<string> {
+    const admin_id = req.user._id.toString();
+    return await this.usersService.approveTempApplication(email, admin_id);
   }
 
   // reject a lead request
@@ -247,12 +252,15 @@ export class UsersAdminsController {
   @Patch('lead/:email/reject')
   async reject(
     @Param('email') email: string,
+    @Request() req: ApiReq,
     @Body() rejectApplicationDto: RejectApplicationDto,
   ): Promise<string> {
     const defaultMessage = 'Your application was rejected';
     const rejectionMessage = rejectApplicationDto.message || defaultMessage;
+    const admin_id = req.user._id.toString();
     return await this.usersService.rejectTempApplication(
       email,
+      admin_id,
       rejectionMessage,
     );
   }

src/users/users.controller.spec.ts

@@ -711,52 +711,63 @@ describe('UsersController', () => {
     describe('approveApplication', () => {
       it('should approve a lead application', async () => {
         const email = 'lead@example.com';
+        const admin_id = 'admin_id';
         const expectedResult = 'Application approved successfully';
+        const mockReq = { user: { _id: admin_id } } as any;
 
         jest
           .spyOn(usersService, 'approveTempApplication')
           .mockResolvedValue(expectedResult);
 
-        const result = await adminController.approveApplication(email);
+        const result = await adminController.approveApplication(email, mockReq);
 
         expect(result).toEqual(expectedResult);
-        expect(usersService.approveTempApplication).toHaveBeenCalledWith(email);
+        expect(usersService.approveTempApplication).toHaveBeenCalledWith(
+          email,
+          admin_id,
+        );
       });
     });
 
     describe('reject', () => {
       it('should reject a lead application with custom message', async () => {
         const email = 'lead@example.com';
+        const admin_id = 'admin_id';
         const rejectDto = { message: 'Custom rejection message' };
         const expectedResult = 'Application rejected successfully';
+        const mockReq = { user: { _id: admin_id } } as any;
 
         jest
           .spyOn(usersService, 'rejectTempApplication')
           .mockResolvedValue(expectedResult);
 
-        const result = await adminController.reject(email, rejectDto);
+        const result = await adminController.reject(email, mockReq, rejectDto);
 
         expect(result).toEqual(expectedResult);
         expect(usersService.rejectTempApplication).toHaveBeenCalledWith(
           email,
+          admin_id,
           rejectDto.message,
         );
       });
 
       it('should reject with default message when no message provided', async () => {
         const email = 'lead@example.com';
+        const admin_id = 'admin_id';
         const rejectDto = {};
         const expectedResult = 'Application rejected successfully';
+        const mockReq = { user: { _id: admin_id } } as any;
 
         jest
           .spyOn(usersService, 'rejectTempApplication')
           .mockResolvedValue(expectedResult);
 
-        const result = await adminController.reject(email, rejectDto);
+        const result = await adminController.reject(email, mockReq, rejectDto);
 
         expect(result).toEqual(expectedResult);
         expect(usersService.rejectTempApplication).toHaveBeenCalledWith(
           email,
+          admin_id,
           'Your application was rejected',
         );
       });

src/users/users.service.ts

@@ -465,7 +465,11 @@ export class UsersService {
   }
 
   // approve a lead application
-  async approveTempApplication(email: string): Promise<string> {
+  async approveTempApplication(
+    admin_id: string,
+    email: string,
+    message: string = '',
+  ): Promise<string> {
     const userApplication = await this.userModel
       .findOne({
         email: email,
@@ -488,7 +492,19 @@ export class UsersService {
     userApplication.applicationStatus = ApplicationStatus.APPROVED;
     userApplication.save();
 
-    // TODO: move existing notification to audit
+    // find notifications for user and resolve them
+    const existingNotification =
+      await this.notificationsService.getNotificationByUserId(
+        userApplication._id.toString(),
+        userApplication._id.toString(),
+      );
+    this.notificationsService.resolveNotification(
+      existingNotification._id.toString(),
+      admin_id,
+      message,
+      'APPROVED',
+    );
+
     // create notification for user
     const _ = await this.notificationsService.createNotification({
       receiverId: userApplication._id.toString(),
@@ -521,13 +537,27 @@ export class UsersService {
 
   // TODO: refactor the createNotification to take a user, message, isAdmin, notificationType and data
   // reject a lead application
-  async rejectTempApplication(email: string, message: string): Promise<string> {
+  async rejectTempApplication(
+    email: string,
+    admin_id: string,
+    message: string,
+  ): Promise<string> {
     const userApplication = await this.viewOneApplication(email);
     userApplication.leadPosition = '';
     userApplication.applicationStatus = ApplicationStatus.REJECTED;
     await userApplication.save();
 
-    // TODO: move existing notification to audit
+    const existingNotification =
+      await this.notificationsService.getNotificationByUserId(
+        userApplication._id.toString(),
+        userApplication._id.toString(),
+      );
+    this.notificationsService.resolveNotification(
+      existingNotification._id.toString(),
+      admin_id,
+      message,
+      'REJECTED',
+    );
     // create notification for user
     const _ = await this.notificationsService.createNotification({
       receiverId: userApplication._id.toString(),