feat(lstv2 move): moved lstv2 into this app to keep them combined and easier to maintain

lstV2/server/services/dataMart/controller/fakeEDIUpdate.ts

@@ -0,0 +1,47 @@
+import { format } from "date-fns-tz";
+import { createLog } from "../../logger/logger.js";
+import { query } from "../../sqlServer/prodSqlServer.js";
+import { fakeEDIUpdate } from "../../sqlServer/querys/dataMart/fakeEDIUpdate.js";
+
+export const getFakeEDI = async (address: string) => {
+    let fakeEDI: any = [];
+
+    let updatedQuery = fakeEDIUpdate;
+
+    if (address) {
+        createLog(
+            "info",
+            "datamart",
+            "datamart",
+            "The user requested a specific address."
+        );
+        updatedQuery = fakeEDIUpdate.replace(
+            "--and IdAdresse = 14",
+            `and IdAdresse = ${address}`
+        );
+    }
+
+    try {
+        fakeEDI = await query(updatedQuery, "Gets fakeEDI orders to be fixed");
+
+        const correctedData = fakeEDI.data.map((n: any) => {
+            return {
+                ...n,
+                DeliveryDate: format(n.DeliveryDate, "M/d/yyyy HH:mm"),
+            };
+        });
+
+        return {
+            success: true,
+            message: "Current open orders",
+            data: correctedData,
+        };
+    } catch (error) {
+        console.log(error);
+        return {
+            success: false,
+            message: "There was an error open orders",
+            data: error,
+        };
+    }
+};

lstV2/server/services/dataMart/controller/getActiveArticles.ts

@@ -0,0 +1,14 @@
+import { query } from "../../sqlServer/prodSqlServer.js";
+import { activeArticle } from "../../sqlServer/querys/dataMart/article.js";
+
+export const getActiveAv = async () => {
+    let articles: any = [];
+    try {
+        const res = await query(activeArticle, "Get active articles");
+        articles = res?.data;
+    } catch (error) {
+        articles = error;
+    }
+
+    return articles;
+};

lstV2/server/services/dataMart/controller/getCustomerInventory.ts

@@ -0,0 +1,41 @@
+import { query } from "../../sqlServer/prodSqlServer.js";
+import { customerInvNoHold } from "../../sqlServer/querys/dataMart/customerInventoryQuerys.js";
+
+export const getCurrentCustomerInv = async (data: any | null) => {
+    //console.log(data.customer[0]);
+
+    let updatedQuery = customerInvNoHold;
+
+    if (data.customer) {
+        //console.log(data.customer);
+        updatedQuery = customerInvNoHold.replaceAll(
+            "--and IdAdressen",
+            `and IdAdressen = ${data.customer[0]}`
+        );
+    }
+
+    if (data.whseToInclude) {
+        updatedQuery = updatedQuery.replaceAll(
+            "--and x.IdWarenlager in (14,15)",
+            `and x.IdWarenlager in (${data.whseToInclude[0]})`
+        );
+    }
+    try {
+        const inventory: any = await query(
+            updatedQuery,
+            "Get active inventory"
+        );
+
+        return {
+            success: true,
+            message: "All customer inventory minus holds",
+            data: inventory.data,
+        };
+    } catch (error) {
+        return {
+            success: false,
+            message: "There was an error getting the inventory",
+            data: error,
+        };
+    }
+};

lstV2/server/services/dataMart/controller/getDeliveryByDateRange.ts

@@ -0,0 +1,84 @@
+import { eq } from "drizzle-orm";
+import { db } from "../../../../database/dbclient.js";
+import { settings } from "../../../../database/schema/settings.js";
+import { tryCatch } from "../../../globalUtils/tryCatch.js";
+import { query } from "../../sqlServer/prodSqlServer.js";
+import { deliveryByDateRange } from "../../sqlServer/querys/dataMart/deleveryByDateRange.js";
+import { addDays, format } from "date-fns";
+
+export const getDeliveryByDateRange = async (data: any | null) => {
+    // const { data: plantToken, error: plantError } = await tryCatch(
+    //     db.select().from(settings).where(eq(settings.name, "plantToken"))
+    // );
+    // if (plantError) {
+    //     return {
+    //         success: false,
+    //         message: "Error getting Settings",
+    //         data: plantError,
+    //     };
+    // }
+    let deliverys: any = [];
+
+    let updatedQuery = deliveryByDateRange;
+
+    // start days can be sent over
+    if (data?.start) {
+        updatedQuery = updatedQuery.replaceAll("[startDate]", data.start[0]);
+    } else {
+        updatedQuery = updatedQuery.replaceAll("[startDate]", "1990-1-1");
+    }
+
+    // end days can be sent over
+    if (data?.end) {
+        updatedQuery = updatedQuery.replaceAll("[endDate]", data.end[0]);
+    } else {
+        const defaultEndDate = format(
+            addDays(new Date(Date.now()), 5),
+            "yyyy-M-d"
+        );
+        updatedQuery = updatedQuery.replaceAll("[endDate]", defaultEndDate);
+    }
+
+    try {
+        const res: any = await query(
+            updatedQuery,
+            "Get Delivery by date range"
+        );
+        deliverys = res.data;
+        //console.log(res.data);
+    } catch (error) {
+        console.log(error);
+        return {
+            success: false,
+            message: "All Deliveries within the range.",
+            data: error,
+        };
+    }
+
+    if (!data) {
+        deliverys = deliverys.splice(1000, 0);
+    }
+    // add plant token in
+    // const pOrders = deliverys.map((item: any) => {
+    //     // const dateCon = new Date(item.loadingDate).toLocaleString("en-US", {
+    //     //     month: "numeric",
+    //     //     day: "numeric",
+    //     //     year: "numeric",
+    //     //     hour: "2-digit",
+    //     //     minute: "2-digit",
+    //     //     hour12: false,
+    //     // });
+
+    //     //const dateCon = new Date(item.loadingDate).toISOString().replace("T", " ").split(".")[0];
+    //     const dateCon = new Date(item.loadingDate).toISOString().split("T")[0];
+    //     //const delDate = new Date(item.deliveryDate).toISOString().replace("T", " ").split(".")[0];
+    //     const delDate = new Date(item.deliveryDate).toISOString().split("T")[0];
+    //     return {
+    //         plantToken: plantToken[0].value,
+    //         ...item,
+    //         loadingDate: dateCon,
+    //         deliveryDate: delDate,
+    //     };
+    // });
+    return { success: true, message: "Current open orders", data: deliverys };
+};

