Add Route Reporting Functionality (#353)

* Added web scrapper files for library and printer locations.

* Created endpoint that returns closest bus on route

* Added endpoint route and fixed function calls

* Added route for fetching all libraries and printers and populated SQLite database

* Wrote code to store route reports in sqlite database

* Added route to get reports by vehicle Id

* Added insert report logic

* Fixed server restart issue

* Remove print statements

* Fixed parameter bug

* Removed unneccessary function

* Removed python files

* Removed null return value for closest bus

---------

Co-authored-by: Nicole Qiu <nfq2@cornell.edu>

Author: daisychangm

package.json

@@ -5,7 +5,7 @@
   "main": "index.js",
   "type": "module",
   "scripts": {
-    "start:dev": "nodemon src/index.js",
+    "start:dev": "nodemon --ignore src/data/notifRequests.json src/index.js",
     "start": "node src/index.js"
   },
   "keywords": [],

src/controllers/RouteReportingController.js

@@ -19,4 +19,32 @@ router.get('/closestBus', async (req, res) => {
   }
 });
 
+router.post('/reports', async (req, res) => {
+  try {
+    const {
+      vehicleId,
+      congestionLevel,
+      deviceToken,
+      timestamp
+    } = req.body;
+
+    const report = await RouteReportingUtils.insertReport(vehicleId, congestionLevel, deviceToken, timestamp);
+    res.status(200).json(report);
+  } catch (error) {
+    LogUtils.logErr(error, req.body, 'Error inserting report');
+    res.status(500).json({ error: 'Failed to insert report' });
+  }
+});
+
+router.get('/reports/:vehicleId', async (req, res) => {
+  try {
+    const { vehicleId } = req.params;
+    const reports = await RouteReportingUtils.fetchReportsByBus(vehicleId);
+    res.status(200).json(reports);
+  } catch (error) {
+    LogUtils.logErr(error, req.params, 'Error fetching reports by vehicleId');
+    res.status(500).json({ error: 'Failed to fetch reports by vehicleId' });
+  }
+});
+
 export default router;

src/data/db/database.py

@@ -2,35 +2,48 @@
 import os
 
 # Get the absolute path of transit.db
-BASE_DIR = os.path.dirname(os.path.abspath(__file__))  # Gets the directory of the script
-DB_PATH = os.path.join(BASE_DIR, '..', 'transit.db')  # Moves up one level to store db in /data/
+BASE_DIR = os.path.dirname(
+    os.path.abspath(__file__)
+)  # Gets the directory of the script
+DB_PATH = os.path.join(
+    BASE_DIR, "..", "transit.db"
+)  # Moves up one level to store db in /data/
+
 
 def get_db_connection():
     """Establish and return an SQLite connection."""
     return sqlite3.connect(DB_PATH)
 
+
 def insert_library(location, address, latitude, longitude):
     """Insert a library into the database."""
     conn = get_db_connection()
     cursor = conn.cursor()
 
-    cursor.execute('''
+    cursor.execute(
+        """
         INSERT OR IGNORE INTO libraries (location, address, latitude, longitude)
         VALUES (?, ?, ?, ?)
-    ''', (location, address, latitude, longitude))
+    """,
+        (location, address, latitude, longitude),
+    )
 
     conn.commit()
     conn.close()
 
+
 def insert_printer(location, description, latitude, longitude):
     """Insert a printer into the database."""
     conn = get_db_connection()
     cursor = conn.cursor()
 
-    cursor.execute('''
+    cursor.execute(
+        """
         INSERT OR IGNORE INTO printers (location, description, latitude, longitude)
         VALUES (?, ?, ?, ?)
