Merge branch 'hngprojects:dev' into feat-implement-pagination-on-find…

…AllInvitations-Endpoint

package.json

@@ -33,7 +33,6 @@
     "postinstall": "npm install --platform=linux --arch=x64 sharp"
   },
   "dependencies": {
-
     "@google/generative-ai": "^0.22.0",
     "@nestjs/axios": "^4.0.0",
     "@nestjs/bull": "^11.0.2",
@@ -47,7 +46,6 @@
     "@nestjs/swagger": "^11.0.5",
     "@nestjs/typeorm": "^11.0.0",
     "@types/nodemailer": "^6.4.17",
-
     "@types/speakeasy": "^2.0.10",
     "@vitalets/google-translate-api": "^9.2.1",
     "aws-sdk": "^2.1692.0",

src/database/migrations/1740788110830-UpdatePhoneNumberType.ts

@@ -2,14 +2,10 @@ import { MigrationInterface, QueryRunner } from 'typeorm';
 
 export class UpdatePhoneNumberType1740788110830 implements MigrationInterface {
   public async up(queryRunner: QueryRunner): Promise<void> {
-    await queryRunner.query(
-      `ALTER TABLE contact ALTER COLUMN phone TYPE VARCHAR(20) USING phone::text`
-    );
+    await queryRunner.query(`ALTER TABLE contact ALTER COLUMN phone TYPE VARCHAR(20) USING phone::text`);
   }
 
   public async down(queryRunner: QueryRunner): Promise<void> {
-    await queryRunner.query(
-      `ALTER TABLE contact ALTER COLUMN phone TYPE INTEGER USING phone::integer`
-    );
+    await queryRunner.query(`ALTER TABLE contact ALTER COLUMN phone TYPE INTEGER USING phone::integer`);
   }
-}
+}

src/guards/job-access.guard.ts

@@ -0,0 +1,37 @@
+import { Injectable, CanActivate, ExecutionContext } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import { Job } from '../modules/jobs/entities/job.entity';
+import { User } from '@modules/user/entities/user.entity';
+
+@Injectable()
+export class JobAccessGuard implements CanActivate {
+  constructor(
+    @InjectRepository(Job)
+    private readonly jobRepository: Repository<Job>,
+    @InjectRepository(User)
+    private readonly userRepository: Repository<User>
+  ) {}
+
+  async canActivate(context: ExecutionContext): Promise<boolean> {
+    const request = context.switchToHttp().getRequest();
+    const jobId = request.params.id;
+    const userId = request.user.sub;
+
+    const user = await this.userRepository.findOne({
+      where: { id: userId },
+    });
+
+    if (user?.is_superadmin) {
+      return true;
+    }
+
+    const job = await this.jobRepository.findOne({
+      where: { id: jobId },
+      relations: ['user'],
+    });
+
+    if (!job) return false;
+    return job.user.id === userId;
+  }
+}

src/modules/comments/comments.controller.ts

@@ -1,3 +1,5 @@
+import { UserPayload } from './../user/interfaces/user-payload.interface';
+import { User } from './../user/entities/user.entity';
 import { Controller, Body, Post, Request, Get, Param, Delete } from '@nestjs/common';
 import { CommentsService } from './comments.service';
 import { CreateCommentDto } from './dtos/create-comment.dto';
