Unify Logic in Image APIs

backend/src/API/coffeeChatImageAPI.ts

@@ -0,0 +1,23 @@
+import {
+  setImage,
+  getImage,
+  getAllImagesForMember,
+  deleteImage,
+  deleteAllImagesForMember
+} from '../utils/image-utils';
+
+export const setCoffeeChatProofImage = async (name: string): Promise<string> => setImage(name);
+
+export const getCoffeeChatProofImage = async (name: string): Promise<string> => getImage(name);
+
+export const allCoffeeChatProofImagesForMember = async (
+  user: IdolMember
+): Promise<readonly Image[]> => getAllImagesForMember(user, 'coffeeChatProofs');
+
+export const deleteCoffeeChatProofImage = async (name: string): Promise<void> => {
+  deleteImage(name);
+};
+
+export const deleteCoffeeChatProofImagesForMember = async (user: IdolMember): Promise<void> => {
+  deleteAllImagesForMember(user, 'coffeeChatProofs');
+};

backend/src/API/teamEventsImageAPI.ts

@@ -1,97 +1,22 @@
-import { bucket } from '../firebase';
-import { getNetIDFromEmail } from '../utils/memberUtil';
-import { NotFoundError } from '../utils/errors';
+import {
+  setImage,
+  getImage,
+  getAllImagesForMember,
+  deleteImage,
+  deleteAllImagesForMember
+} from '../utils/image-utils';
 
-/**
- * Sets TEC proof image for member
- * @param name - the name of the image
- * @param user - the member who made the request
- * @returns a Promise to the signed URL to the image file
- */
-export const setEventProofImage = async (name: string, user: IdolMember): Promise<string> => {
-  const file = bucket.file(`${name}.jpg`);
-  const signedURL = await file.getSignedUrl({
-    action: 'write',
-    version: 'v4',
-    expires: Date.now() + 15 * 60000 // 15 min
-  });
-  return signedURL[0];
-};
-
-/**
- * Gets TEC proof image for member
- * @param name - the name of the image
- * @param user - the member who made the request
- * @throws NotFoundError if the requested image does not exist
- * @returns a Promise to the signed URL to the image file
- */
-export const getEventProofImage = async (name: string, user: IdolMember): Promise<string> => {
-  const file = bucket.file(`${name}.jpg`);
-  const fileExists = await file.exists().then((result) => result[0]);
-  if (!fileExists) {
-    throw new NotFoundError(`The requested image (${name}) does not exist`);
-  }
-  const signedUrl = await file.getSignedUrl({
-    action: 'read',
-    expires: Date.now() + 15 * 60000
-  });
-  return signedUrl[0];
-};
+export const setEventProofImage = async (name: string): Promise<string> => setImage(name);
 
-/**
- * Gets all TEC proof images associated with the IdolMember
- * @param user - the member who made the request
- * @returns a Promise which results in an array of EventProofImage with file name and signed URL
- */
-export const allEventProofImagesForMember = async (
-  user: IdolMember
-): Promise<readonly EventProofImage[]> => {
-  const netId: string = getNetIDFromEmail(user.email);
-  const files = await bucket.getFiles({ prefix: `eventProofs/${netId}` });
-  const images = await Promise.all(
-    files[0].map(async (file) => {
-      const signedURL = await file.getSignedUrl({
-        action: 'read',
-        expires: Date.now() + 15 * 60000 // 15 min
-      });
-      const fileName = await file.getMetadata().then((data) => data[1].body.name);
-      return {
-        fileName,
-        url: signedURL[0]
-      };
-    })
-  );
+export const getEventProofImage = async (name: string): Promise<string> => getImage(name);
 
-  images
-    .filter((image) => image.fileName.length > 'eventProofs/'.length)
-    .map((image) => ({
-      ...image,
-      fileName: image.fileName.slice(image.fileName.indexOf('/') + 1)
-    }));
-
-  return images;
-};
+export const allEventProofImagesForMember = async (user: IdolMember): Promise<readonly Image[]> =>
+  getAllImagesForMember(user, 'eventProofs');
 