lstV2/server/services/dataMart/controller/getFifoIndex.ts

@@ -0,0 +1,18 @@
+import { desc } from "drizzle-orm";
+import { db } from "../../../../database/dbclient.js";
+import { fifoIndex } from "../../../../database/schema/fifoIndex.js";
+
+export const getFifoIndex = async () => {
+    let articles: any = [];
+    try {
+        const res = await db
+            .select()
+            .from(fifoIndex)
+            .orderBy(desc(fifoIndex.add_Date));
+        articles = res;
+    } catch (error) {
+        articles = error;
+    }
+
+    return articles;
+};

lstV2/server/services/dataMart/controller/getFinanceAudit.ts

@@ -0,0 +1,24 @@
+import { format } from "date-fns-tz";
+import { tryCatch } from "../../../globalUtils/tryCatch.js";
+import { query } from "../../sqlServer/prodSqlServer.js";
+import { financeAudit } from "../../sqlServer/querys/dataMart/financeAudit.js";
+
+export const getfinanceAudit = async (date: any) => {
+    let inventoryAudit: any = [];
+
+    const { data, error } = (await tryCatch(
+        query(financeAudit.replace("[date]", date), "inventory audit")
+    )) as any;
+
+    //console.log(data);
+
+    if (error) {
+        return [];
+    }
+
+    inventoryAudit = data.data.map((i: any) => {
+        return { ...i, bookinDate: format(i.bookinDate, "MM/dd/yyyy") };
+    });
+
+    return inventoryAudit;
+};

lstV2/server/services/dataMart/controller/getOpenOrders.ts

@@ -0,0 +1,73 @@
+import { eq } from "drizzle-orm";
+import { db } from "../../../../database/dbclient.js";
+import { settings } from "../../../../database/schema/settings.js";
+import { tryCatch } from "../../../globalUtils/tryCatch.js";
+import { query } from "../../sqlServer/prodSqlServer.js";
+import { openOrders } from "../../sqlServer/querys/dataMart/openOrders.js";
+import { serverSettings } from "../../server/controller/settings/getSettings.js";
+
+export const getOpenOrders = async (data: any | null) => {
+    // const { data: plantToken, error: plantError } = await tryCatch(
+    //     db.select().from(settings).where(eq(settings.name, "plantToken"))
+    // );
+    // if (plantError) {
+    //     return {
+    //         success: false,
+    //         message: "Error getting Settings",
+    //         data: plantError,
+    //     };
+    // }
+
+    const plantToken = serverSettings.filter((n) => n.name === "plantToken");
+    let orders: any = [];
+
+    let updatedQuery = openOrders;
+
+    // start days can be sent over
+    if (data?.sDay) {
+        updatedQuery = updatedQuery.replaceAll("[sDay]", data.sDay[0]);
+    } else {
+        updatedQuery = updatedQuery.replaceAll("[sDay]", "15");
+    }
+
+    // end days can be sent over
+    if (data?.eDay) {
+        updatedQuery = updatedQuery.replaceAll("[eDay]", data.eDay[0]);
+    } else {
+        updatedQuery = updatedQuery.replaceAll("[eDay]", "5");
+    }
+
+    try {
+        orders = await query(updatedQuery, "Get active openorders");
+    } catch (error) {
+        return {
+            success: false,
+            message: "Errot getting current open orders",
+            data: [],
+        };
+    }
+
+    // add plant token in
+    const pOrders = orders.data.map((item: any) => {
+        // const dateCon = new Date(item.loadingDate).toLocaleString("en-US", {
+        //     month: "numeric",
+        //     day: "numeric",
+        //     year: "numeric",
+        //     hour: "2-digit",
+        //     minute: "2-digit",
+        //     hour12: false,
+        // });
+
+        //const dateCon = new Date(item.loadingDate).toISOString().replace("T", " ").split(".")[0];
+        const dateCon = new Date(item.loadingDate).toISOString().split("T")[0];
+        //const delDate = new Date(item.deliveryDate).toISOString().replace("T", " ").split(".")[0];
+        const delDate = new Date(item.deliveryDate).toISOString().split("T")[0];
+        return {
+            plantToken: plantToken[0].value,
+            ...item,
+            loadingDate: dateCon,
+            deliveryDate: delDate,
+        };
+    });
+    return { success: true, message: "Current open orders", data: pOrders };
+};

lstV2/server/services/dataMart/controller/getinventory.ts

@@ -0,0 +1,34 @@
+import { createLog } from "../../logger/logger.js";
+import { query } from "../../sqlServer/prodSqlServer.js";
+import {
+    totalInvNoRn,
+    totalInvRn,
+} from "../../sqlServer/querys/dataMart/totalINV.js";
+
+export const getINV = async (rn: boolean) => {
+    let inventory: any = [];
+
+    let updatedQuery = totalInvNoRn;
+
+    if (rn) {
+        createLog(
+            "info",
+            "datamart",
+            "datamart",
+            "The user requested the running numbers this could take a while."
+        );
+        updatedQuery = totalInvRn;
+    }
+
+    try {
+        inventory = await query(updatedQuery, "Gets Curruent inv");
+        return { success: true, message: "Current inv", data: inventory.data };
+    } catch (error) {
+        console.log(error);
+        return {
+            success: false,
+            message: "There was an error getting the inventory",
+            data: error,
+        };
+    }
+};

lstV2/server/services/dataMart/controller/psiGetArticleData.ts

