fix: resolved 400 error when trying to search notification by id. fixed issues with lead application guard not allowing users register to be leadd. the userguard was removed from this endpoint, since it first checks the request is from a lead or an admin

Author: snebo

src/events/events.admin.controller.ts

@@ -1,12 +1,13 @@
 import {
+  Body,
   Controller,
   Delete,
   Param,
   Patch,
   Request,
   UseGuards,
 } from '@nestjs/common';
-import { ApiBearerAuth, ApiParam, ApiTags } from '@nestjs/swagger';
+import { ApiBearerAuth, ApiBody, ApiOperation, ApiParam, ApiTags } from '@nestjs/swagger';
 import { JwtAdminsGuard } from 'src/shared/auth/guards/jwt.admins.guard';
 import { ApiReq } from 'src/shared/interfaces';
 import { EventService } from './events.users.service';
@@ -25,6 +26,35 @@ export class EventAdminsController {
     return this.eventService.approveEvent(id, admin_id);
   }
 
+  @ApiBearerAuth()
+  @UseGuards(JwtAdminsGuard)
+  @Patch('event/:id/reject')
+  @ApiParam({ name: 'id', type: 'string' })
+  @ApiOperation({
+    summary: 'Reject an event',
+    description: 'Reject an event with a reason',
+  })
+  @ApiBody({
+    schema: {
+      type: 'object',
+      properties: {
+        message: {
+          type: 'string',
+          description: 'Reason for rejection',
+        },
+      },
+    },
+  })
+  async rejectEvent(
+    @Param('id') id: string,
+    @Request() req: ApiReq,
+    @Body() body: { message?: string },
+  ) {
+    const admin_id = req.user._id.toString();
+    const message = body.message || 'Event rejected';
+    return this.eventService.rejectEvent(id, admin_id, message);
+  }
+
   @ApiBearerAuth()
   @UseGuards(JwtAdminsGuard)
   @Delete('event/:id')

src/events/events.service.spec.ts

