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

lstV2/server/services/rfid/route/addReader.ts

@@ -0,0 +1,64 @@
+import { z, createRoute, OpenAPIHono } from "@hono/zod-openapi";
+import { addReader } from "../controller/addReader.js";
+import { authMiddleware } from "../../auth/middleware/authMiddleware.js";
+import { responses } from "../../../globalUtils/routeDefs/responses.js";
+import type { User } from "../../../types/users.js";
+import { verify } from "hono/jwt";
+import { apiHit } from "../../../globalUtils/apiHits.js";
+
+const app = new OpenAPIHono();
+
+export const ReaderBody = z.object({
+    reader: z.string().openapi({ example: "wrapper1" }),
+    readerIP: z.string().openapi({ example: "192.168.1.52" }),
+});
+
+app.openapi(
+    createRoute({
+        tags: ["rfid"],
+        summary: "Add new reader",
+        method: "post",
+        path: "/addreader",
+        middleware: authMiddleware,
+        description: "Adding in a  new reader to add to the network.",
+        request: {
+            body: { content: { "application/json": { schema: ReaderBody } } },
+        },
+        responses: responses(),
+    }),
+    async (c) => {
+        const body = await c.req.json();
+        const authHeader = c.req.header("Authorization");
+        apiHit(c, { endpoint: "/addreader", lastBody: body });
+        const token = authHeader?.split("Bearer ")[1] || "";
+        let user: User;
+
+        try {
+            const payload = await verify(token, process.env.JWT_SECRET!);
+            user = payload.user as User;
+        } catch (error) {
+            return c.json({ message: "Unauthorized" }, 401);
+        }
+
+        try {
+            const addingReader = await addReader(body, user);
+            return c.json(
+                {
+                    success: addingReader.success,
+                    message: addingReader.message,
+                },
+                200
+            );
+        } catch (error) {
+            return c.json(
+                {
+                    success: false,
+                    message: `${body.name} encountered an error while trying to be added`,
+                },
+                400
+            );
+        }
+    }
+);
+
+export default app;

lstV2/server/services/rfid/route/getReaders.ts

@@ -0,0 +1,43 @@
+import { z, createRoute, OpenAPIHono } from "@hono/zod-openapi";
+import { addReader } from "../controller/addReader.js";
+import { authMiddleware } from "../../auth/middleware/authMiddleware.js";
+import { responses } from "../../../globalUtils/routeDefs/responses.js";
+import type { User } from "../../../types/users.js";
+
+import { apiHit } from "../../../globalUtils/apiHits.js";
+import { tryCatch } from "../../../globalUtils/tryCatch.js";
+import { getReaders } from "../controller/getReaders.js";
+
+const app = new OpenAPIHono();
+
+export const ReaderBody = z.object({
+    reader: z.string().openapi({ example: "wrapper1" }),
+    readerIP: z.string().openapi({ example: "192.168.1.52" }),
+});
+
+app.openapi(
+    createRoute({
+        tags: ["rfid"],
+        summary: "Get readers",
+        method: "get",
+        path: "/getreaders",
+        responses: responses(),
+    }),
+    async (c: any) => {
+        apiHit(c, { endpoint: "/getreaders" });
+
+        const { data, error } = await tryCatch(getReaders());
+
+        if (error) {
+            return c.json({
+                error,
+            });
+        }
+
+        return c.json({
+            data,
+        });
+    }
+);
+
+export default app;

lstV2/server/services/rfid/route/manualTagEnter.ts

