Merge branch 'master' of https://github.com/acmucsd/membership-portal …

…into feature/automate-database-migrations

merging from master

api/controllers/AttendanceController.ts

@@ -1,22 +1,26 @@
 import { JsonController, Get, Post, UseBefore, Params, ForbiddenError, Body } from 'routing-controllers';
+import EmailService from '../../services/EmailService';
 import { UserAuthentication } from '../middleware/UserAuthentication';
 import { AuthenticatedUser } from '../decorators/AuthenticatedUser';
-import { AttendEventRequest } from '../validators/AttendanceControllerRequests';
+import { AttendEventRequest, AttendViaExpressCheckinRequest } from '../validators/AttendanceControllerRequests';
 import { UserModel } from '../../models/UserModel';
 import AttendanceService from '../../services/AttendanceService';
 import PermissionsService from '../../services/PermissionsService';
 import { GetAttendancesForEventResponse, GetAttendancesForUserResponse, AttendEventResponse } from '../../types';
 import { UuidParam } from '../validators/GenericRequests';
 
-@UseBefore(UserAuthentication)
 @JsonController('/attendance')
 export class AttendanceController {
   private attendanceService: AttendanceService;
 
-  constructor(attendanceService: AttendanceService) {
+  private emailService: EmailService;
+
+  constructor(attendanceService: AttendanceService, emailService: EmailService) {
     this.attendanceService = attendanceService;
+    this.emailService = emailService;
   }
 
+  @UseBefore(UserAuthentication)
   @Get('/:uuid')
   async getAttendancesForEvent(@Params() params: UuidParam,
     @AuthenticatedUser() user: UserModel): Promise<GetAttendancesForEventResponse> {
@@ -25,12 +29,14 @@ export class AttendanceController {
     return { error: null, attendances };
   }
 
+  @UseBefore(UserAuthentication)
   @Get()
   async getAttendancesForCurrentUser(@AuthenticatedUser() user: UserModel): Promise<GetAttendancesForUserResponse> {
     const attendances = await this.attendanceService.getAttendancesForCurrentUser(user);
     return { error: null, attendances };
   }
 
+  @UseBefore(UserAuthentication)
   @Get('/user/:uuid')
   async getAttendancesForUser(@Params() params: UuidParam,
     @AuthenticatedUser() currentUser: UserModel): Promise<GetAttendancesForEventResponse> {
@@ -41,10 +47,20 @@ export class AttendanceController {
     return { error: null, attendances };
   }
 
+  @UseBefore(UserAuthentication)
   @Post()
   async attendEvent(@Body() body: AttendEventRequest,
     @AuthenticatedUser() user: UserModel): Promise<AttendEventResponse> {
     const { event } = await this.attendanceService.attendEvent(user, body.attendanceCode, body.asStaff);
     return { error: null, event };
   }
+
+  @Post('/expressCheckin')
+  async attendViaExpressCheckin(@Body() body: AttendViaExpressCheckinRequest): Promise<AttendEventResponse> {
+    body.email = body.email.toLowerCase();
+    const { email, attendanceCode } = body;
+    const { event } = await this.attendanceService.attendViaExpressCheckin(attendanceCode, email);
+    await this.emailService.sendExpressCheckinConfirmation(email, event.title, event.pointValue);
+    return { error: null, event };
+  }
 }

api/controllers/MerchStoreController.ts

@@ -20,6 +20,8 @@ import {
   GetAllMerchCollectionsResponse,
   CreateMerchCollectionResponse,
   EditMerchCollectionResponse,
+  CreateCollectionPhotoResponse,
+  DeleteCollectionPhotoResponse,
   GetOneMerchItemResponse,
   DeleteMerchCollectionResponse,
   CreateMerchItemResponse,
@@ -55,6 +57,7 @@ import MerchStoreService from '../../services/MerchStoreService';
 import {
   CreateMerchCollectionRequest,
   EditMerchCollectionRequest,
+  CreateCollectionPhotoRequest,
   CreateMerchItemRequest,
   EditMerchItemRequest,
   PlaceMerchOrderRequest,
@@ -124,6 +127,40 @@ export class MerchStoreController {
     return { error: null };
   }
 
+  @UseBefore(UserAuthentication)
+  @Post('/collection/picture/:uuid')
+  async createMerchCollectionPhoto(@UploadedFile('image',
+    { options: StorageService.getFileOptions(MediaType.MERCH_PHOTO) }) file: File,
+    @Params() params: UuidParam,
+    @Body() createCollectionRequest: CreateCollectionPhotoRequest,
+    @AuthenticatedUser() user: UserModel): Promise<CreateCollectionPhotoResponse> {
+    if (!PermissionsService.canEditMerchStore(user)) throw new ForbiddenError();
+
+    // generate a random string for the uploaded photo url
+    const position = parseInt(createCollectionRequest.position, 10);
+    if (Number.isNaN(position)) throw new BadRequestError('Position must be a number');
+    const uniqueFileName = uuid();
+    const uploadedPhoto = await this.storageService.uploadToFolder(
+      file, MediaType.MERCH_PHOTO, uniqueFileName, params.uuid,
+    );
+    const collectionPhoto = await this.merchStoreService.createCollectionPhoto(
+      params.uuid, { uploadedPhoto, position },
+    );
+
+    return { error: null, collectionPhoto };
+  }
+
+  @UseBefore(UserAuthentication)
+  @Delete('/collection/picture/:uuid')
+  async deleteMerchCollectionPhoto(@Params() params: UuidParam, @AuthenticatedUser() user: UserModel):
+  Promise<DeleteCollectionPhotoResponse> {
+    if (!PermissionsService.canEditMerchStore(user)) throw new ForbiddenError();
+    const photoToDelete = await this.merchStoreService.getCollectionPhotoForDeletion(params.uuid);
+    await this.storageService.deleteAtUrl(photoToDelete.uploadedPhoto);
+    await this.merchStoreService.deleteCollectionPhoto(photoToDelete);
+    return { error: null };
+  }
+
   @Get('/item/:uuid')
   async getOneMerchItem(@Params() params: UuidParam,
     @AuthenticatedUser() user: UserModel): Promise<GetOneMerchItemResponse> {

api/validators/AttendanceControllerRequests.ts

@@ -1,5 +1,8 @@
-import { IsDefined, IsNotEmpty, Allow } from 'class-validator';
-import { AttendEventRequest as IAttendEventRequest } from '../../types';
+import { IsDefined, IsNotEmpty, Allow, IsEmail } from 'class-validator';
+import {
+  AttendEventRequest as IAttendEventRequest,
+  AttendViaExpressCheckinRequest as IAttendViaExpressCheckinRequest,
+} from '../../types';
 
 export class AttendEventRequest implements IAttendEventRequest {
   @IsDefined()
@@ -9,3 +12,13 @@ export class AttendEventRequest implements IAttendEventRequest {
   @Allow()
   asStaff?: boolean;
 }
+
+export class AttendViaExpressCheckinRequest implements IAttendViaExpressCheckinRequest {
+  @IsDefined()
+  @IsNotEmpty()
+  attendanceCode: string;
+
+  @IsDefined()
+  @IsEmail()
+  email: string;
+}

api/validators/MerchStoreRequests.ts

@@ -17,6 +17,7 @@ import { Type } from 'class-transformer';
 import {
   CreateMerchCollectionRequest as ICreateMerchCollectionRequest,
   EditMerchCollectionRequest as IEditMerchCollectionRequest,
+  CreateCollectionPhotoRequest as ICreateCollectionPhotoRequest,
   CreateMerchItemRequest as ICreateMerchItemRequest,
   EditMerchItemRequest as IEditMerchItemRequest,
   CreateMerchItemOptionRequest as ICreateMerchItemOptionRequest,
@@ -32,6 +33,8 @@ import {
   OrderItemFulfillmentUpdate as IOrderItemFulfillmentUpdate,
   MerchCollection as IMerchCollection,
   MerchCollectionEdit as IMerchCollectionEdit,
+  MerchCollectionPhoto as IMerchCollectionPhoto,
+  MerchCollectionPhotoEdit as IMerchCollectionPhotoEdit,
   MerchItem as IMerchItem,
   MerchItemEdit as IMerchItemEdit,
   MerchItemOption as IMerchItemOption,
@@ -60,6 +63,9 @@ export class MerchCollection implements IMerchCollection {
 
   @Allow()
   archived?: boolean;
+
+  @Allow()
+  collectionPhotos: MerchCollectionPhoto[];
 }
 
 export class MerchCollectionEdit implements IMerchCollectionEdit {
@@ -78,6 +84,26 @@ export class MerchCollectionEdit implements IMerchCollectionEdit {
   @Min(0)
   @Max(100)
   discountPercentage?: number;
+
+  @Allow()
+  collectionPhotos?: MerchCollectionPhotoEdit[];
+}
+
+export class MerchCollectionPhoto implements IMerchCollectionPhoto {
+  @Allow()
+  uploadedPhoto: string;
+
+  @Allow()
+  position: number;
+}
+
+export class MerchCollectionPhotoEdit implements IMerchCollectionPhotoEdit {
+  @IsDefined()
+  @IsUUID()
+  uuid: string;
+
+  @Allow()
+  position: number;
 }
 
 export class MerchItemOptionMetadata implements IMerchItemOptionMetadata {
@@ -305,6 +331,12 @@ export class EditMerchCollectionRequest implements IEditMerchCollectionRequest {
   collection: MerchCollectionEdit;
 }
 
+export class CreateCollectionPhotoRequest implements ICreateCollectionPhotoRequest {
+  @IsDefined()
+  @IsNumberString()
+  position: string;
+}
+
 export class CreateMerchItemRequest implements ICreateMerchItemRequest {
   @Type(() => MerchItem)
   @ValidateNested()

config/index.ts

@@ -60,6 +60,7 @@ export const Config = {
     MAX_EVENT_COVER_FILE_SIZE: Number(process.env.MAX_EVENT_COVER_FILE_SIZE) * BYTES_PER_KILOBYTE,
     MAX_BANNER_FILE_SIZE: Number(process.env.MAX_BANNER_FILE_SIZE) * BYTES_PER_KILOBYTE,
     MAX_MERCH_PHOTO_FILE_SIZE: Number(process.env.MAX_MERCH_PHOTO_FILE_SIZE) * BYTES_PER_KILOBYTE,
+    MAX_COLLECTION_PHOTO_FILE_SIZE: Number(process.env.MAX_MERCH_PHOTO_FILE_SIZE) * BYTES_PER_KILOBYTE,
     MAX_RESUME_FILE_SIZE: Number(process.env.MAX_RESUME_FILE_SIZE) * BYTES_PER_KILOBYTE,
     PROFILE_PICTURE_UPLOAD_PATH: process.env.BASE_UPLOAD_PATH + process.env.PROFILE_PICTURE_UPLOAD_PATH,
     EVENT_COVER_UPLOAD_PATH: process.env.BASE_UPLOAD_PATH + process.env.EVENT_COVER_UPLOAD_PATH,

migrations/0039-add-collection-image-table.ts

@@ -0,0 +1,58 @@
+import { MigrationInterface, QueryRunner, Table, TableIndex } from 'typeorm';
+
+const TABLE_NAME = 'MerchCollectionPhotos';
+const COLLECTION_TABLE_NAME = 'MerchandiseCollections';
+
+export class AddCollectionImageTable1696990832868 implements MigrationInterface {
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.createTable(new Table({
+      name: TABLE_NAME,
+      columns: [
+        {
+          name: 'uuid',
+          type: 'uuid',
+          isGenerated: true,
+          isPrimary: true,
+          generationStrategy: 'uuid',
+        },
+        {
+          name: 'merchCollection',
+          type: 'uuid',
+        },
+        {
+          name: 'uploadedPhoto',
+          type: 'varchar(255)',
+        },
+        {
+          name: 'uploadedAt',
+          type: 'timestamptz',
+          default: 'CURRENT_TIMESTAMP(6)',
+        },
+        {
+          name: 'position',
+          type: 'integer',
+        },
+      ],
+      // cascade delete
+      foreignKeys: [
+        {
+          columnNames: ['merchCollection'],
+          referencedTableName: COLLECTION_TABLE_NAME,
+          referencedColumnNames: ['uuid'],
+          onDelete: 'CASCADE',
+        },
+      ],
+    }));
+
+    await queryRunner.createIndices(TABLE_NAME, [
+      new TableIndex({
+        name: 'images_by_collection_index',
+        columnNames: ['merchCollection'],
+      }),
+    ]);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.dropTable(TABLE_NAME);
+  }
+}

migrations/0041-add-expressCheckins-table.ts

@@ -0,0 +1,38 @@
+import { MigrationInterface, QueryRunner, Table } from 'typeorm';
+
+const TABLE_NAME = 'ExpressCheckins';
+
+export class AddExpressCheckinsTable1708807643314 implements MigrationInterface {
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.createTable(new Table({
+      name: TABLE_NAME,
+      columns: [
+        {
+          name: 'uuid',
+          type: 'uuid',
+          isPrimary: true,
+          isGenerated: true,
+          generationStrategy: 'uuid',
+        },
+        {
+          name: 'email',
+          type: 'varchar(255)',
+          isUnique: true,
+        },
+        {
+          name: 'event',
+          type: 'uuid',
+        },
+        {
+          name: 'timestamp',
+          type: 'timestamptz',
+          default: 'CURRENT_TIMESTAMP(6)',
+        },
+      ],
+    }));
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.dropTable(TABLE_NAME);
+  }
+}

models/EventModel.ts

@@ -2,6 +2,7 @@ import * as moment from 'moment';
 import { BaseEntity, Column, Entity, Index, PrimaryGeneratedColumn, OneToMany } from 'typeorm';
 import { PublicEvent, Uuid } from '../types';
 import { AttendanceModel } from './AttendanceModel';
+import { ExpressCheckinModel } from './ExpressCheckinModel';
 
 @Entity('Events')
 @Index('event_start_end_index', ['start', 'end'])
@@ -59,6 +60,9 @@ export class EventModel extends BaseEntity {
   @OneToMany((type) => AttendanceModel, (attendance) => attendance.event, { cascade: true })
   attendances: AttendanceModel[];
 
+  @OneToMany((type) => ExpressCheckinModel, (expressCheckin) => expressCheckin.event, { cascade: true })
+  expressCheckins: ExpressCheckinModel[];
+
   public getPublicEvent(canSeeAttendanceCode = false): PublicEvent {
     const publicEvent: PublicEvent = {
       uuid: this.uuid,

models/ExpressCheckinModel.ts

@@ -0,0 +1,28 @@
+import { BaseEntity, Column, Entity, Index, JoinColumn, ManyToOne, PrimaryGeneratedColumn } from 'typeorm';
+import { PublicExpressCheckin, Uuid } from '../types';
+import { EventModel } from './EventModel';
+
+@Entity('ExpressCheckins')
+export class ExpressCheckinModel extends BaseEntity {
+  @PrimaryGeneratedColumn('uuid')
+  uuid: Uuid;
+
+  @Column()
+  @Index({ unique: true })
+  email: string;
+
+  @ManyToOne((type) => EventModel, (event) => event.expressCheckins, { nullable: false })
+  @JoinColumn({ name: 'event' })
+  event: EventModel;
+
+  @Column('timestamptz', { default: () => 'CURRENT_TIMESTAMP(6)' })
+  timestamp: Date;
+
+  public getPublicExpressCheckin(): PublicExpressCheckin {
+    return {
+      email: this.email,
+      event: this.event.getPublicEvent(),
+      timestamp: this.timestamp,
+    };
+  }
+}