Event sign in endpoint (Ready for review)

src/controllers/EventController.ts

@@ -2,21 +2,27 @@ import { JsonController, Param, Get, Post, Delete, Body } from 'routing-controll
 import { singleton, inject } from 'tsyringe';
 import { ResponseSchema } from 'routing-controllers-openapi';
 
-import { Event } from '@Entities';
-import { EventRequest, EventResponse, MultipleEventResponse } from '@Payloads';
-import { EventService } from '@Services';
-import { EventMapper } from '@Mappers';
+import { Event, AppUserRole, Attendance } from '@Entities';
+import { EventRequest, EventResponse, MultipleEventResponse, EventSignInRequest } from '@Payloads';
+import { AppUserService, EventService } from '@Services';
+import { AppUserMapper, EventMapper } from '@Mappers';
 
 @singleton()
 @JsonController('/api/events')
 export class EventController {
+  private appUserService: AppUserService;
+  private appUserMapper: AppUserMapper;
   private eventService: EventService;
   private eventMapper: EventMapper;
 
   constructor(
+    @inject(AppUserService) appUserService: AppUserService,
+    @inject(AppUserMapper) appUserMapper: AppUserMapper,
     @inject(EventService) eventService: EventService,
     @inject(EventMapper) eventMapper: EventMapper
   ) {
+    this.appUserService = appUserService;
+    this.appUserMapper = appUserMapper;
     this.eventService = eventService;
     this.eventMapper = eventMapper;
   }
@@ -75,4 +81,38 @@ export class EventController {
 
     return this.eventMapper.entityToResponse(deletedEvent);
   }
+
+  @Post('/:eventID/signin')
+  @ResponseSchema(Attendance)
+  async signInToEvent(
+    @Param('eventID') eventID: number,
+    @Body() appUserRequest: EventSignInRequest
+  ): Promise<Attendance> {
+    const { email } = appUserRequest;
+    const appUserFromEmail = await this.appUserService.getAppUserByEmail(email);
+
+    if (appUserFromEmail == undefined) {
+      const newAppUser = this.appUserMapper.requestToNewEntity(appUserRequest);
+      const savedAppUser = await this.appUserService.saveAppUser(newAppUser);
+      await this.eventService.registerAttendance(eventID, savedAppUser);
+
+      return null;
+    } 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;
+      }
+    }
+  }
 }

src/entities/AppUser.ts