@@ -0,0 +1,47 @@
+import { tryCatch } from "../../../globalUtils/tryCatch.js";
+import { createLog } from "../../logger/logger.js";
+import { query } from "../../sqlServer/prodSqlServer.js";
+import { articleInfo } from "../../sqlServer/querys/psiReport/articleData.js";
+
+// type ArticleData = {
+//     id: string
+// }
+export const getGetPSIArticleData = async (avs: string) => {
+    let articles: any = [];
+
+    if (!avs) {
+        return {
+            success: false,
+            message: `Missing av's please send at least one over`,
+            data: [],
+        };
+    }
+
+    const { data, error } = (await tryCatch(
+        query(articleInfo.replace("[articles]", avs), "PSI article info")
+    )) as any;
+
+    if (error) {
+        createLog(
+            "error",
+            "datamart",
+            "datamart",
+            `There was an error getting the article info: ${JSON.stringify(
+                error
+            )}`
+        );
+        return {
+            success: false,
+            messsage: `There was an error getting the article info`,
+            data: error,
+        };
+    }
+
+    articles = data.data;
+
+    return {
+        success: true,
+        message: "PSI Article Data",
+        data: articles,
+    };
+};

lstV2/server/services/dataMart/controller/psiGetInventory.ts

@@ -0,0 +1,63 @@
+import { and, between, inArray, sql } from "drizzle-orm";
+import { db } from "../../../../database/dbclient.js";
+import { invHistoricalData } from "../../../../database/schema/historicalINV.js";
+import { tryCatch } from "../../../globalUtils/tryCatch.js";
+import { createLog } from "../../logger/logger.js";
+
+// type ArticleData = {
+//     id: string
+// }
+export const psiGetInventory = async (
+    avs: string,
+    startDate: string,
+    endDate: string
+) => {
+    let articles: any = [];
+
+    if (!avs) {
+        return {
+            success: false,
+            message: `Missing av's please send at least one over`,
+            data: [],
+        };
+    }
+
+    const ids = avs.split(",").map((id) => id.trim());
+
+    const { data, error } = (await tryCatch(
+        db
+            .select()
+            .from(invHistoricalData)
+            .where(
+                and(
+                    inArray(invHistoricalData.article, ids),
+                    between(invHistoricalData.histDate, startDate, endDate)
+                )
+            )
+        //.limit(100)
+    )) as any;
+
+    if (error) {
+        createLog(
+            "error",
+            "datamart",
+            "datamart",
+            `There was an error getting the planning info: ${JSON.stringify(
+                error
+            )}`
+        );
+        return {
+            success: false,
+            messsage: `There was an error getting the planning info`,
+            data: error,
+        };
+    }
+
+    articles = data;
+    console.log(articles.length);
+    return {
+        success: true,
+        message: "PSI planning Data",
+        data: articles,
+    };
+};

lstV2/server/services/dataMart/controller/psiGetPlanningData.ts

@@ -0,0 +1,63 @@
+import { tryCatch } from "../../../globalUtils/tryCatch.js";
+import { createLog } from "../../logger/logger.js";
+import { query } from "../../sqlServer/prodSqlServer.js";
+import { planningNumbersByAVDate } from "../../sqlServer/querys/psiReport/planningNumbersByAv.js";
+
+// type ArticleData = {
+//     id: string
+// }
+export const psiGetPlanningData = async (
+    avs: string,
+    startDate: string,
+    endDate: string
+) => {
+    let articles: any = [];
+
+    if (!avs) {
+        return {
+            success: false,
+            message: `Missing av's please send at least one over`,
+            data: [],
+        };
+    }
+
+    const { data, error } = (await tryCatch(
+        query(
+            planningNumbersByAVDate
+                .replace("[articles]", avs)
+                .replace("[startDate]", startDate)
+                .replace("[endDate]", endDate),
+            "PSI planning info"
+        )
+    )) as any;
+
+    if (error) {
+        createLog(
+            "error",
+            "datamart",
+            "datamart",
+            `There was an error getting the planning info: ${JSON.stringify(
+                error
+            )}`
+        );
+        return {
+            success: false,
+            messsage: `There was an error getting the planning info`,
+            data: error,
+        };
+    }
+
+    articles = data.data;
+
+    return {
+        success: true,
+        message: "PSI planning Data",
+        data: articles.map((n: any) => {
+            if (n.PalDay) {
+                return { ...n, PalDay: n.PalDay.toFixed(2) };
+            }
+
+            return n;
+        }),
+    };
+};

lstV2/server/services/dataMart/controller/psiGetProductionData.ts

@@ -0,0 +1,63 @@
+import { tryCatch } from "../../../globalUtils/tryCatch.js";
+import { createLog } from "../../logger/logger.js";
+import { query } from "../../sqlServer/prodSqlServer.js";
+import { productionNumbers } from "../../sqlServer/querys/psiReport/prodcuctionNumbers.js";
+
+// type ArticleData = {
+//     id: string
+// }
+export const psiGetProductionData = async (
+    avs: string,
+    startDate: string,
+    endDate: string
+) => {
+    let articles: any = [];
+
+    if (!avs) {
+        return {
+            success: false,
+            message: `Missing av's please send at least one over`,
+            data: [],
+        };
+    }
+
+    const { data, error } = (await tryCatch(
+        query(
+            productionNumbers
+                .replace("[articles]", avs)
+                .replace("[startDate]", startDate)
+                .replace("[endDate]", endDate),
+            "PSI production info"
+        )
+    )) as any;
+
+    if (error) {
+        createLog(
+            "error",
+            "datamart",
+            "datamart",
+            `There was an error getting the planning info: ${JSON.stringify(
+                error
+            )}`
+        );
+        return {
+            success: false,
+            messsage: `There was an error getting the planning info`,
+            data: error,
+        };
+    }
+
+    articles = data.data;
+
+    return {
+        success: true,
+        message: "PSI planning Data",
+        data: articles.map((n: any) => {
+            if (n.PalDay) {
+                return { ...n, PalDay: n.PalDay.toFixed(2) };
+            }
+
+            return n;
+        }),
+    };
+};

lstV2/server/services/dataMart/controller/validateCityState.ts