@@ -63,6 +63,8 @@ describe('EventService', () => {
       createNotification: jest.fn().mockResolvedValue(undefined),
       getNotificationByUserId: jest.fn().mockResolvedValue(undefined),
       resolveNotification: jest.fn().mockResolvedValue(undefined),
+      notifyOtherAdminsOfResolution: jest.fn().mockResolvedValue(undefined),
+      createAdminNotificationForNewRequest: jest.fn().mockResolvedValue(undefined),
     };
 
     const module: TestingModule = await Test.createTestingModule({
@@ -109,6 +111,7 @@ describe('EventService', () => {
         expect.objectContaining({
           receiverId: eventDto.host,
           message: expect.stringContaining(eventDto.title),
+          isAdminNotification: true,
         }),
       );
       expect(result).toEqual(mockEvent);
@@ -215,6 +218,12 @@ describe('EventService', () => {
         message,
         'APPROVED',
       );
+      expect(notificationsServiceMock.notifyOtherAdminsOfResolution).toHaveBeenCalledWith(
+        mockEvent._id.toString(),
+        admin_id,
+        'approved',
+        'EVENTS_REQUEST',
+      );
     });
 
     it('should throw NotFoundException if event not found', async () => {

src/events/events.users.service.ts

@@ -130,6 +130,65 @@ export class EventService {
       message,
       'APPROVED',
     );
+    
+    // Notify other admins about the resolution
+    await this.notificationsService.notifyOtherAdminsOfResolution(
+      event._id.toString(),
+      admin_id,
+      'approved',
+      NotificationType.events,
+    );
+    
     return approveEvent;
   }
+
+  async rejectEvent(
+    id: string,
+    admin_id: string,
+    message: string = 'Event rejected',
+  ): Promise<Event> {
+    const rejectEvent = await this.eventModel.findByIdAndUpdate(
+      id,
+      { status: Status.REJECTED },
+      { new: true },
+    );
+
+    if (!rejectEvent) {
+      throw new NotFoundException(`Event with ID ${id} not found`);
+    }
+
+    const event = await this.eventModel.findById({ _id: id });
+    const existingNotification =
+      await this.notificationsService.getNotificationByUserId(
+        event.host,
+        event._id.toString(),
+      );
+    await this.notificationsService.resolveNotification(
+      existingNotification._id.toString(),
+      admin_id,
+      message,
+      'REJECTED',
+    );
+    
+    // Notify other admins about the resolution
+    await this.notificationsService.notifyOtherAdminsOfResolution(
+      event._id.toString(),
+      admin_id,
+      'rejected',
+      NotificationType.events,
+    );
+    
+    // Create notification for the user about rejection
+    await this.notificationsService.createNotification({
+      receiverId: event.host,
+      notification_type: NotificationType.events,
+      entityId: event._id.toString(),
+      message: `Your event "${event.title}" has been rejected: ${message}`,
+      data: { eventTitle: event.title, reason: message },
+      isRead: false,
+      isAdminNotification: false,
+    });
+    
+    return rejectEvent;
+  }
 }

src/notifications/notifications.controller.spec.ts

@@ -14,6 +14,16 @@ describe('NotificationsController', () => {
           { message: 'Test notification 1' },
           { message: 'Test notification 2' },
         ]),
+      getNotificationById: jest
+        .fn()
+        .mockResolvedValue({ notificationId: 'id', parentId: 'parent-id' }),
+      userReadNotification: jest.fn().mockResolvedValue(true),
+      userClearNotifications: jest.fn().mockResolvedValue(true),
+      getAdminNotifications: jest.fn().mockResolvedValue([
+        { message: 'Admin notification 1' },
+        { message: 'Admin notification 2' },
+      ]),
+      adminReadNotification: jest.fn().mockResolvedValue(true),
     };
     const module: TestingModule = await Test.createTestingModule({
       controllers: [NotificationsController],
@@ -37,5 +47,44 @@ describe('NotificationsController', () => {
       { message: 'Test notification 1' },
       { message: 'Test notification 2' },
     ]);
+    expect(service.getNotifications).toHaveBeenCalledWith('1234');
+  });
+
+  it('should get notification parent id', async () => {
+    const result = await controller.getNotificationParentId('notification-id');
+    expect(result).toEqual({ notificationId: 'id', parentId: 'parent-id' });
+    expect(service.getNotificationById).toHaveBeenCalledWith('notification-id');
+  });
+
+  it('should mark notification as read', async () => {
+    const req = { user: { _id: 'user-id' } } as any;
+    const result = await controller.markNotificationAsRead('notification-id', req);
+    expect(result).toBe(true);
+    expect(service.userReadNotification).toHaveBeenCalledWith(
+      'notification-id',
+      'user-id',
+    );
+  });
+
+  it('should clear user notifications', async () => {
+    const req = { user: { _id: 'user-id' } } as any;
+    const result = await controller.clearUserNotifications(req);
+    expect(result).toBe(true);
+    expect(service.userClearNotifications).toHaveBeenCalledWith('user-id');
+  });
+
+  it('should get admin notifications', async () => {
+    const result = await controller.getAdminNotifications('pending');
+    expect(result).toEqual([
+      { message: 'Admin notification 1' },
+      { message: 'Admin notification 2' },
+    ]);
+    expect(service.getAdminNotifications).toHaveBeenCalledWith('pending');
+  });
+
+  it('should mark admin notification as read', async () => {
+    const result = await controller.markAdminNotificationAsRead('notification-id');
+    expect(result).toBe(true);
+    expect(service.adminReadNotification).toHaveBeenCalledWith('notification-id');
   });
 });

src/notifications/notifications.controller.ts

@@ -1,5 +1,22 @@
-import { Controller, Get, Param, Query, Request } from '@nestjs/common';
-import { ApiBearerAuth, ApiQuery, ApiResponse } from '@nestjs/swagger';
+import {
+  Controller,
+  Delete,
+  Get,
+  Param,
+  Patch,
+  Query,
+  Request,
+  UseGuards,
+} from '@nestjs/common';
+import {
+  ApiBearerAuth,
+  ApiOperation,
+  ApiParam,
+  ApiQuery,
+  ApiResponse,
+} from '@nestjs/swagger';
+import { JwtAdminsGuard } from 'src/shared/auth/guards/jwt.admins.guard';
+import { JwtUsersGuard } from 'src/shared/auth/guards/jwt.users.guard';
 import { ApiReq } from 'src/shared/interfaces';
 import { NotificationsService } from './notifications.service';
 
