refactor(frontend): added date-fns into the frontend

frontend/package-lock.json

@@ -28,6 +28,7 @@
                 "class-variance-authority": "^0.7.1",
                 "clsx": "^2.1.1",
                 "date-fns": "^4.1.0",
+                "date-fns-tz": "^3.2.0",
                 "dotenv": "^16.4.7",
                 "hono": "^4.7.5",
                 "js-cookie": "^3.0.5",
@@ -3775,6 +3776,15 @@
                 "url": "https://github.com/sponsors/kossnocorp"
             }
         },
+        "node_modules/date-fns-tz": {
+            "version": "3.2.0",
+            "resolved": "https://registry.npmjs.org/date-fns-tz/-/date-fns-tz-3.2.0.tgz",
+            "integrity": "sha512-sg8HqoTEulcbbbVXeg84u5UnlsQa8GS5QXMqjjYIhS4abEVVKIUwe0/l/UhrZdKaL/W5eWZNlbTeEIiOXTcsBQ==",
+            "license": "MIT",
+            "peerDependencies": {
+                "date-fns": "^3.0.0 || ^4.0.0"
+            }
+        },
         "node_modules/debug": {
             "version": "4.4.0",
             "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.0.tgz",

frontend/package.json

@@ -32,6 +32,7 @@
         "class-variance-authority": "^0.7.1",
         "clsx": "^2.1.1",
         "date-fns": "^4.1.0",
+        "date-fns-tz": "^3.2.0",
         "dotenv": "^16.4.7",
         "hono": "^4.7.5",
         "js-cookie": "^3.0.5",

frontend/src/components/admin/servers/ServerPage.tsx

@@ -1,108 +1,126 @@
-import {LstCard} from "@/components/extendedUI/LstCard";
+import { LstCard } from "@/components/extendedUI/LstCard";
-
+import { Skeleton } from "@/components/ui/skeleton";
-import {Skeleton} from "@/components/ui/skeleton";
+import {
-import {Table, TableBody, TableCell, TableHead, TableHeader, TableRow} from "@/components/ui/table";
+  Table,
-import {useSessionStore} from "@/lib/store/sessionStore";
+  TableBody,
-import {useModuleStore} from "@/lib/store/useModuleStore";
+  TableCell,
-import {getServers} from "@/utils/querys/servers";
+  TableHead,
-import {useQuery} from "@tanstack/react-query";
+  TableHeader,
-import {useRouter} from "@tanstack/react-router";
+  TableRow,
-import {format} from "date-fns";
+} from "@/components/ui/table";
+import { useSessionStore } from "@/lib/store/sessionStore";
+import { useModuleStore } from "@/lib/store/useModuleStore";
+import { getServers } from "@/utils/querys/servers";
+import { useQuery } from "@tanstack/react-query";
+import { useRouter } from "@tanstack/react-router";
+import { format } from "date-fns";
 import UpdateServer from "./UpdateServer";
-import {adminUrlCheck} from "@/utils/adminUrlCheck";
+import { adminUrlCheck } from "@/utils/adminUrlCheck";
 import RestartServer from "./RestartServer";
 import StopServer from "./StopServer";
 import StartServer from "./StartServer";
+import { formatInTimeZone } from "date-fns-tz";
 
 export type Servers = {
-    server_id?: string;
+  server_id?: string;
-    sName?: string;
+  sName?: string;
-    serverDNS?: string;
+  serverDNS?: string;
-    plantToken?: string;
+  plantToken?: string;
-    idAddress: string;
+  idAddress: string;
-    lastUpdated: string;
+  lastUpdated: string;
-    isUpgrading: boolean;
+  isUpgrading: boolean;
 };
 
 export default function ServerPage() {
-    const {user, token} = useSessionStore();
+  const { user, token } = useSessionStore();
-    const {modules} = useModuleStore();
+  const { modules } = useModuleStore();
-    const router = useRouter();
+  const router = useRouter();
 
-    const {data, isError, error, isLoading} = useQuery(getServers(token ?? ""));
+  const { data, isError, error, isLoading } = useQuery(getServers(token ?? ""));
 
-    const adminModule = modules.filter((n) => n.name === "admin");
+  const adminModule = modules.filter((n) => n.name === "admin");
-    const userLevel = user?.roles?.filter((r) => r.module_id === adminModule[0].module_id) || [];
+  const userLevel =
+    user?.roles?.filter((r) => r.module_id === adminModule[0].module_id) || [];
 
-    if (!adminModule[0]?.roles?.includes(userLevel[0]?.role)) {
+  if (!adminModule[0]?.roles?.includes(userLevel[0]?.role)) {
-        router.navigate({to: "/"});
+    router.navigate({ to: "/" });
-    }
+  }
 
-    if (isError) {
+  if (isError) {
-        return <div>{JSON.stringify(error)}</div>;
+    return <div>{JSON.stringify(error)}</div>;
-    }
+  }
-    return (
+
-        <LstCard className="m-2 flex place-content-center w-dvh">
+  console.log(data);
-            <Table>
+  return (
-                <TableHeader>
+    <LstCard className="m-2 flex place-content-center w-dvh">
-                    <TableRow>
+      <Table>
-                        <TableHead>Name</TableHead>
+        <TableHeader>
-                        <TableHead>Server</TableHead>
+          <TableRow>
-                        <TableHead>PlantToken</TableHead>
+            <TableHead>Name</TableHead>
-                        <TableHead>IP Address</TableHead>
+            <TableHead>Server</TableHead>
-                        <TableHead>Date Last updated</TableHead>
+            <TableHead>PlantToken</TableHead>
-                        <TableHead>Update Server</TableHead>
+            <TableHead>IP Address</TableHead>
-                    </TableRow>
+            <TableHead>Date Last updated</TableHead>
-                </TableHeader>
+            <TableHead>Update Server</TableHead>
-                {isLoading ? (
+          </TableRow>
-                    <>
+        </TableHeader>
-                        <TableBody>
+        {isLoading ? (
-                            {Array(10)
+          <>
-                            .fill(0)
+            <TableBody>
-                            .map((_, i) => (
+              {Array(10)
-                                <TableRow key={i}>
+                .fill(0)
-                                    <TableCell className="font-medium">
+                .map((_, i) => (
-                                        <Skeleton className="h-4" />
+                  <TableRow key={i}>
-                                    </TableCell>
+                    <TableCell className="font-medium">
-                                    <TableCell>
+                      <Skeleton className="h-4" />
-                                        <Skeleton className="h-4" />
+                    </TableCell>
-                                    </TableCell>
+                    <TableCell>
-                                    <TableCell>
+                      <Skeleton className="h-4" />
-                                        <Skeleton className="h-4" />
+                    </TableCell>
-                                    </TableCell>
+                    <TableCell>
-                                    <TableCell>
+                      <Skeleton className="h-4" />
-                                        <Skeleton className="h-4" />
+                    </TableCell>
-                                    </TableCell>
+                    <TableCell>
-                                </TableRow>
+                      <Skeleton className="h-4" />
-                            ))}
+                    </TableCell>
-                        </TableBody>
+                  </TableRow>
-                    </>
+                ))}
-                ) : (
+            </TableBody>
-                    <TableBody>
+          </>
-                        {data?.map((server: Servers) => (
+        ) : (
-                            <TableRow key={server.server_id}>
+          <TableBody>
-                                <TableCell className="font-medium">{server.sName}</TableCell>
+            {data?.map((server: Servers) => {
-                                <TableCell className="font-medium">{server.serverDNS}</TableCell>
+              const strippedDate = server.lastUpdated.replace("Z", ""); // Remove Z
-                                <TableCell className="font-medium">{server.plantToken}</TableCell>
+              const formattedDate = format(strippedDate, "MM/dd/yyyy hh:mm a");
-                                <TableCell className="font-medium">{server.idAddress}</TableCell>
+              return (
-                                <TableCell className="font-medium">
+                <TableRow key={server.server_id}>
-                                    {format(server.lastUpdated, "MM/dd/yyyy hh:mm")}
+                  <TableCell className="font-medium">{server.sName}</TableCell>
-                                </TableCell>
+                  <TableCell className="font-medium">
-                                <TableCell className="font-medium">
+                    {server.serverDNS}
-                                    {adminUrlCheck() && (
+                  </TableCell>
-                                        <div className="flex flex-row">
+                  <TableCell className="font-medium">
-                                            <UpdateServer server={server} token={token as string} />
+                    {server.plantToken}
-                                            <StartServer />
+                  </TableCell>
-                                            <StopServer />
+                  <TableCell className="font-medium">
-                                            <RestartServer />
+                    {server.idAddress}
-                                        </div>
+                  </TableCell>
-                                    )}
+                  <TableCell className="font-medium">{formattedDate}</TableCell>
-                                </TableCell>
+                  <TableCell className="font-medium">
-                            </TableRow>
+                    {adminUrlCheck() && (
-                        ))}
+                      <div className="flex flex-row">
-                    </TableBody>
+                        <UpdateServer server={server} token={token as string} />
-                )}
+                        <StartServer />
-            </Table>
+                        <StopServer />
-        </LstCard>
+                        <RestartServer />
-    );
+                      </div>
+                    )}
+                  </TableCell>
+                </TableRow>
+              );
+            })}
+          </TableBody>
+        )}
+      </Table>
+    </LstCard>
+  );
 }

frontend/src/components/auth/LoginForm.tsx

@@ -1,153 +1,164 @@
-import {useSessionStore} from "../../lib/store/sessionStore";
+import { useSessionStore } from "../../lib/store/sessionStore";
-import {LstCard} from "../extendedUI/LstCard";
+import { LstCard } from "../extendedUI/LstCard";
-import {CardHeader} from "../ui/card";
+import { CardHeader } from "../ui/card";
-import {toast} from "sonner";
+import { toast } from "sonner";
-import {z} from "zod";
+import { z } from "zod";
-import {useRouter} from "@tanstack/react-router";
+import { useRouter } from "@tanstack/react-router";
-import {Controller, useForm} from "react-hook-form";
+import { Controller, useForm } from "react-hook-form";
-import {zodResolver} from "@hookform/resolvers/zod";
+import { zodResolver } from "@hookform/resolvers/zod";
-import {Label} from "../ui/label";
+import { Label } from "../ui/label";
-import {Input} from "../ui/input";
+import { Input } from "../ui/input";
-import {Checkbox} from "../ui/checkbox";
+import { Checkbox } from "../ui/checkbox";
-import {Button} from "../ui/button";
+import { Button } from "../ui/button";
 
 const FormSchema = z.object({
-    username: z.string().min(1, "You must enter a valid username"),
+  username: z.string().min(1, "You must enter a valid username"),
-    password: z.string().min(4, "You must enter a valid password"),
+  password: z.string().min(4, "You must enter a valid password"),
-    rememberMe: z.boolean(),
+  rememberMe: z.boolean(),
 });
 
 const LoginForm = () => {
-    const {setSession} = useSessionStore();
+  const { setSession } = useSessionStore();
-    const rememeberMe = localStorage.getItem("rememberMe") === "true";
+  const rememeberMe = localStorage.getItem("rememberMe") === "true";
-    const username = localStorage.getItem("username") || "";
+  const username = localStorage.getItem("username") || "";
-    const router = useRouter();
+  const router = useRouter();
-    const {
+  const {
-        register,
+    register,
-        handleSubmit,
+    handleSubmit,
-        control,
+    control,
-        formState: {errors},
+    formState: { errors },
-    } = useForm<z.infer<typeof FormSchema>>({
+  } = useForm<z.infer<typeof FormSchema>>({
-        resolver: zodResolver(FormSchema),
+    resolver: zodResolver(FormSchema),
-        defaultValues: {
+    defaultValues: {
-            username: username || "",
+      username: username || "",
-            password: "",
+      password: "",
-            rememberMe: rememeberMe,
+      rememberMe: rememeberMe,
+    },
+  });
+
+  const onSubmitLogin = async (value: z.infer<typeof FormSchema>) => {
+    // Do something with form data
+
+    // first update the rememberMe incase it was selected
+    if (value.rememberMe) {
+      localStorage.setItem("rememberMe", value.rememberMe.toString());
+      localStorage.setItem("username", value.username);
+    } else {
+      localStorage.removeItem("rememberMe");
+      localStorage.removeItem("username");
+    }
+
+    try {
+      const response = await fetch("/api/auth/login", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
         },
-    });
+        body: JSON.stringify({
+          username: value.username,
+          password: value.password,
+        }),
+      });
 
-    const onSubmitLogin = async (value: z.infer<typeof FormSchema>) => {
+      const data = await response.json();
-        // Do something with form data
 
-        // first update the rememberMe incase it was selected
+      // Store token in localStorage
-        if (value.rememberMe) {
+      // localStorage.setItem("auth_token", data.data.token);
-            localStorage.setItem("rememberMe", value.rememberMe.toString());
+      if (data.success) {
-            localStorage.setItem("username", value.username);
+        const prod = btoa(`${value.username.toLowerCase()}:${value.password}`);
-        } else {
+        const prodUser = { ...data.user, prod: prod };
-            localStorage.removeItem("rememberMe");
-            localStorage.removeItem("username");
-        }
 
-        try {
+        setSession(prodUser, data.token);
-            const response = await fetch("/api/auth/login", {
+        toast.success(`You are logged in as ${data.user.username}`);
-                method: "POST",
+        router.navigate({ to: "/" });
-                headers: {
+      }
-                    "Content-Type": "application/json",
-                },
-                body: JSON.stringify({username: value.username, password: value.password}),
-            });
 
-            const data = await response.json();
+      if (!data.success) {
+        toast.error(`${data.message}`);
+      }
 
-            // Store token in localStorage
+      //console.log(data);
-            // localStorage.setItem("auth_token", data.data.token);
+    } catch (err) {
-            if (data.success) {
+      toast.error("Invalid credentials");
-                const prod = btoa(`${value.username.toLowerCase()}:${value.password}`);
+    }
-                const prodUser = {...data.user, prod: prod};
+  };
 
-                setSession(prodUser, data.token);
+  return (
-                toast.success(`You are logged in as ${data.user.username}`);
+    <div className="ml-[25%]">
-                router.navigate({to: "/"});
+      <LstCard className="p-3 w-96">
-            }
+        <CardHeader>
+          <div>
+            <p className="text-2xl">Login to LST</p>
+          </div>
+        </CardHeader>
+        <hr className="rounded"></hr>
+        <form onSubmit={handleSubmit(onSubmitLogin)}>
+          <div>
+            <Label htmlFor="username" className="m-1">
+              Username
+            </Label>
+            <Input
+              placeholder="smith001"
+              {...register("username")}
+              className={errors.username ? "border-red-500" : ""}
+              aria-invalid={!!errors.username}
+            />
+            {errors.username && (
+              <p className="text-red-500 text-sm mt-1">
+                {errors.username.message}
+              </p>
+            )}
+          </div>
+          <div>
+            <>
+              <Label htmlFor={"password"} className="m-1">
+                Password
+              </Label>
+              <Input
+                type="password"
+                {...register("password")}
+                className={errors.password ? "border-red-500" : ""}
+                aria-invalid={!!errors.password}
+              />
+              {errors.password && (
+                <p className="text-red-500 text-sm mt-1">
+                  {errors.password.message}
+                </p>
+              )}
+            </>
+          </div>
+          <div className="flex justify-between pt-2">
+            <div className="flex">
+              <Controller
+                render={({ field }) => (
+                  <>
+                    <Checkbox
+                      id="remember"
+                      checked={field.value}
+                      onCheckedChange={field.onChange}
+                    />
+                    <label
+                      htmlFor="remember"
+                      className="pl-2 text-sm font-medium leading-none peer-disabled:cursor-not-allowed peer-disabled:opacity-70"
+                    >
+                      remember me
+                    </label>
+                  </>
+                )}
+                control={control}
+                name="rememberMe"
+                defaultValue={rememeberMe}
+              />
+            </div>
 
-            if (!data.success) {
+            <div className="flex justify-end">
-                toast.error(`${data.message}`);
+              <Button type="submit">Submit</Button>
-            }
+            </div>
-
+          </div>
-            console.log(data);
+        </form>
-        } catch (err) {
+      </LstCard>
-            toast.error("Invalid credentials");
+    </div>
-        }
+  );
-    };
-
-    return (
-        <div className="ml-[25%]">
-            <LstCard className="p-3 w-96">
-                <CardHeader>
-                    <div>
-                        <p className="text-2xl">Login to LST</p>
-                    </div>
-                </CardHeader>
-                <hr className="rounded"></hr>
-                <form onSubmit={handleSubmit(onSubmitLogin)}>
-                    <div>
-                        <Label htmlFor="username" className="m-1">
-                            Username
-                        </Label>
-                        <Input
-                            placeholder="smith001"
-                            {...register("username")}
-                            className={errors.username ? "border-red-500" : ""}
-                            aria-invalid={!!errors.username}
-                        />
-                        {errors.username && <p className="text-red-500 text-sm mt-1">{errors.username.message}</p>}
-                    </div>
-                    <div>
-                        <>
-                            <Label htmlFor={"password"} className="m-1">
-                                Password
-                            </Label>
-                            <Input
-                                type="password"
-                                {...register("password")}
-                                className={errors.password ? "border-red-500" : ""}
-                                aria-invalid={!!errors.password}
-                            />
-                            {errors.password && <p className="text-red-500 text-sm mt-1">{errors.password.message}</p>}
-                        </>
-                    </div>
-                    <div className="flex justify-between pt-2">
-                        <div className="flex">
-                            <Controller
-                                render={({field}) => (
-                                    <>
-                                        <Checkbox
-                                            id="remember"
-                                            checked={field.value}
-                                            onCheckedChange={field.onChange}
-                                        />
-                                        <label
-                                            htmlFor="remember"
-                                            className="pl-2 text-sm font-medium leading-none peer-disabled:cursor-not-allowed peer-disabled:opacity-70"
-                                        >
-                                            remember me
-                                        </label>
-                                    </>
-                                )}
-                                control={control}
-                                name="rememberMe"
-                                defaultValue={rememeberMe}
-                            />
-                        </div>
-
-                        <div className="flex justify-end">
-                            <Button type="submit">Submit</Button>
-                        </div>
-                    </div>
-                </form>
-            </LstCard>
-        </div>
-    );
 };
 
 export default LoginForm;