@@ -0,0 +1,21 @@
+import { createLog } from "../../logger/logger.js";
+import { query } from "../../sqlServer/prodSqlServer.js";
+import { validateCityState } from "../../sqlServer/querys/dataMart/validatecityState.js";
+
+export const validateCS = async () => {
+    let cs: any = [];
+
+    let updatedQuery = validateCityState;
+
+    try {
+        cs = await query(updatedQuery, "Get address data");
+        return { success: true, message: "City State Data", data: cs.data };
+    } catch (error) {
+        console.log(error);
+        return {
+            success: false,
+            message: "There was an error getting city state data.",
+            data: error,
+        };
+    }
+};

lstV2/server/services/dataMart/dataMartService.ts

@@ -0,0 +1,40 @@
+import { OpenAPIHono } from "@hono/zod-openapi";
+import activequerys from "./route/getCurrentQuerys.js";
+import getArticles from "./route/getActiveArticles.js";
+import currentInv from "./route/getInventory.js";
+import getCustomerInv from "./route/getCustomerInv.js";
+import getOpenOrders from "./route/getOpenOrders.js";
+import getDeliveryByDate from "./route/getDeliveryDateByRange.js";
+import fakeEDI from "./route/fakeEDI.js";
+import addressCorrections from "./route/getCityStateData.js";
+import fifoIndex from "./route/getFifoIndex.js";
+import financeAudit from "./route/getFinanceAudit.js";
+import psiArticleData from "./route/getPsiArticleData.js";
+import psiPlanningData from "./route/getPsiPlanningData.js";
+import psiProductionData from "./route/getPsiProductionData.js";
+import psiInventory from "./route/getPsiinventory.js";
+
+const app = new OpenAPIHono();
+
+const routes = [
+    activequerys,
+    getArticles,
+    currentInv,
+    getCustomerInv,
+    getOpenOrders,
+    getDeliveryByDate,
+    fakeEDI,
+    addressCorrections,
+    fifoIndex,
+    financeAudit,
+    psiArticleData,
+    psiPlanningData,
+    psiProductionData,
+    psiInventory,
+] as const;
+
+const appRoutes = routes.forEach((route) => {
+    app.route("/datamart", route);
+});
+
+export default app;

lstV2/server/services/dataMart/route/fakeEDI.ts

@@ -0,0 +1,54 @@
+import { createRoute, OpenAPIHono, z } from "@hono/zod-openapi";
+import { responses } from "../../../globalUtils/routeDefs/responses.js";
+import { tryCatch } from "../../../globalUtils/tryCatch.js";
+import { getINV } from "../controller/getinventory.js";
+import { getFakeEDI } from "../controller/fakeEDIUpdate.js";
+import { apiHit } from "../../../globalUtils/apiHits.js";
+
+const app = new OpenAPIHono({ strict: false });
+const Body = z.object({
+    address: z.string().openapi({ example: "x" }),
+});
+app.openapi(
+    createRoute({
+        tags: ["dataMart"],
+        summary: "Returns all open orders that need to be updated in fake edi.",
+        method: "get",
+        path: "/fakeediupdate",
+        request: {
+            body: {
+                content: {
+                    "application/json": { schema: Body },
+                },
+            },
+        },
+        responses: responses(),
+    }),
+    async (c) => {
+        const address: string = c.req.query("address") ?? "";
+
+        // make sure we have a vaid user being accessed thats really logged in
+        apiHit(c, { endpoint: "/fakeediupdate" });
+        const { data, error } = await tryCatch(
+            getFakeEDI(address.toString() ?? "")
+        );
+
+        if (error) {
+            return c.json(
+                {
+                    success: false,
+                    message: "There was an error getting the inv.",
+                    data: error,
+                },
+                400
+            );
+        }
+
+        return c.json({
+            success: data.success,
+            message: data.message,
+            data: data.data,
+        });
+    }
+);
+export default app;

lstV2/server/services/dataMart/route/getActiveArticles.ts

@@ -0,0 +1,47 @@
+import { createRoute, OpenAPIHono, z } from "@hono/zod-openapi";
+import { apiHit } from "../../../globalUtils/apiHits.js";
+import { responses } from "../../../globalUtils/routeDefs/responses.js";
+import { getActiveAv } from "../controller/getActiveArticles.js";
+
+const app = new OpenAPIHono({ strict: false });
+const EomStat = z.object({
+    plant: z.string().openapi({ example: "Salt Lake City" }),
+    userRan: z.string().openapi({ example: "smith034" }),
+    eomSheetVersion: z.string().openapi({ example: "0.0.223" }),
+});
+
+app.openapi(
+    createRoute({
+        tags: ["dataMart"],
+        summary: "Returns all the Active articles.",
+        method: "get",
+        path: "/getarticles",
+
+        responses: responses(),
+    }),
+    async (c) => {
+        //const body = await c.req.json();
+        // make sure we have a vaid user being accessed thats really logged in
+        apiHit(c, { endpoint: "/getarticles" });
+        try {
+            return c.json(
+                {
+                    success: true,
+                    message: "Current active Articles",
+                    data: await getActiveAv(),
+                },
+                200
+            );
+        } catch (error) {
+            return c.json(
+                {
+                    success: false,
+                    message: "There was an error posting the eom stat.",
+                    data: error,
+                },
+                400
+            );
+        }
+    }
+);
+export default app;

lstV2/server/services/dataMart/route/getCityStateData.ts

@@ -0,0 +1,50 @@
+import { createRoute, OpenAPIHono, z } from "@hono/zod-openapi";
+import { responses } from "../../../globalUtils/routeDefs/responses.js";
+import { tryCatch } from "../../../globalUtils/tryCatch.js";
+import { getINV } from "../controller/getinventory.js";
+import { apiHit } from "../../../globalUtils/apiHits.js";
+import { validateCS } from "../controller/validateCityState.js";
+
+const app = new OpenAPIHono({ strict: false });
+const Body = z.object({
+    includeRunnningNumbers: z.string().openapi({ example: "x" }),
+});
+app.openapi(
+    createRoute({
+        tags: ["dataMart"],
+        summary: "Returns Address with incorrect city state.",
+        method: "get",
+        path: "/getaddressdata",
+        request: {
+            body: {
+                content: {
+                    "application/json": { schema: Body },
+                },
+            },
+        },
+        responses: responses(),
+    }),
+    async (c) => {
+        // make sure we have a vaid user being accessed thats really logged in
+        apiHit(c, { endpoint: "/getaddressdata" });
+        const { data, error } = await tryCatch(validateCS());
+
+        if (error) {
+            return c.json(
+                {
+                    success: false,
+                    message: "There was an error getting address data.",
+                    data: error,
+                },
+                400
+            );
+        }
+
+        return c.json({
+            success: data.success,
+            message: data.message,
+            data: data.data,
+        });
+    }
+);
+export default app;

