Logo update and FOFR-60 (#469)

ann-aot · web-flow · commit 237acd84c220 · 2025-03-03T17:39:10.000-05:00
diff --git a/forms-flow-nav/src/sidenav/Sidebar.jsx b/forms-flow-nav/src/sidenav/Sidebar.jsx
@@ -238,13 +238,16 @@ const Sidebar = React.memo(({ props, sidenavHeight="100%" }) => {
   return (
       <div className="sidenav" style={{ height: sidenavHeight }}>
         <div className="logo-container">
-          {/* <img
-            className=""
-            src={Appname}
+          {APPLICATION_NAME === "roadsafety" ? (
+          <img
+            width="160"
+            height="auto"
+            src="/RoadsafteyLogo.png"
             alt="applicationName"
-            data-testid="app-logo"
-          /> */}
+          />
+        ) : (
           <ApplicationLogo data-testid="application-logo" />
+        )}
         </div>
         <div className="options-container" data-testid="options-container">
           <Accordion activeKey={activeKey} onSelect={(key) => setActiveKey(key)}>
diff --git a/forms-flow-nav/src/sidenav/hamburgerMenu.jsx b/forms-flow-nav/src/sidenav/hamburgerMenu.jsx
@@ -10,6 +10,7 @@ import Sidebar from "./Sidebar";
 // import hamburger from "./hamburger.svg";
 // import closebutton from "./closebutton.svg";
 import { HamburgerIcon, CloseIcon, ApplicationLogo } from "@formsflow/components";
+import { APPLICATION_NAME } from "../constants/constants";
 function HamburgerMenu({ props }) {
   const [show, setShow] = useState(false);
   const handleClose = () => setShow(false);
@@ -29,8 +30,16 @@ function HamburgerMenu({ props }) {
           <HamburgerIcon data-testid="hamburger-button" aria-label="hamburger button" color={getComputedStyle(document.documentElement).getPropertyValue("--ff-gray-800")} />
         </button>
         <Navbar.Brand href="" className="mx-auto">
-          {/* <img className="" src={Appname} alt="applicationName" /> */}
-          <ApplicationLogo data-testid="application-logo" />
+          {APPLICATION_NAME === "roadsafety" ? (
+            <img
+              width="160"
+              height="auto"
+              src="/RoadsafteyLogo.png"
+              alt="applicationName"
+            />
+          ) : (
+            <ApplicationLogo data-testid="application-logo" />
+          )}
         </Navbar.Brand>
         <Navbar.Collapse id="basic-navbar-nav" className="order-2">
           <Nav className="me-auto">
diff --git a/forms-flow-rsbcservice/src/storage/dbFetchServices.ts b/forms-flow-rsbcservice/src/storage/dbFetchServices.ts
@@ -4,6 +4,16 @@ import { StaticTables } from "../constants/constants";
 import DBServiceHelper from "../helpers/helperDbServices";
 import { FormTypes } from "../constants/constants";
 
+interface TableFilter {
+  column: string;
+  condition: "=" | "IN" | "LIKE";
+  values: string | string[];
+}
+
+interface UpdateFilter {
+  conditions: Record<string, any>; // Object with search conditions
+  updates: Record<string, any>; // Object with updates to make
+}
 
 class OfflineFetchService {
   
@@ -12,29 +22,207 @@ class OfflineFetchService {
    * Ensures that the table is within the predefined static tables list.
    * 
    * @param tableName - Name of the table to fetch data from.
+   * @param filter - Optional filter object for filtering results
+   * @param filter.column - The column name to filter on
+   * @param filter.condition - The condition to apply ("=" | "IN" | "LIKE")
+   * @param filter.values - The value(s) to filter by. String for "=" and "LIKE", string[] for "IN"
    * @returns A promise that resolves to an array of records from the table.
    * @throws Error if IndexedDB is unavailable, the table is inaccessible, or data retrieval fails.
    */
-  public static async fetchStaticDataFromTable(tableName: string): Promise<any[]> {
+  public static async fetchStaticDataFromTable(
+    tableName: string,
+    filter?: TableFilter
+  ): Promise<any[]> {
     try {
       if (!rsbcDb) throw new Error("IndexedDB is not available.");
-      if (!StaticTables.includes(tableName)) throw new Error(`Table ${tableName} is not accessible.`);
-  
+      if (!StaticTables.includes(tableName))
+        throw new Error(`Table ${tableName} is not accessible.`);
+
       await rsbcDb.open(); // Ensure the database is open
-  
+
       const table = rsbcDb[tableName];
-      if (!table) throw new Error(`Table ${tableName} not found in IndexedDB.`);
-  
-      const data = await table.toArray();
-      if (!data.length) console.warn(`No data found in table ${tableName}.`);
-  
+      if (!table) {
+        throw new Error(`Table ${tableName} not found in IndexedDB.`);
+      }
+
+      // Validate filter if provided
+      if (filter) {
+        if (!filter.column || !filter.condition) {
+          throw new Error("Invalid filter: missing required properties");
+        }
+
+        if (filter.condition === "IN" && !Array.isArray(filter.values)) {
+          throw new Error("Values must be an array for IN condition");
+        }
+      }
+
+      let data: any[] = [];
+      if (filter) {
+        const { column, condition, values } = filter;
+
+        switch (condition) {
+          case "=":
+            data = await table.where(column).equals(values).toArray();
+            break;
+
+          case "IN":
+            data = await table
+              .where(column)
+              .anyOf(values as string[])
+              .toArray();
+            break;
+
+          case "LIKE":
+            if (typeof values !== "string") {
+              throw new Error("Values must be a string for LIKE condition");
+            }
+            const allData = await table.toArray();
+            data = allData.filter((item) => {
+              const itemValue = String(item[column] || "").toLowerCase();
+              const searchValue = String(values || "").toLowerCase();
+              return itemValue.includes(searchValue);
+            });
+            break;
+
+          default:
+            throw new Error(`Unsupported condition: ${condition}`);
+        }
+      } else {
+        data = await table.toArray();
+      }
+
+      if (!data.length) {
+        console.warn(`No data found in table ${tableName}.`);
+      }
+
       return data;
     } catch (error) {
       console.error(`Error fetching data from table ${tableName}:`, error);
       throw error;
     }
   }
 
+  /**
+   * Updates data in a static table in IndexedDB.
+   * Ensures that the table is within the predefined static tables list.
+   *
+   * @param tableName - Name of the table to update data in
+   * @param filter - Filter object for updating records
+   * @param filter.conditions - Object with conditions to match records (e.g., {id: 3} or {date: "1990-12-12", status: "new"})
+   * @param filter.updates - Object with updates to make (e.g., {status: "completed"})
+   * @returns A promise that resolves to the number of updated records
+   * @throws Error if IndexedDB is unavailable, the table is inaccessible, or update fails.
+   */
+  public static async updateStaticDataTable(
+    tableName: string,
+    filter: UpdateFilter
+  ): Promise<number> {
+    try {
+      if (!rsbcDb) {
+        throw new Error("IndexedDB is not available.");
+      }
+      if (!StaticTables.includes(tableName)) {
+        throw new Error(`Table ${tableName} is not accessible.`);
+      }
+
+      await rsbcDb.open(); // Ensure the database is open
+
+      // Get table using Dexie's table() method
+      const table = rsbcDb.table(tableName);
+      if (!table) {
+        throw new Error(`Table ${tableName} not found in IndexedDB.`);
+      }
+
+      // Validate filter
+      if (
+        !filter?.conditions ||
+        !filter?.updates ||
+        Object.keys(filter.conditions).length === 0 ||
+        Object.keys(filter.updates).length === 0
+      ) {
+        throw new Error(
+          "Invalid filter: conditions and updates are required and must not be empty"
+        );
+      }
+
+      // Get all records first
+      const allRecords = await table.toArray();
+
+      // Filter records that match ALL conditions
+      const recordsToUpdate = allRecords.filter((record) => {
+        return Object.entries(filter.conditions).every(
+          ([key, value]) => record[key] === value
+        );
+      });
+
+      // Update each record with all specified updates
+      const updatePromises = recordsToUpdate.map(async (record) => {
+        // Apply all updates to the record
+        Object.entries(filter.updates).forEach(([key, value]) => {
+          record[key] = value;
+        });
+        return await table.put(record);
+      });
+
+      await Promise.all(updatePromises);
+      const updateCount = recordsToUpdate.length;
+
+      if (updateCount === 0) {
+        console.warn(`No records updated in table ${tableName}.`);
+      }
+
+      return updateCount;
+    } catch (error) {
+      console.error(`Error updating data in table ${tableName}:`, error);
+      throw error;
+    }
+  }
+
+  /**
+   * Creates a new record in a static table in IndexedDB.
+   * Ensures that the table is within the predefined static tables list.
+   *
+   * @param tableName - Name of the table to create data in
+   * @param data - The data object to insert into the table
+   * @returns A promise that resolves to the id of the created record
+   * @throws Error if IndexedDB is unavailable, the table is inaccessible, or creation fails.
+   */
+  public static async insertStaticDataTable(
+    tableName: string,
+    data: any
+  ): Promise<any> {
+    try {
+      if (!rsbcDb) {
+        throw new Error("IndexedDB is not available.");
+      }
+      if (!StaticTables.includes(tableName)) {
+        throw new Error(`Table ${tableName} is not accessible.`);
+      }
+
+      await rsbcDb.open(); // Ensure the database is open
+
+      const table = rsbcDb.table(tableName);
+      if (!table) {
+        throw new Error(`Table ${tableName} not found in IndexedDB.`);
+      }
+
+      // Validate data
+      if (!data || Object.keys(data).length === 0) {
+        throw new Error(
+          "Invalid data: data object is required and must not be empty"
+        );
+      }
+
+      // Add the record to the table
+      const id = await table.add(data);
+
+      return id;
+    } catch (error) {
+      console.error(`Error creating data in table ${tableName}:`, error);
+      throw error;
+    }
+  }
+
   /**
    * Fetches a specific offline form by its ID from the formDefinition table.
    * 