@@ -7,6 +7,7 @@ export enum AppUserRole {
   OFFICER = 'officer',
   MEMBER = 'member',
   INDUCTEE = 'inductee',
+  GUEST = 'guest',
 }
 
 /**
@@ -41,7 +42,7 @@ export class AppUser {
   @Column({
     type: 'enum',
     enum: AppUserRole,
-    default: AppUserRole.INDUCTEE,
+    default: AppUserRole.GUEST,
   })
   role: string;
 }

src/entities/Attendance.ts

@@ -1,4 +1,4 @@
-import { Entity, Column, PrimaryGeneratedColumn, ManyToOne } from 'typeorm';
+import { Entity, Column, ManyToOne } from 'typeorm';
 import { AppUser } from './AppUser';
 import { Event } from './Event';
 
@@ -10,21 +10,18 @@ import { Event } from './Event';
  */
 @Entity()
 export class Attendance {
-  @PrimaryGeneratedColumn()
-  id: number;
-
-  @ManyToOne(() => AppUser)
+  @ManyToOne(() => AppUser, { primary: true })
   attendee: AppUser;
 
   // Officer who checked off attendee
   @ManyToOne(() => AppUser)
   officer: AppUser;
 
-  @ManyToOne(() => Event)
+  @ManyToOne(() => Event, { primary: true })
   event: Event;
 
   // num_hours
-  @Column('float')
+  @Column('float', { nullable: true })
   duration: number;
 
   // indicates whether or not attendee was inductee at time of attendance

src/entities/index.ts

@@ -1,4 +1,4 @@
-export { AppUser } from './AppUser';
+export { AppUser, AppUserRole } from './AppUser';
 export { Attendance } from './Attendance';
 export { Event, EventStatus, EventType } from './Event';
 export { InducteeStat } from './InducteeStat';

src/loaders/RepositoryLoader.ts

@@ -1,10 +1,25 @@
 import { container } from 'tsyringe';
-import { EventRepositoryToken, EventRepositoryFactory } from '@Repositories';
-import { Event } from '@Entities';
+import {
+  EventRepositoryToken,
+  EventRepositoryFactory,
+  AppUserRepositoryToken,
+  AppUserRepositoryFactory,
+  AttendanceRepositoryToken,
+  AttendanceRepositoryFactory,
+} from '@Repositories';
+import { Event, AppUser, Attendance } from '@Entities';
 import { Repository } from 'typeorm';
 
 export function loadRepositories(): void {
   container.register<Repository<Event>>(EventRepositoryToken, {
     useFactory: EventRepositoryFactory,
   });
+
+  container.register<Repository<AppUser>>(AppUserRepositoryToken, {
+    useFactory: AppUserRepositoryFactory,
+  });
+
+  container.register<Repository<Attendance>>(AttendanceRepositoryToken, {
+    useFactory: AttendanceRepositoryFactory,
+  });
 }

src/mappers/AppUserMapper.ts

@@ -0,0 +1,65 @@
+import { EventSignInRequest, EventSignInResponse } from '@Payloads';
+import { AppUser } from '@Entities';
+import { AppUserRepositoryToken } from '@Repositories';
+
+import { Repository } from 'typeorm';
+import { classToPlain, plainToClass } from 'class-transformer';
+import { singleton, inject } from 'tsyringe';
+
+@singleton()
+export class AppUserMapper {
+  private appUserRepository: Repository<AppUser>;
+
+  constructor(@inject(AppUserRepositoryToken) appUserRepository: Repository<AppUser>) {
+    this.appUserRepository = appUserRepository;
+  }
+
+  /**
+   * Converts an EventSignInRequest payload to an AppUser entity and
+   * returns the newly created entity to the caller.
+   *
+   * @param appUserRequest The request payload from which the AppUser entity
+   *                       is created.
+   */
+  requestToNewEntity(appUserRequest: EventSignInRequest): AppUser {
+    const plainAppUserRequest: Object = classToPlain(appUserRequest);
+    return this.appUserRepository.create(plainAppUserRequest);
+  }
+
+  /**
+   * Updates an existing AppUser entity with new data from the request payload.
+   * If there is no AppUser entity with the passed-in appUserId, then return undefined.
+   *
+   * @param appUserRequest The request payload from which the updated existing AppUser
+   *                       entity is created
+   * @param appUserId The supposed ID of an existing AppUser entity.
+   */
+  async requestToExistingEntity(
+    appUserRequest: EventSignInRequest,
+    appUserId: number
+  ): Promise<AppUser | undefined> {
+    const appUserObj: AppUser = appUserRequest as AppUser;
+    appUserObj.id = appUserId;
+
+    const appUser: AppUser = await this.appUserRepository.preload(appUserObj);
+    if (appUser == undefined) {
+      return undefined;
+    }
+
+    return appUser;
+  }
+
+  /**
+   * Converts an AppUser entity to an EventSignInResponse payload and returns the
+   * newly created response payload to the caller.
+   *
+   * @param appUser The AppUser entity to be converted to an EventSignInResponse
+   *                payload.
+   */
+  entityToResponse(appUser: AppUser): EventSignInResponse {
+    const plainAppUser: Object = classToPlain(appUser);
+    const appUserResponse: EventSignInResponse = plainToClass(EventSignInResponse, plainAppUser);
+
+    return appUserResponse;
+  }
+}

src/mappers/index.ts

@@ -1 +1,2 @@
 export { EventMapper } from './EventMapper';
+export { AppUserMapper } from './AppUserMapper';

src/payloads/AppUser.ts

@@ -1,6 +1,43 @@
-import { IsInt } from 'class-validator';
+import { IsInt, IsString, IsEmail, IsEnum } from 'class-validator';
+import { AppUserRole } from '@Entities';
 
 export class AppUserPKPayload {
   @IsInt()
   readonly id: number;
 }
+
+abstract class BaseAppUserPayload {
+  @IsString()
+  readonly firstName: string;
+
+  @IsString()
+  readonly lastName: string;
+
+  @IsEmail()
+  readonly email: string;
+
+  @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/index.ts

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

src/services/AppUserService.ts

@@ -10,6 +10,16 @@ export class AppUserService {
     this.appUserRepository = getRepository(AppUser);
   }
 
+  /**
+   * Stores the AppUser passed in as a parameter to the
+   * AppUser table.
+   *
+   * @param appUser The AppUser to be stored to the db.
+   */
+  async saveAppUser(appUser: AppUser): Promise<AppUser> {
+    return this.appUserRepository.save(appUser);
+  }
+
   /**
    * Get multiple app users.
    *
@@ -18,4 +28,14 @@ export class AppUserService {
   getMultipleAppUsers(ids: number[]): Promise<AppUser[]> {
     return this.appUserRepository.find({ id: Any(ids) });
   }
+
+  /**
+   * Get an existing AppUser by their email address.
+   *
+   * @param email The email used to look for the corresponding AppUser.
+   *
+   */
+  getAppUserByEmail(email: string): Promise<AppUser> {
+    return this.appUserRepository.findOne({ email });
+  }
 }

src/services/AttendanceService.ts

@@ -0,0 +1,24 @@
+import { Attendance, AppUser, AppUserRole, Event } from '@Entities';
+import { AttendanceRepositoryToken } from '@Repositories';
+
+import { Repository } from 'typeorm';
+import { singleton, inject } from 'tsyringe';
+
+@singleton()
+export class AttendanceService {
+  private attendanceRepository: Repository<Attendance>;
+
+  constructor(@inject(AttendanceRepositoryToken) attendanceRepository: Repository<Attendance>) {
+    this.attendanceRepository = attendanceRepository;
+  }
+
+  createAttendance(event: Event, attendee: AppUser): Attendance {
+    const { role } = attendee;
+    const attendance = { event, attendee, isInductee: role === AppUserRole.INDUCTEE };
+    return this.attendanceRepository.create(attendance);
+  }
+
+  async saveAttendance(attendance: Attendance): Promise<Attendance> {
+    return this.attendanceRepository.save(attendance);
+  }
+}

src/services/EventService.ts

@@ -1,15 +1,21 @@
-import { Event } from '@Entities';
+import { Event, AppUser, Attendance } from '@Entities';
 import { EventRepositoryToken } from '@Repositories';
+import { AttendanceService } from '@Services';
 
 import { Repository } from 'typeorm';
-import { singleton, inject } from 'tsyringe';
+import { singleton, inject, delay } from 'tsyringe';
 
 @singleton()
 export class EventService {
   private eventRepository: Repository<Event>;
+  private attendanceService: AttendanceService;
 
-  constructor(@inject(EventRepositoryToken) eventRepository: Repository<Event>) {
+  constructor(
+    @inject(EventRepositoryToken) eventRepository: Repository<Event>,
+    @inject(delay(() => AttendanceService)) attendanceService: AttendanceService
+  ) {
     this.eventRepository = eventRepository;
+    this.attendanceService = attendanceService;
   }
 
   /**
@@ -50,4 +56,20 @@ export class EventService {
     const event = await this.eventRepository.findOne({ id });
     return event ? this.eventRepository.remove(event) : undefined;
   }
+
+  /**
+   * Creates an Attendance entity using the event obtained from eventId and
+   * the passed-in AppUser entity, then stores that Attendance entity to the
+   * Attendance table.
+   *
+   * @param eventId
+   * @param appUser
+   */
+  async registerAttendance(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);
+
+    return savedAttendance;
+  }
 }

src/services/index.ts

@@ -1,2 +1,3 @@
 export { EventService } from './EventService';
 export { AppUserService } from './AppUserService';
+export { AttendanceService } from './AttendanceService';