lstV2/server/services/dataMart/route/getCurrentQuerys.ts

@@ -0,0 +1,146 @@
+import { createRoute, OpenAPIHono, z } from "@hono/zod-openapi";
+import { responses } from "../../../globalUtils/routeDefs/responses.js";
+import { apiHit } from "../../../globalUtils/apiHits.js";
+
+const app = new OpenAPIHono({ strict: false });
+const current: any = [
+    {
+        name: "getActiveAv",
+        endpoint: "/api/datamart/getarticles",
+        description: "Gets all current active AV, with specific critiera.",
+    },
+    // {
+    //     name: "getStockLaneDims",
+    //     endpoint: "/api/v1/masterData/getStockDims",
+    //     description: "Returns the lane dims along with a column to send actaul dims to be updated.",
+    // },
+    // {
+    //     name: "getAddressInfo",
+    //     endpoint: "/api/v1/masterData/getAddressInfo",
+    //     description: "Returns current active addresses with street and zip",
+    // },
+    // {
+    //     name: "getMissingPkgData",
+    //     endpoint: "/api/v1/masterData/getMissingPKGData",
+    //     description: "Returns all packaging data that is missing either printer, layout, or carton layout",
+    // },
+    {
+        name: "getCustomerInventory",
+        endpoint: "/api/datamart/getcustomerinventory",
+        description:
+            "Returns specific customer inventory based on there address ID, with optional to include warehouses, IE 36,41,5. leaving warehouse blank will just pull everything",
+        criteria: "customer,whseToInclude",
+    },
+    // {
+    //     name: "getPalletLabels",
+    //     endpoint: "/api/v1/masterData/getPalletLabels",
+    //     description: "Returns specific amount of pallets RN, Needs label number and printer, Specfic to Dayton.",
+    //     criteria: "runningNumber,printerName,count",
+    // },
+    {
+        name: "getopenorders",
+        endpoint: "/api/datamart/getopenorders",
+        description:
+            "Returns open orders based on day count sent over, sDay 15 days in the past eDay 5 days in the future, can be left empty for this default days",
+        criteria: "sDay,eDay",
+    },
+    // {
+    //     name: "getOpenIncoming",
+    //     endpoint: "/api/v1/masterData/getOpenIncoming",
+    //     description:
+    //         "Returns open orders based on day count sent over, sDay 15 days in the past eDay 5 days in the future, can be left empty for this default days",
+    //     criteria: "sDay,eDay",
+    // },
+    // {
+    //     name: "planningCheckPkg",
+    //     endpoint: "/api/v1/masterData/planningPkgCheck",
+    //     description: "Returns all lots starting later than today and has a pkg that is missing layouts.",
+    // },
+    {
+        name: "getinventory",
+        endpoint: "/api/datamart/getinventory",
+        // description: "Returns all inventory, by default excludes running numebrs, also excludes inv locations.",
+        description:
+            "Returns all inventory,  excludes inv locations. no running numbers",
+        criteria: "includeRunnningNumbers", // uncomment this out once the improt process can be faster
+    },
+    // {
+    //     name: "getOpenOrderUpdates",
+    //     endpoint: "/api/v1/masterData/getOpenOrderUpdates",
+    //     // description: "Returns all inventory, by default excludes running numebrs, also excludes inv locations.",
+    //     description: "Returns all orders based on customer id, leaving empty will pull everythinng in.",
+    //     criteria: "customer", // uncomment this out once the improt process can be faster
+    // },
+    {
+        name: "getSiloAdjustment",
+        endpoint: "/api/logistics/getsilosdjustment",
+        // description: "Returns all inventory, by default excludes running numebrs, also excludes inv locations.",
+        description:
+            "Returns all siloadjustments in selected date range IE: 1/1/2025 to 1/31/2025",
+        criteria: "startDate,endDate", // uncomment this out once the improt process can be faster
+    },
+    {
+        name: "Delivery by date trange",
+        endpoint: "/api/datamart/deliverybydaterange",
+        // description: "Returns all inventory, by default excludes running numebrs, also excludes inv locations.",
+        description:
+            "Returns all Deliverys in selected date range IE: 1/1/2025 to 1/31/2025",
+        criteria: "start,end", // uncomment this out once the improt process can be faster
+    },
+    {
+        name: "Fake Edi Update",
+        endpoint: "/api/datamart/fakeediupdate",
+        // description: "Returns all inventory, by default excludes running numebrs, also excludes inv locations.",
+        description:
+            "Returns all open orders to correct and resubmit, leaving blank will get everything putting an address only returns the specified address",
+        criteria: "address", // uncomment this out once the improt process can be faster
+    },
+    {
+        name: "Address Corrections",
+        endpoint: "/api/datamart/getaddressdata",
+        // description: "Returns all inventory, by default excludes running numebrs, also excludes inv locations.",
+        description:
+            "Returns all addresses that will not process correctly in tms due to incorrect city state setup.",
+        //criteria: "address", // uncomment this out once the improt process can be faster
+    },
+    {
+        name: "Fifo index",
+        endpoint: "/api/datamart/getfifoindex",
+        // description: "Returns all inventory, by default excludes running numebrs, also excludes inv locations.",
+        description:
+            "Returns fifo index for all pallets shipped within the last 90 days.",
+        //criteria: "address", // uncomment this out once the improt process can be faster
+    },
+    {
+        name: "Finance Audit inv",
+        endpoint: "/api/datamart/getfinanceaudit",
+        // description: "Returns all inventory, by default excludes running numebrs, also excludes inv locations.",
+        description:
+            "Returns all inventory past the date provided, ie: 5/31/2025",
+        criteria: "date", // uncomment this out once the improt process can be faster
+    },
+];
+
+app.openapi(
+    createRoute({
+        tags: ["dataMart"],
+        summary: "Returns all avalible querys.",
+        method: "get",
+        path: "/getavalibleaquerys",
+
+        responses: responses(),
+    }),
+    async (c) => {
+        //const body = await c.req.json();
+        // make sure we have a vaid user being accessed thats really logged in
+        apiHit(c, { endpoint: "/getavalibleaquerys" });
+
+        return c.json({
+            success: true,
+            message: "All Current Active Querys.",
+            sheetVersion: 2.8,
+            data: current,
+        });
+    }
+);
+export default app;