@@ -15,7 +17,7 @@ export class CommentsController {
   @ApiResponse({ status: 400, description: 'Bad Request.' })
   @ApiResponse({ status: 500, description: 'Internal Server Error.' })
   async addComment(@Body() createCommentDto: CreateCommentDto, @Request() req): Promise<CommentResponseDto> {
-    const { userId } = req.user;
+    const userId = req.user.id;
     return await this.commentsService.addComment(createCommentDto, userId);
   }
 
@@ -26,10 +28,20 @@ export class CommentsController {
     return await this.commentsService.getAComment(id);
   }
 
+  @ApiOperation({ summary: 'Dislike a comment' })
+  @ApiResponse({ status: 200, description: 'Dislike updated successfully' })
+  @ApiResponse({ status: 404, description: 'Comment not found' })
+  @Post(':id/dislike')
+  async dislikeComment(@Param('id') id: string, @Request() req) {
+    const userId = req.user.id;
+    // console.log('User ID:', userId); debug
+    return await this.commentsService.dislikeComment(id, userId);
+  }
+
   @ApiOperation({ summary: 'Delete a comment' })
   @ApiResponse({ status: 200, description: 'The comment has been deleted successfully.' })
   @Delete(':id/delete')
   async deleteAComment(@Param('id') id: string, @Request() req): Promise<any> {
-    return await this.commentsService.deleteAComment(id, req.user.userId);
+    return await this.commentsService.deleteAComment(id, req.user.id);
   }
 }

src/modules/comments/comments.service.ts

@@ -66,12 +66,43 @@ export class CommentsService {
       throw new CustomHttpException('You are not authorized to delete this comment', HttpStatus.FORBIDDEN);
     }
 
-    await this.commentRepository.delete(comment);
+    await this.commentRepository.delete(comment.id);
 
     return {
       message: 'Comment deleted successfully!',
       status: HttpStatus.OK,
       data: { comment },
     };
   }
+
+  async dislikeComment(commentId: string, userId: string): Promise<{ message: string; dislikeCount: number }> {
+    const comment = await this.commentRepository
+      .createQueryBuilder('comment')
+      .where('comment.id = :id', { id: commentId })
+      .getOne();
+
+    if (!comment) {
+      throw new CustomHttpException('Comment not found', HttpStatus.NOT_FOUND);
+    }
+
+    if (!comment.dislikedBy) {
+      comment.dislikedBy = [];
+    }
+
+    // Check if the user has already disliked the comment
+    if (comment.dislikedBy.includes(userId)) {
+      throw new CustomHttpException('You have already disliked this comment', HttpStatus.BAD_REQUEST);
+    }
+
+    // Add the user to the dislikedBy array and increment dislikes
+    comment.dislikedBy.push(userId);
+    comment.dislikes = comment.dislikedBy.length;
+
+    await this.commentRepository.save(comment);
+
+    return {
+      message: 'Dislike updated successfully',
+      dislikeCount: comment.dislikes,
+    };
+  }
 }

src/modules/comments/dtos/dislike-comment.dto

@@ -0,0 +1,9 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { IsNotEmpty, IsUUID } from 'class-validator';
+
+export class DislikeCommentDto {
+  @ApiProperty({ description: 'Comment ID to dislike' })
+  @IsNotEmpty()
+  @IsUUID()
+  commentId: string;
+}

src/modules/comments/entities/comments.entity.ts

@@ -19,4 +19,10 @@ export class Comment extends AbstractBaseEntity {
 
   @Column({ nullable: true })
   model_type: string;
+
+  @Column({ type: 'int', default: 0 }) // Add dislikes column
+  dislikes: number;
+
+  @Column('simple-array', { nullable: true }) // Store user IDs as an array
+  dislikedBy: string[];
 }

src/modules/comments/tests/comments.service.spec.ts

@@ -8,11 +8,17 @@ import { User } from '../../user/entities/user.entity';
 import { CustomHttpException } from '@shared/helpers/custom-http-filter';
 import { HttpStatus } from '@nestjs/common';
 