-    ''', (location, description, latitude, longitude))
+    """,
+        (location, description, latitude, longitude),
+    )
 
     conn.commit()
-    conn.close()
+    conn.close()

src/data/db/models.py

@@ -2,36 +2,58 @@
 import os
 
 # Get the absolute path of transit.db
-BASE_DIR = os.path.dirname(os.path.abspath(__file__))  # Gets the directory of the script
-DB_PATH = os.path.join(BASE_DIR, '..', 'transit.db')  # Moves up one level to store db in /data/
+BASE_DIR = os.path.dirname(
+    os.path.abspath(__file__)
+)  # Gets the directory of the script
+DB_PATH = os.path.join(
+    BASE_DIR, "..", "transit.db"
+)  # Moves up one level to store db in /data/
+
 
 def create_tables():
     """Creates tables for storing locations in SQLite."""
     conn = sqlite3.connect(DB_PATH)
     cursor = conn.cursor()
 
-    cursor.execute('''
+    cursor.execute(
+        """
         CREATE TABLE IF NOT EXISTS libraries (
             id INTEGER PRIMARY KEY AUTOINCREMENT,
             location TEXT UNIQUE,
             address TEXT,
             latitude REAL,
             longitude REAL
         )
-    ''')
+    """
+    )
 
-    cursor.execute('''
+    cursor.execute(
+        """
         CREATE TABLE IF NOT EXISTS printers (
             id INTEGER PRIMARY KEY AUTOINCREMENT,
             location TEXT UNIQUE,
             description TEXT,
             latitude REAL,
             longitude REAL
         )
-    ''')
+    """
+    )
+
+    cursor.execute(
+        """
+        CREATE TABLE IF NOT EXISTS reports (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
+            vehicleID TEXT,
+            congestionLevel TEXT,
+            deviceToken TEXT
+        )
+    """
+    )
 
     conn.commit()
     conn.close()
 
+
 if __name__ == "__main__":
-    create_tables()
+    create_tables()

src/data/scrapers/__pycache__/libraries.cpython-39.pyc

@@ -1,63 +1,206 @@
-import LogUtils from "./LogUtils.js";
-import RealtimeFeedUtilsV3 from "./RealtimeFeedUtilsV3.js";
-import ParseRouteUtilsV3 from "./ParseRouteUtilsV3.js";
+import LogUtils from './LogUtils.js';
+import RealtimeFeedUtilsV3 from './RealtimeFeedUtilsV3.js';
+import ParseRouteUtilsV3 from './ParseRouteUtilsV3.js';
+import sqlite3 from "sqlite3";
+import { fileURLToPath } from 'url';
+import path from "path";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const dbPath = path.join(__dirname, '..', 'data', 'transit.db');
+
+const nullBus = {
+  bearing: 0,
+  congestionLevel: 0,
+  currentStatus: 0,
+  currentStopSequence: 0,
+  latitude: 0,
+  longitude: 0,
+  occupancyStatus: 0,
+  routeId: "",
+  speed: 0,
+  stopId: "",
+  timestamp: {},
+  tripId: "",
+  vehicleId: "",
+}
 
 /**
  * Returns the closest bus on a given routeId and start position.
+ * 
  * @param routeId
  * @param start
  * @returns {Object}
  */
 async function getClosestBus(routeId, start) {
-  LogUtils.log({ message: "getClosestBus: entering function", routeId });
+  LogUtils.log({ message: 'getClosestBus: entering function', routeId });
   const vehicles = await RealtimeFeedUtilsV3.getVehicleData();
 
   if (!vehicles) {
-    LogUtils.log({ message: "No vehicle data available" });
-    return null;
+    LogUtils.log({ message: 'No vehicle data available' });
+    return nullBus;
   }
-
+  
   const routeVehicles = Object.values(vehicles).filter(
-    (vehicle) => vehicle.routeId == routeId
-  );
-
+    v => v.routeId === routeId );
+  
   if (routeVehicles.length === 0) {
-    LogUtils.log({ message: "No vehicles found for given route", routeId });
-    return null;
+    LogUtils.log({ message: 'No vehicles found for given route', routeId });
+    return nullBus;
   }
 
-  const startPointList = start.split(",");
+  const startPointList = start.split(',');
   const startPoint = { lat: startPointList[0], long: startPointList[1] };
-
-  let closestVehicle = null;
+  
+  let closestVehicle = nullBus;
   let minDistance = Infinity;
-
+  
   for (const vehicle of routeVehicles) {
     const vehiclePosition = {
       lat: vehicle.latitude,
       long: vehicle.longitude,
     };
-
+      
     const distance = ParseRouteUtilsV3.distanceBetweenPointsMiles(
       vehiclePosition,
-      startPoint
+      startPoint,
     );
-
+      
     if (distance < minDistance) {
       minDistance = distance;
       closestVehicle = vehicle;
     }
   }
+  
+  return closestVehicle;
+}
 
-  if (!closestVehicle) {
-    LogUtils.log({ message: "No closest vehicle found", routeId });
-    return null;
-  }
 
-  LogUtils.log({ message: "Closest bus found", closestVehicle });
-  return closestVehicle;
+
+/**
+ * Fetches a report from the database by its id.
+ *
+ * @param reportId
+ * @returns {Promise<Object>}
+ */
+function fetchReportById(reportId) {
+  return new Promise((resolve, reject) => {
+    const db = new sqlite3.Database(dbPath, (err) => {
+      if (err) {
+        console.error(err.message);
+        return reject(err);
+      }
+      console.log('Connected to the SQLite database.');
+    });
+
+    db.get('SELECT * FROM reports WHERE id = ?', [reportId], (err, row) => {
+      if (err) {
+        console.error(err.message);
+        return reject(err);
+      }
+      db.close((err) => {
+        if (err) console.error(err.message);
+        console.log('Closed the database connection.');
+      });
+      resolve(row);
+    });
+  });
 }
 
+
+/**
+ * Inserts a report into the database. If a timestamp is not provided, the current time will be used.
+ * 
+ * @param vehicleId
+ * @param routeId
+ * @param reportText
+ * @param deviceToken
+ * @param timestamp Optional
+ * @returns {Promise<Object>}
+ */
+function insertReport(vehicleId, congestionLevel, deviceToken, timestamp = null) {
+  return new Promise((resolve, reject) => {
+    const db = new sqlite3.Database(dbPath, (err) => {
+      if (err) {
+        console.error('Error opening database:', err.message);
+        return reject(err);
+      }
+      console.log('Connected to the SQLite database.');
+    });
+
+    let query, values;
+
+    if (timestamp) {
+      query = `
+        INSERT INTO reports (timestamp, vehicleID, congestionLevel, deviceToken)
+        VALUES (?, ?, ?, ?)
+      `;
+      values = [timestamp, vehicleId, congestionLevel, deviceToken];
+    } else {
+      query = `
+        INSERT INTO reports (vehicleId, congestionLevel, deviceToken)
+        VALUES (?, ?, ?)
+      `;
+      values = [vehicleId, congestionLevel, deviceToken];
+    }
+
+    db.run(query, values, async function (err) {
+      if (err) {
+        console.error('Error inserting report:', err.message);
+        return reject(err);
+      }
+
+      const insertedId = this.lastID;
+      db.close((err) => {
+        if (err) console.error('Error closing database after insert:', err.message);
+        console.log('Closed the database connection after insert.');
+      });
+
+      try {
+        const report = await fetchReportById(insertedId);
+        resolve(report);
+      } catch (fetchErr) {
+        reject(fetchErr);
+      }
+    });
+  });
+}
+
+
+
+/**
+ * Fetches all reports from the database by vehicle ID.
+ *
+ * @param vehicleId
+ * @returns {Promise<Array<Object>>}
+ */
+function fetchReportsByBus(vehicleId) {
+  return new Promise((resolve, reject) => {
+    const db = new sqlite3.Database(dbPath, (err) => {
+      if (err) {
+        console.error(err.message);
+        return reject(err);
+      }
+    });
+
+    db.all('SELECT * FROM reports WHERE vehicleID = ?', [vehicleId], (err, rows) => {
+      if (err) {
+        console.error(err.message);
+        return reject(err);
+      }
+
+      db.close((err) => {
+        if (err) console.error(err.message);
+      });
+
+      resolve(rows);
+    })
+  })
+}
+  
 export default {
   getClosestBus,
+  insertReport,
+  fetchReportsByBus
 };
+