lstV2/server/services/dataMart/route/getCustomerInv.ts

@@ -0,0 +1,54 @@
+import { createRoute, OpenAPIHono, z } from "@hono/zod-openapi";
+import { responses } from "../../../globalUtils/routeDefs/responses.js";
+import { tryCatch } from "../../../globalUtils/tryCatch.js";
+import { getINV } from "../controller/getinventory.js";
+import { getCurrentCustomerInv } from "../controller/getCustomerInventory.js";
+import { apiHit } from "../../../globalUtils/apiHits.js";
+
+const app = new OpenAPIHono({ strict: false });
+const Body = z.object({
+    includeRunnningNumbers: z.string().openapi({ example: "x" }),
+});
+app.openapi(
+    createRoute({
+        tags: ["dataMart"],
+        summary: "Returns All customer minus holds.",
+        method: "get",
+        path: "/getcustomerinventory",
+        request: {
+            body: {
+                content: {
+                    "application/json": { schema: Body },
+                },
+            },
+        },
+        responses: responses(),
+    }),
+    async (c) => {
+        const customerData: any = c.req.queries();
+
+        // make sure we have a vaid user being accessed thats really logged in
+        apiHit(c, { endpoint: "/getcustomerinventory" });
+        const { data, error } = await tryCatch(
+            getCurrentCustomerInv(customerData ? customerData : null)
+        );
+
+        if (error) {
+            return c.json(
+                {
+                    success: false,
+                    message: "There was an error getting the inv.",
+                    data: error,
+                },
+                400
+            );
+        }
+
+        return c.json({
+            success: data.success,
+            message: data.message,
+            data: data.data,
+        });
+    }
+);
+export default app;

lstV2/server/services/dataMart/route/getDeliveryDateByRange.ts

@@ -0,0 +1,54 @@
+import { createRoute, OpenAPIHono, z } from "@hono/zod-openapi";
+import { responses } from "../../../globalUtils/routeDefs/responses.js";
+import { tryCatch } from "../../../globalUtils/tryCatch.js";
+import { getDeliveryByDateRange } from "../controller/getDeliveryByDateRange.js";
+import { apiHit } from "../../../globalUtils/apiHits.js";
+
+const app = new OpenAPIHono({ strict: false });
+const Body = z.object({
+    includeRunnningNumbers: z.string().openapi({ example: "x" }),
+});
+app.openapi(
+    createRoute({
+        tags: ["dataMart"],
+        summary: "Returns deliverys by daterange.",
+        method: "get",
+        path: "/deliverybydaterange",
+        request: {
+            body: {
+                content: {
+                    "application/json": { schema: Body },
+                },
+            },
+        },
+        responses: responses(),
+    }),
+    async (c) => {
+        const delivery: any = c.req.queries();
+
+        // make sure we have a vaid user being accessed thats really logged in
+        apiHit(c, { endpoint: "/deliverybydaterange" });
+        const { data, error } = await tryCatch(
+            getDeliveryByDateRange(delivery ? delivery : null)
+        );
+
+        if (error) {
+            console.log(error);
+            return c.json(
+                {
+                    success: false,
+                    message: "There was an error getting the deliveries.",
+                    data: error,
+                },
+                400
+            );
+        }
+
+        return c.json({
+            success: data.success,
+            message: data.message,
+            data: data.data,
+        });
+    }
+);
+export default app;

lstV2/server/services/dataMart/route/getFifoIndex.ts

@@ -0,0 +1,48 @@
+import { createRoute, OpenAPIHono, z } from "@hono/zod-openapi";
+import { apiHit } from "../../../globalUtils/apiHits.js";
+import { responses } from "../../../globalUtils/routeDefs/responses.js";
+import { getActiveAv } from "../controller/getActiveArticles.js";
+import { getFifoIndex } from "../controller/getFifoIndex.js";
+
+const app = new OpenAPIHono({ strict: false });
+const EomStat = z.object({
+    plant: z.string().openapi({ example: "Salt Lake City" }),
+    userRan: z.string().openapi({ example: "smith034" }),
+    eomSheetVersion: z.string().openapi({ example: "0.0.223" }),
+});
+
+app.openapi(
+    createRoute({
+        tags: ["dataMart"],
+        summary: "Returns all the fifo data.",
+        method: "get",
+        path: "/getfifoindex",
+
+        responses: responses(),
+    }),
+    async (c) => {
+        //const body = await c.req.json();
+        // make sure we have a vaid user being accessed thats really logged in
+        apiHit(c, { endpoint: "/getfifoindex" });
+        try {
+            return c.json(
+                {
+                    success: true,
+                    message: "Fifo index data for the last 90days",
+                    data: await getFifoIndex(),
+                },
+                200
+            );
+        } catch (error) {
+            return c.json(
+                {
+                    success: false,
+                    message: "There was an error getting fifo index data.",
+                    data: error,
+                },
+                400
+            );
+        }
+    }
+);
+export default app;

lstV2/server/services/dataMart/route/getFinanceAudit.ts

