created routes for user timetables

Author: sunny chen

server/src/user/types.ts

@@ -15,3 +15,11 @@ export class UserSettings {
   unscheduleClassesByDefault: boolean;
   hideExamClasses: boolean;
 }
+
+export class UserTimetable {
+  id: string;
+  name: string;
+  year: number;
+  term: string;
+  primary: boolean;
+}

server/src/user/user.controller.ts

@@ -1,4 +1,15 @@
-import { Body, Controller, Get, Post, Req, UseGuards } from '@nestjs/common';
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  Param,
+  Patch,
+  Post,
+  Query,
+  Req,
+  UseGuards,
+} from '@nestjs/common';
 import { UserService } from './user.service';
 import { AuthenticatedGuard } from 'src/auth/authenticated.guard';
 import { Request } from 'express';
@@ -49,4 +60,84 @@ export class UserController {
     await this.userService.setSettings(req.user.id, settings);
     return;
   }
+
+  @Get('timetables/:id')
+  @UseGuards(AuthenticatedGuard)
+  async getTimetable(
+    @Req() req: AuthenticatedRequest,
+    @Param('id') timetableId: string,
+  ) {
+    const timetable = await this.userService.getTimetable(
+      req.user.id,
+      timetableId,
+    );
+    return timetable;
+  }
+
+  @Get('timetables')
+  @UseGuards(AuthenticatedGuard)
+  async getUserTimetables(
+    @Req() req: AuthenticatedRequest,
+    @Query('year') year: string,
+    @Query('term') term: string,
+  ) {
+    const timetables = await this.userService.getUserTimetables(
+      req.user.id,
+      Number(year),
+      term,
+    );
+    return timetables;
+  }
+
+  @Post('timetables')
+  @UseGuards(AuthenticatedGuard)
+  async createTimetable(
+    @Req() req: AuthenticatedRequest,
+    @Body() data: { name: string; year: number; term: string },
+  ) {
+    const timetable = await this.userService.createTimetable(
+      req.user!.id,
+      data,
+    );
+    return timetable;
+  }
+
+  @Delete('timetables/:id')
+  @UseGuards(AuthenticatedGuard)
+  async deleteTimetable(
+    @Req() req: AuthenticatedRequest,
+    @Param('id') timetableId: string,
+    @Query('year') year: string,
+    @Query('term') term: string,
+  ) {
+    await this.userService.deleteTimetable(
+      req.user!.id,
+      timetableId,
+      Number(year),
+      term,
+    );
+    return;
+  }
+
+  @Patch('timetables/:id/rename')
+  @UseGuards(AuthenticatedGuard)
+  async renameTimetable(
+    @Req() req: AuthenticatedRequest,
+    @Param('id') timetableId: string,
+    @Body('name') newName: string,
+  ) {
+    await this.userService.renameTimetable(req.user!.id, timetableId, newName);
+    return;
+  }
+
+  @Patch('timetables/:id/change-primary')
+  @UseGuards(AuthenticatedGuard)
+  async makePrimary(
+    @Req() req: AuthenticatedRequest,
+    @Param('id') timetableId: string,
+    @Body() data: { year: number; term: string },
+  ) {
+    await this.userService.makePrimary(req.user!.id, timetableId, data);
+    return;
+  }
 }

server/src/user/user.service.ts

@@ -1,6 +1,10 @@
-import { Injectable } from '@nestjs/common';
+import {
+  ForbiddenException,
+  Injectable,
+  NotFoundException,
+} from '@nestjs/common';
 import { PrismaService } from 'src/prisma/prisma.service';
-import { UserInfo, UserSettings } from './types';
+import { UserInfo, UserSettings, UserTimetable } from './types';
 
 @Injectable({})
 export class UserService {
@@ -64,4 +68,171 @@ export class UserService {
       },
     });
   }
+
+  async getTimetable(
+    userId: string,
+    timetableId: string,
+  ): Promise<UserTimetable> {
+    const data = await this.prisma.timetable.findFirstOrThrow({
+      where: {
+        userId,
+        id: timetableId,
+      },
+    });
+
+    return {
+      id: data.id,
+      name: data.name,
+      year: data.year,
+      term: data.term,
+      primary: data.primary,
+    };
+  }
+
+  async getUserTimetables(
+    userId: string,
+    year: number,
+    term: string,
+  ): Promise<UserTimetable[]> {
+    const timetables = await this.prisma.timetable.findMany({
+      where: {
+        userId,
+        year,
+        term,
+      },
+      select: {
+        id: true,
+        name: true,
+        year: true,
+        term: true,
+        primary: true,
+      },
+    });
+
+    return timetables;
+  }
+
+  // get term timetable
+
+  async createTimetable(
+    userId: string,
+    data: { name: string; year: number; term: string },
+  ): Promise<string> {
+    // check if user has existing timetables
+    const numTimetables = await this.prisma.timetable.count({
+      where: {
+        userId,
+        year: data.year,
+        term: data.term,
+      },
+    });
+
+    // add timetable and return id from prisma
+    const timetable = await this.prisma.timetable.create({
+      data: {
+        userId,
+        name: data.name,
+        year: data.year,
+        term: data.term,
+        primary: numTimetables === 0,
+      },
+      select: {
+        id: true,
+      },
+    });
+
+    return timetable.id;
+  }
+
+  async deleteTimetable(
+    userId: string,
+    timetableId: string,
+    year: number,
+    term: string,
+  ): Promise<void> {
+    const numTimetables = await this.prisma.timetable.count({
+      where: {
+        userId,
+        year,
+        term,
+      },
+    });
+
+    if (numTimetables <= 1) {
+      throw new ForbiddenException('Cannot delete the last timetable.');
+    }
+
+    const timetable = await this.prisma.timetable.findFirst({
+      where: { id: timetableId, userId },
+    });
+
+    if (!timetable) {
+      throw new ForbiddenException('Timetable does not belong to this user.');
+    }
+
+    if (timetable.primary) {
+      throw new ForbiddenException('Cannot delete the primary timetable.');
+    }
+
+    await this.prisma.timetable.delete({
+      where: {
+        id: timetableId,
+      },
+    });
+  }
+
+  async renameTimetable(
+    userId: string,
+    timetableId: string,
+    newName: string,
+  ): Promise<void> {
+    await this.prisma.timetable.updateMany({
+      where: {
+        userId,
+        id: timetableId,
+      },
+      data: {
+        name: newName,
+      },
+    });
+  }
+
+  async makePrimary(
+    userId: string,
+    timetableId: string,
+    data: { year: number; term: string },
+  ): Promise<void> {
+    const timetable = await this.prisma.timetable.findFirst({
+      where: {
+        id: timetableId,
+        userId,
+      },
+    });
+
+    if (!timetable) {
+      throw new ForbiddenException('Timetable does not belong to this user.');
+    }
+
+    await this.prisma.$transaction([
+      this.prisma.timetable.updateMany({
+        where: {
+          userId,
+          primary: true,
+          year: data.year,
+          term: data.term,
+        },
+        data: {
+          primary: false,
+        },
+      }),
+      this.prisma.timetable.update({
+        where: {
+          id: timetableId,
+        },
+        data: {
+          primary: true,
+        },
+      }),
+    ]);
+  }
 }