Linting

2024-08-11 15:57:46 -04:00
parent 5cd47378d6
commit 117cbea67f
37 changed files with 2273 additions and 1738 deletions
--- a/modules/mongo-wrappers/mongoDiscordIDWrappers.mjs
+++ b/modules/mongo-wrappers/mongoDiscordIDWrappers.mjs
@@ -1,8 +1,12 @@
 import { DebugBuilder } from "../../modules/debugger.mjs";
 const log = new DebugBuilder("server", "mongoDiscordIDWrappers");
-import { insertDocument, getDocuments, connectToDatabase } from "./mongoHandler.mjs";
+import {
+  insertDocument,
+  getDocuments,
+  connectToDatabase,
+} from "./mongoHandler.mjs";

-const collectionName = 'discord-ids';
+const collectionName = "discord-ids";

 // Wrapper for inserting a Discord ID
 export const createDiscordID = async (discordID) => {
@@ -10,7 +14,7 @@ export const createDiscordID = async (discordID) => {
    const insertedId = await insertDocument(collectionName, discordID);
    return insertedId;
  } catch (error) {
-    log.ERROR('Error creating Discord ID:', error);
+    log.ERROR("Error creating Discord ID:", error);
    throw error;
  }
 };
@@ -21,7 +25,7 @@ export const getAllDiscordIDs = async () => {
    const discordIDs = await getDocuments(collectionName);
    return discordIDs;
  } catch (error) {
-    log.ERROR('Error getting all Discord IDs:', error);
+    log.ERROR("Error getting all Discord IDs:", error);
    throw error;
  }
 };
