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)

src/poll/poll.controller.ts

@@ -22,15 +22,29 @@ 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) {
+      if (error.message === 'User not found') {
+        return res.status(404).json({ message: error.message });
+      } else if (error.message === 'worldId Not Provided') {
+        return res.status(404).json({ message: error.message });
+      }
+      return res
+        .status(500)
+        .json({ message: 'Internal server error', error: error.message });
+    }
   }
 
   @Get(':id')

src/poll/poll.service.ts

@@ -7,9 +7,9 @@ import { CreatePollDto, GetPollsDto } from './Poll.dto';
 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;
     }

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;
 }
@@ -60,3 +62,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';
 
@@ -232,4 +234,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,
+    };
+  }
 }