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

lstV2/server/services/notifications/routes/fifoIndex.ts

@@ -0,0 +1,41 @@
+// an external way to creating logs
+import { createRoute, OpenAPIHono, z } from "@hono/zod-openapi";
+import { responses } from "../../../globalUtils/routeDefs/responses.js";
+import { apiHit } from "../../../globalUtils/apiHits.js";
+import fifoIndexCheck from "../controller/notifications/fifoIndex.js";
+
+const app = new OpenAPIHono({ strict: false });
+
+app.openapi(
+    createRoute({
+        tags: ["notify"],
+        summary: "Manually trigger TI intergrations.",
+        method: "get",
+        path: "/fifoindex",
+        //middleware: authMiddleware,
+        responses: responses(),
+    }),
+    async (c) => {
+        /**
+         * get the blocking notification stuff
+         */
+        apiHit(c, { endpoint: "/fifoindex" });
+
+        /**
+         * getting the shipped pallets
+         */
+        const checkedData = await fifoIndexCheck();
+
+        return c.json({
+            success: true,
+            message: "Fifo index results",
+            data: checkedData.data.palletsOut,
+            fifoCheck: {
+                totalShipped: checkedData.data.totalShipped,
+                inFifo: checkedData.data.inFifo,
+                outOfFifoData: checkedData.data.outOfFifoData,
+            },
+        });
+    }
+);
+export default app;

lstV2/server/services/notifications/routes/getActiveNotifications.ts

@@ -0,0 +1,31 @@
+// an external way to creating logs
+import { createRoute, OpenAPIHono, z } from "@hono/zod-openapi";
+import { responses } from "../../../globalUtils/routeDefs/responses.js";
+import { getAllJobs } from "../utils/processNotifications.js";
+import { apiHit } from "../../../globalUtils/apiHits.js";
+
+const app = new OpenAPIHono({ strict: false });
+
+app.openapi(
+    createRoute({
+        tags: ["server"],
+        summary: "Returns current active notifications.",
+        method: "get",
+        path: "/activenotifications",
+        //middleware: authMiddleware,
+        responses: responses(),
+    }),
+    async (c) => {
+        apiHit(c, { endpoint: "/activenotifications" });
+        const jobs = getAllJobs();
+        return c.json({
+            success: true,
+            message:
+                jobs.length === 0
+                    ? "There are no active Notifications Currently."
+                    : "Current Active notifications",
+            data: jobs,
+        });
+    }
+);
+export default app;

lstV2/server/services/notifications/routes/getNotifications.ts

@@ -0,0 +1,45 @@
+// an external way to creating logs
+import { createRoute, OpenAPIHono, z } from "@hono/zod-openapi";
+//import { apiHit } from "../../../globalUtils/apiHits.js";
+import { responses } from "../../../globalUtils/routeDefs/responses.js";
+import { getNotifications } from "../controller/getNotifications.js";
+import { tryCatch } from "../../../globalUtils/tryCatch.js";
+import { apiHit } from "../../../globalUtils/apiHits.js";
+
+const app = new OpenAPIHono({ strict: false });
+
+app.openapi(
+    createRoute({
+        tags: ["notify"],
+        summary: "Gets notifications.",
+        method: "get",
+        path: "/notifications",
+        // description:
+        //     "This might be a temp soltuin during the transtion between versions",
+        responses: responses(),
+    }),
+    async (c: any) => {
+        apiHit(c, { endpoint: "/notifications" });
+        const { data, error } = await tryCatch(getNotifications());
+
+        if (error) {
+            return c.json(
+                {
+                    success: false,
+                    message: "There was an error clearing the log.",
+                    data: error,
+                },
+                400
+            );
+        }
+        return c.json(
+            {
+                success: data?.success,
+                message: data?.message,
+                data: data?.data,
+            },
+            200
+        );
+    }
+);
+export default app;

lstV2/server/services/notifications/routes/manualTiggerTi.ts

