Update getUser and create getApplication endpoint

apps/backend/src/app/app.module.ts

@@ -5,12 +5,13 @@ import { AppController } from './app.controller';
 import { AppService } from './app.service';
 import { UsersModule } from '../users/users.module';
 import { PluralNamingStrategy } from '../strategies/plural-naming.strategy';
+import { ApplicationsModule } from '../applications/applications.module';
 
 @Module({
   imports: [
     TypeOrmModule.forRoot({
       type: 'mongodb',
-      host: 'localhost',
+      host: '127.0.0.1',
       port: 27017,
       database: 'c4cOpsTest',
       // username: 'root',
@@ -22,6 +23,7 @@ import { PluralNamingStrategy } from '../strategies/plural-naming.strategy';
       namingStrategy: new PluralNamingStrategy(),
     }),
     UsersModule,
+    ApplicationsModule,
   ],
   controllers: [AppController],
   providers: [AppService],

apps/backend/src/applications/application.entity.ts

@@ -0,0 +1,39 @@
+import {
+  IsArray,
+  IsDateString,
+  IsEnum,
+  IsObject,
+  IsPositive,
+} from 'class-validator';
+import { Entity, Column } from 'typeorm';
+import { Response, Note, ApplicationStatus } from './types';
+import { Cycle } from './dto/cycle.dto';
+
+@Entity()
+export class Application {
+  @Column({ primary: true })
+  @IsPositive()
+  id: number;
+
+  @Column()
+  @IsDateString()
+  createdAt: Date;
+
+  @Column()
+  @IsObject()
+  cycle: Cycle;
+
+  @Column()
+  @IsEnum(ApplicationStatus)
+  status: ApplicationStatus;
+
+  @Column()
+  @IsArray()
+  @IsObject({ each: true })
+  application: Response[];
+
+  @Column()
+  @IsArray()
+  @IsObject({ each: true })
+  notes: Note[];
+}

apps/backend/src/applications/applications.controller.ts

@@ -0,0 +1,12 @@
+import { Controller, Get, ParseIntPipe, Param } from '@nestjs/common';
+import { ApplicationsService } from './applications.service';
+
+@Controller('apps')
+export class ApplicationsController {
+  constructor(private readonly applicationsService: ApplicationsService) {}
+
+  @Get('/:userId')
+  getApplication(@Param('userId', ParseIntPipe) userId: number) {
+    return this.applicationsService.findOne(userId);
+  }
+}

apps/backend/src/applications/applications.module.ts

@@ -0,0 +1,14 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { ApplicationsService } from './applications.service';
+import { ApplicationsController } from './applications.controller';
+import { Application } from './application.entity';
+import { UsersService } from '../users/users.service';
+import { User } from '../users/user.entity';
+
+@Module({
+  imports: [TypeOrmModule.forFeature([Application, User])],
+  providers: [ApplicationsService, UsersService],
+  controllers: [ApplicationsController],
+})
+export class ApplicationsModule {}

apps/backend/src/applications/applications.service.ts

@@ -0,0 +1,55 @@
+import {
+  BadRequestException,
+  Injectable,
+  UnauthorizedException,
+} from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { MongoRepository } from 'typeorm';
+import { UserStatus } from '../users/types';
+import { UsersService } from '../users/users.service';
+import { getCurrentUser } from '../users/utils';
+import { Application } from './application.entity';
+import { getCurrentCycle } from './utils';
+import { Cycle } from './dto/cycle.dto';
+import { plainToClass } from 'class-transformer';
+
+@Injectable()
+export class ApplicationsService {
+  constructor(
+    @InjectRepository(Application)
+    private applicationsRepository: MongoRepository<Application>,
+    private readonly usersService: UsersService,
+  ) {}
+
+  async findOne(userId: number): Promise<Application> {
+    const currentUser = getCurrentUser();
+    const currentStatus = currentUser.status;
+    switch (currentStatus) {
+      case UserStatus.ADMIN:
+      case UserStatus.RECRUITER:
+        break;
+      default:
+        if (currentUser.userId !== userId) {
+          throw new UnauthorizedException('User not found');
+        }
+        break;
+    }
+
+    const applicant = await this.usersService.findOne(userId);
+    const application = applicant.applications[0];
+    if (application == null) {
+      throw new BadRequestException('Application not found');
+    }
+
+    const cycle = plainToClass(Cycle, application.cycle);
+
+    //the user with the given userId has not applied in the current recruitment cycle
+    if (!cycle.isCurrentCycle(getCurrentCycle())) {
+      throw new BadRequestException(
+        "Applicant hasn't applied in the current cycle",
+      );
+    }
+
+    return application;
+  }
+}

apps/backend/src/applications/dto/cycle.dto.ts

@@ -0,0 +1,19 @@
+import { IsEnum, IsPositive } from 'class-validator';
+import { Semester } from '../types';
+
+export class Cycle {
+  @IsPositive()
+  year: number;
+
+  @IsEnum(Semester)
+  semester: Semester;
+
+  constructor(year: number, semester: Semester) {
+    this.year = year;
+    this.semester = semester;
+  }
+
+  public isCurrentCycle(cycle: Cycle): boolean {
+    return this.year === cycle.year && this.semester === cycle.semester;
+  }
+}

apps/backend/src/applications/types.ts

@@ -0,0 +1,21 @@
+export type Response = {
+  question: string;
+  answer: string;
+};
+
+export type Note = {
+  userId: number;
+  note: string;
+};
+
+export enum Semester {
+  FALL = 'FALL',
+  SPRING = 'SPRING',
+}
+
+export enum ApplicationStatus {
+  SUBMITTED = 'SUBMITTED',
+  REVIEWED = 'REVIEWED',
+  ACCEPTED = 'ACCEPTED',
+  REJECTED = 'REJECTED',
+}

apps/backend/src/applications/utils.ts

@@ -0,0 +1,4 @@
+import { Cycle } from './dto/cycle.dto';
+import { Semester } from './types';
+
+export const getCurrentCycle = () => new Cycle(2023, Semester.FALL);

apps/backend/src/users/dto/get-user-response.dto.ts

@@ -0,0 +1,54 @@
+import {
+  IsArray,
+  IsEmail,
+  IsEnum,
+  IsNumber,
+  IsString,
+  IsUrl,
+} from 'class-validator';
+import { Role, Team, UserStatus } from '../types';
+
+export class GetUserResponseDto {
+  @IsNumber()
+  userId: number;
+
+  @IsEnum(UserStatus)
+  status: UserStatus;
+
+  @IsString()
+  firstName: string;
+
+  @IsString()
+  lastName: string;
+
+  @IsEmail()
+  email: string;
+
+  // TODO make custom decorator for @IsUrl()s
+  @IsUrl({
+    protocols: ['https'],
+    require_protocol: true,
+  })
+  profilePicture: string | null;
+
+  @IsUrl({
+    protocols: ['https'],
+    require_protocol: true,
+    host_whitelist: ['www.linkedin.com'],
+  })
+  linkedin: string | null;
+
+  @IsUrl({
+    protocols: ['https'],
+    require_protocol: true,
+    host_whitelist: ['github.com'],
+  })
+  github: string | null;
+
+  @IsEnum(Team)
+  team: Team | null;
+
+  @IsArray()
+  @IsEnum(Role, { each: true })
+  role: Role[] | null;
+}

apps/backend/src/users/update-user.dto.ts → apps/backend/src/users/dto/update-user.dto.ts

@@ -1,4 +1,4 @@
-import { Status, Role, Team } from './types';
+import { UserStatus, Role, Team } from '../types';
 import {
   IsEmail,
   IsOptional,
@@ -11,14 +11,15 @@ import {
 
 export class UpdateUserDTO {
   @IsOptional()
-  @IsEnum(Status)
-  status?: Status;
+  @IsEnum(UserStatus)
+  status?: UserStatus;
 
   @IsOptional()
   @IsEmail()
   email?: string;
 
   @IsOptional()
+  @IsUrl()
   profilePicture?: string;
 
   @IsOptional()

apps/backend/src/users/types.ts

@@ -1,5 +1,6 @@
 // TODO: Probably want these types to be available to both the frontend and backend in a "common" folder
-export enum Status {
+
+export enum UserStatus {
   MEMBER = 'Member',
   RECRUITER = 'Recruiter',
   ADMIN = 'Admin',

apps/backend/src/users/user.entity.ts

@@ -1,35 +1,72 @@
+import {
+  IsArray,
+  IsEmail,
+  IsEnum,
+  IsObject,
+  IsPositive,
+  IsString,
+  IsUrl,
+} from 'class-validator';
 import { Entity, Column } from 'typeorm';
-import { Status, Role, Team } from './types';
+import { Application } from '../applications/application.entity';
+import { Role, Team, UserStatus } from './types';
 
 @Entity()
 export class User {
   @Column({ primary: true })
+  @IsPositive()
   userId: number;
 
   @Column()
-  status: Status;
+  @IsEnum(UserStatus)
+  status: UserStatus;
 
   @Column()
+  @IsString()
   firstName: string;
 
   @Column()
+  @IsString()
   lastName: string;
 
   @Column()
+  @IsEmail()
   email: string;
 
   @Column()
+  @IsUrl({
+    protocols: ['https'],
+    require_protocol: true,
+  })
   profilePicture: string | null;
 
   @Column()
+  @IsUrl({
+    protocols: ['https'],
+    require_protocol: true,
+    host_whitelist: ['www.linkedin.com'],
+  })
   linkedin: string | null;
 
   @Column()
+  @IsUrl({
+    protocols: ['https'],
+    require_protocol: true,
+    host_whitelist: ['github.com'],
+  })
   github: string | null;
 
   @Column()
+  @IsEnum(Team)
   team: Team | null;
 
   @Column()
+  @IsArray()
+  @IsEnum(Role, { each: true })
   role: Role[] | null;
+
+  @Column()
+  @IsArray()
+  @IsObject({ each: true })
+  applications: Application[];
 }

apps/backend/src/users/users.controller.ts

@@ -1,15 +1,15 @@
 import {
   DefaultValuePipe,
   ParseBoolPipe,
+  ParseIntPipe,
   Query,
   Body,
   Controller,
   Get,
   Param,
   Patch,
-  ParseIntPipe,
 } from '@nestjs/common';
-import { UpdateUserDTO } from './update-user.dto';
+import { UpdateUserDTO } from './dto/update-user.dto';
 import { UsersService } from './users.service';
 import { User } from './user.entity';
 
@@ -25,6 +25,11 @@ export class UsersController {
     return this.usersService.findAll(getAllMembers);
   }
 
+  @Get('/:userId')
+  getUser(@Param('userId', ParseIntPipe) userId: number) {
+    return this.usersService.findOne(userId);
+  }
+
   @Patch(':userId')
   async updateUser(
     @Body() updateUserDTO: UpdateUserDTO,