Merge pull request #11 from GeneralMagicio/fix-schema-create-poll

fixed the schema and create create poll

Author: RamRamez

package.json

@@ -22,7 +22,10 @@
   "dependencies": {
     "@nestjs/common": "^11.0.1",
     "@nestjs/core": "^11.0.1",
+    "@nestjs/mapped-types": "*",
     "@nestjs/platform-express": "^11.0.1",
+    "@prisma/client": "^6.5.0",
+    "class-validator": "^0.14.1",
     "prisma": "^6.3.1",
     "reflect-metadata": "^0.2.2",
     "rxjs": "^7.8.1"

…ations/20250314191236_init/migration.sql …50322183108_changed_schema/migration.sqlprisma/migrations/20250314191236_init/migration.sql renamed to prisma/migrations/20250322183108_changed_schema/migration.sql prisma/migrations/20250314191236_init/migration.sql renamed to prisma/migrations/20250322183108_changed_schema/migration.sql

@@ -3,30 +3,31 @@ CREATE TYPE "ActionType" AS ENUM ('CREATED', 'VOTED');
 
 -- CreateTable
 CREATE TABLE "User" (
+    "id" SERIAL NOT NULL,
     "worldID" TEXT NOT NULL,
     "name" TEXT NOT NULL,
     "profilePicture" TEXT,
     "pollsCreatedCount" INTEGER NOT NULL DEFAULT 0,
     "pollsParticipatedCount" INTEGER NOT NULL DEFAULT 0,
 
-    CONSTRAINT "User_pkey" PRIMARY KEY ("worldID")
+    CONSTRAINT "User_pkey" PRIMARY KEY ("id")
 );
 
 -- CreateTable
 CREATE TABLE "UserAction" (
-    "id" TEXT NOT NULL,
-    "worldID" TEXT NOT NULL,
+    "id" SERIAL NOT NULL,
+    "userId" INTEGER NOT NULL,
     "actionID" TEXT NOT NULL,
-    "pollID" TEXT NOT NULL,
+    "pollId" INTEGER NOT NULL,
     "type" "ActionType" NOT NULL,
 
     CONSTRAINT "UserAction_pkey" PRIMARY KEY ("id")
 );
 
 -- CreateTable
 CREATE TABLE "Poll" (
-    "pollID" TEXT NOT NULL,
-    "authorUserID" TEXT NOT NULL,
+    "pollId" SERIAL NOT NULL,
+    "authorUserId" INTEGER NOT NULL,
     "title" TEXT NOT NULL,
     "description" TEXT,
     "options" TEXT[],
@@ -38,32 +39,38 @@ CREATE TABLE "Poll" (
     "participantCount" INTEGER NOT NULL DEFAULT 0,
     "voteResults" JSONB NOT NULL,
 
-    CONSTRAINT "Poll_pkey" PRIMARY KEY ("pollID")
+    CONSTRAINT "Poll_pkey" PRIMARY KEY ("pollId")
 );
 
 -- CreateTable
 CREATE TABLE "Vote" (
     "voteID" TEXT NOT NULL,
-    "worldID" TEXT NOT NULL,
-    "pollID" TEXT NOT NULL,
+    "userId" INTEGER NOT NULL,
+    "pollId" INTEGER NOT NULL,
     "votingPower" INTEGER NOT NULL,
     "weightDistribution" JSONB NOT NULL,
     "proof" TEXT NOT NULL,
 
     CONSTRAINT "Vote_pkey" PRIMARY KEY ("voteID")
 );
 
+-- CreateIndex
+CREATE UNIQUE INDEX "User_worldID_key" ON "User"("worldID");
+
 -- CreateIndex
 CREATE UNIQUE INDEX "UserAction_actionID_key" ON "UserAction"("actionID");
 
 -- AddForeignKey
-ALTER TABLE "UserAction" ADD CONSTRAINT "UserAction_worldID_fkey" FOREIGN KEY ("worldID") REFERENCES "User"("worldID") ON DELETE CASCADE ON UPDATE CASCADE;
+ALTER TABLE "UserAction" ADD CONSTRAINT "UserAction_userId_fkey" FOREIGN KEY ("userId") REFERENCES "User"("id") ON DELETE RESTRICT ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "UserAction" ADD CONSTRAINT "UserAction_pollId_fkey" FOREIGN KEY ("pollId") REFERENCES "Poll"("pollId") ON DELETE RESTRICT ON UPDATE CASCADE;
 
 -- AddForeignKey
-ALTER TABLE "Poll" ADD CONSTRAINT "Poll_authorUserID_fkey" FOREIGN KEY ("authorUserID") REFERENCES "User"("worldID") ON DELETE CASCADE ON UPDATE CASCADE;
+ALTER TABLE "Poll" ADD CONSTRAINT "Poll_authorUserId_fkey" FOREIGN KEY ("authorUserId") REFERENCES "User"("id") ON DELETE RESTRICT ON UPDATE CASCADE;
 
 -- AddForeignKey
-ALTER TABLE "Vote" ADD CONSTRAINT "Vote_worldID_fkey" FOREIGN KEY ("worldID") REFERENCES "User"("worldID") ON DELETE CASCADE ON UPDATE CASCADE;
+ALTER TABLE "Vote" ADD CONSTRAINT "Vote_userId_fkey" FOREIGN KEY ("userId") REFERENCES "User"("id") ON DELETE RESTRICT ON UPDATE CASCADE;
 
 -- AddForeignKey
-ALTER TABLE "Vote" ADD CONSTRAINT "Vote_pollID_fkey" FOREIGN KEY ("pollID") REFERENCES "Poll"("pollID") ON DELETE CASCADE ON UPDATE CASCADE;
+ALTER TABLE "Vote" ADD CONSTRAINT "Vote_pollId_fkey" FOREIGN KEY ("pollId") REFERENCES "Poll"("pollId") ON DELETE RESTRICT ON UPDATE CASCADE;

prisma/schema.prisma

@@ -15,7 +15,8 @@ datasource db {
 
 
 model User {
-  worldID                 String   @id
+  id                      Int   @id @default(autoincrement())
+  worldID                 String   @unique
   name                    String
   profilePicture          String?
   pollsCreatedCount       Int      @default(0)
@@ -26,40 +27,43 @@ model User {
 }
 
 model UserAction {
-  id        String   @id @default(uuid())
-  worldID   String
+  id        Int   @id @default(autoincrement())
+  userId   Int
   actionID  String   @unique
-  pollID    String
+  pollId  Int
   type      ActionType
-  user      User     @relation(fields: [worldID], references: [worldID], onDelete: Cascade)
+  user      User     @relation(fields: [userId], references: [id])
+  poll      Poll       @relation(fields: [pollId], references: [pollId])
+ 
 }
 
 model Poll {
-  pollID            String   @id @default(uuid())
-  authorUserID      String
+  pollId           Int   @id @default(autoincrement())
+  authorUserId     Int
   title            String
   description      String?
   options          String[]
   creationDate     DateTime @default(now())
   startDate        DateTime
-  endDate          DateTime
+  endDate          DateTime 
   tags             String[]
   isAnonymous      Boolean  @default(false)
   participantCount Int      @default(0)
   voteResults      Json
-  author          User      @relation("PollAuthor", fields: [authorUserID], references: [worldID], onDelete: Cascade)
+  author          User      @relation("PollAuthor", fields: [authorUserId], references: [id])
   votes           Vote[]
+  userAction       UserAction[]
 }
 
 model Vote {
   voteID            String   @id @default(uuid())
-  worldID           String
-  pollID            String
+  userId           Int
+  pollId            Int
   votingPower       Int
   weightDistribution Json
   proof             String
-  user             User     @relation(fields: [worldID], references: [worldID], onDelete: Cascade)
-  poll             Poll     @relation(fields: [pollID], references: [pollID], onDelete: Cascade)
+  user             User     @relation(fields: [userId], references: [id])
+  poll             Poll     @relation(fields: [pollId], references: [pollId])
 }
 
 enum ActionType {

src/app.module.ts

@@ -1,10 +1,13 @@
 import { Module } from '@nestjs/common';
 import { AppController } from './app.controller';
 import { AppService } from './app.service';
+import { DatabaseService } from './database/database.service';
+import { DatabaseModule } from './database/database.module';
+import { PollModule } from './poll/poll.module';
 
 @Module({
-  imports: [],
+  imports: [DatabaseModule, PollModule],
   controllers: [AppController],
-  providers: [AppService],
+  providers: [AppService, DatabaseService],
 })
 export class AppModule {}

src/database/database.module.ts

@@ -0,0 +1,9 @@
+import { Global, Module } from '@nestjs/common';
+import { DatabaseService } from './database.service';
+
+@Global()
+@Module({
+  providers: [DatabaseService],
+  exports: [DatabaseService],
+})
+export class DatabaseModule {}

src/database/database.service.ts

@@ -0,0 +1,11 @@
+import { Injectable, OnModuleInit } from '@nestjs/common';
+import { PrismaClient } from '@prisma/client';
+
+@Injectable()
+export class DatabaseService extends PrismaClient implements OnModuleInit {
+  async onModuleInit() {
+    await this.$connect()
+      .then(() => console.log('Connected to DB'))
+      .catch((err) => console.log('Error connecting to DB', err));
+  }
+}

src/poll/createPoll.dto.ts

@@ -0,0 +1,40 @@
+import {
+  IsArray,
+  IsBoolean,
+  IsDateString,
+  IsNotEmpty,
+  IsOptional,
+  IsString,
+} from 'class-validator';
+
+export class CreatePollDto {
+  @IsString()
+  @IsNotEmpty()
+  title: string;
+
+  @IsString()
+  @IsOptional()
+  description?: string;
+
+  @IsArray()
+  @IsString({ each: true })
+  @IsNotEmpty()
+  options: string[];
+
+  @IsDateString()
+  @IsNotEmpty()
+  startDate: string;
+
+  @IsDateString()
+  @IsNotEmpty()
+  endDate: string;
+
+  @IsArray()
+  @IsString({ each: true })
+  @IsOptional()
+  tags?: string[];
+
+  @IsBoolean()
+  @IsOptional()
+  isAnonymous?: boolean;
+}

src/poll/poll.controller.ts

@@ -0,0 +1,25 @@
+import { Controller, Get, Post, Body, Param, Delete } from '@nestjs/common';
+import { PollService } from './poll.service';
+import { Prisma } from '@prisma/client';
+import { CreatePollDto } from './createPoll.dto';
+
+@Controller('poll')
+export class PollController {
+  constructor(private readonly pollService: PollService) {}
+
+  @Post()
+  create(@Body() createPollDto: CreatePollDto) {
+    let userId = 1; // need to implement Auth
+    return this.pollService.createPoll(userId, createPollDto);
+  }
+
+  @Get()
+  getPolls() {
+    return this.pollService.getPolls();
+  }
+
+  @Get(':id')
+  getPollDetails(@Param('id') id: string) {
+    return this.pollService.getPollDetails(Number(id));
+  }
+}

src/poll/poll.module.ts

@@ -0,0 +1,9 @@
+import { Module } from '@nestjs/common';
+import { PollService } from './poll.service';
+import { PollController } from './poll.controller';
+
+@Module({
+  controllers: [PollController],
+  providers: [PollService],
+})
+export class PollModule {}

src/poll/poll.service.ts

@@ -0,0 +1,80 @@
+import { BadRequestException, Injectable } from '@nestjs/common';
+import { ActionType, Prisma } from '@prisma/client';
+import { DatabaseService } from 'src/database/database.service';
+import { CreatePollDto } from './createPoll.dto';
+
+@Injectable()
+export class PollService {
+  constructor(private readonly databaseService: DatabaseService) {}
+
+  async createPoll(userId: number, createPollDto: CreatePollDto) {
+    const user = await this.databaseService.user.findUnique({
+      where: { id: userId },
+    });
+    if (!user) {
+      throw new BadRequestException('User does not exist');
+    }
+    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: userId,
+          title: createPollDto.title,
+          description: createPollDto.description,
+          options: createPollDto.options,
+          startDate,
+          endDate,
+          tags: createPollDto.tags || [],
+          isAnonymous: createPollDto.isAnonymous || false,
+          voteResults: {}, // Initialize empty vote results
+        },
+      });
+
+      // Create user action for CREATED
+      await tx.userAction.create({
+        data: {
+          userId,
+          actionID: `created-${newPoll.pollId}-${userId}-${Date.now()}`,
+          pollId: newPoll.pollId,
+          type: ActionType.CREATED,
+        },
+      });
+
+      // Update user's pollsCreatedCount
+      await tx.user.update({
+        where: { id: userId },
+        data: {
+          pollsCreatedCount: {
+            increment: 1,
+          },
+        },
+      });
+
+      return newPoll;
+    });
+  }
+
+  async getPolls() {
+    return this.databaseService.poll.findMany({});
+  }
+
+  async getPollDetails(id: number) {
+    return this.databaseService.poll.findUnique({
+      where: {
+        pollId: id,
+      },
+    });
+  }
+}