Event sign in endpoint (Ready for review)

src/controllers/EventController.ts

@@ -1,22 +1,28 @@
-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';
 
-import { Event } from '@Entities';
-import { EventRequest, EventResponse, MultipleEventResponse } from '@Payloads';
-import { EventService } from '@Services';
-import { EventMapper } from '@Mappers';
+import { Event, 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,25 @@ export class EventController {
 
     return this.eventMapper.entityToResponse(deletedEvent);
   }
+
+  @Post('/:eventID/signin')
+  @OnUndefined(409)
+  @ResponseSchema(Attendance)
+  async signInToEvent(
+    @Param('eventID') eventID: number,
+    @Body() appUserRequest: EventSignInRequest
+  ): Promise<Attendance | undefined> {
+    const appUserToSave = await this.appUserMapper.requestToEntityByEmail(appUserRequest);
+    const savedAppUser = await this.appUserService.saveNonAffiliate(appUserToSave);
+
+    if (savedAppUser === undefined) {
+      /*
+       * 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.
+       */
+    }
+
+    return await this.eventService.registerForEventAttendance(eventID, savedAppUser);
+  }
 }

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,81 @@
+import { EventSignInRequest, EventSignInResponse } from '@Payloads';
+import { AppUser } from '@Entities';
+import { AppUserService } from '@Services';
+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>;
+  private appUserService: AppUserService;
+
+  constructor(
+    @inject(AppUserRepositoryToken) appUserRepository: Repository<AppUser>,
+    @inject(AppUserService) appUserService: AppUserService
+  ) {
+    this.appUserRepository = appUserRepository;
+    this.appUserService = appUserService;
+  }
+
+  /**
+   * 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);
+
+    return appUser;
+  }
+
+  async requestToEntityByEmail(appUserRequest: EventSignInRequest): Promise<AppUser> {
+    const { email } = appUserRequest;
+    const appUserFromEmail = await this.appUserService.getAppUserByEmail(email);
+
+    if (appUserFromEmail === undefined) {
+      return this.requestToNewEntity(appUserRequest);
+    } else {
+      const { id } = appUserFromEmail;
+
+      return await this.requestToExistingEntity(appUserRequest, id);
+    }
+  }
+
+  /**
+   * 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,20 @@
-import { IsInt } from 'class-validator';
+import { IsInt, IsString, IsEmail } from 'class-validator';
 
 export class AppUserPKPayload {
   @IsInt()
   readonly id: number;
 }
+
+export class BaseAppUserPayload {
+  @IsString()
+  readonly firstName: string;
+
+  @IsString()
+  readonly lastName: string;
+
+  @IsEmail()
+  readonly email: string;
+
+  @IsString()
+  readonly major: 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 } from './AppUser';
+export {
+  EventRequest,
+  EventResponse,
+  MultipleEventResponse,
+  EventSignInRequest,
+  EventSignInResponse,
+} from './Event';
+export { AppUserPKPayload, BaseAppUserPayload } from './AppUser';

src/services/AppUserService.ts

@@ -1,5 +1,5 @@
-import { AppUser } from '@Entities';
-import { singleton } from 'tsyringe';
+import { AppUser, AppUserRole } from '@Entities';
+import { singleton, inject } from 'tsyringe';
 import { Any, Repository, getRepository } from 'typeorm';
 
 @singleton()
@@ -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 await this.appUserRepository.save(appUser);
+  }
+
   /**
    * Get multiple app users.
    *
@@ -18,4 +28,24 @@ 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 | undefined> {
+    return this.appUserRepository.findOne({ email });
+  }
+
+  async saveNonAffiliate(appUser: AppUser): Promise<AppUser | undefined> {
+    const { role } = appUser;
+
+    if (role !== undefined && role !== AppUserRole.GUEST) {
+      return undefined;
+    }
+
+    return await this.saveAppUser(appUser);
+  }
 }

src/services/AttendanceService.ts

@@ -0,0 +1,28 @@
+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;
+  }
+
+  async registerAttendance(event: Event, attendee: AppUser): Promise<Attendance | undefined> {
+    const { role } = attendee;
+    const attendance = { event, attendee, isInductee: role === AppUserRole.INDUCTEE };
+    const newAttendance = this.attendanceRepository.create(attendance);
+
+    try {
+      await this.attendanceRepository.insert(newAttendance);
+    } catch {
+      return undefined;
+    }
+
+    return newAttendance;
+  }
+}