@@ -8,20 +25,27 @@ import { NotificationsService } from './notifications.service';
 export class NotificationsController {
   constructor(private readonly notificationsService: NotificationsService) {}
 
-  @Get('/notifications')
+  @ApiBearerAuth()
+  @ApiOperation({
+    summary: 'get all notifications',
+    description:
+      'returns all notifications based on the user type making the request',
+  })
   @ApiResponse({
     status: 200,
     description: 'List of notifications',
   })
+  @UseGuards(JwtUsersGuard)
+  @Get()
   async getNotifications(@Request() req: ApiReq): Promise<string[]> {
-    // fetch notifications for user
     const notifications = await this.notificationsService.getNotifications(
       req.user._id.toString(),
     );
     return notifications;
   }
 
-  @Get('/notifications/:notificationId')
+  @UseGuards(JwtUsersGuard)
+  @Get(':notificationId')
   @ApiResponse({
     status: 200,
     description: 'Return the id of the object that prompted the notification',
@@ -33,4 +57,83 @@ export class NotificationsController {
       await this.notificationsService.getNotificationById(notificationId);
     return notification;
   }
+
+  @ApiBearerAuth()
+  @ApiOperation({
+    summary:
+      'Mark notification as read for users (DOES NOT WORK FOR ADMIN NOTIFICATIONS)',
+    description:
+      'Marks a specific notification as read for the requesting user',
+  })
+  @ApiParam({ name: 'notificationId', type: 'string' })
+  @ApiResponse({
+    status: 200,
+    description: 'Notification marked as read',
+  })
+  @UseGuards(JwtUsersGuard)
+  @Patch(':notificationId/read')
+  async markNotificationAsRead(
+    @Param('notificationId') notificationId: string,
+    @Request() req: ApiReq,
+  ): Promise<boolean> {
+    return await this.notificationsService.userReadNotification(
+      notificationId,
+      req.user._id.toString(),
+    );
+  }
+
+  @ApiBearerAuth()
+  @ApiOperation({
+    summary: 'Clear all notifications for user',
+    description: 'Deletes all notifications for the requesting user',
+  })
+  @ApiResponse({
+    status: 200,
+    description: 'Notifications cleared',
+  })
+  @UseGuards(JwtUsersGuard)
+  @Delete('clear')
+  async clearUserNotifications(@Request() req: ApiReq): Promise<boolean> {
+    return await this.notificationsService.userClearNotifications(
+      req.user._id.toString(),
+    );
+  }
+
+  @ApiBearerAuth()
+  @ApiOperation({
+    summary: 'Get admin notifications dashboard',
+    description: 'Returns all admin notifications with optional filtering',
+  })
+  @ApiQuery({ name: 'status', required: false, enum: ['pending', 'read'] })
+  @ApiResponse({
+    status: 200,
+    description: 'List of admin notifications',
+  })
+  @UseGuards(JwtAdminsGuard)
+  @Get('admin/dashboard')
+  async getAdminNotifications(
+    @Query('status') status?: string,
+  ): Promise<any[]> {
+    return await this.notificationsService.getAdminNotifications(status);
+  }
+
+  @ApiBearerAuth()
+  @ApiOperation({
+    summary: 'Mark admin notification as read',
+    description: 'Marks a specific notification as read for admins',
+  })
+  @ApiParam({ name: 'notificationId', type: 'string' })
+  @ApiResponse({
+    status: 200,
+    description: 'Notification marked as read',
+  })
+  @UseGuards(JwtAdminsGuard)
+  @Patch('admin/:notificationId/read')
+  async markAdminNotificationAsRead(
+    @Param('notificationId') notificationId: string,
+  ): Promise<boolean> {
+    return await this.notificationsService.adminReadNotification(
+      notificationId,
+    );
+  }
 }