@@ -0,0 +1,28 @@
+// an external way to creating logs
+import { createRoute, OpenAPIHono, z } from "@hono/zod-openapi";
+import { responses } from "../../../globalUtils/routeDefs/responses.js";
+
+import runTiImport from "../controller/notifications/tiIntergration.js";
+import { apiHit } from "../../../globalUtils/apiHits.js";
+
+const app = new OpenAPIHono({ strict: false });
+
+app.openapi(
+    createRoute({
+        tags: ["notify"],
+        summary: "Manually trigger TI intergrations.",
+        method: "get",
+        path: "/tiTrigger",
+        //middleware: authMiddleware,
+        responses: responses(),
+    }),
+    async (c) => {
+        apiHit(c, { endpoint: "/tiTrigger" });
+        const tiImport = await runTiImport();
+        return c.json({
+            success: tiImport?.success,
+            message: tiImport?.message,
+        });
+    }
+);
+export default app;

lstV2/server/services/notifications/routes/qualityBlocking.ts

@@ -0,0 +1,51 @@
+// an external way to creating logs
+import { createRoute, OpenAPIHono, z } from "@hono/zod-openapi";
+import { responses } from "../../../globalUtils/routeDefs/responses.js";
+
+import qualityBlockingMonitor from "../controller/notifications/qualityBlocking.js";
+import { tryCatch } from "../../../globalUtils/tryCatch.js";
+
+import { notifications } from "../../../../database/schema/notifications.js";
+import { db } from "../../../../database/dbclient.js";
+import { eq } from "drizzle-orm";
+import { apiHit } from "../../../globalUtils/apiHits.js";
+
+const app = new OpenAPIHono({ strict: false });
+
+app.openapi(
+    createRoute({
+        tags: ["notify"],
+        summary: "Manually trigger TI intergrations.",
+        method: "get",
+        path: "/blockingTrigger",
+        //middleware: authMiddleware,
+        responses: responses(),
+    }),
+    async (c) => {
+        /**
+         * get the blocking notification stuff
+         */
+        apiHit(c, { endpoint: "/blockingTrigger" });
+        const { data, error } = await tryCatch(
+            db
+                .select()
+                .from(notifications)
+                .where(eq(notifications.name, "qualityBlocking"))
+        );
+
+        if (error) {
+            return c.json({
+                success: false,
+                message: "Error Getting Notification Settings.",
+                data: error,
+            });
+        }
+        const blocking = await qualityBlockingMonitor(data[0]);
+
+        return c.json({
+            success: blocking?.success,
+            message: blocking?.message,
+        });
+    }
+);
+export default app;

lstV2/server/services/notifications/routes/sendMail.ts

@@ -0,0 +1,75 @@
+// an external way to creating logs
+import { createRoute, OpenAPIHono, z } from "@hono/zod-openapi";
+import { responses } from "../../../globalUtils/routeDefs/responses.js";
+import { authMiddleware } from "../../auth/middleware/authMiddleware.js";
+import { sendEmail } from "../controller/sendMail.js";
+import { tryCatch } from "../../../globalUtils/tryCatch.js";
+import { apiHit } from "../../../globalUtils/apiHits.js";
+
+const app = new OpenAPIHono({ strict: false });
+
+const EmailSchema = z
+    .object({
+        email: z.string().email().openapi({ example: "smith@example.come" }),
+        subject: z.string().openapi({ example: "Welcome to LST" }),
+        template: z.string().openapi({ example: "exampleTemplate" }),
+        context: z
+            .object({
+                name: z.string().optional(),
+                score: z.string().optional(),
+            })
+            .optional()
+            .openapi({}),
+    })
+    .openapi("User");
+app.openapi(
+    createRoute({
+        tags: ["server"],
+        summary: "Returns current active lots that are tech released",
+        method: "post",
+        path: "/sendmail",
+        middleware: authMiddleware,
+        request: {
+            body: {
+                content: {
+                    "application/json": { schema: EmailSchema },
+                },
+            },
+        },
+        responses: responses(),
+    }),
+    async (c) => {
+        const { data: bodyData, error: bodyError } = await tryCatch(
+            c.req.json()
+        );
+        apiHit(c, { endpoint: "/sendmail", lastBody: bodyData });
+        if (bodyError) {
+            return c.json(
+                {
+                    success: false,
+                    message: "There was an error sending the email",
+                    data: bodyError,
+                },
+                400
+            );
+        }
+        const { data: emailData, error: emailError } = await tryCatch(
+            sendEmail(bodyData)
+        );
+
+        if (emailError) {
+            return c.json({
+                success: false,
+                message: "There was an error sending the email",
+                data: emailError,
+            });
+        }
+
+        return c.json({
+            success: emailData.success,
+            message: emailData.message,
+            data: emailData.data,
+        });
+    }
+);
+export default app;