+const mockQueryBuilder = {
+  where: jest.fn().mockReturnThis(),
+  getOne: jest.fn(),
+};
+
 const mockCommentRepository = () => ({
   create: jest.fn(),
   save: jest.fn(),
   findOne: jest.fn(),
   delete: jest.fn(),
+  createQueryBuilder: jest.fn(() => mockQueryBuilder),
 });
 
 const mockUserRepository = () => ({
@@ -105,24 +111,24 @@ describe('CommentsService', () => {
       it('should delete a comment successfully', async () => {
         const commentId = 'comment-id';
         const userId = 'user-id';
-        const mockUser = { id: 'user-id' };
+        const mockUser = { id: userId };
         const mockComment = {
-          id: 'comment-id',
+          id: commentId,
           model_id: '1',
           model_type: 'post',
           comment: 'A valid comment',
           user: mockUser,
         };
 
         commentRepository.findOne.mockResolvedValue(mockComment);
-        commentRepository.delete.mockResolvedValue(mockComment);
+        commentRepository.delete.mockResolvedValue({ affected: 1 });
 
         console.log(await commentRepository.findOne({ where: { id: commentId }, relations: ['user'] })); // Debugging
 
         const result = await service.deleteAComment(commentId, userId);
 
         expect(commentRepository.findOne).toHaveBeenCalledWith({ where: { id: commentId }, relations: ['user'] });
-        expect(commentRepository.delete).toHaveBeenCalledWith(mockComment);
+        expect(commentRepository.delete).toHaveBeenCalledWith(commentId);
         expect(result).toEqual({
           message: 'Comment deleted successfully!',
           status: HttpStatus.OK,
@@ -131,4 +137,39 @@ describe('CommentsService', () => {
       });
     });
   });
+
+  describe('CommentsService - dislikeComment', () => {
+    it('should throw CustomHttpException if comment is not found', async () => {
+      commentRepository.findOne.mockResolvedValue(null);
+
+      await expect(service.dislikeComment('comment-id', 'user-id')).rejects.toThrow(CustomHttpException);
+      await expect(service.dislikeComment('comment-id', 'user-id')).rejects.toMatchObject({
+        message: 'Comment not found',
+        status: HttpStatus.NOT_FOUND,
+      });
+    });
+
+    it('should increase the dislike count successfully', async () => {
+      const mockComment = {
+        id: 'comment-id',
+        dislikes: 2,
+        dislikedBy: ['user1', 'user2'], // Ensure this is initialized
+      };
+
+      // Mock `getOne()` from `createQueryBuilder`
+      mockQueryBuilder.getOne.mockResolvedValue(mockComment);
+      commentRepository.createQueryBuilder.mockReturnValue(mockQueryBuilder);
+
+      commentRepository.save.mockResolvedValue({ ...mockComment, dislikes: 3 });
+
+      const result = await service.dislikeComment('comment-id', 'user-id');
+
+      expect(result).toEqual({
+        message: 'Dislike updated successfully',
+        dislikeCount: 3,
+      });
+
+      expect(commentRepository.save).toHaveBeenCalledWith({ ...mockComment, dislikes: 3 });
+    });
+  });
 });

src/modules/contact-us/contact-us.service.ts

@@ -39,4 +39,4 @@ export class ContactUsService {
       },
     });
   }
-}
+}

src/modules/contact-us/dto/create-contact-us.dto.ts

@@ -1,22 +1,22 @@
 import { IsEmail, IsNotEmpty, IsOptional, IsString, Matches } from 'class-validator';
 
 export class CreateContactDto {
-    @IsNotEmpty({ message: 'Name should not be empty' })
-    @IsString({ message: 'Name must be a string' })
-    name: string;
+  @IsNotEmpty({ message: 'Name should not be empty' })
+  @IsString({ message: 'Name must be a string' })
+  name: string;
 
-    @IsNotEmpty({ message: 'Email should not be empty' })
-    @IsEmail({}, { message: 'Email must be valid' })
-    email: string;
+  @IsNotEmpty({ message: 'Email should not be empty' })
+  @IsEmail({}, { message: 'Email must be valid' })
+  email: string;
 
-    @IsOptional()
-    @IsString({ message: 'Phone must be a string' })
-    @Matches(/^\+?[0-9\-\s()]{8,20}$/, {
-        message: 'Invalid phone number format'
-    })
-    phone: string; 
+  @IsOptional()
+  @IsString({ message: 'Phone must be a string' })
+  @Matches(/^\+?[0-9\-\s()]{8,20}$/, {
+    message: 'Invalid phone number format',
+  })
+  phone: string;
 
-    @IsNotEmpty({ message: 'Message should not be empty' })
-    @IsString({ message: 'Message must be a string' })
-    message: string;
-}
+  @IsNotEmpty({ message: 'Message should not be empty' })
+  @IsString({ message: 'Message must be a string' })
+  message: string;
+}

