Made changes based on comments on PR #44 and fixed circular dependency!

src/controllers/EventController.ts

@@ -1,4 +1,4 @@
-import { JsonController, Param, Get, Post, Delete, Body } from 'routing-controllers';
+import { JsonController, Param, Get, Post, Delete, Body, OnUndefined } from 'routing-controllers';
 import { singleton, inject } from 'tsyringe';
 import { ResponseSchema } from 'routing-controllers-openapi';
 
@@ -83,36 +83,49 @@ export class EventController {
   }
 
   @Post('/:eventID/signin')
-  @ResponseSchema(Attendance)
+  @OnUndefined(409)
   async signInToEvent(
     @Param('eventID') eventID: number,
     @Body() appUserRequest: EventSignInRequest
-  ): Promise<Attendance> {
+  ): Promise<Attendance | undefined> {
     const { email } = appUserRequest;
     const appUserFromEmail = await this.appUserService.getAppUserByEmail(email);
 
-    if (appUserFromEmail == undefined) {
+    if (appUserFromEmail === undefined) {
       const newAppUser = this.appUserMapper.requestToNewEntity(appUserRequest);
       const savedAppUser = await this.appUserService.saveAppUser(newAppUser);
-      await this.eventService.registerAttendance(eventID, savedAppUser);
+      const newAttendance = await this.eventService.registerForEventAttendance(
+        eventID,
+        savedAppUser
+      );
 
-      return null;
+      return newAttendance;
     } else {
       const { id, role } = appUserFromEmail;
 
-      if (role !== AppUserRole.GUEST) {
-        /*
-         * TODO: Handle the case where user is an affiliate
-         * If affiliated user has a token, then verify it and proceed. If said
-         * user does not have a token, then send back an HTTP error.
-         */
-      } else {
-        const updatedAppUser = await this.appUserMapper.requestToExistingEntity(appUserRequest, id);
-        const savedUpdatedUser = await this.appUserService.saveAppUser(updatedAppUser);
-        await this.eventService.registerAttendance(eventID, savedUpdatedUser);
-
-        return null;
+      if (!(await this.eventService.hasDuplicateAttendance(eventID, appUserFromEmail))) {
+        if (role !== AppUserRole.GUEST) {
+          /*
+           * TODO: Handle the case where user is an affiliate
+           * If affiliated user has a token, then verify it and proceed. If said
+           * user does not have a token, then send back an HTTP error.
+           */
+        } else {
+          const updatedAppUser = await this.appUserMapper.requestToExistingEntity(
+            appUserRequest,
+            id
+          );
+          const savedUpdatedUser = await this.appUserService.saveAppUser(updatedAppUser);
+          const newAttendance = await this.eventService.registerForEventAttendance(
+            eventID,
+            savedUpdatedUser
+          );
+
+          return newAttendance;
+        }
       }
+
+      return undefined;
     }
   }
 }

src/mappers/AppUserMapper.ts

@@ -42,9 +42,6 @@ export class AppUserMapper {
     appUserObj.id = appUserId;
 
     const appUser: AppUser = await this.appUserRepository.preload(appUserObj);
-    if (appUser == undefined) {
-      return undefined;
-    }
 
     return appUser;
   }

src/payloads/AppUser.ts

@@ -1,12 +1,11 @@
-import { IsInt, IsString, IsEmail, IsEnum } from 'class-validator';
-import { AppUserRole } from '@Entities';
+import { IsInt, IsString, IsEmail } from 'class-validator';
 
 export class AppUserPKPayload {
   @IsInt()
   readonly id: number;
 }
 
-abstract class BaseAppUserPayload {
+export class BaseAppUserPayload {
   @IsString()
   readonly firstName: string;
 
@@ -19,25 +18,3 @@ abstract class BaseAppUserPayload {
   @IsString()
   readonly major: string;
 }
-
-export class EventSignInRequest extends BaseAppUserPayload {}
-
-export class EventSignInResponse {
-  @IsInt()
-  id: number;
-
-  @IsString()
-  firstName: string;
-
-  @IsString()
-  lastName: string;
-
-  @IsEmail()
-  email: string;
-
-  @IsString()
-  major: string;
-
-  @IsEnum(AppUserRole)
-  role: string;
-}

src/payloads/Event.ts

@@ -10,8 +10,8 @@ import {
 } from 'class-validator';
 import { Type } from 'class-transformer';
 
-import { AppUser, EventType, EventStatus } from '@Entities';
-import { AppUserPKPayload } from '@Payloads';
+import { AppUser, AppUserRole, EventType, EventStatus } from '@Entities';
+import { AppUserPKPayload, BaseAppUserPayload } from './AppUser';
 
 abstract class BaseEventPayload {
   @IsString()
@@ -73,3 +73,13 @@ export class MultipleEventResponse {
   @Type(() => EventResponse)
   events: EventResponse[];
 }
+
+export class EventSignInRequest extends BaseAppUserPayload {}
+
+export class EventSignInResponse extends BaseAppUserPayload {
+  @IsInt()
+  id: number;
+
+  @IsEnum(AppUserRole)
+  role: string;
+}

src/payloads/index.ts

@@ -1,2 +1,8 @@
-export { EventRequest, EventResponse, MultipleEventResponse } from './Event';
-export { AppUserPKPayload, EventSignInRequest, EventSignInResponse } from './AppUser';
+export {
+  EventRequest,
+  EventResponse,
+  MultipleEventResponse,
+  EventSignInRequest,
+  EventSignInResponse,
+} from './Event';
+export { AppUserPKPayload, BaseAppUserPayload } from './AppUser';

src/services/AttendanceService.ts

@@ -12,13 +12,16 @@ export class AttendanceService {
     this.attendanceRepository = attendanceRepository;
   }
 
-  createAttendance(event: Event, attendee: AppUser): Attendance {
+  async registerAttendance(event: Event, attendee: AppUser): Promise<Attendance> {
     const { role } = attendee;
     const attendance = { event, attendee, isInductee: role === AppUserRole.INDUCTEE };
-    return this.attendanceRepository.create(attendance);
+    const newAttendance = this.attendanceRepository.create(attendance);
+    return this.attendanceRepository.save(newAttendance);
   }
 
-  async saveAttendance(attendance: Attendance): Promise<Attendance> {
-    return this.attendanceRepository.save(attendance);
+  async getAttendanceByEventUser(event: Event, attendee: AppUser): Promise<Attendance | undefined> {
+    const attendanceToCheck = await this.attendanceRepository.findOne({ event, attendee });
+
+    return attendanceToCheck;
   }
 }

src/services/EventService.ts

@@ -1,9 +1,9 @@
 import { Event, AppUser, Attendance } from '@Entities';
 import { EventRepositoryToken } from '@Repositories';
-import { AttendanceService } from '@Services';
+import { AttendanceService } from './AttendanceService';
 
 import { Repository } from 'typeorm';
-import { singleton, inject, delay } from 'tsyringe';
+import { singleton, inject } from 'tsyringe';
 
 @singleton()
 export class EventService {
@@ -12,7 +12,7 @@ export class EventService {
 
   constructor(
     @inject(EventRepositoryToken) eventRepository: Repository<Event>,
-    @inject(delay(() => AttendanceService)) attendanceService: AttendanceService
+    @inject(AttendanceService) attendanceService: AttendanceService
   ) {
     this.eventRepository = eventRepository;
     this.attendanceService = attendanceService;
@@ -65,11 +65,20 @@ export class EventService {
    * @param eventId
    * @param appUser
    */
-  async registerAttendance(eventId: number, appUser: AppUser): Promise<Attendance> {
+  async registerForEventAttendance(eventId: number, appUser: AppUser): Promise<Attendance> {
     const event = await this.eventRepository.findOne({ id: eventId });
-    const attendance = this.attendanceService.createAttendance(event, appUser);
-    const savedAttendance = await this.attendanceService.saveAttendance(attendance);
+    const newAttendance = await this.attendanceService.registerAttendance(event, appUser);
 
-    return savedAttendance;
+    return newAttendance;
+  }
+
+  async hasDuplicateAttendance(eventId: number, appUser: AppUser): Promise<Boolean | undefined> {
+    const event = await this.eventRepository.findOne({ id: eventId });
+    const possibleDuplicateAttendance = await this.attendanceService.getAttendanceByEventUser(
+      event,
+      appUser
+    );
+
+    return possibleDuplicateAttendance !== undefined;
   }
 }