-/**
- * Deletes TEC proof image for member
- * @param name - the name of the image
- * @param user - the member who made the request
- */
-export const deleteEventProofImage = async (name: string, user: IdolMember): Promise<void> => {
-  const imageFile = bucket.file(`${name}.jpg`);
-  await imageFile.delete();
+export const deleteEventProofImage = async (name: string): Promise<void> => {
+  deleteImage(name);
 };
 
-/**
- * Deletes all TEC proof images for given member
- * @param user - the member who made the request
- */
 export const deleteEventProofImagesForMember = async (user: IdolMember): Promise<void> => {
-  const netId: string = getNetIDFromEmail(user.email);
-  const files = await bucket.getFiles({ prefix: `eventProofs/${netId}` });
-  Promise.all(
-    files[0].map(async (file) => {
-      file.delete();
-    })
-  );
+  deleteAllImagesForMember(user, 'eventProofs');
 };

backend/src/api.ts

@@ -91,6 +91,11 @@ import {
   regradeSubmissions,
   updateSubmissions
 } from './API/devPortfolioAPI';
+import {
+  getCoffeeChatProofImage,
+  setCoffeeChatProofImage,
+  deleteCoffeeChatProofImage
+} from './API/coffeeChatImageAPI';
 import DPSubmissionRequestLogDao from './dao/DPSubmissionRequestLogDao';
 import AdminsDao from './dao/AdminsDao';
 import { sendMail } from './API/mailAPI';
@@ -288,6 +293,7 @@ loginCheckedDelete('/shoutout/:uuid', async (req, user) => {
   return {};
 });
 
+// Coffee Chats
 loginCheckedGet('/coffee-chat', async () => ({
   coffeeChats: await getAllCoffeeChats()
 }));
@@ -315,6 +321,20 @@ loginCheckedPut('/coffee-chat', async (req, user) => ({
   coffeeChats: await updateCoffeeChat(req.body, user)
 }));
 
+// Coffee Chat Proof Image
+loginCheckedGet('/coffee-chat-proof-image/:name(*)', async (req) => ({
+  url: await getCoffeeChatProofImage(req.params.name)
+}));
+
+loginCheckedGet('/coffee-chat-proof-image-signed-url/:name(*)', async (req) => ({
+  url: await setCoffeeChatProofImage(req.params.name)
+}));
+
+loginCheckedDelete('/coffee-chat-proof-image/:name(*)', async (req) => {
+  await deleteCoffeeChatProofImage(req.params.name);
+  return {};
+});
+
 // Pull from IDOL
 loginCheckedPost('/pullIDOLChanges', (_, user) => requestIDOLPullDispatch(user));
 loginCheckedGet('/getIDOLChangesPR', (_, user) => getIDOLChangesPR(user));
@@ -382,16 +402,17 @@ loginCheckedPost('/team-event-reminder', async (req, user) => ({
 }));
 
 // Team Events Proof Image
-loginCheckedGet('/event-proof-image/:name(*)', async (req, user) => ({
-  url: await getEventProofImage(req.params.name, user)
+loginCheckedGet('/event-proof-image/:name(*)', async (req) => ({
+  url: await getEventProofImage(req.params.name)
 }));
 
 // TODO: Modify this endpoint to /event-proof-image/* to be more RESTful
-loginCheckedGet('/event-proof-image-signed-url/:name(*)', async (req, user) => ({
-  url: await setEventProofImage(req.params.name, user)
+loginCheckedGet('/event-proof-image-signed-url/:name(*)', async (req) => ({
+  url: await setEventProofImage(req.params.name)
 }));
-loginCheckedDelete('/event-proof-image/:name(*)', async (req, user) => {
-  await deleteEventProofImage(req.params.name, user);
+
+loginCheckedDelete('/event-proof-image/:name(*)', async (req) => {
+  await deleteEventProofImage(req.params.name);
   return {};
 });
 

backend/src/utils/image-utils.ts

@@ -0,0 +1,97 @@
+import { bucket } from '../firebase';
+import { getNetIDFromEmail } from './memberUtil';
+import { NotFoundError } from './errors';
+
+/**
+ * Sets image for member
+ * @param name - the name of the image
+ * @returns a Promise to the signed URL to the image file
+ */
+export const setImage = async (name: string): Promise<string> => {
+  const file = bucket.file(`${name}.jpg`);
+  const signedURL = await file.getSignedUrl({
+    action: 'write',
+    version: 'v4',
+    expires: Date.now() + 15 * 60000 // 15 min
+  });
+  return signedURL[0];
+};
+
+/**
+ * Gets image for member
+ * @param name - the name of the image
+ * @throws NotFoundError if the requested image does not exist
+ * @returns a Promise to the signed URL to the image file
+ */
+export const getImage = async (name: string): Promise<string> => {
+  const file = bucket.file(`${name}.jpg`);
+  const fileExists = await file.exists().then((result) => result[0]);
+  if (!fileExists) {
+    throw new NotFoundError(`The requested image (${name}) does not exist`);
+  }
+  const signedUrl = await file.getSignedUrl({
+    action: 'read',
+    expires: Date.now() + 15 * 60000
+  });
+  return signedUrl[0];
+};
+
+/**
+ * Gets all images associated with the IdolMember
+ * @param user - the member who made the request
+ * @param type - the type of image (ex: eventProof, coffeeChatProof)
+ * @returns a Promise which results in an array of ProofImage with file name and signed URL
+ */
+export const getAllImagesForMember = async (
+  user: IdolMember,
+  type: string
+): Promise<readonly Image[]> => {
+  const netId: string = getNetIDFromEmail(user.email);
+  const files = await bucket.getFiles({ prefix: `${type}/${netId}` });
+  const images = await Promise.all(
+    files[0].map(async (file) => {
+      const signedURL = await file.getSignedUrl({
+        action: 'read',
+        expires: Date.now() + 15 * 60000 // 15 min
+      });
+      const fileName = await file.getMetadata().then((data) => data[1].body.name);
+      return {
+        fileName,
+        url: signedURL[0]
+      };
+    })
+  );
+
+  images
+    .filter((image) => image.fileName.length > `${type}/`.length)
+    .map((image) => ({
+      ...image,
+      fileName: image.fileName.slice(image.fileName.indexOf('/') + 1)
+    }));
+
+  return images;
+};
+
+/**
+ * Deletes image for member
+ * @param name - the name of the image
+ */
+export const deleteImage = async (name: string): Promise<void> => {
+  const imageFile = bucket.file(`${name}.jpg`);
+  await imageFile.delete();
+};
+
+/**
+ * Deletes all images for given member
+ * @param user - the member who made the request
+ * @param type - the type of image (ex: eventProof, coffeeChatProof)
+ */
+export const deleteAllImagesForMember = async (user: IdolMember, type: string): Promise<void> => {
+  const netId: string = getNetIDFromEmail(user.email);
+  const files = await bucket.getFiles({ prefix: `${type}/${netId}` });
+  Promise.all(
+    files[0].map(async (file) => {
+      file.delete();
+    })
+  );
+};

common-types/index.d.ts

@@ -116,7 +116,7 @@ interface TeamEvent extends TeamEventInfo {
   readonly requests: TeamEventAttendance[];
 }
 
-interface EventProofImage {
+interface Image {
   readonly url: string;
   readonly fileName: string;
 }

frontend/src/API/ImagesAPI.ts

@@ -3,11 +3,8 @@ import APIWrapper from './APIWrapper';
 import HeadshotPlaceholder from '../static/images/headshot-placeholder.png';
 
 export default class ImagesAPI {
-  // member images
-  public static getMemberImage(email: string): Promise<string> {
-    const responseProm = APIWrapper.get(`${backendURL}/member-image/${email}`).then(
-      (res) => res.data
-    );
+  public static getImage(email: string, name: string): Promise<string> {
+    const responseProm = APIWrapper.get(`${backendURL}/${name}/${email}`).then((res) => res.data);
 
     return responseProm.then((val) => {
       if (val.error) {
@@ -17,48 +14,19 @@ export default class ImagesAPI {
     });
   }
 
-  private static getSignedURL(): Promise<string> {
-    const responseProm = APIWrapper.get(`${backendURL}/member-image-signedURL`).then(
-      (res) => res.data
-    );
+  private static getSignedURL(name: string): Promise<string> {
+    const responseProm = APIWrapper.get(`${backendURL}/${name}`).then((res) => res.data);
     return responseProm.then((val) => val.url);
   }
 
-  public static uploadMemberImage(body: Blob): Promise<void> {
-    return this.getSignedURL().then((url) => {
+  public static uploadImage(body: Blob, name: string): Promise<void> {
+    return this.getSignedURL(`${name}`).then((url) => {
       const headers = { 'content-type': 'image/jpeg' };
       APIWrapper.put(url, body, headers).then((res) => res.data);
     });
   }
 
-  // Event proof images
-  public static getEventProofImage(name: string): Promise<string> {
-    const responseProm = APIWrapper.get(`${backendURL}/event-proof-image/${name}`).then(
-      (res) => res.data
-    );
-    return responseProm.then((val) => {
-      if (val.error) {
-        return HeadshotPlaceholder.src;
-      }
-      return val.url;
-    });
-  }
-
-  private static getEventProofImageSignedURL(name: string): Promise<string> {
-    const responseProm = APIWrapper.get(`${backendURL}/event-proof-image-signed-url/${name}`).then(
-      (res) => res.data
-    );
-    return responseProm.then((val) => val.url);
-  }
-
-  public static uploadEventProofImage(body: Blob, name: string): Promise<void> {
-    return this.getEventProofImageSignedURL(name).then((url) => {
-      const headers = { 'content-type': 'image/jpeg' };
-      APIWrapper.put(url, body, headers).then((res) => res.data);
-    });
-  }
-
-  public static async deleteEventProofImage(name: string): Promise<void> {
-    await APIWrapper.delete(`${backendURL}/event-proof-image/${name}`);
+  public static async deleteImage(name: string): Promise<void> {
+    await APIWrapper.delete(`${backendURL}/${name}`);
   }
 }

frontend/src/components/Admin/TeamEvent/TeamEventCreditReview.tsx

@@ -18,7 +18,7 @@ const TeamEventCreditReview = (props: {
 
   useEffect(() => {
     setLoading(true);
-    ImagesAPI.getEventProofImage(teamEventAttendance.image).then((url: string) => {
+    ImagesAPI.getImage(teamEventAttendance.image, 'event-proof-image').then((url: string) => {
       setImage(url);
       setLoading(false);
     });
@@ -58,7 +58,7 @@ const TeamEventCreditReview = (props: {
           headerMsg: 'Team Event Attendance Rejected!',
           contentMsg: 'The team event attendance was successfully rejected!'
         });
-        ImagesAPI.deleteEventProofImage(teamEventAttendance.image);
+        ImagesAPI.deleteImage(`event-proof-image/${teamEventAttendance.image}`);
         Emitters.teamEventsUpdated.emit();
       })
       .catch((error) => {