@@ -0,0 +1,57 @@
+//http://usday1vms006:4000/api/v1/zebra/wrapper1
+import { z, createRoute, OpenAPIHono } from "@hono/zod-openapi";
+import { responses } from "../../../globalUtils/routeDefs/responses.js";
+import { authMiddleware } from "../../auth/middleware/authMiddleware.js";
+import { manualTag } from "../controller/tags/manualTag.js";
+import { apiHit } from "../../../globalUtils/apiHits.js";
+
+const app = new OpenAPIHono();
+
+const RequestBody = z.object({
+    tagNumber: z.string().openapi({ example: "2541" }),
+});
+
+app.openapi(
+    createRoute({
+        tags: ["rfid"],
+        summary: "Post a manual Tag",
+        method: "post",
+        path: "/manualtag",
+        middleware: authMiddleware,
+        request: {
+            body: { content: { "application/json": { schema: RequestBody } } },
+        },
+        responses: responses(),
+    }),
+    async (c) => {
+        const body =
+            (await c.req.json()) ??
+            c.json(
+                {
+                    success: false,
+                    message: `Please check that you are sending over a json object`,
+                },
+                400
+            );
+
+        apiHit(c, { endpoint: "/manualtag" });
+        try {
+            const tag = await manualTag(body.tag, body.area);
+            return c.json(
+                { success: tag.success, message: tag.message, data: tag.data },
+                200
+            );
+        } catch (error) {
+            return c.json(
+                {
+                    success: true,
+                    message: `There was an error with entering  a new tag`,
+                    error,
+                },
+                400
+            );
+        }
+    }
+);
+
+export default app;

lstV2/server/services/rfid/route/manualTagRead.ts

@@ -0,0 +1,47 @@
+//http://usday1vms006:4000/api/v1/zebra/wrapper1
+import { z, createRoute, OpenAPIHono } from "@hono/zod-openapi";
+import { responses } from "../../../globalUtils/routeDefs/responses.js";
+import { readTags } from "../controller/readTags.js";
+import { apiHit } from "../../../globalUtils/apiHits.js";
+
+const app = new OpenAPIHono();
+
+const ParamsSchema = z.object({
+    reader: z
+        .string()
+        .min(3)
+        .openapi({
+            param: {
+                name: "reader",
+                in: "path",
+            },
+            example: "1212121",
+        }),
+});
+
+app.openapi(
+    createRoute({
+        tags: ["rfid"],
+        summary: "Manual triggers the read function",
+        method: "post",
+        path: "/manualtrigger/{reader}",
+        request: {
+            params: ParamsSchema,
+        },
+        responses: responses(),
+    }),
+    async (c) => {
+        const { reader } = c.req.valid("param");
+        const manualTrigger = await readTags(reader);
+        apiHit(c, { endpoint: `/manualtrigger/${reader}` });
+        return c.json(
+            {
+                success: true,
+                message: `A Manaul trigger was done on ${reader}`,
+            },
+            200
+        );
+    }
+);
+
+export default app;

lstV2/server/services/rfid/route/mgtEvents.ts

@@ -0,0 +1,81 @@
+//http://usday1vms006:4000/api/v1/zebra/wrapper1
+import { z, createRoute, OpenAPIHono } from "@hono/zod-openapi";
+import { readTags } from "../controller/readTags.js";
+import { createLog } from "../../logger/logger.js";
+import { responses } from "../../../globalUtils/routeDefs/responses.js";
+import { newHeartBeat } from "../controller/readerControl.js";
+import { apiHit } from "../../../globalUtils/apiHits.js";
+
+const app = new OpenAPIHono();
+let lastGpiTimestamp = 0;
+
+const ParamsSchema = z.object({
+    reader: z
+        .string()
+        .min(3)
+        .openapi({
+            param: {
+                name: "reader",
+                in: "path",
+            },
+            example: "1212121",
+        }),
+});
+
+app.openapi(
+    createRoute({
+        tags: ["rfid"],
+        summary: "Post info from the reader",
+        method: "post",
+        path: "/mgtevents/{reader}",
+        request: {
+            params: ParamsSchema,
+        },
+        responses: responses(),
+    }),
+    async (c) => {
+        const { reader } = c.req.valid("param");
+        const body = await c.req.json();
+        apiHit(c, { endpoint: `/mgtevents/${reader}` });
+        if (body.type === "heartbeat") {
+            const heart = await newHeartBeat(reader);
+            return c.json(
+                { success: heart.success, message: heart.message },
+                200
+            );
+        }
+
+        if (body.type === "gpi" && body.data.state === "HIGH") {
+            const eventTimestamp = new Date(body.timestamp).getTime(); // Convert ISO timestamp to milliseconds
+            if (eventTimestamp - lastGpiTimestamp > 30 * 1000) {
+                // Check if it's been more than 2ms
+                lastGpiTimestamp = eventTimestamp; // Update last seen timestamp
+
+                createLog(
+                    "info",
+                    "rfid",
+                    "rfid",
+                    `${reader} is reading a tag.`
+                );
+                await readTags(reader);
+            } else {
+                createLog(
+                    "debug",
+                    "rfid",
+                    "rfid",
+                    `A new trigger from ${reader} was to soon`
+                );
+                lastGpiTimestamp = eventTimestamp;
+            }
+
+            //console.log(body);
+        }
+
+        return c.json(
+            { success: true, message: `New info from ${reader}` },
+            200
+        );
+    }
+);
+
+export default app;

