Merge pull request #76 from GeneralMagicio/fix/pull_worldid_from_midleware

Pull worldlD from middleware instead or request query/body

Author: Meriem-BM

src/auth/user.docerator.ts src/auth/user.decorator.tssrc/auth/user.docerator.ts renamed to src/auth/user.decorator.ts

@@ -12,10 +12,6 @@ import {
 } from 'class-validator';
 
 export class CreatePollDto {
-  @IsString()
-  @IsNotEmpty()
-  worldID: string;
-
   @IsString()
   @IsNotEmpty()
   title: string;
@@ -48,10 +44,6 @@ export class CreatePollDto {
 }
 
 export class GetPollsDto {
-  @IsString()
-  @IsOptional()
-  worldID?: string;
-
   @IsString()
   @IsOptional()
   search?: string;
@@ -91,9 +83,3 @@ export class GetPollsDto {
   @IsEnum(['asc', 'desc'])
   sortOrder?: 'asc' | 'desc';
 }
-
-export class DeletePollDto {
-  @IsString()
-  @IsNotEmpty()
-  worldID: string;
-}

src/poll/Poll.dto.ts

@@ -7,26 +7,28 @@ import {
   Post,
   Query,
 } from '@nestjs/common';
-import { CreatePollDto, DeletePollDto, GetPollsDto } from './Poll.dto';
+import { CreatePollDto, GetPollsDto } from './Poll.dto';
 import { PollService } from './poll.service';
-import { User } from 'src/auth/user.docerator';
+import { User } from 'src/auth/user.decorator';
 
 @Controller('poll')
 export class PollController {
   constructor(private readonly pollService: PollService) {}
 
   @Post()
-  async createPoll(@Body() dto: CreatePollDto) {
-    return await this.pollService.createPoll(dto);
+  async createPoll(
+    @Body() dto: CreatePollDto,
+    @User('worldID') worldID: string,
+  ) {
+    return await this.pollService.createPoll(dto, worldID);
   }
 
   @Get()
   async getPolls(
     @Query() query: GetPollsDto,
     @User('worldID') worldID: string,
   ) {
-    query.worldID = worldID;
-    return await this.pollService.getPolls(query);
+    return await this.pollService.getPolls(query, worldID);
   }
 
   @Get(':id')
@@ -35,8 +37,8 @@ export class PollController {
   }
 
   @Delete(':id')
-  async deletePoll(@Param('id') id: number, @Body() query: DeletePollDto) {
-    const poll = await this.pollService.deletePoll(Number(id), query);
+  async deletePoll(@Param('id') id: number, @User('worldID') worldID: string) {
+    const poll = await this.pollService.deletePoll(Number(id), worldID);
     return { message: 'Poll deleted', poll };
   }
 }

src/poll/poll.controller.ts

@@ -12,7 +12,7 @@ import {
   UnauthorizedActionException,
   UserNotFoundException,
 } from '../common/exceptions';
-import { CreatePollDto, DeletePollDto, GetPollsDto } from './Poll.dto';
+import { CreatePollDto, GetPollsDto } from './Poll.dto';
 
 @Injectable()
 export class PollService {
@@ -51,17 +51,26 @@ export class PollService {
     return searchResults.map((result) => result.pollId);
   }
 
-  async createPoll(createPollDto: CreatePollDto) {
+  async createPoll(createPollDto: CreatePollDto, worldID: string) {
     const user = await this.databaseService.user.findUnique({
-      where: { worldID: createPollDto.worldID },
+      where: { worldID },
     });
     if (!user) {
       throw new UserNotFoundException();
     }
     const startDate = new Date(createPollDto.startDate);
+    // temporary fix by adding 1min for tiny delay in time from receiving the request
+    const checkDate = new Date(startDate.getTime() + 60000);
     const endDate = new Date(createPollDto.endDate);
     const now = new Date();
-    if (startDate < now) {
+
+    console.log('date', {
+      checkDate,
+      startDate,
+      now,
+    });
+
+    if (checkDate < now) {
       throw new BadRequestException('Start date cannot be in the past');
     }
     if (endDate <= startDate) {
@@ -97,7 +106,7 @@ export class PollService {
     });
   }
 
-  async getPolls(query: GetPollsDto) {
+  async getPolls(query: GetPollsDto, worldID: string) {
     const {
       page = 1,
       limit = 10,
@@ -122,9 +131,9 @@ export class PollService {
       filters.OR = [{ startDate: { gt: now } }, { endDate: { lte: now } }];
     }
 
-    if ((userCreated || userVoted) && query.worldID) {
+    if ((userCreated || userVoted) && worldID) {
       const user = await this.databaseService.user.findUnique({
-        where: { worldID: query.worldID },
+        where: { worldID },
         select: { id: true },
       });
 
@@ -178,6 +187,9 @@ export class PollService {
     const [polls, total] = await this.databaseService.$transaction([
       this.databaseService.poll.findMany({
         where: filters,
+        include: {
+          author: true,
+        },
         orderBy,
         skip,
         take: Number(limit),
@@ -208,9 +220,9 @@ export class PollService {
     return { poll, isActive, optionsTotalVotes, totalVotes };
   }
 
-  async deletePoll(pollId: number, query: DeletePollDto) {
+  async deletePoll(pollId: number, worldID: string) {
     const user = await this.databaseService.user.findUnique({
-      where: { worldID: query.worldID },
+      where: { worldID },
       select: { id: true },
     });
     if (!user) {

src/poll/poll.service.ts

@@ -14,6 +14,7 @@ import {
   UserVotesResponseDto,
 } from './user.dto';
 import { UserService } from './user.service';
+import { User } from 'src/auth/user.decorator';
 
 @Controller('user')
 export class UserController {
@@ -36,18 +37,25 @@ export class UserController {
   @Get('getUserVotes')
   async getUserVotes(
     @Query() query: GetUserVotesDto,
+    @User('worldID') worldID: string,
   ): Promise<UserVotesResponseDto> {
-    return await this.userService.getUserVotes(query);
+    return await this.userService.getUserVotes(query, worldID);
   }
 
   @Post('setVote')
-  async setVote(@Body() dto: SetVoteDto): Promise<SetVoteResponseDto> {
-    return await this.userService.setVote(dto);
+  async setVote(
+    @Body() dto: SetVoteDto,
+    @User('worldID') worldID: string,
+  ): Promise<SetVoteResponseDto> {
+    return await this.userService.setVote(dto, worldID);
   }
 
   @Post('editVote')
-  async editVote(@Body() dto: EditVoteDto): Promise<EditVoteResponseDto> {
-    return await this.userService.editVote(dto);
+  async editVote(
+    @Body() dto: EditVoteDto,
+    @User('worldID') worldID: string,
+  ): Promise<EditVoteResponseDto> {
+    return await this.userService.editVote(dto, worldID);
   }
 
   @Post('createUser')

src/user/user.controller.ts

@@ -95,13 +95,13 @@ export class GetUserVotesDto {
   @Validate(IsPositiveInteger)
   @Transform(({ value }) => parseInt(value, 10))
   pollId: number;
-
-  @IsString()
-  @IsNotEmpty()
-  worldID: string;
 }
 
 export class UserVotesResponseDto {
+  @IsNotEmpty()
+  @IsString()
+  voteID: string;
+
   @IsNotEmpty()
   @IsString({ each: true })
   options: string[];
@@ -120,10 +120,6 @@ export class SetVoteDto {
   @Validate(IsPositiveInteger)
   pollId: number;
 
-  @IsNotEmpty()
-  @IsString()
-  worldID: string;
-
   @IsNotEmpty()
   @Validate(IsRecordStringNumber)
   weightDistribution: Record<string, number>;
@@ -140,10 +136,6 @@ export class SetVoteResponseDto {
 }
 
 export class EditVoteDto {
-  @IsNotEmpty()
-  @IsString()
-  worldID: string;
-
   @IsNotEmpty()
   @IsString()
   voteID: string;

src/user/user.dto.ts

@@ -201,9 +201,12 @@ export class UserService {
     return { userActions: actions };
   }
 
-  async getUserVotes(dto: GetUserVotesDto): Promise<UserVotesResponseDto> {
+  async getUserVotes(
+    dto: GetUserVotesDto,
+    worldID: string,
+  ): Promise<UserVotesResponseDto> {
     const user = await this.databaseService.user.findUnique({
-      where: { worldID: dto.worldID },
+      where: { worldID },
       select: { id: true },
     });
     if (!user) {
@@ -221,21 +224,26 @@ export class UserService {
         pollId: dto.pollId,
         userId: user.id,
       },
-      select: { votingPower: true, weightDistribution: true },
+      select: {
+        voteID: true,
+        votingPower: true,
+        weightDistribution: true,
+      },
     });
     if (!vote) {
       throw new VoteNotFoundException();
     }
     return {
+      voteID: vote.voteID,
       options: poll.options,
       votingPower: vote.votingPower,
       weightDistribution: vote.weightDistribution as Record<string, number>,
     };
   }
 
-  async setVote(dto: SetVoteDto): Promise<SetVoteResponseDto> {
+  async setVote(dto: SetVoteDto, worldID: string): Promise<SetVoteResponseDto> {
     const user = await this.databaseService.user.findUnique({
-      where: { worldID: dto.worldID },
+      where: { worldID },
       select: { id: true },
     });
     if (!user) {
@@ -284,7 +292,10 @@ export class UserService {
     });
   }
 
-  async editVote(dto: EditVoteDto): Promise<EditVoteResponseDto> {
+  async editVote(
+    dto: EditVoteDto,
+    worldID: string,
+  ): Promise<EditVoteResponseDto> {
     const vote = await this.databaseService.vote.findUnique({
       where: { voteID: dto.voteID },
       select: {
@@ -305,7 +316,7 @@ export class UserService {
       where: { id: vote.userId },
       select: { worldID: true },
     });
-    if (user?.worldID !== dto.worldID) {
+    if (user?.worldID !== worldID) {
       throw new UnauthorizedActionException();
     }
     this.validateWeightDistribution(dto.weightDistribution, vote.poll.options);