@@ -29,17 +33,14 @@ export const getAllDiscordIDs = async () => {
 // Wrapper for retrieving a Discord ID by name or discord_id
 export const getDiscordID = async (identifier) => {
  const db = await connectToDatabase();
-  try {    
+  try {
    const collection = db.db().collection(collectionName);
    const discordID = await collection.findOne({
-      $or: [
-        { name: identifier },
-        { discord_id: identifier }
-      ]
+      $or: [{ name: identifier }, { discord_id: identifier }],
    });
    return discordID;
  } catch (error) {
-    log.ERROR('Error getting Discord ID:', error);
+    log.ERROR("Error getting Discord ID:", error);
    throw error;
  } finally {
    // Close the connection
@@ -52,16 +53,16 @@ export const updateDiscordID = async (identifier, updatedFields) => {
  const db = await connectToDatabase();
  try {
    const collection = db.db().collection(collectionName);
-    const result = await collection.updateOne({
-      $or: [
-        { name: identifier },
-        { discord_id: identifier }
-      ]
-    }, { $set: updatedFields });
-    log.INFO('Discord ID updated:', result.modifiedCount);
+    const result = await collection.updateOne(
+      {
+        $or: [{ name: identifier }, { discord_id: identifier }],
+      },
+      { $set: updatedFields },
+    );
+    log.INFO("Discord ID updated:", result.modifiedCount);
    return result.modifiedCount;
  } catch (error) {
-    log.ERROR('Error updating Discord ID:', error);
+    log.ERROR("Error updating Discord ID:", error);
    throw error;
  } finally {
    // Close the connection
@@ -72,21 +73,18 @@ export const updateDiscordID = async (identifier, updatedFields) => {
 // Wrapper for deleting a Discord ID by name or discord_id
 export const deleteDiscordID = async (identifier) => {
  const db = await connectToDatabase();
-  try {    
+  try {
    const collection = db.db().collection(collectionName);
    const result = await collection.deleteOne({
-      $or: [
-        { name: identifier },
-        { discord_id: identifier }
-      ]
+      $or: [{ name: identifier }, { discord_id: identifier }],
    });
-    log.INFO('Discord ID deleted:', result.deletedCount);
+    log.INFO("Discord ID deleted:", result.deletedCount);
    return result.deletedCount;
  } catch (error) {
-    log.ERROR('Error deleting Discord ID:', error);
+    log.ERROR("Error deleting Discord ID:", error);
    throw error;
  } finally {
    // Close the connection
    await db.close();
  }
-};
+};
--- a/modules/mongo-wrappers/mongoFeedsWrappers.mjs
+++ b/modules/mongo-wrappers/mongoFeedsWrappers.mjs
@@ -1,112 +1,124 @@
 import { DebugBuilder } from "../../modules/debugger.mjs";
 const log = new DebugBuilder("server", "mongoFeedsWrappers");
 import {
-    insertDocument,
-    getDocuments,
-    getDocumentByField,
-    updateDocumentByField,
-    deleteDocumentByField,
-  } from "./mongoHandler.mjs";
-  
-  const feedCollectionName = 'feeds';
-  const postCollectionName = 'posts';
-  
-  // Wrapper for inserting a feed
-  export const createFeed = async (feed) => {
-    try {
-      const insertedId = await insertDocument(feedCollectionName, feed);
-      return insertedId;
-    } catch (error) {
-      log.ERROR('Error creating feed:', error);
-      throw error;
-    }
-  };
-  
-  // Wrapper for retrieving all feeds
-  export const getAllFeeds = async () => {
-    try {
-      const feeds = await getDocuments(feedCollectionName);
-      return feeds;
-    } catch (error) {
-      log.ERROR('Error getting all feeds:', error);
-      throw error;
-    }
-  };
-  
-  // Wrapper for retrieving a feed by link
-  export const getFeedByLink = async (link) => {
-    try {
-      const feed = await getDocumentByField(feedCollectionName, 'link', link);
-      return feed;
-    } catch (error) {
-      log.ERROR('Error getting feed by link:', error);
-      throw error;
-    }
-  };
+  insertDocument,
+  getDocuments,
+  getDocumentByField,
+  updateDocumentByField,
+  deleteDocumentByField,
+} from "./mongoHandler.mjs";

-  // Wrapper for retrieving a feed by the title
-  export const getFeedByTitle = async (title) => {
-    try {
-      const feed = await getDocumentByField(feedCollectionName, 'title', title);
-      return feed;
-    } catch (error) {
-      log.ERROR('Error getting feed by link:', error);
-      throw error;
-    }
-  };
-  
-  // Wrapper for updating a feed by link
-  export const updateFeedByLink = async (link, updatedFields) => {
-    try {
-      const modifiedCount = await updateDocumentByField(feedCollectionName, 'link', link, updatedFields);
-      return modifiedCount;
-    } catch (error) {
-      log.ERROR('Error updating feed by link:', error);
-      throw error;
-    }
-  };
-  
-  // Wrapper for deleting a feed by link
-  export const deleteFeedByLink = async (link) => {
-    try {
-      const deletedCount = await deleteDocumentByField(feedCollectionName, 'link', link);
-      return deletedCount;
-    } catch (error) {
-      log.ERROR('Error deleting feed by link:', error);
-      throw error;
-    }
-  };
+const feedCollectionName = "feeds";
+const postCollectionName = "posts";

-  // Wrapper for deleting a feed by title
-  export const deleteFeedByTitle = async (title) => {
-    try {
-      const deletedCount = await deleteDocumentByField(feedCollectionName, 'title', title);
-      return deletedCount;
-    } catch (error) {
-      log.ERROR('Error deleting feed by link:', error);
-      throw error;
-    }
-  };
-  
-  // Wrapper for inserting a post
-  export const createPost = async (post) => {
-    try {
-      const insertedId = await insertDocument(postCollectionName, post);
-      return insertedId;
-    } catch (error) {
-      log.ERROR('Error creating post:', error);
-      throw error;
-    }
-  };
-  
-  // Wrapper for retrieving a post by postId
-  export const getPostByPostId = async (postId) => {
-    try {
-      const post = await getDocumentByField(postCollectionName, 'postId', postId);
-      return post;
-    } catch (error) {
-      log.ERROR('Error getting post by postId:', error);
-      throw error;
-    }
-  };
-  
+// Wrapper for inserting a feed
+export const createFeed = async (feed) => {
+  try {
+    const insertedId = await insertDocument(feedCollectionName, feed);
+    return insertedId;
+  } catch (error) {
+    log.ERROR("Error creating feed:", error);
+    throw error;
+  }
+};
+
+// Wrapper for retrieving all feeds
+export const getAllFeeds = async () => {
+  try {
+    const feeds = await getDocuments(feedCollectionName);
+    return feeds;
+  } catch (error) {
+    log.ERROR("Error getting all feeds:", error);
+    throw error;
+  }
+};
+
+// Wrapper for retrieving a feed by link
+export const getFeedByLink = async (link) => {
+  try {
+    const feed = await getDocumentByField(feedCollectionName, "link", link);
+    return feed;
+  } catch (error) {
+    log.ERROR("Error getting feed by link:", error);
+    throw error;
+  }
+};
+
+// Wrapper for retrieving a feed by the title
+export const getFeedByTitle = async (title) => {
+  try {
+    const feed = await getDocumentByField(feedCollectionName, "title", title);
+    return feed;
+  } catch (error) {
+    log.ERROR("Error getting feed by link:", error);
+    throw error;
+  }
+};
+
+// Wrapper for updating a feed by link
+export const updateFeedByLink = async (link, updatedFields) => {
+  try {
+    const modifiedCount = await updateDocumentByField(
+      feedCollectionName,
+      "link",
+      link,
+      updatedFields,
+    );
+    return modifiedCount;
+  } catch (error) {
+    log.ERROR("Error updating feed by link:", error);
+    throw error;
+  }
+};
+
+// Wrapper for deleting a feed by link
+export const deleteFeedByLink = async (link) => {
+  try {
+    const deletedCount = await deleteDocumentByField(
+      feedCollectionName,
+      "link",
+      link,
+    );
+    return deletedCount;
+  } catch (error) {
+    log.ERROR("Error deleting feed by link:", error);
+    throw error;
+  }
+};
+
+// Wrapper for deleting a feed by title
+export const deleteFeedByTitle = async (title) => {
+  try {
+    const deletedCount = await deleteDocumentByField(
+      feedCollectionName,
+      "title",
+      title,
+    );
+    return deletedCount;
+  } catch (error) {
+    log.ERROR("Error deleting feed by link:", error);
+    throw error;
+  }
+};
+
+// Wrapper for inserting a post
+export const createPost = async (post) => {
+  try {
+    const insertedId = await insertDocument(postCollectionName, post);
+    return insertedId;
+  } catch (error) {
+    log.ERROR("Error creating post:", error);
+    throw error;
+  }
+};
+
+// Wrapper for retrieving a post by postId
+export const getPostByPostId = async (postId) => {
+  try {
+    const post = await getDocumentByField(postCollectionName, "postId", postId);
+    return post;
+  } catch (error) {
+    log.ERROR("Error getting post by postId:", error);
+    throw error;
+  }
+};
--- a/modules/mongo-wrappers/mongoHandler.mjs
+++ b/modules/mongo-wrappers/mongoHandler.mjs
@@ -1,10 +1,10 @@
 // Import necessary modules
-import { MongoClient } from 'mongodb';
-import { DebugBuilder } from '../debugger.mjs';
-const log = new DebugBuilder("server", 'mongoHandler');
+import { MongoClient } from "mongodb";
+import { DebugBuilder } from "../debugger.mjs";
+const log = new DebugBuilder("server", "mongoHandler");

-import dotenv from 'dotenv';
-dotenv.config()
+import dotenv from "dotenv";
+dotenv.config();

 // MongoDB connection URI
 const uri = process.env.MONGO_URL;
@@ -15,7 +15,7 @@ export const connectToDatabase = async () => {
    const client = await MongoClient.connect(uri);
    return client;
  } catch (error) {
-    console.error('Error connecting to the database:', error);
+    console.error("Error connecting to the database:", error);
    throw error;
  }
 };
@@ -24,13 +24,13 @@ export const connectToDatabase = async () => {
 export const insertDocument = async (collectionName, document) => {
  const db = await connectToDatabase();
  log.DEBUG("Inserting document:", collectionName, document);
-  try {    
+  try {
    const collection = db.db().collection(collectionName);
    const result = await collection.insertOne(document);
-    log.DEBUG('Document inserted:', result.insertedId);
+    log.DEBUG("Document inserted:", result.insertedId);
    return result.insertedId;
  } catch (error) {
-    console.error('Error inserting document:', error);
+    console.error("Error inserting document:", error);
    throw error;
  } finally {
    // Close the connection
@@ -42,13 +42,13 @@ export const insertDocument = async (collectionName, document) => {
 export const getDocuments = async (collectionName) => {
  log.DEBUG("Getting all documents:", collectionName);
  const db = await connectToDatabase();
-  try {    
+  try {
    const collection = db.db().collection(collectionName);
    const documents = await collection.find({}).toArray();
-    log.DEBUG('Documents retrieved:', documents);
+    log.DEBUG("Documents retrieved:", documents);
    return documents;
  } catch (error) {
-    console.error('Error retrieving documents:', error);
+    console.error("Error retrieving documents:", error);
    throw error;
  } finally {
    // Close the connection
@@ -65,7 +65,7 @@ export const getDocumentByField = async (collectionName, field, value) => {
    const document = await collection.findOne({ [field]: value });
    return document;
  } catch (error) {
-    console.error('Error retrieving document:', error);
+    console.error("Error retrieving document:", error);
    throw error;
  } finally {
    await db.close();
@@ -73,16 +73,30 @@ export const getDocumentByField = async (collectionName, field, value) => {
 };

 // Function to update a document by a specific field
-export const updateDocumentByField = async (collectionName, field, value, updatedFields) => {
-  log.DEBUG("Update document by field:", collectionName, field, value, updatedFields);
+export const updateDocumentByField = async (
+  collectionName,
+  field,
+  value,
+  updatedFields,
+) => {
+  log.DEBUG(
+    "Update document by field:",
+    collectionName,
+    field,
+    value,
+    updatedFields,
+  );
  const db = await connectToDatabase();
  try {
    const collection = db.db().collection(collectionName);
-    const result = await collection.updateOne({ [field]: value }, { $set: updatedFields });
-    log.DEBUG('Document updated:', result.modifiedCount);
+    const result = await collection.updateOne(
+      { [field]: value },
+      { $set: updatedFields },
+    );
+    log.DEBUG("Document updated:", result.modifiedCount);
    return result.modifiedCount;
  } catch (error) {
-    console.error('Error updating document:', error);
+    console.error("Error updating document:", error);
    throw error;
  } finally {
    await db.close();
@@ -96,12 +110,12 @@ export const deleteDocumentByField = async (collectionName, field, value) => {
  try {
    const collection = db.db().collection(collectionName);
    const result = await collection.deleteOne({ [field]: value });
-    log.DEBUG('Document deleted:', result.deletedCount);
+    log.DEBUG("Document deleted:", result.deletedCount);
    return result.deletedCount;
  } catch (error) {
-    console.error('Error deleting document:', error);
+    console.error("Error deleting document:", error);
    throw error;
  } finally {
    await db.close();
  }
-};
+};
--- a/modules/mongo-wrappers/mongoNodesWrappers.mjs
+++ b/modules/mongo-wrappers/mongoNodesWrappers.mjs
@@ -1,8 +1,12 @@
 import { DebugBuilder } from "../../modules/debugger.mjs";
 const log = new DebugBuilder("server", "mongoNodesWrappers");
-import { insertDocument, getDocuments, connectToDatabase } from "./mongoHandler.mjs";
+import {
+  insertDocument,
+  getDocuments,
+  connectToDatabase,
+} from "./mongoHandler.mjs";

-const collectionName = 'nodes';
+const collectionName = "nodes";

 // Wrapper for inserting a node
 export const createNode = async (node) => {
@@ -10,7 +14,7 @@ export const createNode = async (node) => {
    const insertedId = await insertDocument(collectionName, node);
    return insertedId;
  } catch (error) {
-    log.ERROR('Error creating node:', error);
+    log.ERROR("Error creating node:", error);
    throw error;
  }
 };
@@ -21,7 +25,7 @@ export const getAllNodes = async () => {
    const nodes = await getDocuments(collectionName);
    return nodes;
  } catch (error) {
-    log.ERROR('Error getting all nodes:', error);
+    log.ERROR("Error getting all nodes:", error);
    throw error;
  }
 };
@@ -29,12 +33,12 @@ export const getAllNodes = async () => {
 // Wrapper for retrieving a node by NUID
 export const getNodeByNuid = async (nuid) => {
  const db = await connectToDatabase();
-  try {    
+  try {
    const collection = db.db().collection(collectionName);
    const node = await collection.findOne({ nuid });
    return node;
  } catch (error) {
-    log.ERROR('Error getting node by NUID:', error);
+    log.ERROR("Error getting node by NUID:", error);
    throw error;
  } finally {
    // Close the connection
@@ -47,11 +51,14 @@ export const updateNodeByNuid = async (nuid, updatedFields) => {
  const db = await connectToDatabase();
  try {
    const collection = db.db().collection(collectionName);
-    const result = await collection.updateOne({ nuid }, { $set: updatedFields });
-    log.INFO('Node updated:', result.modifiedCount);
+    const result = await collection.updateOne(
+      { nuid },
+      { $set: updatedFields },
+    );
+    log.INFO("Node updated:", result.modifiedCount);
    return result.modifiedCount;
  } catch (error) {
-    log.ERROR('Error updating node by NUID:', error);
+    log.ERROR("Error updating node by NUID:", error);
    throw error;
  } finally {
    // Close the connection
@@ -62,16 +69,16 @@ export const updateNodeByNuid = async (nuid, updatedFields) => {
 // Wrapper for deleting a node by NUID
 export const deleteNodeByNuid = async (nuid) => {
  const db = await connectToDatabase();
-  try {    
+  try {
    const collection = db.db().collection(collectionName);
    const result = await collection.deleteOne({ nuid });
-    log.INFO('Node deleted:', result.deletedCount);
+    log.INFO("Node deleted:", result.deletedCount);
    return result.deletedCount;
  } catch (error) {
-    log.ERROR('Error deleting node by NUID:', error);
+    log.ERROR("Error deleting node by NUID:", error);
    throw error;
  } finally {
    // Close the connection
    await db.close();
  }
-};
+};
--- a/modules/mongo-wrappers/mongoSystemsWrappers.mjs
+++ b/modules/mongo-wrappers/mongoSystemsWrappers.mjs
@@ -1,113 +1,119 @@
 import { DebugBuilder } from "../../modules/debugger.mjs";
 const log = new DebugBuilder("server", "mongoSystemsWrappers");
-import { insertDocument, getDocuments, connectToDatabase } from "./mongoHandler.mjs";
+import {
+  insertDocument,
+  getDocuments,
+  connectToDatabase,
+} from "./mongoHandler.mjs";

-const collectionName = 'radio-systems';
+const collectionName = "radio-systems";

 // Local wrapper to remove any local files from radio systems
 const removeLocalFilesFromsystem = async (system) => {
-    if (system.trunkFile) delete system.trunkFile;
-    if (system.whitelistFile) delete system.whitelistFile;
-}
-
+  if (system.trunkFile) delete system.trunkFile;
+  if (system.whitelistFile) delete system.whitelistFile;
+};

 // Wrapper for inserting a system
 export const createSystem = async (name, system, nuid) => {
-    try {
-        // Remove any local files
-        await removeLocalFilesFromsystem(system);
-        // Add the NUID of the node that created this system
-        system.nodes = [nuid];
-        // Add the name of the system 
-        system.name = name
-        const insertedId = await insertDocument(collectionName, system);
-        return insertedId;
-    } catch (error) {
-        log.ERROR('Error creating system:', error);
-        throw error;
-    }
+  try {
+    // Remove any local files
+    await removeLocalFilesFromsystem(system);
+    // Add the NUID of the node that created this system
+    system.nodes = [nuid];
+    // Add the name of the system
+    system.name = name;
+    const insertedId = await insertDocument(collectionName, system);
+    return insertedId;
+  } catch (error) {
+    log.ERROR("Error creating system:", error);
+    throw error;
+  }
 };

 // Wrapper for retrieving all systems
 export const getAllSystems = async () => {
-    try {
-        const systems = await getDocuments(collectionName);
-        return systems;
-    } catch (error) {
-        log.ERROR('Error getting all systems:', error);
-        throw error;
-    }
+  try {
+    const systems = await getDocuments(collectionName);
+    return systems;
+  } catch (error) {
+    log.ERROR("Error getting all systems:", error);
+    throw error;
+  }
 };

 // Wrapper for retrieving a system by name
 export const getSystemByName = async (name) => {
-    const db = await connectToDatabase();
-    try {        
-        const collection = db.db().collection(collectionName);
-        const system = await collection.findOne({ name });
-        return system;
-    } catch (error) {
-        log.ERROR('Error getting system by name:', error);
-        throw error;
-    } finally {
-        // Close the connection
-        await db.close();
-    }
+  const db = await connectToDatabase();
+  try {
+    const collection = db.db().collection(collectionName);
+    const system = await collection.findOne({ name });
+    return system;
+  } catch (error) {
+    log.ERROR("Error getting system by name:", error);
+    throw error;
+  } finally {
+    // Close the connection
+    await db.close();
+  }
 };

 // Wrapper to get all systems from a given node
 export const getSystemsByNuid = async (nuid) => {
-    const db = await connectToDatabase();
-    try {        
-        const collection = db.db().collection(collectionName);
+  const db = await connectToDatabase();
+  try {
+    const collection = db.db().collection(collectionName);

-        // Query for documents where the 'nodes' array contains the given nodeID
-        const query = { nodes: nuid };
-        const systems = await collection.find(query).toArray();
+    // Query for documents where the 'nodes' array contains the given nodeID
+    const query = { nodes: nuid };
+    const systems = await collection.find(query).toArray();

-        return systems;
-    } catch (error) {
-        log.ERROR('Error finding entries:', error);
-        throw error;
-    } finally {
-        // Close the connection
-        await db.close();
-    }
+    return systems;
+  } catch (error) {
+    log.ERROR("Error finding entries:", error);
+    throw error;
+  } finally {
+    // Close the connection
+    await db.close();
+  }
 };

 // Wrapper for updating a system by name
 export const updateSystemByName = async (name, updatedSystem) => {
-    // Remove any local files
-    await removeLocalFilesFromsystem(updatedSystem);
-    
-    const db = await connectToDatabase();
-    try {        
-        const collection = db.db().collection(collectionName);
-        const result = await collection.updateOne({ name }, { $set: updatedSystem });
-        log.INFO('System updated:', result.modifiedCount);
-        return result.modifiedCount;
-    } catch (error) {
-        log.ERROR('Error updating system by name:', error);
-        throw error;
-    } finally {
-        // Close the connection
-        await db.close();
-    }
+  // Remove any local files
+  await removeLocalFilesFromsystem(updatedSystem);
+
+  const db = await connectToDatabase();
+  try {
+    const collection = db.db().collection(collectionName);
+    const result = await collection.updateOne(
+      { name },
+      { $set: updatedSystem },
+    );
+    log.INFO("System updated:", result.modifiedCount);
+    return result.modifiedCount;
+  } catch (error) {
+    log.ERROR("Error updating system by name:", error);
+    throw error;
+  } finally {
+    // Close the connection
+    await db.close();
+  }
 };

 // Wrapper for deleting a system by name
 export const deleteSystemByName = async (name) => {
-    const db = await connectToDatabase();
-    try {        
-        const collection = db.db().collection(collectionName);
-        const result = await collection.deleteOne({ name });
-        log.INFO('System deleted:', result.deletedCount);
-        return result.deletedCount;
-    } catch (error) {
-        log.ERROR('Error deleting system by name:', error);
-        throw error;
-    } finally {
-        // Close the connection
-        await db.close();
-    }
-};
+  const db = await connectToDatabase();
+  try {
+    const collection = db.db().collection(collectionName);
+    const result = await collection.deleteOne({ name });
+    log.INFO("System deleted:", result.deletedCount);
+    return result.deletedCount;
+  } catch (error) {
+    log.ERROR("Error deleting system by name:", error);
+    throw error;
+  } finally {
+    // Close the connection
+    await db.close();
+  }
+};