Merge pull request #56 from GeneralMagicio/add-user-endpoint

added createuser endpoint

Author: lovelgeorge99

src/poll/Poll.dto.ts

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

src/poll/poll.controller.ts

@@ -10,10 +10,11 @@ import {
   Delete,
   UsePipes,
   ValidationPipe,
+  BadRequestException,
 } from '@nestjs/common';
 import { Response } from 'express';
 import { PollService } from './poll.service';
-import { CreatePollDto, GetPollsDto } from './Poll.dto';
+import { CreatePollDto, DeletePollDto, GetPollsDto } from './Poll.dto';
 
 @Controller('poll')
 export class PollController {
@@ -22,15 +23,24 @@ export class PollController {
   @Post()
   @UsePipes(ValidationPipe)
   create(@Body() createPollDto: CreatePollDto) {
-    const userId = 1; // need to implement Auth
-    return this.pollService.createPoll(userId, createPollDto);
+    return this.pollService.createPoll(createPollDto);
   }
 
   @Get()
   @UsePipes(ValidationPipe)
-  getPolls(@Req() req, @Query() query: GetPollsDto) {
-    const userId = 1;
-    return this.pollService.getPolls(userId, query);
+  async getPolls(
+    @Req() req,
+    @Query() query: GetPollsDto,
+    @Res() res: Response,
+  ) {
+    try {
+      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);
+    }
   }
 
   @Get(':id')
@@ -50,16 +60,19 @@ export class PollController {
   }
 
   @Delete(':id')
-  async deletePoll(@Param('id') id: number, @Res() res: Response) {
-    const userId = 1; // need to implement Auth
+  async deletePoll(
+    @Param('id') id: number,
+    @Body() query: DeletePollDto,
+    @Res() res: Response,
+  ) {
     try {
-      const poll = await this.pollService.deletePoll(userId, Number(id));
+      const poll = await this.pollService.deletePoll(Number(id), query);
 
       return res.status(200).json({ message: 'Poll deleted', poll: poll });
-    } catch (error) {
-      return res
-        .status(500)
-        .json({ message: 'Internal server error', error: error.message });
+    } catch (error: unknown) {
+      const errorMessage =
+        error instanceof Error ? error.message : 'An unexpected error occurred';
+      throw new BadRequestException(errorMessage);
     }
   }
 }

src/poll/poll.service.ts

@@ -1,15 +1,15 @@
 import { BadRequestException, Injectable } from '@nestjs/common';
 import { ActionType, Prisma } from '@prisma/client';
 import { DatabaseService } from 'src/database/database.service';
-import { CreatePollDto, GetPollsDto } from './Poll.dto';
+import { CreatePollDto, DeletePollDto, GetPollsDto } from './Poll.dto';
 
 @Injectable()
 export class PollService {
   constructor(private readonly databaseService: DatabaseService) {}
 
-  async createPoll(userId: number, createPollDto: CreatePollDto) {
+  async createPoll(createPollDto: CreatePollDto) {
     const user = await this.databaseService.user.findUnique({
-      where: { id: userId },
+      where: { worldID: createPollDto.worldID },
     });
     if (!user) {
       throw new BadRequestException('User does not exist');
@@ -30,7 +30,7 @@ export class PollService {
       // Create the poll
       const newPoll = await tx.poll.create({
         data: {
-          authorUserId: userId,
+          authorUserId: user.id,
           title: createPollDto.title,
           description: createPollDto.description,
           options: createPollDto.options,
@@ -45,15 +45,15 @@ export class PollService {
       // Create user action for CREATED
       await tx.userAction.create({
         data: {
-          userId,
+          userId: user.id,
           pollId: newPoll.pollId,
           type: ActionType.CREATED,
         },
       });
 
       // Update user's pollsCreatedCount
       await tx.user.update({
-        where: { id: userId },
+        where: { worldID: createPollDto.worldID },
         data: {
           pollsCreatedCount: {
             increment: 1,
@@ -65,7 +65,7 @@ export class PollService {
     });
   }
 
-  async getPolls(userId: number, query: GetPollsDto) {
+  async getPolls(query: GetPollsDto) {
     const {
       page = 1,
       limit = 10,
@@ -78,10 +78,27 @@ export class PollService {
     const skip = (page - 1) * limit;
     const now = new Date();
     const filters: any = {};
+    let userId: number | undefined;
+
     if (isActive) {
       filters.startDate = { lte: now };
       filters.endDate = { gt: now };
     }
+
+    if ((userCreated || userVoted) && query.worldID) {
+      const user = await this.databaseService.user.findUnique({
+        where: { worldID: query.worldID },
+        select: { id: true },
+      });
+
+      if (!user) {
+        throw new Error('User not found');
+      }
+      userId = user.id;
+    } else if (userCreated || userVoted) {
+      throw new Error('worldId Not Provided');
+    }
+
     if (userCreated) {
       filters.authorUserId = userId;
     }
@@ -135,15 +152,24 @@ export class PollService {
     return { user, poll, isActive };
   }
 
-  async deletePoll(userId: number, pollId: number) {
+  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');
+    }
+
     const poll = await this.databaseService.poll.findUnique({
       where: { pollId },
     });
 
     if (!poll) {
       throw new Error('Poll not found');
     }
-    if (poll.authorUserId !== userId) {
+    if (poll.authorUserId !== user.id) {
       throw new Error('User Not Authorized');
     }
 

src/user/user.controller.ts

@@ -5,9 +5,13 @@ import {
   Get,
   Post,
   Query,
+  UsePipes,
+  ValidationPipe,
 } from '@nestjs/common';
 import { UserService } from './user.service';
 import {
+  CreateUserDto,
+  CreateUserResponseDto,
   EditVoteDto,
   EditVoteResponseDto,
   GetUserActivitiesDto,
@@ -84,4 +88,15 @@ export class UserController {
       throw new BadRequestException(errorMessage);
     }
   }
+
+  @Post('createUser')
+  async createUser(@Body() dto: CreateUserDto): Promise<CreateUserResponseDto> {
+    try {
+      return await this.userService.createUser(dto);
+    } catch (error: unknown) {
+      const errorMessage =
+        error instanceof Error ? error.message : 'An unexpected error occurred';
+      throw new BadRequestException(errorMessage);
+    }
+  }
 }

src/user/user.dto.ts

@@ -1,3 +1,5 @@
+import { IsNotEmpty, IsOptional, IsString } from 'class-validator';
+
 export class GetUserDataDto {
   worldID: string;
 }
@@ -61,3 +63,21 @@ export class EditVoteDto {
 export class EditVoteResponseDto {
   actionId: number;
 }
+
+export class CreateUserDto {
+  @IsString()
+  @IsNotEmpty()
+  name: string;
+
+  @IsString()
+  @IsNotEmpty()
+  worldID: string;
+
+  @IsString()
+  @IsOptional()
+  profilePicture?: string;
+}
+
+export class CreateUserResponseDto {
+  userId: number;
+}

src/user/user.service.ts

@@ -12,6 +12,8 @@ import {
   SetVoteResponseDto,
   EditVoteDto,
   EditVoteResponseDto,
+  CreateUserDto,
+  CreateUserResponseDto,
 } from './user.dto';
 import { ActionType } from '@prisma/client';
 
@@ -234,4 +236,31 @@ export class UserService {
       actionId: userAction.id,
     };
   }
+
+  async createUser(dto: CreateUserDto): Promise<CreateUserResponseDto> {
+    const existingUser = await this.databaseService.user.findUnique({
+      where: { worldID: dto.worldID },
+    });
+    if (existingUser) {
+      return {
+        userId: existingUser?.id,
+      };
+    }
+
+    const newUser = await this.databaseService.user.create({
+      data: {
+        name: dto.name,
+        worldID: dto.worldID,
+        profilePicture: dto.profilePicture || null,
+      },
+    });
+
+    if (!newUser) {
+      throw new Error('User not created');
+    }
+
+    return {
+      userId: newUser.id,
+    };
+  }
 }