Merge pull request #70 from GeneralMagicio/add-optionsTotalVotes-and-totalVotes-to-getPollDetails

Add optionsTotalVotes and totalVotes to getPollDetails

Author: RamRamez

src/auth/auth.controller.ts

@@ -1,12 +1,19 @@
 import { Body, Controller, Get, Post, Req, Res } from '@nestjs/common';
-import { Response, Request } from 'express';
-import { AuthService } from './auth.service';
 import { MiniAppWalletAuthSuccessPayload } from '@worldcoin/minikit-js';
+import { Request, Response } from 'express';
+import { handleError } from '../common/helpers';
+import { AuthService } from './auth.service';
 
 interface IRequestPayload {
   payload: MiniAppWalletAuthSuccessPayload;
 }
 
+type RequestWithCookies = Request & {
+  cookies: {
+    siwe?: string;
+  };
+};
+
 function isHttps(req: Request) {
   return (
     req.protocol === 'https' || req.headers['x-forwarded-proto'] === 'https'
@@ -32,12 +39,12 @@ export class AuthController {
 
   @Post('verifyPayload')
   async verifyPayload(
-    @Req() req: Request,
+    @Req() req: RequestWithCookies,
     @Body() body: IRequestPayload,
     @Res() res: Response,
   ) {
     const { payload } = body;
-    const storedNonce = req.cookies?.siwe;
+    const storedNonce = req.cookies.siwe;
     if (!storedNonce) {
       return res.status(400).json({
         status: 'error',
@@ -51,11 +58,8 @@ export class AuthController {
         storedNonce,
       );
       return res.status(200).json({ isValid: validMessage });
-    } catch (error: any) {
-      console.log('Error verifying payload:', error);
-      return res
-        .status(400)
-        .json({ status: 'error', isValid: false, message: error.message });
+    } catch (error: unknown) {
+      return handleError(error);
     }
   }
 }

src/common/helpers.ts

@@ -0,0 +1,7 @@
+import { InternalServerErrorException } from '@nestjs/common';
+
+export function handleError(error: unknown): never {
+  const errorMessage =
+    error instanceof Error ? error.message : 'An unexpected error occurred';
+  throw new InternalServerErrorException(errorMessage);
+}

src/poll/poll.controller.ts

@@ -1,33 +1,33 @@
 import {
+  Body,
   Controller,
+  Delete,
   Get,
-  Post,
-  Body,
   Param,
-  Req,
+  Post,
   Query,
+  Req,
   Res,
-  Delete,
-  UsePipes,
-  ValidationPipe,
-  BadRequestException,
 } from '@nestjs/common';
 import { Response } from 'express';
-import { PollService } from './poll.service';
+import { handleError } from '../common/helpers';
 import { CreatePollDto, DeletePollDto, GetPollsDto } from './Poll.dto';
+import { PollService } from './poll.service';
 
 @Controller('poll')
 export class PollController {
   constructor(private readonly pollService: PollService) {}
 
   @Post()
-  @UsePipes(ValidationPipe)
-  create(@Body() createPollDto: CreatePollDto) {
-    return this.pollService.createPoll(createPollDto);
+  async createPoll(@Body() dto: CreatePollDto) {
+    try {
+      return await this.pollService.createPoll(dto);
+    } catch (error: unknown) {
+      return handleError(error);
+    }
   }
 
   @Get()
-  @UsePipes(ValidationPipe)
   async getPolls(
     @Req() req,
     @Query() query: GetPollsDto,
@@ -37,9 +37,7 @@ export class PollController {
       const polls = await this.pollService.getPolls(query);
       return res.status(200).json(polls);
     } catch (error: unknown) {
-      const errorMessage =
-        error instanceof Error ? error.message : 'An unexpected error occurred';
-      throw new BadRequestException(errorMessage);
+      return handleError(error);
     }
   }
 
@@ -48,14 +46,8 @@ export class PollController {
     try {
       const poll = await this.pollService.getPollDetails(Number(id));
       return res.status(200).json(poll);
-    } catch (error) {
-      if (error.message === 'Poll Id not found') {
-        return res.status(404).json({ message: error.message });
-      }
-
-      return res
-        .status(500)
-        .json({ message: 'Internal server error', error: error.message });
+    } catch (error: unknown) {
+      return handleError(error);
     }
   }
 
@@ -67,12 +59,9 @@ export class PollController {
   ) {
     try {
       const poll = await this.pollService.deletePoll(Number(id), query);
-
       return res.status(200).json({ message: 'Poll deleted', poll: poll });
     } catch (error: unknown) {
-      const errorMessage =
-        error instanceof Error ? error.message : 'An unexpected error occurred';
-      throw new BadRequestException(errorMessage);
+      return handleError(error);
     }
   }
 }

src/poll/poll.service.ts

@@ -1,6 +1,11 @@
 import { BadRequestException, Injectable } from '@nestjs/common';
-import { ActionType, Prisma } from '@prisma/client';
+import { ActionType } from '@prisma/client';
 import { DatabaseService } from 'src/database/database.service';
+import {
+  PollNotFoundException,
+  UnauthorizedActionException,
+  UserNotFoundException,
+} from '../common/exceptions';
 import { CreatePollDto, DeletePollDto, GetPollsDto } from './Poll.dto';
 
 @Injectable()
@@ -12,22 +17,18 @@ export class PollService {
       where: { worldID: createPollDto.worldID },
     });
     if (!user) {
-      throw new BadRequestException('User does not exist');
+      throw new UserNotFoundException();
     }
     const startDate = new Date(createPollDto.startDate);
     const endDate = new Date(createPollDto.endDate);
     const now = new Date();
-
     if (startDate < now) {
       throw new BadRequestException('Start date cannot be in the past');
     }
-
     if (endDate <= startDate) {
       throw new BadRequestException('End date must be after start date');
     }
-
     return this.databaseService.$transaction(async (tx) => {
-      // Create the poll
       const newPoll = await tx.poll.create({
         data: {
           authorUserId: user.id,
@@ -38,29 +39,28 @@ export class PollService {
           endDate,
           tags: createPollDto.tags || [],
           isAnonymous: createPollDto.isAnonymous || false,
-          voteResults: {}, // Initialize empty vote results
+          voteResults: {},
         },
       });
-
-      // Create user action for CREATED
       await tx.userAction.create({
         data: {
           userId: user.id,
           pollId: newPoll.pollId,
           type: ActionType.CREATED,
         },
       });
-
-      // Update user's pollsCreatedCount
+      const pollsCreatedCount = await tx.userAction.count({
+        where: {
+          userId: user.id,
+          type: ActionType.CREATED,
+        },
+      });
       await tx.user.update({
         where: { worldID: createPollDto.worldID },
         data: {
-          pollsCreatedCount: {
-            increment: 1,
-          },
+          pollsCreatedCount,
         },
       });
-
       return newPoll;
     });
   }
@@ -95,7 +95,7 @@ export class PollService {
       });
 
       if (!user) {
-        throw new Error('User not found');
+        throw new UserNotFoundException();
       }
       userId = user.id;
     } else if (userCreated || userVoted) {
@@ -154,48 +154,46 @@ export class PollService {
   async getPollDetails(id: number) {
     const poll = await this.databaseService.poll.findUnique({
       where: { pollId: id },
+      include: {
+        author: true,
+      },
     });
     if (!poll) {
-      throw new Error('Poll Id not found');
+      throw new PollNotFoundException();
     }
-    const user = await this.databaseService.user.findUnique({
-      where: { id: poll?.authorUserId },
-    });
     const now = new Date();
     const isActive = now >= poll.startDate && now <= poll.endDate;
-
-    return { user, poll, isActive };
+    const optionsTotalVotes = await this.getPollQuadraticResults(id);
+    const totalVotes = Object.values(optionsTotalVotes).reduce(
+      (acc, votes) => acc + votes,
+      0,
+    );
+    return { poll, isActive, optionsTotalVotes, totalVotes };
   }
 
   async deletePoll(pollId: number, query: DeletePollDto) {
     const user = await this.databaseService.user.findUnique({
       where: { worldID: query.worldID },
       select: { id: true },
     });
-
     if (!user) {
-      throw new Error('User not found');
+      throw new UserNotFoundException();
     }
-
     const poll = await this.databaseService.poll.findUnique({
       where: { pollId },
     });
-
     if (!poll) {
-      throw new Error('Poll not found');
+      throw new PollNotFoundException();
     }
     if (poll.authorUserId !== user.id) {
-      throw new Error('User Not Authorized');
+      throw new UnauthorizedActionException();
     }
-
     return this.databaseService.$transaction(async (tx) => {
       const deleted = await tx.poll.delete({
         where: {
           pollId,
         },
       });
-
-      // Update user's pollsCreatedCount
       await tx.user.update({
         where: { id: deleted.authorUserId },
         data: {
@@ -204,8 +202,40 @@ export class PollService {
           },
         },
       });
-
       return deleted;
     });
   }
+
+  async getPollQuadraticResults(
+    pollId: number,
+  ): Promise<Record<string, number>> {
+    const poll = await this.databaseService.poll.findUnique({
+      where: { pollId },
+      select: { options: true },
+    });
+    if (!poll) {
+      throw new PollNotFoundException();
+    }
+    const votes = await this.databaseService.vote.findMany({
+      where: { pollId },
+      select: { quadraticWeights: true },
+    });
+    const result: Record<string, number> = poll.options.reduce(
+      (acc, option) => {
+        acc[option] = 0;
+        return acc;
+      },
+      {} as Record<string, number>,
+    );
+    votes.forEach((vote) => {
+      if (vote.quadraticWeights) {
+        Object.entries(vote.quadraticWeights as Record<string, number>).forEach(
+          ([option, weight]) => {
+            result[option] = (result[option] || 0) + weight;
+          },
+        );
+      }
+    });
+    return result;
+  }
 }