Add total hours sheet tracking for signing out and amending hours

Team4159 · May 12, 2024 · b9b665c · b9b665c
1 parent f10ef4b
commit b9b665c
Show file tree

Hide file tree

Showing 9 changed files with 97 additions and 105 deletions.
diff --git a/src/api/routes/users.ts b/src/api/routes/users.ts
@@ -1,9 +1,17 @@
 import express from "express";
 
 import User, { getUserByPassword, updateUser } from "../../models/User.model";
-import { createSession, deleteSessionBySessionId, doesSessionExist, getSessionBySessionId, getSessionsByUserId, updateSession } from "../../models/Session.model";
+import {
+    createSession,
+    deleteSessionBySessionId,
+    doesSessionExist,
+    getSessionBySessionId,
+    getSessionsByUserId,
+    updateSession,
+} from "../../models/Session.model";
 import Time, { isOverlappingPreviousTimes } from "../../utils/time";
 import { InvalidTimeError, RowNotFoundError } from "../../utils/errors";
+import { addSingleSessionToSpreadsheet } from "../../utils/spreadsheet-hours";
 
 const router = express.Router();
 
@@ -98,9 +106,7 @@ router.post("/session", async (req, res) => {
     let previousSessionTimes: Time[] = [];
 
     for (const session of previousSessions) {
-        previousSessionTimes.push(
-            new Time(session.start_time, session.end_time)
-        );
+        previousSessionTimes.push(new Time(session.start_time, session.end_time));
     }
 
     if (isOverlappingPreviousTimes(newSessionTime, previousSessionTimes)) {
@@ -109,12 +115,9 @@ router.post("/session", async (req, res) => {
         });
     }
 
-    await createSession(
-        user.user_id,
-        req.body.start_time,
-        req.body.end_time,
-        true
-    );
+    const session = await createSession(user.user_id, req.body.start_time, req.body.end_time, true);
+
+    await addSingleSessionToSpreadsheet(user, session);
 
     return res.status(200).json({
         description: "Amended new session!",
@@ -152,9 +155,7 @@ router.patch("/session", async (req, res) => {
             continue;
         }
 
-        previousSessionTimes.push(
-            new Time(session.start_time, session.end_time)
-        );
+        previousSessionTimes.push(new Time(session.start_time, session.end_time));
     }
 
     if (isOverlappingPreviousTimes(editedSessionTime, previousSessionTimes)) {
@@ -194,10 +195,11 @@ router.delete("/session", async (req, res) => {
 
     const deleted = await deleteSessionBySessionId(req.body.session_id);
 
-    if (!deleted) { // Should never happen
+    if (!deleted) {
+        // Should never happen
         return res.status(500).json({
             description: "Could not delete session!",
-        })
+        });
     }
 
     return res.status(200).json({

diff --git a/src/integration-tests/info-routes.spec.ts b/src/integration-tests/info-routes.spec.ts
@@ -34,7 +34,7 @@ describe("Info Routes", () => {
                         description: "Returning all users!",
                         users: structuredClone(fakeUsers).map((user: Partial<User>) => {
                             delete user.password;
-                            user.signed_in = (user.signed_in) ? 1 : 0 as any;
+                            user.signed_in = user.signed_in ? 1 : (0 as any);
                             return user;
                         }),
                     })
@@ -51,7 +51,7 @@ describe("Info Routes", () => {
             it("should return user data given valid user ID", (done) => {
                 const user: Partial<User> = structuredClone(fakeUsers[16]); // Random user
                 delete user.password;
-                user.signed_in = (user.signed_in) ? 1 : 0 as any;
+                user.signed_in = user.signed_in ? 1 : (0 as any);
 
                 request(app)
                     .get(`/api/v1/info/users/${user.user_id}`)

diff --git a/src/integration-tests/users-routes.spec.ts b/src/integration-tests/users-routes.spec.ts
@@ -411,6 +411,7 @@ describe("User Routes", () => { // TODO: make each api request into a helper fun
                 let startTime;
                 let endTime;
 
+                // Creates a valid session
                 outer: for (const fakeUser of fakeUsers) { // TODO: Turn into helper function
                     let sessions = fakeSessions.filter((session: Session) => session.user_id === fakeUser.user_id);
                     let lastSession = sessions[0];

diff --git a/src/models/Config.model.ts b/src/models/Config.model.ts
@@ -30,39 +30,24 @@ async function getConfigByName(name: string): Promise<Config> {
     return configs[0];
 }
 
-async function createConfigs(
-    newConfigs: Config[]
-): Promise<Config[]> {
-    const sql =
-        `INSERT INTO ${configsTableName} (name, value) VALUES ? RETURNING name, value`;
-    const params = newConfigs.map((newConfig) => [
-        newConfig.name,
-        newConfig.value,
-    ]);
-    const [configs] = await db.query<ConfigRowDataPacket[]>(sql, [
-        params,
-    ]);
+async function createConfigs(newConfigs: Config[]): Promise<Config[]> {
+    const sql = `INSERT INTO ${configsTableName} (name, value) VALUES ? RETURNING name, value`;
+    const params = newConfigs.map((newConfig) => [newConfig.name, newConfig.value]);
+    const [configs] = await db.query<ConfigRowDataPacket[]>(sql, [params]);
 
     return configs;
 }
 
 async function createConfig(name: string, value: string): Promise<Config> {
-    const sql =
-        `INSERT INTO ${configsTableName} (name, value) VALUES (?, ?) RETURNING name, value`;
-    const [configs] = await db.query<ConfigRowDataPacket[]>(sql, [
-        name,
-        value,
-    ]);
+    const sql = `INSERT INTO ${configsTableName} (name, value) VALUES (?, ?) RETURNING name, value`;
+    const [configs] = await db.query<ConfigRowDataPacket[]>(sql, [name, value]);
 
     return configs[0];
 }
 
 async function updateConfig(name: string, newValue: string): Promise<boolean> {
     const sql = `UPDATE ${configsTableName} SET value = ? WHERE name = ?`;
-    const [resHeader] = await db.query<ResultSetHeader>(sql, [
-        newValue,
-        name,
-    ]);
+    const [resHeader] = await db.query<ResultSetHeader>(sql, [newValue, name]);
 
     return resHeader.affectedRows > 0;
 }
@@ -75,11 +60,4 @@ async function deleteConfigByName(name: string): Promise<Config> {
 }
 
 export default Config;
-export {
-    getAllConfigs,
-    getConfigByName,
-    createConfigs,
-    createConfig,
-    updateConfig,
-    deleteConfigByName,
-};
+export { getAllConfigs, getConfigByName, createConfigs, createConfig, updateConfig, deleteConfigByName };
diff --git a/src/models/Session.model.ts b/src/models/Session.model.ts
@@ -53,13 +53,14 @@ async function doesSessionExist(session_id: number): Promise<boolean> {
     return sessions.length > 0;
 }
 
-async function createSession(user_id: number, start_time: number, end_time: number, amended: boolean): Promise<boolean> {
-    const sql = `INSERT INTO ${sessionsTableName} (user_id, start_time, end_time, amended) SELECT user_id, ?, ?, ? FROM ${usersTableName} WHERE user_id = ?`;
+async function createSession(user_id: number, start_time: number, end_time: number, amended: boolean): Promise<Session> {
+    const sql = `INSERT INTO ${sessionsTableName} (user_id, start_time, end_time, amended) SELECT user_id, ?, ?, ? FROM ${usersTableName} WHERE user_id = ?
+                RETURNING session_id, user_id, start_time, end_time, amended`;
     const params = [start_time, end_time, amended, user_id];
 
-    const [resHeader] = await db.query<ResultSetHeader>(sql, params);
+    const [sessions] = await db.query<SessionRowDataPacket[]>(sql, params);
 
-    return resHeader.affectedRows === 1;
+    return sessions[0];
 }
 
 async function updateSession(session_id: number, values: Partial<Session>): Promise<boolean> {
@@ -69,19 +70,37 @@ async function updateSession(session_id: number, values: Partial<Session>): Prom
     return resHeader.affectedRows === 1;
 }
 
-async function deleteSessionBySessionId(session_id: number): Promise<boolean> {
-    const sql = `DELETE FROM ${sessionsTableName} WHERE session_id = ?`;
-    const [resHeader] = await db.query<ResultSetHeader>(sql, [session_id]);
+async function deleteSessionBySessionId(session_id: number): Promise<Session> {
+    const sql = `DELETE FROM ${sessionsTableName} WHERE session_id = ? RETURNING session_id, user_id, start_time, end_time, amended`;
+    const [sessions] = await db.query<SessionRowDataPacket[]>(sql, [session_id]);
 
-    return resHeader.affectedRows === 1;
+    return sessions[0];
 }
 
-async function deleteSessionsByUserPassword(password: number): Promise<boolean> {
-    const sql = `DELETE FROM ${sessionsTableName} WHERE user_id = (SELECT user_id from ${usersTableName} WHERE password = ?)`;
-    const [resHeader] = await db.query<ResultSetHeader>(sql, [password]);
+async function deleteSessionsByUserId(user_id: number): Promise<Session> {
+    const sql = `DELETE FROM ${sessionsTableName} WHERE user_id = ? RETURNING session_id, user_id, start_time, end_time, amended`;
+    const [sessions] = await db.query<SessionRowDataPacket[]>(sql, [user_id]);
 
-    return resHeader.affectedRows > 0;
+    return sessions[0];
+}
+
+async function deleteSessionsByUserPassword(password: number): Promise<Session> {
+    const sql = `DELETE FROM ${sessionsTableName} WHERE user_id = (SELECT user_id from ${usersTableName} WHERE password = ?)
+                RETURNING (session_id, user_id, start_time, end_time, amended)`;
+    const [sessions] = await db.query<SessionRowDataPacket[]>(sql, [password]);
+
+    return sessions[0];
 }
 
 export default Session;
-export { getAllSessions, getSessionsByUserId, getSessionBySessionId, doesSessionExist, createSession, updateSession, deleteSessionBySessionId, deleteSessionsByUserPassword };
+export {
+    getAllSessions,
+    getSessionsByUserId,
+    getSessionBySessionId,
+    doesSessionExist,
+    createSession,
+    updateSession,
+    deleteSessionBySessionId,
+    deleteSessionsByUserId,
+    deleteSessionsByUserPassword,
+};
diff --git a/src/models/User.model.ts b/src/models/User.model.ts
@@ -30,9 +30,7 @@ async function getUserById(userId: number): Promise<User> {
     const [users] = await db.query<UserRowDataPacket[]>(sql, [userId]);
 
     if (users.length < 1) {
-        throw new RowNotFoundError(
-            `User of ID: ${userId} not found in table: ${usersTableName}`
-        );
+        throw new RowNotFoundError(`User of ID: ${userId} not found in table: ${usersTableName}`);
     }
 
     return users[0];
@@ -49,49 +47,26 @@ async function getUserByPassword(password: string): Promise<User> {
     return users[0];
 }
 
-async function createUser(
-    first_name: string,
-    last_name: string,
-    password: string
-): Promise<User> {
-    const sql =
-        `INSERT INTO ${usersTableName} (first_name, last_name, password) VALUES (?, ?, ?); SELECT user_id, first_name, last_name FROM ${usersTableName} where password = ?`;
-    const [users] = await db.query<UserRowDataPacket[]>(sql, [
-        first_name,
-        last_name,
-        password,
-        password,
-    ]);
+async function createUser(first_name: string, last_name: string, password: string): Promise<User> {
+    const sql = `INSERT INTO ${usersTableName} (first_name, last_name, password) VALUES (?, ?, ?) RETURNING user_id, first_name, last_name, password, signed_in, last_signed_in, total_time`;
+    const [users] = await db.query<UserRowDataPacket[]>(sql, [first_name, last_name, password, password]);
 
     return users[0];
 }
 
-async function updateUser(
-    user_id: number,
-    values: Partial<User>
-): Promise<boolean> {
+async function updateUser(user_id: number, values: Partial<User>): Promise<boolean> {
     const update = updateBuilder(usersTableName, values, { user_id });
-    const [resHeader] = await db.query<ResultSetHeader>(
-        update.query,
-        update.params
-    );
+    const [resHeader] = await db.query<ResultSetHeader>(update.query, update.params);
 
     return resHeader.affectedRows === 1;
 }
 
-async function deleteUserByPassword(password: number): Promise<boolean> {
-    const sql = `DELETE FROM ${usersTableName} WHERE password = ?`;
-    const [resHeader] = await db.query<ResultSetHeader>(sql, [password]);
+async function deleteUserByPassword(password: number): Promise<User> {
+    const sql = `DELETE FROM ${usersTableName} WHERE password = ? RETURNING user_id, first_name, last_name, password, signed_in, last_signed_in, total_time`;
+    const [users] = await db.query<UserRowDataPacket[]>(sql, [password]);
 
-    return resHeader.affectedRows === 1;
+    return users[0];
 }
 
 export default User;
-export {
-    getAllUsers,
-    getUserById,
-    getUserByPassword,
-    createUser,
-    updateUser,
-    deleteUserByPassword,
-};
+export { getAllUsers, getUserById, getUserByPassword, createUser, updateUser, deleteUserByPassword };
diff --git a/src/spreadsheet/sheets.ts b/src/spreadsheet/sheets.ts
@@ -74,13 +74,13 @@ async function getSheets(): Promise<sheets_v4.Sheets> {
 
 async function getSheetNameById(spreadsheetId: string, sheetId: number): Promise<string> {
     const sheets = await getSheets();
-    const data = (await asyncExponentialBackoff(async () => (await sheets.spreadsheets.get({
+    const data = (await asyncExponentialBackoff(async () => await sheets.spreadsheets.get({
         spreadsheetId,
         includeGridData: false,
-    })))).data;
+    }))).data;
 
     for (let i = 0; i < data.sheets!.length; i++) {
-        if (data.sheets![i].properties!.sheetId! === sheetId) {
+        if (data.sheets![i].properties!.sheetId! == sheetId) {
             return data.sheets![i].properties!.title!;
         }
     }

diff --git a/src/utils/spreadsheet-hours/add-single-session.ts b/src/utils/spreadsheet-hours/add-single-session.ts
@@ -1,20 +1,37 @@
 import Session from "../../models/Session.model";
 import User from "../../models/User.model";
-import { readCell } from "../../spreadsheet";
+import { readCell, writeCell } from "../../spreadsheet";
 import { Cell } from "../../spreadsheet/cell";
+import { RangeNotFound } from "../errors";
 import { getUserRowFromTotalHoursSheet, getUserRowFromHoursHistorySheet } from "./helpers/get-user-row";
 import { msTimesToHourDuration } from "./helpers/times-to-duration";
 
 // Add session time to spreadsheet
-async function addSingleSession(user: User, session: Session): Promise<void> {
+async function addSingleSessionToSpreadsheet(user: User, session: Session): Promise<void> {
+    // No spreadsheets while testing
+    if (process.env.NODE_ENV === "testing") {
+        return;
+    }
+
     const totalHoursSheetRow = await getUserRowFromTotalHoursSheet(user);
     const hoursHistorySheetRow = await getUserRowFromHoursHistorySheet(user);
+    const cell = new Cell(process.env.TOTAL_HOURS_SHEET_HOURS_COLUMN, totalHoursSheetRow);
 
-    const hoursCellData = await readCell(process.env.HOURS_SPREADSHEET_ID, process.env.TOTAL_HOURS_SHEET_ID, new Cell(process.env.TOTAL_HOURS_SHEET_HOURS_COLUMN, totalHoursSheetRow));
-    let totalHours = isFinite(parseFloat(hoursCellData)) ? parseFloat(hoursCellData) : 0; // If is not finite, then set to 0 TODO: have it check the hours logged in database
+    let hoursCellData;
+    try {
+        hoursCellData = await readCell(process.env.HOURS_SPREADSHEET_ID, process.env.TOTAL_HOURS_SHEET_ID, cell);
+    } catch (e) {
+        if (e instanceof RangeNotFound) {
+            hoursCellData = "";
+        } else {
+            throw e;
+        }
+    }
 
+    let totalHours = isFinite(parseFloat(hoursCellData)) ? parseFloat(hoursCellData) : 0; // If is not finite, then set to 0 TODO: have it check the hours logged in database
     totalHours += msTimesToHourDuration(session.start_time, session.end_time);
+    await writeCell(process.env.HOURS_SPREADSHEET_ID, process.env.TOTAL_HOURS_SHEET_ID, cell, totalHours);
     // TODO: total hours calculation
 }
 
-export { addSingleSession }
+export { addSingleSessionToSpreadsheet };
diff --git a/src/utils/spreadsheet-hours/index.ts b/src/utils/spreadsheet-hours/index.ts
@@ -1 +1 @@
-export { addSingleSession } from "./add-single-session";
+export { addSingleSessionToSpreadsheet } from "./add-single-session";
Original file line number	Diff line number	Diff line change
		@@ -1 +1 @@
		export { addSingleSession } from "./add-single-session";
		export { addSingleSessionToSpreadsheet } from "./add-single-session";