src/modules/contact-us/entities/contact-us.entity.ts

@@ -3,18 +3,18 @@ import { Entity, Column } from 'typeorm';
 
 @Entity()
 export class ContactUs extends AbstractBaseEntity {
-    @Column('varchar', { length: 20, nullable: true }) 
-    phone: string;
+  @Column('varchar', { length: 20, nullable: true })
+  phone: string;
 
-    @Column('varchar', { nullable: false })
-    name: string;
+  @Column('varchar', { nullable: false })
+  name: string;
 
-    @Column('varchar', { nullable: false })
-    email: string;
+  @Column('varchar', { nullable: false })
+  email: string;
 
-    @Column('text', { nullable: false })
-    message: string;
+  @Column('text', { nullable: false })
+  message: string;
 
-    @Column({ type: 'timestamp', default: () => 'CURRENT_TIMESTAMP' })
-    createdAt: Date;
-}
+  @Column({ type: 'timestamp', default: () => 'CURRENT_TIMESTAMP' })
+  createdAt: Date;
+}

src/modules/invite/mocks/mockUser.ts

@@ -6,6 +6,7 @@ export const mockUser: User = {
   first_name: 'John',
   last_name: 'Doe',
   is_active: true,
+  is_superadmin: false,
   phone: '+1234567890',
   status: 'Hello from the children of planet Earth',
   id: 'some-uuid-value-here',

src/modules/jobs/jobs.controller.ts

@@ -41,6 +41,7 @@ import { JobSearchDto } from './dto/jobSearch.dto';
 import { UpdateJobDto } from './dto/update-job.dto';
 import { JobOwnerGuard } from '../../guards/job-owner.guard';
 import { AuthGuard } from '../../guards/auth.guard';
+import { JobAccessGuard } from '@guards/job-access.guard';
 
 @ApiTags('Jobs')
 @Controller('jobs')
@@ -124,8 +125,7 @@ export class JobsController {
   }
 
   @Patch('/:id')
-  @UseGuards(AuthGuard)
-  @UseGuards(SuperAdminGuard, JobOwnerGuard)
+  @UseGuards(AuthGuard, JobAccessGuard)
   @ApiBearerAuth()
   @ApiOperation({ summary: 'Update a job posting' })
   @ApiResponse({ status: 200, description: 'Job updated successfully' })

src/modules/jobs/jobs.module.ts

@@ -10,16 +10,16 @@ import { OrganisationUserRole } from '@modules/role/entities/organisation-user-r
 import { Profile } from '@modules/profile/entities/profile.entity';
 import { Role } from '@modules/role/entities/role.entity';
 import { UserModule } from '@modules/user/user.module';
-import { JobOwnerGuard } from '@guards/job-owner.guard';
 import { AuthGuard } from '@guards/auth.guard';
-import { SuperAdminGuard } from '@guards/super-admin.guard';
+import { JobAccessGuard } from '@guards/job-access.guard';
 import { S3Service } from '@modules/s3/s3.service';
+
 @Module({
   imports: [
     TypeOrmModule.forFeature([Job, User, JobApplication, Organisation, OrganisationUserRole, Profile, Role]),
     UserModule,
   ],
-  providers: [JobsService, JobOwnerGuard, AuthGuard, SuperAdminGuard, S3Service],
+  providers: [JobsService, JobAccessGuard, AuthGuard, S3Service],
   controllers: [JobsController],
 })
 export class JobsModule {}