@@ -0,0 +1,69 @@
+import { createRoute, OpenAPIHono, z } from "@hono/zod-openapi";
+import { apiHit } from "../../../globalUtils/apiHits.js";
+import { responses } from "../../../globalUtils/routeDefs/responses.js";
+import { getfinanceAudit } from "../controller/getFinanceAudit.js";
+import { tryCatch } from "../../../globalUtils/tryCatch.js";
+
+const app = new OpenAPIHono({ strict: false });
+const EomStat = z.object({
+    plant: z.string().openapi({ example: "Salt Lake City" }),
+    userRan: z.string().openapi({ example: "smith034" }),
+    eomSheetVersion: z.string().openapi({ example: "0.0.223" }),
+});
+
+app.openapi(
+    createRoute({
+        tags: ["dataMart"],
+        summary:
+            "Returns inventory to date and current sales prices and booking date of the inventory.",
+        method: "get",
+        path: "/getfinanceaudit",
+
+        responses: responses(),
+    }),
+    async (c: any) => {
+        //const body = await c.req.json();
+        // make sure we have a vaid user being accessed thats really logged in
+        const { data, error } = (await tryCatch(c.req.query())) as any;
+
+        //console.log(data.date);
+
+        if (error) {
+            return {
+                success: false,
+                message: "Missing Mandatory Data",
+                data: error,
+            };
+        }
+
+        if (!data.date) {
+            return {
+                success: false,
+                message: "Missing Date",
+                data: [],
+            };
+        }
+        apiHit(c, { endpoint: "/getfinanceaudit", lastBody: data });
+
+        try {
+            return c.json(
+                {
+                    success: true,
+                    message: `Inventory older than ${data.date}`,
+                    data: await getfinanceAudit(data.date),
+                },
+                200
+            );
+        } catch (error) {
+            return c.json(
+                {
+                    success: false,
+                    message: "There was an error getting inventory data",
+                    data: error,
+                },
+                400
+            );
+        }
+    }
+);
+export default app;

lstV2/server/services/dataMart/route/getInventory.ts

@@ -0,0 +1,54 @@
+import { createRoute, OpenAPIHono, z } from "@hono/zod-openapi";
+import { responses } from "../../../globalUtils/routeDefs/responses.js";
+import { tryCatch } from "../../../globalUtils/tryCatch.js";
+import { getINV } from "../controller/getinventory.js";
+import { apiHit } from "../../../globalUtils/apiHits.js";
+
+const app = new OpenAPIHono({ strict: false });
+const Body = z.object({
+    includeRunnningNumbers: z.string().openapi({ example: "x" }),
+});
+app.openapi(
+    createRoute({
+        tags: ["dataMart"],
+        summary: "Returns All current inventory.",
+        method: "get",
+        path: "/getinventory",
+        request: {
+            body: {
+                content: {
+                    "application/json": { schema: Body },
+                },
+            },
+        },
+        responses: responses(),
+    }),
+    async (c) => {
+        const includeRunnningNumbers: string =
+            c.req.query("includeRunnningNumbers") ?? "";
+
+        // make sure we have a vaid user being accessed thats really logged in
+        apiHit(c, { endpoint: "/getinventory" });
+        const { data, error } = await tryCatch(
+            getINV(includeRunnningNumbers?.length > 0 ? true : false)
+        );
+
+        if (error) {
+            return c.json(
+                {
+                    success: false,
+                    message: "There was an error getting the inv.",
+                    data: error,
+                },
+                400
+            );
+        }
+
+        return c.json({
+            success: data.success,
+            message: data.message,
+            data: data.data,
+        });
+    }
+);
+export default app;

lstV2/server/services/dataMart/route/getOpenOrders.ts

@@ -0,0 +1,54 @@
+import { createRoute, OpenAPIHono, z } from "@hono/zod-openapi";
+import { responses } from "../../../globalUtils/routeDefs/responses.js";
+import { tryCatch } from "../../../globalUtils/tryCatch.js";
+import { getOpenOrders } from "../controller/getOpenOrders.js";
+import { apiHit } from "../../../globalUtils/apiHits.js";
+
+const app = new OpenAPIHono({ strict: false });
+// const Body = z.object({
+//     includeRunnningNumbers: z.string().openapi({ example: "x" }),
+// });
+app.openapi(
+    createRoute({
+        tags: ["dataMart"],
+        summary: "Returns All open orders.",
+        method: "get",
+        path: "/getopenorders",
+        // request: {
+        //     body: {
+        //         content: {
+        //             "application/json": { schema: Body },
+        //         },
+        //     },
+        // },
+        responses: responses(),
+    }),
+    async (c) => {
+        const customer: any = c.req.queries();
+
+        // make sure we have a vaid user being accessed thats really logged in
+        apiHit(c, { endpoint: "/getopenorders" });
+        const { data, error } = await tryCatch(
+            getOpenOrders(customer ? customer : null)
+        );
+
+        if (error) {
+            console.log(error);
+            return c.json(
+                {
+                    success: false,
+                    message: "There was an error getting the inv.",
+                    data: error,
+                },
+                400
+            );
+        }
+
+        return c.json({
+            success: data.success,
+            message: data.message,
+            data: data.data,
+        });
+    }
+);
+export default app;

lstV2/server/services/dataMart/route/getPsiArticleData.ts

@@ -0,0 +1,61 @@
+import { createRoute, OpenAPIHono, z } from "@hono/zod-openapi";
+import { responses } from "../../../globalUtils/routeDefs/responses.js";
+import { tryCatch } from "../../../globalUtils/tryCatch.js";
+import { getDeliveryByDateRange } from "../controller/getDeliveryByDateRange.js";
+import { apiHit } from "../../../globalUtils/apiHits.js";
+import { getGetPSIArticleData } from "../controller/psiGetArticleData.js";
+
+const app = new OpenAPIHono({ strict: false });
+const Body = z.object({
+    includeRunnningNumbers: z.string().openapi({ example: "x" }),
+});
+app.openapi(
+    createRoute({
+        tags: ["dataMart"],
+        summary: "Returns the psiarticleData.",
+        method: "get",
+        path: "/psiarticledata",
+        request: {
+            body: {
+                content: {
+                    "application/json": { schema: Body },
+                },
+            },
+        },
+        responses: responses(),
+    }),
+    async (c) => {
+        const articles: any = c.req.queries();
+
+        // make sure we have a vaid user being accessed thats really logged in
+        apiHit(c, { endpoint: "/psiarticledata" });
+        //console.log(articles["avs"][0]);
+        const { data, error } = await tryCatch(
+            getGetPSIArticleData(articles ? articles["avs"][0] : null)
+        );
+
+        if (error) {
+            console.log(error);
+            return c.json(
+                {
+                    success: false,
+                    message: "There was an error getting the articles.",
+                    data: error,
+                },
+                400
+            );
+        }
+
+        //console.log(data);
+
+        return c.json(
+            {
+                success: data.success,
+                message: data.message,
+                data: data.data,
+            },
+            data.success ? 200 : 400
+        );
+    }
+);
+export default app;

