feat: fully implement service features

interapp-backend/api/models/auth.ts

@@ -46,6 +46,7 @@ export class AuthModel {
     user.email = email;
     user.service_hours = 0;
     user.verified = false;
+    user.profile_picture = null;
 
     try {
       user.password_hash = await Bun.password.hash(password);

interapp-backend/api/models/service.ts

@@ -2,8 +2,9 @@ import { HTTPError, HTTPErrorCode } from '@utils/errors';
 import appDataSource from '@utils/init_datasource';
 import minioClient from '@utils/init_minio';
 import dataUrlToBuffer from '@utils/dataUrlToBuffer';
-import { Service, ServiceSession, ServiceSessionUser } from '@db/entities';
+import { AttendanceStatus, Service, ServiceSession, ServiceSessionUser } from '@db/entities';
 import { UserModel } from './user';
+import redisClient from '@utils/init_redis';
 
 export class ServiceModel {
   public static async createService(
@@ -79,19 +80,25 @@ export class ServiceModel {
     const service_ic = await UserModel.getUser(service.service_ic_username);
     if (!service.promotional_image) service.promotional_image = null;
     else {
-      const convertedFile = dataUrlToBuffer(service.promotional_image);
-      if (!convertedFile) {
-        throw new HTTPError(
-          'Invalid promotional image',
-          'Promotional image is not a valid data URL',
-          HTTPErrorCode.BAD_REQUEST_ERROR,
+      // why we do this:
+      // if promotional_image is a URL, then it is not changed
+      // if promotional_image is a data:image/gif...., then it is changed to a URL and dumped into minio
+      // in either case, service.promotional_image points to the location of the image in minio
+      if (service.promotional_image.startsWith('data:')) {
+        const convertedFile = dataUrlToBuffer(service.promotional_image);
+        if (!convertedFile) {
+          throw new HTTPError(
+            'Invalid promotional image',
+            'Promotional image is not a valid data URL',
+            HTTPErrorCode.BAD_REQUEST_ERROR,
+          );
+        }
+        await minioClient.putObject(
+          process.env.MINIO_BUCKETNAME as string,
+          'service/' + service.name,
+          convertedFile.buffer,
         );
       }
-      await minioClient.putObject(
-        process.env.MINIO_BUCKETNAME as string,
-        'service/' + service.name,
-        convertedFile.buffer,
-      );
       service.promotional_image = 'service/' + service.name;
     }
 
@@ -288,4 +295,114 @@ export class ServiceModel {
   public static async deleteServiceSessionUser(service_session_id: number, username: string) {
     await appDataSource.manager.delete(ServiceSessionUser, { service_session_id, username });
   }
+  public static async deleteServiceSessionUsers(service_session_id: number, usernames: string[]) {
+    await appDataSource.manager
+      .createQueryBuilder()
+      .delete()
+      .from(ServiceSessionUser)
+      .where('service_session_id = :service_session_id', { service_session_id })
+      .andWhere('username IN (:...usernames)', { usernames })
+      .execute();
+  }
+  public static async getAllServiceSessions(page?: number, perPage?: number, service_id?: number) {
+    const parseRes = (res: (Omit<ServiceSession, 'service'> & { service?: Service })[]) =>
+      res.map((session) => {
+        const service_name = session.service?.name;
+        delete session.service;
+        return { ...session, service_name };
+      });
+    const condition = service_id ? 'service_session.service_id = :service_id' : '1 = 1';
+
+    const total_entries = await appDataSource.manager
+      .createQueryBuilder()
+      .select('service_session')
+      .from(ServiceSession, 'service_session')
+      .where(condition, { service_id })
+      .getCount();
+
+    const res = await appDataSource.manager
+      .createQueryBuilder()
+      .select('service_session')
+      .from(ServiceSession, 'service_session')
+      .where(condition, { service_id })
+
+      .leftJoinAndSelect('service_session.service_session_users', 'service_session_users')
+      .leftJoin('service_session.service', 'service')
+      .addSelect('service.name')
+      .take(page && perPage ? perPage : undefined)
+      .skip(page && perPage ? (page - 1) * perPage : undefined)
+      .orderBy('service_session.start_time', 'DESC')
+      .getMany();
+
+    return { data: parseRes(res), total_entries, length_of_page: res.length };
+  }
+  public static async getActiveServiceSessions() {
+    const active = await redisClient.hGetAll('service_session');
+
+    if (Object.keys(active).length === 0) return [];
+
+    const ICs: {
+      username: string;
+      service_session_id: number;
+    }[] = await appDataSource.manager
+      .createQueryBuilder()
+      .select(['service_session_user.username', 'service_session_user.service_session_id'])
+      .from(ServiceSessionUser, 'service_session_user')
+      .where('service_session_id IN (:...service_session_ids)', {
+        service_session_ids: Object.values(active).map((v) => parseInt(v)),
+      })
+      .andWhere('service_session_user.is_ic = true')
+      .getMany();
+
+    // sort by service_session_id
+    const sortedICs = ICs.reduce(
+      (acc, cur) => {
+        acc[cur.service_session_id] = acc[cur.service_session_id] ?? [];
+        acc[cur.service_session_id].push(cur.username);
+        return acc;
+      },
+      {} as { [key: number]: string[] },
+    );
+
+    return Object.entries(active).map(([hash, id]) => ({
+      [hash]: {
+        service_session_id: parseInt(id),
+        ICs: sortedICs[parseInt(id)],
+      },
+    }));
+  }
+  public static async verifyAttendance(hash: string, username: string) {
+    const service_session_id = await redisClient.hGet('service_session', hash);
+    if (!service_session_id) {
+      throw new HTTPError(
+        'Invalid hash',
+        `Hash ${hash} is not a valid hash`,
+        HTTPErrorCode.BAD_REQUEST_ERROR,
+      );
+    }
+    const service_session_user = await this.getServiceSessionUser(
+      parseInt(service_session_id),
+      username,
+    );
+
+    if (service_session_user.attended === AttendanceStatus.Attended) {
+      throw new HTTPError(
+        'Already attended',
+        `User ${username} has already attended service session with service_session_id ${service_session_id}`,
+        HTTPErrorCode.CONFLICT_ERROR,
+      );
+    }
+    service_session_user.attended = AttendanceStatus.Attended;
+    await this.updateServiceSessionUser(service_session_user);
+    return service_session_user;
+  }
+  public static async getAdHocServiceSessions() {
+    const res = await appDataSource.manager
+      .createQueryBuilder()
+      .select('service_session')
+      .from(ServiceSession, 'service_session')
+      .where('service_session.ad_hoc_enabled = true')
+      .getMany();
+    return res;
+  }
 }

interapp-backend/api/models/user.ts

@@ -1,10 +1,19 @@
 import appDataSource from '@utils/init_datasource';
-import { User, UserPermission, UserService, Service } from '@db/entities';
+import {
+  User,
+  UserPermission,
+  UserService,
+  Service,
+  ServiceSessionUser,
+  ServiceSession,
+} from '@db/entities';
 import { HTTPError, HTTPErrorCode } from '@utils/errors';
 import { randomBytes } from 'crypto';
 import redisClient from '@utils/init_redis';
 import transporter from '@email_handler/index';
 import Mail from 'nodemailer/lib/mailer';
+import dataUrlToBuffer from '@utils/dataUrlToBuffer';
+import minioClient from '@utils/init_minio';
 
 interface EmailOptions extends Mail.Options {
   template: string;
@@ -31,7 +40,9 @@ export class UserModel {
   public static async deleteUser(username: string) {
     await appDataSource.manager.delete(User, { username });
   }
-  public static async getAllUsers() {
+  // the following function does not expose sensitive information
+  public static async getUserDetails(username?: string) {
+    const condition = username ? 'user.username = :username' : '1=1';
     const users = await appDataSource.manager
       .createQueryBuilder()
       .select([
@@ -40,9 +51,48 @@ export class UserModel {
         'user.verified',
         'user.user_id',
         'user.service_hours',
+        'user.profile_picture',
       ])
+      .where(condition, { username })
       .from(User, 'user')
       .getMany();
+
+    for (const user of users) {
+      if (user.profile_picture) {
+        const url = await minioClient.presignedGetObject(
+          process.env.MINIO_BUCKETNAME as string,
+          user.profile_picture,
+        );
+        user.profile_picture = url;
+      }
+    }
+
+    if (username) {
+      switch (users.length) {
+        case 0:
+          throw new HTTPError(
+            'User not found',
+            `The user with username ${username} was not found in the database`,
+            HTTPErrorCode.NOT_FOUND_ERROR,
+          );
+        case 1:
+          return users[0] as Omit<
+            User,
+            | 'password_hash'
+            | 'refresh_token'
+            | 'user_permissions'
+            | 'user_services'
+            | 'service_session_users'
+          >;
+        default:
+          throw new HTTPError(
+            'Multiple users found',
+            `Multiple users with username ${username} were found in the database`,
+            HTTPErrorCode.INTERNAL_SERVER_ERROR,
+          );
+      }
+    }
+
     return users as Omit<
       User,
       | 'password_hash'
@@ -351,6 +401,74 @@ export class UserModel {
       .where('service.service_id IN (:...services)', { services: service_ids })
       .getMany();
   }
+  public static async getAllServiceSessionsByUser(username: string) {
+    type getAllServiceSessionsByUserResult = Omit<ServiceSessionUser, 'service_session' | 'user'> &
+      {service_session: Pick<ServiceSession, 'start_time' | 'end_time' | 'service_id'> & {service: Pick<Service, 'name' | 'promotional_image'>}};
+
+    const serviceSessions = (await appDataSource.manager
+      .createQueryBuilder()
+      .select(['service_session_user'])
+      .from(ServiceSessionUser, 'service_session_user')
+      .where('service_session_user.username = :username', { username })
+      .leftJoin('service_session_user.service_session', 'service_session')
+      .addSelect([
+        'service_session.service_id',
+        'service_session.start_time',
+        'service_session.end_time',
+      ])
+      .leftJoin('service_session.service', 'service')
+      .addSelect(['service.name', 'service.promotional_image'])
+      .orderBy('service_session.start_time', 'DESC')
+      .getMany()) as unknown as getAllServiceSessionsByUserResult[];
+
+    if (!serviceSessions) {
+      throw new HTTPError(
+        'User not found',
+        `The user with username ${username} has no service sessions`,
+        HTTPErrorCode.NOT_FOUND_ERROR,
+      );
+    }
+
+    for (const session of serviceSessions) {
+      if (session.service_session.service.promotional_image) {
+        const url = await minioClient.presignedGetObject(
+          process.env.MINIO_BUCKETNAME as string,
+          session.service_session.service.promotional_image,
+        );
+        session.service_session.service.promotional_image = url;
+      }
+    }
+    let parsed: {
+      service_id: number;
+      start_time: string;
+      end_time: string;
+      name: string;
+      promotional_image?: string | null;
+      service_session_id: number;
+      username: string;
+      ad_hoc: boolean;
+      attended: string;
+      is_ic: boolean;
+      service_session?: any;
+
+    }[] = serviceSessions.map((session) => ({
+      ...session,
+      service_id: session.service_session.service_id,
+      start_time: session.service_session.start_time,
+      end_time: session.service_session.end_time,
+      name: session.service_session.service.name,
+      promotional_image: session.service_session.service.promotional_image,
+
+    }));
+
+    for (const sess of parsed) {
+      delete sess.service_session;
+    }
+
+
+
+    return parsed;
+  }
   public static async getAllUsersByService(service_id: number) {
     const service_users = await appDataSource
       .createQueryBuilder()
@@ -493,4 +611,57 @@ export class UserModel {
     user.service_hours = hours;
     await appDataSource.manager.update(User, { username }, user);
   }
+  public static async updateProfilePicture(username: string, profile_picture: string) {
+    const user = await appDataSource.manager
+      .createQueryBuilder()
+      .select(['user'])
+      .from(User, 'user')
+      .where('user.username = :username', { username })
+      .getOne();
+    if (!user)
+      throw new HTTPError(
+        'User not found',
+        `The user with username ${username} was not found in the database`,
+        HTTPErrorCode.NOT_FOUND_ERROR,
+      );
+    const converted = dataUrlToBuffer(profile_picture);
+
+    if (!converted)
+      throw new HTTPError(
+        'Invalid image',
+        'The image you provided is invalid',
+        HTTPErrorCode.BAD_REQUEST_ERROR,
+      );
+    await minioClient.putObject(
+      process.env.MINIO_BUCKETNAME as string,
+      `profile_pictures/${username}`,
+      converted.buffer,
+      { 'Content-Type': converted.mimetype },
+    );
+    user.profile_picture = `profile_pictures/${username}`;
+
+    await appDataSource.manager.update(User, { username }, user);
+  }
+  public static async deleteProfilePicture(username: string) {
+    const user = await appDataSource.manager
+      .createQueryBuilder()
+      .select(['user'])
+      .from(User, 'user')
+      .where('user.username = :username', { username })
+      .getOne();
+    if (!user)
+      throw new HTTPError(
+        'User not found',
+        `The user with username ${username} was not found in the database`,
+        HTTPErrorCode.NOT_FOUND_ERROR,
+      );
+
+    await minioClient.removeObject(
+      process.env.MINIO_BUCKETNAME as string,
+      `profile_pictures/${username}`,
+    );
+    user.profile_picture = null;
+
+    await appDataSource.manager.update(User, { username }, user);
+  }
 }