package.json

@@ -32,7 +32,7 @@
     }
   },
   "admConfig": {
-    "build": 47,
+    "build": 48,
     "oldBuild": "backend-0.1.3.zip"
   },
   "devDependencies": {
@@ -78,4 +78,4 @@
     "ws": "^8.18.1",
     "zod": "^3.24.2"
   }
-}
+}

server/services/auth/routes/user/getUserRoles.ts

@@ -1,10 +1,7 @@
 import { z, createRoute, OpenAPIHono } from "@hono/zod-openapi";
-import { apiHit } from "../../../../globalUtils/apiHits.js";
 import jwt from "jsonwebtoken";
-
 import type { CustomJwtPayload } from "../../../../types/jwtToken.js";
 import { authMiddleware } from "../../middleware/authMiddleware.js";
-import hasCorrectRole from "../../middleware/roleCheck.js";
 import { roleCheck } from "../../controllers/userRoles/getUserAccess.js";
 
 const { verify } = jwt;
@@ -16,10 +13,10 @@ const responseSchema = z.object({
 
 app.openapi(
   createRoute({
-    tags: ["Auth:user"],
+    tags: ["auth:user"],
     summary: "returns the users access",
     method: "get",
-    path: "/getAccess",
+    path: "/getuseraccess",
     middleware: [authMiddleware],
     responses: {
       200: {

server/services/sqlServer/prodSqlServer.ts

@@ -1,111 +1,198 @@
 import sql from "mssql";
-import {prodSqlConfig} from "./utils/prodServerConfig.js";
+import { prodSqlConfig } from "./utils/prodServerConfig.js";
-import {createLog} from "../logger/logger.js";
+import { createLog } from "../logger/logger.js";
-import {db} from "../../../database/dbclient.js";
+import { db } from "../../../database/dbclient.js";
-import {settings} from "../../../database/schema/settings.js";
+import { settings } from "../../../database/schema/settings.js";
-import {eq} from "drizzle-orm";
+import { eq } from "drizzle-orm";
-import {installed} from "../../index.js";
+import { installed } from "../../index.js";
-import {checkHostnamePort} from "../../globalUtils/pingServer.js";
+import { checkHostnamePort } from "../../globalUtils/pingServer.js";
 
 let pool: any;
 let connected: boolean = false;
 export const initializeProdPool = async () => {
-    if (!installed) {
+  if (!installed) {
-        createLog("info", "lst", "sqlProd", "The server was not installed will reconnect in 5 seconds");
+    createLog(
-        setTimeout(() => {
+      "info",
-            initializeProdPool();
+      "lst",
-        }, 5 * 1000);
+      "sqlProd",
+      "The server was not installed will reconnect in 5 seconds"
+    );
+    setTimeout(() => {
+      initializeProdPool();
+    }, 5 * 1000);
 
-        return {success: false, message: "The server is not installed."};
+    return { success: false, message: "The server is not installed." };
-    }
+  }
-    const dbServer = await db.select().from(settings).where(eq(settings.name, "dbServer"));
+  const dbServer = await db
-    const serverUp = await checkHostnamePort(`${dbServer[0].value}:1433`);
+    .select()
+    .from(settings)
+    .where(eq(settings.name, "dbServer"));
+  const serverUp = await checkHostnamePort(`${dbServer[0].value}:1433`);
 
-    if (!serverUp) {
+  if (!serverUp) {
-        createLog("error", "lst", "server", `The sql ${dbServer[0].value} is not reachable`);
+    createLog(
-        return {success: false, message: `The sql ${dbServer[0].value} is not reachable`};
+      "error",
-    }
+      "lst",
+      "server",
+      `The sql ${dbServer[0].value} is not reachable`
+    );
+    return {
+      success: false,
+      message: `The sql ${dbServer[0].value} is not reachable`,
+    };
+  }
 
-    // make sure the server is not set to localhost this will prevent some weird issues later but can be localhost on the dev
+  // make sure the server is not set to localhost this will prevent some weird issues later but can be localhost on the dev
-    const serverLoc = await db.select().from(settings).where(eq(settings.name, "dbServer"));
+  const serverLoc = await db
-    if (serverLoc[0].value === "localhost" && process.env.NODE_ENV !== "development") {
+    .select()
-        createLog("error", "lst", "sqlProd", "The server is set to localhost, and you are not in development mode.");
+    .from(settings)
-        return {success: false, message: "The server is set to localhost, and you are not in development mode."};
+    .where(eq(settings.name, "dbServer"));
-    }
+  if (
+    serverLoc[0].value === "localhost" &&
+    process.env.NODE_ENV !== "development"
+  ) {
+    createLog(
+      "error",
+      "lst",
+      "sqlProd",
+      "The server is set to localhost, and you are not in development mode."
+    );
+    return {
+      success: false,
+      message:
+        "The server is set to localhost, and you are not in development mode.",
+    };
+  }
 
-    // if you were restarting from the endpoint you get this lovely error
+  // if you were restarting from the endpoint you get this lovely error
-    if (connected) {
+  if (connected) {
-        createLog("error", "lst", "sqlProd", "There is already a connection.");
+    createLog("error", "lst", "sqlProd", "There is already a connection.");
-        return {success: false, message: "There is already a connection."};
+    return { success: false, message: "There is already a connection." };
-    }
+  }
-    try {
+  try {
-        const config = await prodSqlConfig();
+    const config = await prodSqlConfig();
-        pool = await sql.connect(config!);
+    pool = await sql.connect(config!);
 
-        createLog("info", "lst", "sqlProd", `Connected to ${config?.server}, and looking at ${config?.database}`);
+    createLog(
-        connected = true;
+      "info",
-        return {success: true, message: "The sql server connection has been closed"};
+      "lst",
-    } catch (error) {
+      "sqlProd",
-        createLog("error", "lst", "sqlProd", `${JSON.stringify(error)}, "There was an error connecting to the pool."`);
+      `Connected to ${config?.server}, and looking at ${config?.database}`
-        throw new Error("There was an error closing the sql connection");
+    );
-    }
+    connected = true;
+    return {
+      success: true,
+      message: "The sql server connection has been closed",
+    };
+  } catch (error) {
+    createLog(
+      "error",
+      "lst",
+      "sqlProd",
+      `${JSON.stringify(error)}, "There was an error connecting to the pool."`
+    );
+    throw new Error("There was an error closing the sql connection");
+  }
 };
 
 export const closePool = async () => {
-    try {
+  if (!connected) {
-        await pool.close();
+    createLog(
-        createLog("info", "lst", "sqlProd", "Connection pool closed");
+      "error",
-        connected = false;
+      "lst",
-        return {success: true, message: "The sql server connection has been closed"};
+      "sqlProd",
-    } catch (error) {
+      "There is no connection a connection."
-        createLog(
+    );
-            "error",
+    return { success: false, message: "There is already a connection." };
-            "lst",
+  }
-            "sqlProd",
+  try {
-            `${JSON.stringify(error)},  "There was an error closing the sql connection"`
+    await pool.close();
-        );
+    createLog("info", "lst", "sqlProd", "Connection pool closed");
-        throw new Error("There was an error closing the sql connection");
+    connected = false;
-    }
+    return {
+      success: true,
+      message: "The sql server connection has been closed",
+    };
+  } catch (error) {
+    createLog(
+      "error",
+      "lst",
+      "sqlProd",
+      `${JSON.stringify(
+        error
+      )},  "There was an error closing the sql connection"`
+    );
+    throw new Error("There was an error closing the sql connection");
+  }
 };
 
 export async function query(queryToRun: string, name: string) {
-    /**
+  /**
-     * Just an extra catch incase someone tried to run a query while we were not connected to the server or sql server
+   * Just an extra catch incase someone tried to run a query while we were not connected to the server or sql server
-     */
+   */
-    const dbServer = await db.select().from(settings).where(eq(settings.name, "dbServer"));
+  const dbServer = await db
-    const serverUp = await checkHostnamePort(`${dbServer[0].value}:1433`);
+    .select()
+    .from(settings)
+    .where(eq(settings.name, "dbServer"));
+  const serverUp = await checkHostnamePort(`${dbServer[0].value}:1433`);
 
-    if (!serverUp) {
+  if (!serverUp) {
-        createLog("error", "lst", "server", `The sql ${dbServer[0].value} is not reachable`);
+    createLog(
-        return {success: false, message: `The sql ${dbServer[0].value} is not reachable`};
+      "error",
+      "lst",
+      "server",
+      `The sql ${dbServer[0].value} is not reachable`
+    );
+    return {
+      success: false,
+      message: `The sql ${dbServer[0].value} is not reachable`,
+    };
+  }
+
+  if (!connected) {
+    createLog(
+      "error",
+      "lst",
+      "server",
+      `The sql ${dbServer[0].value} is not connected`
+    );
+    return {
+      success: false,
+      message: `The sql ${dbServer[0].value} is not not connected`,
+    };
+  }
+  /**
+   * We no longer need to send over the plant token change as we do it inside the query function.
+   */
+  const plantToken = await db
+    .select()
+    .from(settings)
+    .where(eq(settings.name, "plantToken"));
+  const query = queryToRun.replaceAll("test1", plantToken[0].value);
+
+  try {
+    const result = await pool.request().query(query);
+
+    return result.recordset;
+  } catch (error: any) {
+    if (error.code === "ETIMEOUT") {
+      createLog(
+        "error",
+        "lst",
+        "sqlProd",
+        `${JSON.stringify(error)}, ${name} did not run due to a timeout.`
+      );
+      throw new Error(`${name} query did not run due to a timeout.`);
     }
 
-    if (!connected) {
+    if (error.code === "EREQUEST") {
-        createLog("error", "lst", "server", `The sql ${dbServer[0].value} is not connected`);
+      throw new Error(
-        return {success: false, message: `The sql ${dbServer[0].value} is not not connected`};
+        `${name} encoutnered an error ${error.originalError.info.message}`
+      );
     }
-    /**
-     * We no longer need to send over the plant token change as we do it inside the query function.
-     */
-    const plantToken = await db.select().from(settings).where(eq(settings.name, "plantToken"));
-    const query = queryToRun.replaceAll("test1", plantToken[0].value);
 
-    try {
+    //console.log(error.originalError.info.message);
-        const result = await pool.request().query(query);
+    //EREQUEST
-
+    //throw new Error(`${name} encoutnered an error ${error.code}`);
-        return result.recordset;
+  }
-    } catch (error: any) {
-        if (error.code === "ETIMEOUT") {
-            createLog("error", "lst", "sqlProd", `${JSON.stringify(error)}, ${name} did not run due to a timeout.`);
-            throw new Error(`${name} query did not run due to a timeout.`);
-        }
-
-        if (error.code === "EREQUEST") {
-            throw new Error(`${name} encoutnered an error ${error.originalError.info.message}`);
-        }
-
-        //console.log(error.originalError.info.message);
-        //EREQUEST
-        //throw new Error(`${name} encoutnered an error ${error.code}`);
-    }
 }