lstV2/server/services/rfid/route/resetRatio.ts

@@ -0,0 +1,54 @@
+import { z, createRoute, OpenAPIHono } from "@hono/zod-openapi";
+import { addReader } from "../controller/addReader.js";
+import { authMiddleware } from "../../auth/middleware/authMiddleware.js";
+import { responses } from "../../../globalUtils/routeDefs/responses.js";
+import type { User } from "../../../types/users.js";
+import { verify } from "hono/jwt";
+import { apiHit } from "../../../globalUtils/apiHits.js";
+import { resetRatios } from "../controller/readerControl.js";
+
+const app = new OpenAPIHono();
+
+export const ReaderBody = z.object({
+    reader: z.string().openapi({ example: "wrapper1" }),
+});
+
+app.openapi(
+    createRoute({
+        tags: ["rfid"],
+        summary: "Resets the ratio on the reader",
+        method: "post",
+        path: "/resetRatio",
+        //middleware: authMiddleware,
+        //description: "Adding in a  new reader to add to the network.",
+        request: {
+            body: { content: { "application/json": { schema: ReaderBody } } },
+        },
+        responses: responses(),
+    }),
+    async (c) => {
+        const body = await c.req.json();
+        apiHit(c, { endpoint: "/resetRatio", lastBody: body });
+
+        try {
+            const reset = await resetRatios(body.reader);
+            return c.json(
+                {
+                    success: reset.success,
+                    message: reset.message,
+                },
+                200
+            );
+        } catch (error) {
+            return c.json(
+                {
+                    success: false,
+                    message: `${body.name} encountered an error while trying to reset the readers ratio`,
+                },
+                400
+            );
+        }
+    }
+);
+
+export default app;

lstV2/server/services/rfid/route/tagInfo.ts