lstV2/server/services/dataMart/route/getPsiPlanningData.ts

@@ -0,0 +1,64 @@
+import { createRoute, OpenAPIHono, z } from "@hono/zod-openapi";
+import { responses } from "../../../globalUtils/routeDefs/responses.js";
+import { tryCatch } from "../../../globalUtils/tryCatch.js";
+import { apiHit } from "../../../globalUtils/apiHits.js";
+import { psiGetPlanningData } from "../controller/psiGetPlanningData.js";
+
+const app = new OpenAPIHono({ strict: false });
+const Body = z.object({
+    includeRunnningNumbers: z.string().openapi({ example: "x" }),
+});
+app.openapi(
+    createRoute({
+        tags: ["dataMart"],
+        summary: "Returns the psiarticleData.",
+        method: "get",
+        path: "/psiplanningdata",
+        request: {
+            body: {
+                content: {
+                    "application/json": { schema: Body },
+                },
+            },
+        },
+        responses: responses(),
+    }),
+    async (c) => {
+        const q: any = c.req.queries();
+
+        // make sure we have a vaid user being accessed thats really logged in
+        apiHit(c, { endpoint: "/psiplanningdata" });
+        //console.log(articles["avs"][0]);
+        const { data, error } = await tryCatch(
+            psiGetPlanningData(
+                q["avs"] ? q["avs"][0] : null,
+                q["startDate"] ? q["startDate"][0] : null,
+                q["endDate"] ? q["endDate"][0] : null
+            )
+        );
+
+        if (error) {
+            console.log(error);
+            return c.json(
+                {
+                    success: false,
+                    message: "There was an error getting the planning.",
+                    data: error,
+                },
+                400
+            );
+        }
+
+        //console.log(data);
+
+        return c.json(
+            {
+                success: data.success,
+                message: data.message,
+                data: data.data,
+            },
+            data.success ? 200 : 400
+        );
+    }
+);
+export default app;

lstV2/server/services/dataMart/route/getPsiProductionData.ts

@@ -0,0 +1,64 @@
+import { createRoute, OpenAPIHono, z } from "@hono/zod-openapi";
+import { responses } from "../../../globalUtils/routeDefs/responses.js";
+import { tryCatch } from "../../../globalUtils/tryCatch.js";
+import { apiHit } from "../../../globalUtils/apiHits.js";
+import { psiGetProductionData } from "../controller/psiGetProductionData.js";
+
+const app = new OpenAPIHono({ strict: false });
+const Body = z.object({
+    includeRunnningNumbers: z.string().openapi({ example: "x" }),
+});
+app.openapi(
+    createRoute({
+        tags: ["dataMart"],
+        summary: "Returns the psiproductiondata.",
+        method: "get",
+        path: "/psiproductiondata",
+        request: {
+            body: {
+                content: {
+                    "application/json": { schema: Body },
+                },
+            },
+        },
+        responses: responses(),
+    }),
+    async (c) => {
+        const q: any = c.req.queries();
+
+        // make sure we have a vaid user being accessed thats really logged in
+        apiHit(c, { endpoint: "/psiproductiondata" });
+        //console.log(articles["avs"][0]);
+        const { data, error } = await tryCatch(
+            psiGetProductionData(
+                q["avs"] ? q["avs"][0] : null,
+                q["startDate"] ? q["startDate"][0] : null,
+                q["endDate"] ? q["endDate"][0] : null
+            )
+        );
+
+        if (error) {
+            console.log(error);
+            return c.json(
+                {
+                    success: false,
+                    message: "There was an error getting the production.",
+                    data: error,
+                },
+                400
+            );
+        }
+
+        //console.log(data);
+
+        return c.json(
+            {
+                success: data.success,
+                message: data.message,
+                data: data.data,
+            },
+            data.success ? 200 : 400
+        );
+    }
+);
+export default app;

lstV2/server/services/dataMart/route/getPsiinventory.ts

@@ -0,0 +1,64 @@
+import { createRoute, OpenAPIHono, z } from "@hono/zod-openapi";
+import { responses } from "../../../globalUtils/routeDefs/responses.js";
+import { tryCatch } from "../../../globalUtils/tryCatch.js";
+import { apiHit } from "../../../globalUtils/apiHits.js";
+import { psiGetInventory } from "../controller/psiGetInventory.js";
+
+const app = new OpenAPIHono({ strict: false });
+const Body = z.object({
+    includeRunnningNumbers: z.string().openapi({ example: "x" }),
+});
+app.openapi(
+    createRoute({
+        tags: ["dataMart"],
+        summary: "Returns the getPsiinventory.",
+        method: "get",
+        path: "/getpsiinventory",
+        request: {
+            body: {
+                content: {
+                    "application/json": { schema: Body },
+                },
+            },
+        },
+        responses: responses(),
+    }),
+    async (c) => {
+        const q: any = c.req.queries();
+
+        // make sure we have a vaid user being accessed thats really logged in
+        apiHit(c, { endpoint: "/getpsiinventory" });
+        //console.log(articles["avs"][0]);
+        const { data, error } = await tryCatch(
+            psiGetInventory(
+                q["avs"] ? q["avs"][0] : null,
+                q["startDate"] ? q["startDate"][0] : null,
+                q["endDate"] ? q["endDate"][0] : null
+            )
+        );
+
+        if (error) {
+            console.log(error);
+            return c.json(
+                {
+                    success: false,
+                    message: "There was an error getting the production.",
+                    data: error,
+                },
+                400
+            );
+        }
+
+        //console.log(data);
+
+        return c.json(
+            {
+                success: data.success,
+                message: data.message,
+                data: data.data,
+            },
+            data.success ? 200 : 400
+        );
+    }
+);
+export default app;