Merge pull request #30 from GeneralMagicio/add-user-service

Add user service

Author: RamRamez

package.json

@@ -6,13 +6,15 @@
   "private": true,
   "license": "UNLICENSED",
   "scripts": {
-    "prebuild": "npx prisma generate",
+    "prebuild": "npx prisma generate && rm -rf dist",
     "build": "nest build",
     "format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
     "start": "nest start",
     "start:dev": "nest start --watch",
     "start:debug": "nest start --debug --watch",
     "start:prod": "node dist/main",
+    "migration:dev": "npx prisma migrate dev",
+    "migration:prod": "npx prisma migrate deploy",
     "lint": "eslint \"{src,apps,libs,test}/**/*.ts\" --fix",
     "test": "jest",
     "test:watch": "jest --watch",
@@ -31,7 +33,6 @@
     "rxjs": "^7.8.1"
   },
   "devDependencies": {
-    "prisma": "^6.5.0",
     "@eslint/eslintrc": "^3.2.0",
     "@eslint/js": "^9.18.0",
     "@nestjs/cli": "^11.0.0",
@@ -49,6 +50,7 @@
     "globals": "^15.14.0",
     "jest": "^29.7.0",
     "prettier": "^3.4.2",
+    "prisma": "^6.5.0",
     "source-map-support": "^0.5.21",
     "supertest": "^7.0.0",
     "ts-jest": "^29.2.5",

src/poll/poll.controller.ts

@@ -20,7 +20,7 @@ export class PollController {
 
   @Post()
   create(@Body() createPollDto: CreatePollDto) {
-    let userId = 1; // need to implement Auth
+    const userId = 1; // need to implement Auth
     return this.pollService.createPoll(userId, createPollDto);
   }
 

src/user/user.controller.ts

@@ -0,0 +1,36 @@
+import { Body, Controller, Get, Post, Query } from '@nestjs/common';
+import { UserService } from './user.service';
+import {
+  GetUserActivitiesDto,
+  GetUserDataDto,
+  GetUserVotesDto,
+  UserActivitiesResponseDto,
+  UserDataResponseDto,
+  UserVotesResponseDto,
+} from './user.dto';
+
+@Controller('user')
+export class UserController {
+  constructor(private readonly userService: UserService) {}
+
+  @Get('getUserData')
+  async getUserData(
+    @Query() query: GetUserDataDto,
+  ): Promise<UserDataResponseDto> {
+    return this.userService.getUserData(query);
+  }
+
+  @Get('getUserActivities')
+  async getUserActivities(
+    @Query() query: GetUserActivitiesDto,
+  ): Promise<UserActivitiesResponseDto> {
+    return this.userService.getUserActivities(query);
+  }
+
+  @Post('getUserVotes')
+  async getUserVotes(
+    @Body() body: GetUserVotesDto,
+  ): Promise<UserVotesResponseDto> {
+    return this.userService.getUserVotes(body);
+  }
+}

src/user/user.dto.ts

@@ -0,0 +1,39 @@
+export class GetUserDataDto {
+  worldID: string;
+}
+
+export class UserDataResponseDto {
+  pollsCreated: number;
+  pollsParticipated: number;
+  worldID: string;
+}
+
+export class GetUserActivitiesDto {
+  worldID: string;
+  filter?: 'active' | 'inactive' | 'created' | 'participated';
+}
+
+export class UserActionDto {
+  type: 'created' | 'voted';
+  pollId: number;
+  pollTitle: string;
+  pollDescription: string;
+  endDate: Date;
+  votersParticipated: number;
+  authorUserId: number;
+}
+
+export class UserActivitiesResponseDto {
+  userActions: UserActionDto[];
+}
+
+export class GetUserVotesDto {
+  pollID: number;
+  worldID: string;
+}
+
+export class UserVotesResponseDto {
+  options: string[];
+  votingPower: number;
+  weightDistribution?: Record<string, number>;
+}

src/user/user.service.ts

@@ -0,0 +1,131 @@
+// src/user/user.service.ts
+import { Injectable } from '@nestjs/common';
+import { DatabaseService } from '../database/database.service';
+import {
+  GetUserActivitiesDto,
+  GetUserDataDto,
+  UserDataResponseDto,
+  UserActivitiesResponseDto,
+  UserActionDto,
+  GetUserVotesDto,
+  UserVotesResponseDto,
+} from './user.dto';
+
+type UserActionFilters = {
+  userId: number;
+  type?: 'CREATED' | 'VOTED';
+  poll?: {
+    endDate?: {
+      gte?: Date;
+      lt?: Date;
+    };
+  };
+};
+
+@Injectable()
+export class UserService {
+  constructor(private readonly databaseService: DatabaseService) {}
+
+  async getUserData(dto: GetUserDataDto): Promise<UserDataResponseDto> {
+    const user = await this.databaseService.user.findUnique({
+      where: { worldID: dto.worldID },
+      select: {
+        pollsCreatedCount: true,
+        pollsParticipatedCount: true,
+        worldID: true,
+      },
+    });
+    if (!user) {
+      throw new Error('User not found');
+    }
+    return {
+      pollsCreated: user.pollsCreatedCount,
+      pollsParticipated: user.pollsParticipatedCount,
+      worldID: user.worldID,
+    };
+  }
+
+  async getUserActivities(
+    dto: GetUserActivitiesDto,
+  ): Promise<UserActivitiesResponseDto> {
+    const user = await this.databaseService.user.findUnique({
+      where: { worldID: dto.worldID },
+      select: { id: true },
+    });
+    if (!user) {
+      throw new Error('User not found');
+    }
+    const filters: UserActionFilters = { userId: user.id };
+    const now = new Date();
+    if (dto.filter === 'active') {
+      filters.poll = { endDate: { gte: now } };
+    } else if (dto.filter === 'inactive') {
+      filters.poll = { endDate: { lt: now } };
+    } else if (dto.filter === 'created') {
+      filters.type = 'CREATED';
+    } else if (dto.filter === 'participated') {
+      filters.type = 'VOTED';
+    }
+    const userActions = await this.databaseService.userAction.findMany({
+      where: filters,
+      orderBy: { poll: { endDate: 'desc' } },
+      select: {
+        type: true,
+        poll: {
+          select: {
+            pollId: true,
+            title: true,
+            description: true,
+            endDate: true,
+            participantCount: true,
+            authorUserId: true,
+          },
+        },
+      },
+    });
+    const actions: UserActionDto[] = userActions.map((action) => ({
+      type: action.type.toLowerCase() as 'created' | 'voted',
+      pollId: action.poll.pollId,
+      pollTitle: action.poll.title,
+      pollDescription: action.poll.description ?? '',
+      endDate: action.poll.endDate,
+      isActive: action.poll.endDate >= now,
+      votersParticipated: action.poll.participantCount,
+      authorUserId: action.poll.authorUserId,
+    }));
+    return { userActions: actions };
+  }
+
+  async getUserVotes(dto: GetUserVotesDto): Promise<UserVotesResponseDto> {
+    const user = await this.databaseService.user.findUnique({
+      where: { worldID: dto.worldID },
+      select: { id: true },
+    });
+    if (!user) {
+      throw new Error('User not found');
+    }
+    const poll = await this.databaseService.poll.findUnique({
+      where: { pollId: dto.pollID },
+      select: { endDate: true, options: true },
+    });
+    if (!poll || poll.endDate < new Date()) {
+      throw new Error('Poll is not active or does not exist');
+    }
+    const votes = await this.databaseService.vote.findMany({
+      where: {
+        pollId: dto.pollID,
+        userId: user.id,
+      },
+      select: { votingPower: true, weightDistribution: true },
+    });
+    if (votes.length === 0) {
+      throw new Error('Vote not found for the given poll and user');
+    }
+    const vote = votes[0];
+    return {
+      options: poll.options,
+      votingPower: vote.votingPower,
+      weightDistribution: vote.weightDistribution as Record<string, number>,
+    };
+  }
+}