@@ -0,0 +1,98 @@
+//http://usday1vms006:4000/api/v1/zebra/wrapper1
+import { z, createRoute, OpenAPIHono } from "@hono/zod-openapi";
+import { ConsoleLogWriter } from "drizzle-orm";
+import { tagData } from "../controller/tagData.js";
+import { responses } from "../../../globalUtils/routeDefs/responses.js";
+import { clearNoReadTimer, noRead } from "../controller/noRead.js";
+import { badRead, goodRead } from "../controller/readerControl.js";
+import { createLog } from "../../logger/logger.js";
+import { tryCatch } from "../../../globalUtils/tryCatch.js";
+import { stopRead } from "../controller/readTags.js";
+import { apiHit } from "../../../globalUtils/apiHits.js";
+
+const app = new OpenAPIHono();
+
+const ParamsSchema = z.object({
+    reader: z
+        .string()
+        .min(3)
+        .openapi({
+            param: {
+                name: "reader",
+                in: "path",
+            },
+            example: "1212121",
+        }),
+});
+
+app.openapi(
+    createRoute({
+        tags: ["rfid"],
+        summary: "Tag info posted from the reader.",
+        method: "post",
+        path: "/taginfo/{reader}",
+        request: {
+            params: ParamsSchema,
+        },
+        responses: responses(),
+    }),
+    async (c) => {
+        const { reader } = c.req.valid("param");
+        createLog("info", "rfid", "rfid", `${reader} is sending us data.`);
+        let tagdata: any = [];
+        const { data: body, error: bodyError } = await tryCatch(c.req.json());
+        apiHit(c, { endpoint: `/taginfo/${reader}`, lastBody: body });
+        if (bodyError) {
+            return c.json({ success: false, message: "missing data" }, 400);
+        }
+        //console.log(`Tag: ${Buffer.from(body.idHex, "hex").toString("utf-8")}, ${body[key].data.idHex}`);
+
+        for (let i = 0; i < body.length; i++) {
+            const tag = Buffer.from(body[i].data.idHex, "hex").toString(
+                "utf-8"
+            );
+            // console.log(
+            //     "Raw value:",
+            //     body[i].data.peakRssi,
+            //     "Parsed:",
+            //     parseInt(body[i].data.peakRssi)
+            // );
+            if (
+                tag.includes("ALPLA") &&
+                parseInt(body[i].data.peakRssi) < -30
+            ) {
+                tagdata = [
+                    ...tagdata,
+                    {
+                        tagHex: body[i].data.idHex,
+                        reader: reader,
+                        tag: tag,
+                        timeStamp: body[i].timestamp,
+                        antenna: body[i].data.antenna,
+                        tagStrength: body[i].data.peakRssi,
+                    },
+                ];
+            }
+        }
+
+        if (tagdata.length === 0) {
+            // noRead(reader);
+            // badRead(reader);
+            return c.json(
+                { success: false, message: `There were no tags scanned.` },
+                200
+            );
+        } else {
+            tagData(tagdata);
+            goodRead(reader);
+            clearNoReadTimer();
+
+            return c.json(
+                { success: true, message: `New info from ${reader}` },
+                200
+            );
+        }
+    }
+);
+
+export default app;

lstV2/server/services/rfid/route/updateReader.ts

@@ -0,0 +1,65 @@
+import { z, createRoute, OpenAPIHono } from "@hono/zod-openapi";
+import { addReader } from "../controller/addReader.js";
+import { authMiddleware } from "../../auth/middleware/authMiddleware.js";
+import { responses } from "../../../globalUtils/routeDefs/responses.js";
+import type { User } from "../../../types/users.js";
+import { verify } from "hono/jwt";
+import { apiHit } from "../../../globalUtils/apiHits.js";
+
+const app = new OpenAPIHono();
+
+export const ReaderBody = z.object({
+    reader: z.string().openapi({ example: "wrapper1" }),
+    readerIP: z.string().openapi({ example: "192.168.1.52" }),
+    active: z.boolean().optional().openapi({ example: true }),
+});
+
+app.openapi(
+    createRoute({
+        tags: ["rfid"],
+        summary: "Add new reader",
+        method: "patch",
+        path: "/updatereader",
+        middleware: authMiddleware,
+        description: "Updates the reader data..",
+        request: {
+            body: { content: { "application/json": { schema: ReaderBody } } },
+        },
+        responses: responses(),
+    }),
+    async (c) => {
+        const body = await c.req.json();
+        const authHeader = c.req.header("Authorization");
+        apiHit(c, { endpoint: `/updatereader`, lastBody: body });
+        const token = authHeader?.split("Bearer ")[1] || "";
+        let user: User;
+
+        try {
+            const payload = await verify(token, process.env.JWT_SECRET!);
+            user = payload.user as User;
+        } catch (error) {
+            return c.json({ message: "Unauthorized" }, 401);
+        }
+
+        try {
+            const addingReader = await addReader(body, user);
+            return c.json(
+                {
+                    success: addingReader.success,
+                    message: addingReader.message,
+                },
+                200
+            );
+        } catch (error) {
+            return c.json(
+                {
+                    success: false,
+                    message: `${body.name} encountered an error while trying to be added`,
+                },
+                400
+            );
+        }
+    }
+);
+
+export default app;