chore(release): 0.0.2-alpha.8

this is to help prevent errors in the build and release stuff in git

.env-example

@@ -50,3 +50,11 @@ GP_PASSWORD=
 # how often to check for new/updated queries in min
 QUERY_TIME_TYPE=m #valid options are m, h 
 QUERY_CHECK=1
+
+
+# Oauth setup
+PROVIDER=""
+CLIENT_ID=""
+CLIENT_SECRET=""
+CLIENT_SCOPES="openid profile email groups"
+DISCOVERY_URL=""

.gitignore

@@ -149,3 +149,4 @@ dist
 .yarn/install-state.gz
 .pnp.*
 
+frontend/.tanstack/tmp/2249110e-da91fb0b1b87b6c4cc3e2c2cd25037fd

.vscode/settings.json

@@ -1,6 +1,6 @@
 {
 	"editor.defaultFormatter": "biomejs.biome",
-	"workbench.colorTheme": "Default Dark+",
+	"workbench.colorTheme": "Dark+",
 	"terminal.integrated.env.windows": {},
 	"editor.formatOnSave": true,
 	  "typescript.preferences.importModuleSpecifier": "relative",

CHANGELOG.md

@@ -1,5 +1,97 @@
 # All Changes to LST can be found below.
 
+## [0.0.2-alpha.8](https://git.tuffraid.net/cowch/lst_v3/compare/v0.0.2-alpha.7...v0.0.2-alpha.8) (2026-05-06)
+
+
+### 🌟 Enhancements
+
+* **mobile:** auth added in ([ba30281](https://git.tuffraid.net/cowch/lst_v3/commits/ba30281e59040513a036fb7413e372457d04a7c8))
+
+## [0.0.2-alpha.7](https://git.tuffraid.net/cowch/lst_v3/compare/v0.0.2-alpha.6...v0.0.2-alpha.7) (2026-05-06)
+
+
+### 🌟 Enhancements
+
+* **intial auth:** intial auth setup for the scanner ([cd13360](https://git.tuffraid.net/cowch/lst_v3/commits/cd13360cfb931daca50fd7b111e1c8f8ab09a909))
+* **mobile:** new route for the ehs launcher ([649ae1e](https://git.tuffraid.net/cowch/lst_v3/commits/649ae1ee9f245a9b5d308ea8a636357bf72b1e34))
+* **mobile:** shadcn like and tailwind added to make things look yummy ([7d2f048](https://git.tuffraid.net/cowch/lst_v3/commits/7d2f048932b77269568149de34351840b75486e2))
+* **mobile:** update notifications and more error handling added ([30ffd84](https://git.tuffraid.net/cowch/lst_v3/commits/30ffd843c725da79ed035e2d9564f60a6babcda8))
+* **scanner:** more work on the scanner and can now scan to prod no lst right now ([77b4533](https://git.tuffraid.net/cowch/lst_v3/commits/77b4533dea8314fd4fb81a597995cabd041fe188))
+* **servers:** added iowa ebm ([8446dbc](https://git.tuffraid.net/cowch/lst_v3/commits/8446dbc955462235b9df35c501354761661e4f6a))
+
+
+### 🐛 Bug fixes
+
+* **mobile:** typo for version checking ([0b7318f](https://git.tuffraid.net/cowch/lst_v3/commits/0b7318f8566d15414edd3cd67c89fa5346058ab0))
+
+
+### 🛠️ Code Refactor
+
+* **docker compose:** changed to have the correct url that will be used as this is for auth ([4e0cf8c](https://git.tuffraid.net/cowch/lst_v3/commits/4e0cf8c54c4dfd68edba7e733518846a47c55064))
+* **gp connection:** added in gp ip into env if not there use static name for dns ([36995e9](https://git.tuffraid.net/cowch/lst_v3/commits/36995e9fb42cfa1b72c096b8860866d70b86e70c))
+* **mobile:** more look and feel work ([bb6155c](https://git.tuffraid.net/cowch/lst_v3/commits/bb6155c9692220542a52664848abf0b9eee91a43))
+* **mobile:** moved the versioning lookup at at the mobile folder plus renamed ([bddc9ac](https://git.tuffraid.net/cowch/lst_v3/commits/bddc9aca0d2da2b2f53dec1250276d7a076a8601))
+* **scanner:** format changes ([518c0a8](https://git.tuffraid.net/cowch/lst_v3/commits/518c0a8c19a4bff0b757bbd06ca5460d3565d8bd))
+
+
+### 📈 Project Builds
+
+* **scripts:** changing how the relase works so it purposly builds before it trys to release ([83a542d](https://git.tuffraid.net/cowch/lst_v3/commits/83a542d1b7beafe394949c001917f2b25056fac2))
+
+## [0.0.2-alpha.6](https://git.tuffraid.net/cowch/lst_v3/compare/v0.0.2-alpha.1...v0.0.2-alpha.6) (2026-04-23)
+
+## [0.0.2-alpha.1](https://git.tuffraid.net/cowch/lst_v3/compare/v0.0.2-alpha.0...v0.0.2-alpha.1) (2026-04-23)
+
+## [0.0.2-alpha.0](https://git.tuffraid.net/cowch/lst_v3/compare/v0.0.1...v0.0.2-alpha.0) (2026-04-23)
+
+## [0.0.1](https://git.tuffraid.net/cowch/lst_v3/compare/v0.0.1-alpha.5...v0.0.1) (2026-04-23)
+
+
+### 🐛 Bug fixes
+
+* **frontend:** lingering import crashed us ([781025d](https://git.tuffraid.net/cowch/lst_v3/commits/781025dca00e9dd4b2ad9b283be944ed91bbc1e5))
+
+
+### 📝 Chore
+
+* **doc remove:** removed a doc and put it in the real area for docs ([a593bb2](https://git.tuffraid.net/cowch/lst_v3/commits/a593bb2baafd0166a178b80cd76dd8862f240e11))
+
+## [0.0.1-alpha.5](https://git.tuffraid.net/cowch/lst_v3/compare/v0.0.1-alpha.4...v0.0.1-alpha.5) (2026-04-23)
+
+
+### 🌟 Enhancements
+
+* **admin:** moved server build/update to full app ([cb00add](https://git.tuffraid.net/cowch/lst_v3/commits/cb00addee96b3ecccf2694f85cb7882cac9c7e3d))
+* **lstmobile:** intial scanner setup kinda working ([3734d9d](https://git.tuffraid.net/cowch/lst_v3/commits/3734d9daac143ad8fb4404c59990bc4f546f365b))
+* **oidc:** added in so we could use an oidc to login as well :D ([f7276ca](https://git.tuffraid.net/cowch/lst_v3/commits/f7276ca2d722e30da65bbead23dc9bd57df25aa7))
+* **servers:** added marked tree in to the mix ([4d53af0](https://git.tuffraid.net/cowch/lst_v3/commits/4d53af033876d81e0d38c148c15cb0af6f3d5bf0))
+
+
+### 🐛 Bug fixes
+
+* **datamart:** fixes to correct how we handle activations of new features and legacy queries ([b832d7a](https://git.tuffraid.net/cowch/lst_v3/commits/b832d7aa1ecd063be1bbb7e969617fc7a6376ffa))
+* **datamart:** if we do not have 2.0 warehousing activate we need to use legacy ([5b1c885](https://git.tuffraid.net/cowch/lst_v3/commits/5b1c88546ff9a42dc572450fe05ad68015edb627))
+* **gp:** weird issue with db username and password ([d6328ab](https://git.tuffraid.net/cowch/lst_v3/commits/d6328ab764c3626aef99727b873003384951d299))
+* **inventory:** changes to accruatly adjust the query and check the feature set ([32517d0](https://git.tuffraid.net/cowch/lst_v3/commits/32517d0c98c42a0f0f60135b4a9951c4090ccd58))
+* **logistics:** historical issue where it was being really weird ([cfbc156](https://git.tuffraid.net/cowch/lst_v3/commits/cfbc1565172f7c2e27f0a1593fe8e99b00d91bb7))
+* **logistics:** purchasing monitoring was going off every 5th min instead of every 5 min ([3639c1b](https://git.tuffraid.net/cowch/lst_v3/commits/3639c1b77c597a94816bfedd0892f0c8980c6403))
+* **ocp:** fixes to make sure we always hav printer.data as an array or dont do anything ([fb3cd85](https://git.tuffraid.net/cowch/lst_v3/commits/fb3cd85b411315cac0abd22d050ee88929754833))
+* **psi:** refactor psi queries ([a1eeade](https://git.tuffraid.net/cowch/lst_v3/commits/a1eeadeec438f7c5c6d31f190fee5c22f83dc6b0))
+
+
+### 📝 Chore
+
+* **clean:** removed bruno api a proper api doc will be added to lst later ([f716de1](https://git.tuffraid.net/cowch/lst_v3/commits/f716de1a58a4a4c02d9a0a375444ceecea4a018b))
+* **scripts:** added in a helper to remove old stuff ([de5df2b](https://git.tuffraid.net/cowch/lst_v3/commits/de5df2b00b1c6fe7c53d6ea075b4cf7e0fb845f9))
+
+
+### 🛠️ Code Refactor
+
+* **scanner:** more basic work to get the scanner just running ([82f8369](https://git.tuffraid.net/cowch/lst_v3/commits/82f8369640b2b0ff63dd640dc0aa0609a42c7dda))
+* **servers:** added mcd and stp1 ([88cef2a](https://git.tuffraid.net/cowch/lst_v3/commits/88cef2a56c390b692866658ce519e59ffeaf4c17))
+* **server:** server updates can now only be done from a dev pc ([7962463](https://git.tuffraid.net/cowch/lst_v3/commits/7962463927c4c5d2e12db9a0dd536b0f29fc65b2))
+* **sql:** changed sql connection to ip:port ([a6d53f0](https://git.tuffraid.net/cowch/lst_v3/commits/a6d53f0266f1edc3f3946cd1f07d893c8a98d9c7))
+
 ## [0.0.1-alpha.4](https://git.tuffraid.net/cowch/lst_v3/compare/v0.0.1-alpha.3...v0.0.1-alpha.4) (2026-04-15)
 
 

backend/admin/admin.build.ts

@@ -0,0 +1,38 @@
+/**
+ * To be able to run this we need to set our dev pc in the .env.
+ * if its empty just ignore it. this will just be the double catch
+ */
+
+import { Router } from "express";
+import { build, building } from "../utils/build.utils.js";
+import { apiReturn } from "../utils/returnHelper.utils.js";
+
+const router = Router();
+
+router.post("/release", async (_, res) => {
+	if (!building) {
+		build();
+
+		return apiReturn(res, {
+			success: true,
+			level: "info",
+			module: "admin",
+			subModule: "build",
+			message: `The build has been triggered see logs for progress of the current build.`,
+			data: [],
+			status: 200,
+		});
+	} else {
+		return apiReturn(res, {
+			success: false,
+			level: "error",
+			module: "admin",
+			subModule: "build",
+			message: `There is a build in progress already please check the logs for on going progress.`,
+			data: [],
+			status: 200,
+		});
+	}
+});
+
+export default router;

backend/admin/admin.routes.ts

@@ -0,0 +1,12 @@
+import type { Express } from "express";
+import { requireAuth } from "../middleware/auth.middleware.js";
+import build from "./admin.build.js";
+import update from "./admin.updateServer.js";
+
+export const setupAdminRoutes = (baseUrl: string, app: Express) => {
+	//stats will be like this as we dont need to change this
+	app.use(`${baseUrl}/api/admin/build`, requireAuth, build);
+	app.use(`${baseUrl}/api/admin/build`, requireAuth, update);
+
+	// all other system should be under /api/system/*
+};

backend/admin/admin.updateServer.ts

@@ -0,0 +1,86 @@
+/**
+ * To be able to run this we need to set our dev pc in the .env.
+ * if its empty just ignore it. this will just be the double catch
+ */
+
+import { Router } from "express";
+import z from "zod";
+import { building } from "../utils/build.utils.js";
+import { runUpdate, updating } from "../utils/deployApp.js";
+import { apiReturn } from "../utils/returnHelper.utils.js";
+
+const updateServer = z.object({
+	server: z.string(),
+	destination: z.string(),
+	token: z.string().min(5, "Plant tokens should be at least 5 characters long"),
+});
+
+const router = Router();
+
+type Update = {
+	success: boolean;
+	message: string;
+};
+
+router.post("/updateServer", async (req, res) => {
+	try {
+		const validated = updateServer.parse(req.body);
+
+		if (!updating && !building) {
+			const update = (await runUpdate({
+				server: validated.server,
+				destination: validated.destination,
+				token: validated.token,
+			})) as Update;
+			return apiReturn(res, {
+				success: update.success,
+				level: update.success ? "info" : "error",
+				module: "admin",
+				subModule: "update",
+				message: update.message,
+				data: [],
+				status: 200,
+			});
+		} else {
+			return apiReturn(res, {
+				success: false,
+				level: "error",
+				module: "admin",
+				subModule: "update",
+				message: `${validated.server}: ${validated.token} is already being updated, or is currently building the app.`,
+				data: [],
+				status: 200,
+			});
+		}
+	} catch (err) {
+		if (err instanceof z.ZodError) {
+			const flattened = z.flattenError(err);
+			// return res.status(400).json({
+			// 	error: "Validation failed",
+			// 	details: flattened,
+			// });
+
+			return apiReturn(res, {
+				success: false,
+				level: "error", //connect.success ? "info" : "error",
+				module: "routes",
+				subModule: "auth",
+				message: "Validation failed",
+				data: [flattened.fieldErrors],
+				status: 400, //connect.success ? 200 : 400,
+			});
+		}
+
+		return apiReturn(res, {
+			success: false,
+			level: "error", //connect.success ? "info" : "error",
+			module: "routes",
+			subModule: "auth",
+			message: "Internal Server Error creating user",
+			data: [err],
+			status: 400, //connect.success ? 200 : 400,
+		});
+	}
+});
+
+export default router;

backend/configs/gpSql.config.ts

@@ -1,10 +1,16 @@
 import type sql from "mssql";
 
+// TODO : Remove this later and get it onto the env
 const username = "gpviewer";
 const password = "gp$$ViewOnly!";
 
+const port = process.env.SQL_PORT
+	? Number.parseInt(process.env.SQL_PORT, 10)
+	: undefined;
+
 export const gpSqlConfig: sql.config = {
-	server: `USMCD1VMS011`,
+	server: `${process.env.GP_SERVER ?? "USMCD1VMS011"}`,
+	port: port,
 	database: `ALPLA`,
 	user: username,
 	password: password,

backend/configs/prodSql.config.ts

@@ -1,7 +1,13 @@
 import type sql from "mssql";
+
+const port = process.env.SQL_PORT
+	? Number.parseInt(process.env.SQL_PORT, 10)
+	: undefined;
+
 export const prodSqlConfig: sql.config = {
 	server: `${process.env.PROD_SERVER}`,
 	database: `AlplaPROD_${process.env.PROD_PLANT_TOKEN}_cus`,
+	port: port,
 	user: process.env.PROD_USER,
 	password: process.env.PROD_PASSWORD,
 	options: {

backend/datamart/datamart.controller.ts

@@ -116,10 +116,17 @@ export const runDatamartQuery = async (data: Data) => {
 
 	// for queries that will need to be ran on legacy until we get the plant updated need to go in here
 	const doubleQueries = ["inventory"];
-	const sqlQuery = sqlQuerySelector(
+	let queryFile = "";
-		`datamart.${fd.data[0].activated > 0 && !doubleQueries.includes(data.name) ? data.name : `legacy.${data.name}`}`,
-	) as SqlQuery;
 
+	if (doubleQueries.includes(data.name)) {
+		queryFile = `datamart.${
+			fd.data[0].activated > 0 ? data.name : `legacy.${data.name}`
+		}`;
+	} else {
+		queryFile = `datamart.${data.name}`;
+	}
+
+	const sqlQuery = sqlQuerySelector(queryFile) as SqlQuery;
 	// checking if warehousing is as it will start to effect a lot of queries for plants that are not on 2.
 
 	const getDataMartInfo = datamartData.filter((x) => x.endpoint === data.name);
@@ -172,6 +179,12 @@ export const runDatamartQuery = async (data: Data) => {
 						data.options.articles
 							? `and r.ArticleHumanReadableId in (${data.options.articles})`
 							: "--and r.ArticleHumanReadableId in ([articles]) ",
+					)
+					.replace(
+						"and DeliveredQuantity > 0",
+						data.options.all
+							? "--and DeliveredQuantity > 0"
+							: "and DeliveredQuantity > 0",
 					);
 
 				break;
@@ -201,10 +214,15 @@ export const runDatamartQuery = async (data: Data) => {
 						"--,l.MachineLocation,l.MachineName,l.ProductionLotRunningNumber as lot",
 						`${data.options.lots ? `,l.MachineLocation,l.MachineName,l.ProductionLotRunningNumber as lot` : `--,l.MachineLocation,l.MachineName,l.ProductionLotRunningNumber as lot`}`,
 					)
+					.replaceAll(
+						"--,l.MachineLocation,l.MachineName,l.ProductionLotRunningNumber",
+						`${data.options.lots ? `,l.MachineLocation,l.MachineName,l.ProductionLotRunningNumber` : `--,l.MachineLocation,l.MachineName,l.ProductionLotRunningNumber`}`,
+					)
 					.replaceAll(
 						"--,l.WarehouseDescription,l.LaneDescription",
 						`${data.options.locations ? `,l.WarehouseDescription,l.LaneDescription` : `--,l.WarehouseDescription,l.LaneDescription`}`,
 					);
+
 				break;
 			case "fakeEDIUpdate":
 				datamartQuery = datamartQuery.replace(
@@ -231,7 +249,6 @@ export const runDatamartQuery = async (data: Data) => {
 				);
 
 				break;
-
 			case "psiDeliveryData":
 				datamartQuery = datamartQuery
 					.replace("[startDate]", `${data.options.startDate}`)

backend/db/db.controller.ts

@@ -1,6 +1,8 @@
 import { drizzle } from "drizzle-orm/postgres-js";
 import postgres from "postgres";
 
+import * as scanUserSchema from "./schema/scanUsers.js";
+
 const dbURL = `postgres://${process.env.DATABASE_USER}:${process.env.DATABASE_PASSWORD}@${process.env.DATABASE_HOST}:${process.env.DATABASE_PORT}/${process.env.DATABASE_DB}`;
 
 const queryClient = postgres(dbURL, {
@@ -13,4 +15,10 @@ const queryClient = postgres(dbURL, {
 	},
 });
 
-export const db = drizzle({ client: queryClient });
+//export const db = drizzle({ client: queryClient });
+
+export const db = drizzle(queryClient, {
+	schema: {
+		...scanUserSchema,
+	},
+});

backend/db/schema/buildHistory.schema.ts

@@ -0,0 +1,10 @@
+import { integer, pgTable, text, timestamp, uuid } from "drizzle-orm/pg-core";
+
+export const deploymentHistory = pgTable("deployment_history", {
+	id: uuid("id").defaultRandom().primaryKey(),
+	serverId: uuid("server_id"),
+	buildNumber: integer("build_number").notNull(),
+	status: text("status").notNull(), // started, success, failed
+	message: text("message"),
+	createdAt: timestamp("created_at").defaultNow(),
+});

backend/db/schema/scanUsers.ts

@@ -0,0 +1,48 @@
+import {
+	boolean,
+	jsonb,
+	pgEnum,
+	pgTable,
+	text,
+	timestamp,
+	unique,
+	uuid,
+} from "drizzle-orm/pg-core";
+import { createInsertSchema, createSelectSchema } from "drizzle-zod";
+import type z from "zod";
+
+export const mobileRoleEnum = pgEnum("mobile_role", [
+	"user",
+	"lead",
+	"manager",
+	"admin",
+]);
+
+export const scanUser = pgTable(
+	"scan_users",
+	{
+		id: uuid("id").defaultRandom().primaryKey(),
+		name: text("name").notNull(), // the user that will be using the scanner
+		scannerId: text("scanner_id").unique().notNull(),
+		pinNumber: text("pin_number").unique().notNull(),
+		pinHash: text("pin_hash").notNull(),
+		excludedCommand: jsonb("excluded_commands").default([]),
+		role: mobileRoleEnum("role").notNull().default("user"),
+		active: boolean("active").default(true),
+		lastScan: timestamp("last_scan").defaultNow(),
+		add_Date: timestamp("add_Date").defaultNow(),
+		upd_date: timestamp("upd_date").defaultNow(),
+	},
+	(table) => ({
+		userNotificationUnique: unique("scan_user_unique").on(
+			table.scannerId,
+			table.pinNumber,
+		),
+	}),
+);
+
+export const scanUserSchema = createSelectSchema(scanUser);
+export const newsSanUserSchema = createInsertSchema(scanUser);
+
+export type ScanUser = z.infer<typeof scanUserSchema>;
+export type NewScanUser = z.infer<typeof newsSanUserSchema>;

backend/db/schema/scanlog.schema.ts

@@ -0,0 +1,21 @@
+import { jsonb, pgTable, text, timestamp, uuid } from "drizzle-orm/pg-core";
+import { createInsertSchema, createSelectSchema } from "drizzle-zod";
+import type z from "zod";
+
+export const scanLog = pgTable("scan_log", {
+	id: uuid("id").defaultRandom().primaryKey(),
+	user: text("user"),
+	scannerId: text("scanner_id"),
+	message: text("message").notNull(),
+	prompt: text("prompt"),
+	commandDescription: text("command_description"),
+	status: text("status"),
+	lines: jsonb("lines").default([]),
+	add_Date: timestamp("add_Date").defaultNow(),
+});
+
+export const scanLogSchema = createSelectSchema(scanLog);
+export const newScanLogSchema = createInsertSchema(scanLog);
+
+export type Printer = z.infer<typeof scanLogSchema>;
+export type NewPrinter = z.infer<typeof newScanLogSchema>;

backend/db/schema/serverData.schema.ts

@@ -0,0 +1,40 @@
+import {
+	boolean,
+	integer,
+	pgTable,
+	text,
+	timestamp,
+	uuid,
+} from "drizzle-orm/pg-core";
+import { createInsertSchema, createSelectSchema } from "drizzle-zod";
+import type z from "zod";
+
+export const serverData = pgTable(
+	"server_data",
+	{
+		server_id: uuid("id").defaultRandom().primaryKey(),
+		name: text("name").notNull(),
+		server: text("server"),
+		plantToken: text("plant_token").notNull().unique(),
+		idAddress: text("id_address"),
+		greatPlainsPlantCode: text("great_plains_plant_code"),
+		contactEmail: text("contact_email"),
+		contactPhone: text("contact_phone"),
+		active: boolean("active").default(true),
+		serverLoc: text("server_loc"),
+		lastUpdated: timestamp("last_updated").defaultNow(),
+		buildNumber: integer("build_number"),
+		isUpgrading: boolean("is_upgrading").default(false),
+	},
+
+	// (table) => [
+	// 	// uniqueIndex('emailUniqueIndex').on(sql`lower(${table.email})`),
+	// 	uniqueIndex("plant_token").on(table.plantToken),
+	// ],
+);
+
+export const serverDataSchema = createSelectSchema(serverData);
+export const newServerDataSchema = createInsertSchema(serverData);
+
+export type ServerDataSchema = z.infer<typeof serverDataSchema>;
+export type NewServerData = z.infer<typeof newServerDataSchema>;

backend/db/schema/stats.schema.ts

@@ -1,10 +1,27 @@
-import type { InferSelectModel } from "drizzle-orm";
+import {
-import { integer, pgTable, text, timestamp } from "drizzle-orm/pg-core";
+	boolean,
+	integer,
+	jsonb,
+	pgTable,
+	text,
+	timestamp,
+} from "drizzle-orm/pg-core";
+import { createInsertSchema, createSelectSchema } from "drizzle-zod";
+import type z from "zod";
 
-export const serverStats = pgTable("stats", {
+export const appStats = pgTable("app_stats", {
-	id: text("id").primaryKey().default("serverStats"),
+	id: text("id").primaryKey().default("primary"),
-	build: integer("build").notNull().default(1),
+	currentBuild: integer("current_build").notNull().default(1),
-	lastUpdate: timestamp("last_update").defaultNow(),
+	lastBuildAt: timestamp("last_build_at"),
+	lastDeployAt: timestamp("last_deploy_at"),
+	building: boolean("building").notNull().default(false),
+	updating: boolean("updating").notNull().default(false),
+	lastUpdated: timestamp("last_updated").defaultNow(),
+	meta: jsonb("meta").$type<Record<string, unknown>>().default({}),
 });
 
-export type ServerStats = InferSelectModel<typeof serverStats>;
+export const appStatsSchema = createSelectSchema(appStats);
+export const newAppStatsSchema = createInsertSchema(appStats, {});
+
+export type AppStats = z.infer<typeof appStatsSchema>;
+export type NewAppStats = z.infer<typeof newAppStatsSchema>;

backend/gpSql/gpSqlConnection.controller.ts

@@ -13,7 +13,9 @@ let attempt = 0;
 const maxAttempts = 10;
 
 export const connectGPSql = async () => {
-	const serverUp = await checkHostnamePort(`USMCD1VMS011:1433`);
+	const serverUp = await checkHostnamePort(
+		`${process.env.GP_SERVER ?? "usmcd1vms011"}:1433`,
+	);
 	if (!serverUp) {
 		// we will try to reconnect
 		connected = false;
@@ -53,13 +55,14 @@ export const connectGPSql = async () => {
 			notify: false,
 		});
 	} catch (error) {
+		console.log(error);
 		reconnectToSql;
 		return returnFunc({
 			success: false,
 			level: "error",
 			module: "system",
 			subModule: "db",
-			message: "Failed to connect to the prod sql server.",
+			message: "Failed to connect to the gp sql server.",
 			data: [error],
 			notify: false,
 		});
@@ -118,7 +121,9 @@ export const reconnectToSql = async () => {
 
 		await new Promise((res) => setTimeout(res, delayStart));
 
-		const serverUp = await checkHostnamePort(`${process.env.PROD_SERVER}:1433`);
+		const serverUp = await checkHostnamePort(
+			`${process.env.GP_SERVER ?? "usmcd1vms011"}:1433`,
+		);
 
 		if (!serverUp) {
 			delayStart = Math.min(delayStart * 2, 30000); // exponential backoff until up to 30000

backend/mobile/donwloadApps.route.ts

@@ -11,26 +11,10 @@ const __dirname = path.dirname(__filename);
 const downloadDir = path.resolve(__dirname, "../../downloads/mobile");
 
 const currentApk = {
-	packageName: "net.alpla.lst.mobile",
-	versionName: "0.0.1-alpha",
-	versionCode: 1,
-	minSupportedVersionCode: 1,
 	fileName: "lst-mobile.apk",
 };
 
-router.get("/version", async (req, res) => {
+router.get("/latest", (_, res) => {
-	const baseUrl = `${req.protocol}://${req.get("host")}`;
-
-	res.json({
-		packageName: currentApk.packageName,
-		versionName: currentApk.versionName,
-		versionCode: currentApk.versionCode,
-		minSupportedVersionCode: currentApk.minSupportedVersionCode,
-		downloadUrl: `${baseUrl}/lst/api/mobile/apk/latest`,
-	});
-});
-
-router.get("/apk/latest", (_, res) => {
 	const apkPath = path.join(downloadDir, currentApk.fileName);
 
 	if (!fs.existsSync(apkPath)) {
@@ -46,4 +30,17 @@ router.get("/apk/latest", (_, res) => {
 	return res.sendFile(apkPath);
 });
 
+router.get("/ehs", (_, res) => {
+	const apkPath = path.join(downloadDir, "EHS.apk");
+
+	if (!fs.existsSync(apkPath)) {
+		return res.status(404).json({ success: false, message: "APK not found" });
+	}
+
+	res.setHeader("Content-Type", "application/vnd.android.package-archive");
+	res.setHeader("Content-Disposition", `attachment; filename="EHS.apk}"`);
+
+	return res.sendFile(apkPath);
+});
+
 export default router;

backend/mobile/mobile.routes.ts

@@ -0,0 +1,17 @@
+import type { Express } from "express";
+import downloads from "./donwloadApps.route.js";
+import authPin from "./mobileAuth.route.js";
+import newPin from "./mobilePin.route.js";
+import logs from "./scanLogs.route.js";
+import version from "./version.route.js";
+
+export const setupMobileRoutes = (baseUrl: string, app: Express) => {
+	//stats will be like this as we dont need to change this
+	app.use(`${baseUrl}/api/mobile/version`, version);
+	app.use(`${baseUrl}/api/mobile/apk`, downloads);
+	app.use(`${baseUrl}/api/mobile/logs`, logs);
+	app.use(`${baseUrl}/api/mobile/auth`, authPin);
+	app.use(`${baseUrl}/api/mobile/pin`, newPin);
+
+	// all other system should be under /api/system/*
+};

backend/mobile/mobileAuth.route.ts

@@ -0,0 +1,331 @@
+import bcrypt from "bcryptjs";
+import { eq, sql } from "drizzle-orm";
+import { Router } from "express";
+import z from "zod";
+import { db } from "../db/db.controller.js";
+import {
+	type NewScanUser,
+	type ScanUser,
+	scanUser,
+} from "../db/schema/scanUsers.js";
+import { requireAuth } from "../middleware/auth.middleware.js";
+import { apiReturn, returnFunc } from "../utils/returnHelper.utils.js";
+import { tryCatch } from "../utils/trycatch.utils.js";
+
+const r = Router();
+
+export async function hashPin(pin: string) {
+	//   if (!/^\d{6}$/.test(pin)) {
+	//     throw new Error("PIN must be exactly 6 digits");
+	//   }
+
+	return bcrypt.hashSync(pin, 12);
+}
+
+const registerSchema = z.object({
+	name: z.string().min(2).max(100),
+	pinNumber: z.string(),
+	scannerId: z
+		.string()
+		.min(1)
+		.max(500)
+		.optional()
+		.describe("if you leave blank it will be the same as your username"),
+	role: z
+		.enum(["user", "lead", "manager", "admin"])
+		.optional()
+		.describe("What roles are available to use."),
+	pinHash: z.string().optional(),
+});
+
+r.post("/pin", async (req, res) => {
+	const { pin } = req.body;
+
+	if (!pin || pin.length !== 6) {
+		return apiReturn(res, {
+			success: false,
+			level: "error",
+			module: "mobile",
+			subModule: "auth",
+			message: `Pin number must be a min of 6 digits`,
+			data: [],
+			status: 401,
+		});
+	}
+
+	// const user = await db
+	// 	.select()
+	// 	.from(scanUser)
+	// 	.where(eq(scanUser.pinNumber, parseInt(pin, 10)));
+
+	const user = await db.query.scanUser.findFirst({
+		where: (u, { eq }) => eq(u.pinNumber, pin),
+	});
+
+	if (!user) {
+		return apiReturn(res, {
+			success: false,
+			level: "error",
+			module: "mobile",
+			subModule: "auth",
+			message: `Invalid login please try again.`,
+			data: [],
+			status: 401,
+		});
+	}
+
+	const validPin = bcrypt.compareSync(pin, user.pinHash);
+
+	if (!validPin) {
+		return apiReturn(res, {
+			success: false,
+			level: "error",
+			module: "mobile",
+			subModule: "auth",
+			message: `Invalid pin please try again.`,
+			data: [],
+			status: 401,
+		});
+	}
+
+	return apiReturn(res, {
+		success: true,
+		level: "info",
+		module: "mobile",
+		subModule: "auth",
+		message: `Welcome back ${user.name}`,
+		data: user as ScanUser | any,
+		status: 200,
+	});
+});
+
+r.post("/user", async (req, res) => {
+	try {
+		// validate the body is correct before accepting it
+		let validated = registerSchema.parse(req.body);
+
+		validated = {
+			...validated,
+			pinHash: await hashPin(validated.pinNumber.toString()),
+		};
+
+		const values: NewScanUser = {
+			name: validated.name,
+			pinNumber: validated.pinNumber,
+			pinHash: validated.pinHash ?? "",
+			scannerId: validated.scannerId ?? "",
+		};
+
+		const newUser = await db.insert(scanUser).values(values).returning();
+
+		apiReturn(res, {
+			success: true,
+			level: "info", //connect.success ? "info" : "error",
+			module: "mobile",
+			subModule: "auth",
+			message: `${validated.name} was just created`,
+			data: newUser as any,
+			status: 200, //connect.success ? 200 : 400,
+		});
+	} catch (err) {
+		if (err instanceof z.ZodError) {
+			const flattened = z.flattenError(err);
+			// return res.status(400).json({
+			// 	error: "Validation failed",
+			// 	details: flattened,
+			// });
+
+			return apiReturn(res, {
+				success: false,
+				level: "error", //connect.success ? "info" : "error",
+				module: "mobile",
+				subModule: "auth",
+				message: "Validation failed",
+				data: [flattened.fieldErrors],
+				status: 400, //connect.success ? 200 : 400,
+			});
+		}
+
+		return apiReturn(res, {
+			success: false,
+			level: "error", //connect.success ? "info" : "error",
+			module: "mobile",
+			subModule: "auth",
+			message:
+				"This User already exist with this pin or scanner id please try again",
+			data: [err],
+			status: 400, //connect.success ? 200 : 400,
+		});
+	}
+});
+
+r.get("/user", requireAuth, async (_, res) => {
+	const { data, error } = await tryCatch(db.select().from(scanUser));
+
+	if (error) {
+		return apiReturn(res, {
+			success: false,
+			level: "error",
+			module: "mobile",
+			subModule: "auth",
+			message: `There was an error getting the user`,
+			data: error as any,
+			status: 400,
+		});
+	}
+
+	if (!data) {
+		return apiReturn(res, {
+			success: true,
+			level: "info",
+			module: "mobile",
+			subModule: "auth",
+			message: `There are no users you should add one . `,
+			data: [],
+			status: 200,
+		});
+	}
+
+	return apiReturn(res, {
+		success: true,
+		level: "info",
+		module: "mobile",
+		subModule: "auth",
+		message: `All users. `,
+		data,
+		status: 200,
+	});
+});
+
+r.patch("/user/:id", requireAuth, async (req, res) => {
+	const updates: Record<string, unknown | null> = {};
+	const { id } = req.params;
+
+	const { data, error } = await tryCatch(
+		db.query.scanUser.findFirst({
+			where: (u, { eq }) => eq(u.id, `${id}`),
+		}),
+	);
+
+	if (error) {
+		return apiReturn(res, {
+			success: false,
+			level: "error",
+			module: "mobile",
+			subModule: "auth",
+			message: `There was an error getting the user`,
+			data: error as any,
+			status: 400,
+		});
+	}
+
+	if (!data) {
+		return apiReturn(res, {
+			success: false,
+			level: "error",
+			module: "mobile",
+			subModule: "auth",
+			message: `Invalid user id was passed over. `,
+			data: [],
+			status: 400,
+		});
+	}
+
+	if (req.body?.name !== undefined) {
+		updates.name = req.body.name;
+	}
+
+	if (req.body?.pinNumber !== undefined) {
+		const existing = await db.query.scanUser.findFirst({
+			where: (u, { eq }) => eq(u.pinHash, req.body.pinNumber),
+		});
+
+		if (existing)
+			return returnFunc({
+				success: false,
+				level: "error",
+				module: "mobile",
+				subModule: "auth",
+				message: `${req.body.pinNumber} already exists please try again`,
+				data: [],
+				notify: false,
+				room: "",
+			});
+		updates.pinNumber = req.body.pinNumber;
+		updates.pinHash = await hashPin(req.body.pinNumber);
+	}
+
+	if (req.body?.scannerId !== undefined) {
+		updates.scannerId = req.body.scannerId;
+	}
+
+	if (req.body?.active !== undefined) {
+		updates.active = req.body.active;
+	}
+
+	if (req.body?.role !== undefined) {
+		updates.role = req.body.role;
+	}
+
+	updates.upd_date = sql`NOW()`;
+
+	const updatedSetting = await db
+		.update(scanUser)
+		.set(updates)
+		.where(eq(scanUser.id, `${id}`))
+		.returning();
+
+	return apiReturn(res, {
+		success: true,
+		level: "info",
+		module: "mobile",
+		subModule: "user",
+		message: `User ${data.name} was updated. `,
+		data: updatedSetting,
+		status: 200,
+	});
+});
+
+r.delete("/user/:id", requireAuth, async (req, res) => {
+	const { id } = req.params;
+
+	const { data, error } = await tryCatch(
+		db.delete(scanUser).where(eq(scanUser.id, `${id}`)),
+	);
+
+	if (error) {
+		return apiReturn(res, {
+			success: false,
+			level: "error",
+			module: "mobile",
+			subModule: "auth",
+			message: `There was an error deleting the user`,
+			data: error as any,
+			status: 400,
+		});
+	}
+
+	if (!data) {
+		return apiReturn(res, {
+			success: false,
+			level: "error",
+			module: "mobile",
+			subModule: "auth",
+			message: `There was no user to delete. `,
+			data: [],
+			status: 400,
+		});
+	}
+
+	return apiReturn(res, {
+		success: true,
+		level: "info",
+		module: "mobile",
+		subModule: "user",
+		message: `User was deleted. `,
+		data: data ?? [],
+		status: 200,
+	});
+});
+
+export default r;

backend/mobile/mobilePin.route.ts

@@ -0,0 +1,21 @@
+import { Router } from "express";
+import { generateUniquePin } from "../utils/generateScannerPin.utils.js";
+import { apiReturn } from "../utils/returnHelper.utils.js";
+
+const r = Router();
+
+r.get("/new", async (_, res) => {
+	const getPin = await generateUniquePin();
+
+	return apiReturn(res, {
+		success: getPin.success,
+		level: getPin.level,
+		module: "mobile",
+		subModule: "auth",
+		message: getPin.message,
+		data: getPin.data,
+		status: getPin.success ? 200 : 400,
+	});
+});
+
+export default r;

backend/mobile/scanLogs.route.ts

@@ -0,0 +1,35 @@
+import { Router } from "express";
+
+import { db } from "../db/db.controller.js";
+import { scanLog } from "../db/schema/scanlog.schema.js";
+import { apiReturn } from "../utils/returnHelper.utils.js";
+
+const router = Router();
+
+router.post("/", async (req, res) => {
+	const body = req.body;
+
+	const newLog = await db
+		.insert(scanLog)
+		.values({
+			scannerId: body.scannerId,
+			message: body.message,
+			prompt: body.prompt,
+			commandDescription: body.commandDescription,
+			status: body.status,
+			lines: body.lines,
+		})
+		.returning();
+
+	return apiReturn(res, {
+		success: true,
+		level: "info",
+		module: "mobile",
+		subModule: "scan logs",
+		message: `New log from ${body.scannerId}`,
+		data: newLog,
+		status: 200,
+	});
+});
+
+export default router;

backend/mobile/version.route.ts

@@ -0,0 +1,28 @@
+import fs from "node:fs";
+import { Router } from "express";
+
+import path from "path";
+
+const router = Router();
+
+const projectRoot = path.resolve("./lstMobile"); // adjust as needed
+const appJsonPath = path.join(projectRoot, "app.json");
+
+router.get("/", async (req, res) => {
+	const baseUrl = `${req.protocol}://${req.get("host")}`;
+
+	const raw = fs.readFileSync(appJsonPath, "utf-8");
+	const config = JSON.parse(raw);
+
+	const exp = config.expo;
+
+	res.json({
+		packageName: exp.android?.package,
+		versionName: exp.version,
+		versionCode: exp.android?.versionCode,
+		minSupportedVersionCode: exp?.android?.minSupportedVersionCode ?? 0,
+		downloadUrl: `${baseUrl}/lst/api/mobile/apk/latest`,
+	});
+});
+
+export default router;

backend/notification/notification.minLevel.ts

@@ -0,0 +1,113 @@
+import { eq } from "drizzle-orm";
+import { db } from "../db/db.controller.js";
+import { notifications } from "../db/schema/notifications.schema.js";
+import { prodQuery } from "../prodSql/prodSqlQuery.controller.js";
+import {
+	type SqlQuery,
+	sqlQuerySelector,
+} from "../prodSql/prodSqlQuerySelector.utils.js";
+import { returnFunc } from "../utils/returnHelper.utils.js";
+import { sendEmail } from "../utils/sendEmail.utils.js";
+import { tryCatch } from "../utils/trycatch.utils.js";
+
+/**
+ *
+ */
+const func = async (data: any, emails: string) => {
+	// get the actual notification as items will be updated between intervals if no one touches
+	const { data: l, error: le } = (await tryCatch(
+		db.select().from(notifications).where(eq(notifications.id, data.id)),
+	)) as any;
+
+	if (le) {
+		return returnFunc({
+			success: false,
+			level: "error",
+			module: "notification",
+			subModule: "query",
+			message: `${data.name} encountered an error while trying to get initial info`,
+			data: [le],
+			notify: true,
+		});
+	}
+
+	// search the query db for the query by name
+	const sqlQuery = sqlQuerySelector(`${data.name}`) as SqlQuery;
+	// create the ignore audit logs ids
+	const ignoreIds = l[0].options[0]?.auditId
+		? `${l[0].options[0]?.auditId}`
+		: "0";
+
+	// run the check
+	const { data: queryRun, error } = await tryCatch(
+		prodQuery(
+			sqlQuery.query
+				.replace("[intervalCheck]", l[0].interval)
+				.replace("[ignoreList]", ignoreIds),
+			`Running notification query: ${l[0].name}`,
+		),
+	);
+
+	if (error) {
+		return returnFunc({
+			success: false,
+			level: "error",
+			module: "notification",
+			subModule: "query",
+			message: `Data for: ${l[0].name} encountered an error while trying to get it`,
+			data: [error],
+			notify: true,
+		});
+	}
+
+	if (queryRun.data.length > 0) {
+		// update the latest audit id
+		const { error: dbe } = await tryCatch(
+			db
+				.update(notifications)
+				.set({ options: [{ auditId: `${queryRun.data[0].id}` }] })
+				.where(eq(notifications.id, data.id)),
+		);
+
+		if (dbe) {
+			return returnFunc({
+				success: false,
+				level: "error",
+				module: "notification",
+				subModule: "query",
+				message: `Data for: ${l[0].name} encountered an error while trying to get it`,
+				data: [dbe],
+				notify: true,
+			});
+		}
+
+		// send the email
+
+		const sentEmail = await sendEmail({
+			email: emails,
+			subject: "Alert! Label Reprinted",
+			template: "reprintLabels",
+			context: {
+				items: queryRun.data,
+			},
+		});
+
+		if (!sentEmail?.success) {
+			return returnFunc({
+				success: false,
+				level: "error",
+				module: "email",
+				subModule: "notification",
+				message: `${l[0].name} failed to send the email`,
+				data: [sentEmail],
+				notify: true,
+			});
+		}
+	} else {
+		console.log("doing nothing as there is nothing to do.");
+	}
+	// TODO send the error to systemAdmin users so they do not always need to be on the notifications.
+	// these errors are defined per notification.
+};
+
+export default func;

backend/routeHandler.routes.ts

@@ -1,10 +1,11 @@
 import type { Express } from "express";
-
+import { setupAdminRoutes } from "./admin/admin.routes.js";
 import { setupAuthRoutes } from "./auth/auth.routes.js";
 // import the routes and route setups
 import { setupApiDocsRoutes } from "./configs/scaler.config.js";
 import { setupDatamartRoutes } from "./datamart/datamart.routes.js";
 import { setupGPSqlRoutes } from "./gpSql/gpSql.routes.js";
+import { setupMobileRoutes } from "./mobile/mobile.routes.js";
 import { setupNotificationRoutes } from "./notification/notification.routes.js";
 import { setupOCPRoutes } from "./ocp/ocp.routes.js";
 import { setupOpendockRoutes } from "./opendock/opendock.routes.js";
@@ -16,6 +17,7 @@ import { setupUtilsRoutes } from "./utils/utils.routes.js";
 export const setupRoutes = (baseUrl: string, app: Express) => {
 	//routes that are on by default
 	setupSystemRoutes(baseUrl, app);
+	setupAdminRoutes(baseUrl, app);
 	setupApiDocsRoutes(baseUrl, app);
 	setupProdSqlRoutes(baseUrl, app);
 	setupGPSqlRoutes(baseUrl, app);
@@ -26,4 +28,5 @@ export const setupRoutes = (baseUrl: string, app: Express) => {
 	setupNotificationRoutes(baseUrl, app);
 	setupOCPRoutes(baseUrl, app);
 	setupTCPRoutes(baseUrl, app);
+	setupMobileRoutes(baseUrl, app);
 };

backend/server.ts

@@ -15,6 +15,7 @@ import { opendockSocketMonitor } from "./opendock/opendockSocketMonitor.utils.js
 import { connectProdSql } from "./prodSql/prodSqlConnection.controller.js";
 import { monitorAlplaPurchase } from "./purchase/purchase.controller.js";
 import { setupSocketIORoutes } from "./socket.io/serverSetup.js";
+import { serversChecks } from "./system/serverData.controller.js";
 import { baseSettingValidationCheck } from "./system/settingsBase.controller.js";
 import { startTCPServer } from "./tcpServer/tcp.server.js";
 import { createCronJob } from "./utils/croner.utils.js";
@@ -70,6 +71,7 @@ const start = async () => {
 		// one shots only needed to run on server startups
 		createNotifications();
 		startNotifications();
+		serversChecks();
 	}, 5 * 1000);
 
 	process.on("uncaughtException", async (err) => {

backend/socket.io/roomDefinitions.socket.ts

@@ -9,7 +9,7 @@ type RoomDefinition<T = unknown> = {
 
 export const protectedRooms: any = {
 	logs: { requiresAuth: true, role: ["admin", "systemAdmin"] },
-	admin: { requiresAuth: true, role: ["admin", "systemAdmin"] },
+	//admin: { requiresAuth: false, role: ["admin", "systemAdmin"] },
 };
 
 export const roomDefinition: Record<RoomId, RoomDefinition> = {
@@ -36,4 +36,16 @@ export const roomDefinition: Record<RoomId, RoomDefinition> = {
 			return [];
 		},
 	},
+	admin: {
+		seed: async (limit) => {
+			console.info(limit);
+			return [];
+		},
+	},
+	"admin:build": {
+		seed: async (limit) => {
+			console.info(limit);
+			return [];
+		},
+	},
 };

backend/socket.io/serverSetup.ts

@@ -88,14 +88,12 @@ export const setupSocketIORoutes = (baseUrl: string, server: HttpServer) => {
 				});
 			}
 
-			const roles = Array.isArray(config.role) ? config.role : [config.role];
+			const roles = Array.isArray(config?.role) ? config?.role : [config?.role];
-
-			console.log(roles, s.user.role);
 
 			//if (config?.role && s.user?.role !== config.role) {
 			if (config?.role && !roles.includes(s.user?.role)) {
 				return s.emit("room-error", {
-					room: rn,
+					roomId: rn,
 					message: `Not authorized to be in room: ${rn}`,
 				});
 			}

backend/socket.io/types.socket.ts

@@ -1 +1 @@
-export type RoomId = "logs" | "labels"; //| "alerts" | "metrics";
+export type RoomId = "logs" | "labels" | "admin" | "admin:build"; //| "alerts" | "metrics";

backend/system/serverData.controller.ts

@@ -0,0 +1,205 @@
+import { sql } from "drizzle-orm";
+import { db } from "../db/db.controller.js";
+import {
+	type NewServerData,
+	serverData,
+} from "../db/schema/serverData.schema.js";
+import { createLogger } from "../logger/logger.controller.js";
+import { tryCatch } from "../utils/trycatch.utils.js";
+
+const servers: NewServerData[] = [
+	{
+		name: "Test server 1",
+		server: "USMCD1VMS036",
+		plantToken: "test3",
+		idAddress: "10.193.0.56",
+		greatPlainsPlantCode: "00",
+		contactEmail: "",
+		contactPhone: "",
+		serverLoc: "D$\\LST_V3",
+		buildNumber: 1,
+	},
+	{
+		name: "Test server 2",
+		server: "USIOW1VMS036",
+		plantToken: "test2",
+		idAddress: "10.75.0.56",
+		greatPlainsPlantCode: "00",
+		contactEmail: "",
+		contactPhone: "",
+		serverLoc: "D$\\LST_V3",
+		buildNumber: 1,
+	},
+	{
+		name: "Lima",
+		server: "USLIM1VMS006",
+		plantToken: "uslim1",
+		idAddress: "10.53.0.26", // port opened 3000 2222
+		greatPlainsPlantCode: "50",
+		contactEmail: "",
+		contactPhone: "",
+		serverLoc: "D$\\LST_V3",
+		buildNumber: 1,
+	},
+	{
+		name: "Houston",
+		server: "ushou1VMS006",
+		plantToken: "ushou1",
+		idAddress: "10.195.0.26",
+		greatPlainsPlantCode: "20",
+		contactEmail: "",
+		contactPhone: "",
+		serverLoc: "D$\\LST_V3",
+		buildNumber: 1,
+	},
+	{
+		name: "Dayton",
+		server: "usday1VMS006",
+		plantToken: "usday1",
+		idAddress: "10.44.0.56", // ports opened 3000 and 2222
+		greatPlainsPlantCode: "80",
+		contactEmail: "",
+		contactPhone: "",
+		serverLoc: "D$\\LST_V3",
+		buildNumber: 1,
+	},
+	{
+		name: "West Bend",
+		server: "usweb1VMS006",
+		plantToken: "usweb1",
+		idAddress: "10.80.0.26",
+		greatPlainsPlantCode: "65",
+		contactEmail: "",
+		contactPhone: "",
+		serverLoc: "D$\\LST_V3",
+		buildNumber: 1,
+	},
+	{
+		name: "Jeff City",
+		server: "usjci1VMS006",
+		plantToken: "usjci",
+		idAddress: "10.167.0.26",
+		greatPlainsPlantCode: "40",
+		contactEmail: "",
+		contactPhone: "",
+		serverLoc: "D$\\LST_V3",
+		buildNumber: 1,
+	},
+	{
+		name: "Sherman",
+		server: "usshe1vms006",
+		plantToken: "usshe1",
+		idAddress: "10.205.0.26",
+		greatPlainsPlantCode: "21",
+		contactEmail: "",
+		contactPhone: "",
+		serverLoc: "D$\\LST_V3",
+		buildNumber: 1,
+	},
+	{
+		name: "McDonough",
+		server: "USMCD1VMS006",
+		plantToken: "usmcd1",
+		idAddress: "10.193.0.26",
+		greatPlainsPlantCode: "10",
+		contactEmail: "",
+		contactPhone: "",
+		serverLoc: "D$\\LST_V3",
+		buildNumber: 1,
+	},
+	{
+		name: "St. Peters",
+		server: "USSTP1VMS006",
+		plantToken: "usstp1",
+		idAddress: "10.37.0.26",
+		greatPlainsPlantCode: "45",
+		contactEmail: "",
+		contactPhone: "",
+		serverLoc: "D$\\LST_V3",
+		buildNumber: 1,
+	},
+	{
+		name: "Marked Tree",
+		server: "USMAR1VMS006",
+		plantToken: "usmar1",
+		idAddress: "10.206.9.26", // 3000,2222 requested REQ0236838
+		greatPlainsPlantCode: "90",
+		contactEmail: "",
+		contactPhone: "",
+		serverLoc: "D$\\LST_V3",
+		buildNumber: 1,
+	},
+	{
+		name: "Iowa City EBM",
+		server: "USIOW1VMS006",
+		plantToken: "usiow1",
+		idAddress: "10.75.0.26",
+		greatPlainsPlantCode: "30",
+		contactEmail: "",
+		contactPhone: "",
+		serverLoc: "D$\\LST_V3",
+		buildNumber: 1,
+	},
+	{
+		name: "Bowling Green 1",
+		server: "USBOW1VMS006",
+		plantToken: "usbow1",
+		idAddress: "10.25.0.26", //  3000 is open REQ0236527 2222 already open
+		greatPlainsPlantCode: "55",
+		contactEmail: "",
+		contactPhone: "",
+		serverLoc: "D$\\LST_V3",
+		buildNumber: 1,
+	},
+	{
+		name: "Bethlehem",
+		server: "USBET1VMS006",
+		plantToken: "usbet1",
+		idAddress: "10.25.0.26",
+		greatPlainsPlantCode: "75",
+		contactEmail: "",
+		contactPhone: "",
+		serverLoc: "D$\\LST_V3",
+		buildNumber: 1,
+	},
+];
+
+// notes here for when it comes time to pull in all the server address info [test1_AlplaPROD2.0_Read].[masterData].[Plant] has everything from every server :D
+export const serversChecks = async () => {
+	const log = createLogger({ module: "system", subModule: "serverData" });
+	const { data, error } = await tryCatch(
+		db
+			.insert(serverData)
+			.values(servers)
+			.onConflictDoUpdate({
+				target: serverData.plantToken,
+				set: {
+					server: sql`excluded.server`,
+					name: sql`excluded.name`,
+					idAddress: sql`excluded."id_address"`,
+					greatPlainsPlantCode: sql`excluded.great_plains_plant_code`,
+					contactEmail: sql`excluded."contact_email"`,
+					contactPhone: sql`excluded.contact_phone`,
+					serverLoc: sql`excluded.server_loc`,
+				},
+			})
+			.returning(),
+	);
+
+	if (error) {
+		log.error(
+			{ error: error },
+			"There was an error when adding or updating the servers.",
+		);
+	}
+
+	if (data) {
+		log.info({}, "All Servers were added/updated");
+	}
+};
+
+// Communication from logistic network to logisticsSupportTool (for printers and scanners)
+
+// network justification
+
+// scanners and printers are on dhcp

backend/system/serverData.route.ts

@@ -0,0 +1,43 @@
+import { type Response, Router } from "express";
+import { db } from "../db/db.controller.js";
+import { serverData } from "../db/schema/serverData.schema.js";
+import { apiReturn } from "../utils/returnHelper.utils.js";
+import { tryCatch } from "../utils/trycatch.utils.js";
+
+// export const updateSetting = async (setting: Setting) => {
+// 	// TODO: when the setting is a feature setting we will need to have it run each kill switch on the crons well just stop them and during a reset it just wont start them
+// 	// TODO: when the setting is a system we will need to force an app restart
+// 	// TODO: when the setting is standard we don't do anything.
+// };
+
+const r = Router();
+
+r.get("/", async (_, res: Response) => {
+	const { data: sName, error: sError } = await tryCatch(
+		db.select().from(serverData).orderBy(serverData.name),
+	);
+
+	if (sError) {
+		return apiReturn(res, {
+			success: false,
+			level: "error",
+			module: "system",
+			subModule: "serverData",
+			message: `There was an error getting the servers `,
+			data: [sError],
+			status: 400,
+		});
+	}
+
+	return apiReturn(res, {
+		success: true,
+		level: "info",
+		module: "system",
+		subModule: "serverData",
+		message: `All current servers`,
+		data: sName ?? [],
+		status: 200,
+	});
+});
+
+export default r;

backend/system/stats.route.ts

@@ -27,7 +27,7 @@ router.get("/", async (_, res) => {
 			? sqlServerStats?.data[0].UptimeSeconds
 			: [],
 		eomFGPkgSheetVersion: 1, // this is the excel file version when we have a change to the macro we want to grab this
-		masterMacroFile: 1,
+		masterMacroFile: 1.1,
 		tcpServerOnline: isServerRunning,
 		sqlServerConnected: prodSql,
 		gpServerConnected: gpSql,

backend/system/system.routes.ts

@@ -1,15 +1,15 @@
 import type { Express } from "express";
 import { requireAuth } from "../middleware/auth.middleware.js";
+import getServers from "./serverData.route.js";
 import getSettings from "./settings.route.js";
 import updSetting from "./settingsUpdate.route.js";
 import stats from "./stats.route.js";
-import mobile from "./system.mobileApp.js";
 
 export const setupSystemRoutes = (baseUrl: string, app: Express) => {
 	//stats will be like this as we dont need to change this
 	app.use(`${baseUrl}/api/stats`, stats);
-	app.use(`${baseUrl}/api/mobile`, mobile);
 	app.use(`${baseUrl}/api/settings`, getSettings);
+	app.use(`${baseUrl}/api/servers`, getServers);
 	app.use(`${baseUrl}/api/settings`, requireAuth, updSetting);
 
 	// all other system should be under /api/system/*

backend/utils/auth.utils.ts

@@ -2,6 +2,7 @@ import { betterAuth } from "better-auth";
 import { drizzleAdapter } from "better-auth/adapters/drizzle";
 import {
 	admin as adminPlugin,
+	genericOAuth,
 	// apiKey,
 	// createAuthMiddleware,
 	//customSession,
@@ -16,6 +17,46 @@ import { ac, admin, systemAdmin, user } from "./auth.permissions.js";
 import { allowedOrigins } from "./cors.utils.js";
 import { sendEmail } from "./sendEmail.utils.js";
 
+function decodeJwtPayload<T = Record<string, unknown>>(jwt: string): T {
+	const parts = jwt.split(".");
+	if (parts.length < 2) {
+		throw new Error("Invalid JWT");
+	}
+
+	const payload = parts[1]?.replace(/-/g, "+").replace(/_/g, "/");
+
+	const padded = payload?.padEnd(
+		payload.length + ((4 - (payload.length % 4)) % 4),
+		"=",
+	);
+
+	const json = Buffer.from(padded ?? "", "base64").toString("utf8");
+	return JSON.parse(json) as T;
+}
+
+function normalizeGroups(groups?: unknown): string[] {
+	if (!Array.isArray(groups)) return [];
+
+	return groups
+		.filter((g): g is string => typeof g === "string")
+		.map((g) => g.trim().toLowerCase())
+		.filter((g) => g.length > 0);
+}
+
+type VoidAuthClaims = {
+	sub: string;
+	name?: string;
+	preferred_username?: string;
+	email?: string;
+	email_verified?: boolean;
+	groups?: string[];
+	picture?: string;
+	iss?: string;
+	aud?: string;
+	exp?: number;
+	iat?: number;
+};
+
 export const schema = {
 	user: rawSchema.user,
 	session: rawSchema.session,
@@ -25,9 +66,73 @@ export const schema = {
 	apiKey: rawSchema.apikey, // 🔑 rename to apiKey
 };
 
+const hasOAuth =
+	Boolean(process.env.PROVIDER) &&
+	Boolean(process.env.CLIENT_ID) &&
+	Boolean(process.env.CLIENT_SECRET) &&
+	Boolean(process.env.DISCOVERY_URL);
+
+if (!hasOAuth) {
+	console.warn("Missing oauth data.");
+}
+
+const oauthPlugins = hasOAuth
+	? [
+			genericOAuth({
+				config: [
+					{
+						providerId: process.env.PROVIDER!,
+						clientId: process.env.CLIENT_ID!,
+						clientSecret: process.env.CLIENT_SECRET!,
+						discoveryUrl: process.env.DISCOVERY_URL!,
+						scopes: (process.env.CLIENT_SCOPES ?? "")
+							.split(/[,\s]+/)
+							.filter(Boolean),
+						pkce: true,
+						requireIssuerValidation: true,
+						redirectURI: `${process.env.URL}/lst/api/auth/oauth2/callback/${process.env.PROVIDER!}`,
+						getUserInfo: async (tokens) => {
+							if (!tokens.idToken) {
+								throw new Error("VoidAuth did not return an idToken");
+							}
+
+							const claims = decodeJwtPayload<VoidAuthClaims>(tokens.idToken);
+							const groups = normalizeGroups(claims.groups);
+
+							return {
+								id: claims.sub,
+								email: claims.email ?? "",
+								name:
+									claims.name ??
+									claims.preferred_username ??
+									claims.email ??
+									"Unknown User",
+								image: claims.picture ?? null,
+								emailVerified: Boolean(claims.email_verified),
+								groups,
+								username: claims.preferred_username ?? null,
+							} as any;
+						},
+
+						mapProfileToUser: async (profile) => {
+							return {
+								name: profile.name,
+								role: profile.groups?.includes("lst_admins")
+									? "systemAdmin"
+									: profile.groups?.includes("admins")
+										? "admin"
+										: "user",
+							};
+						},
+					},
+				],
+			}),
+		]
+	: [];
+
 export const auth = betterAuth({
 	appName: "lst",
-	baseURL: process.env.URL,
+	baseURL: `${process.env.URL}/lst/api/auth`,
 	database: drizzleAdapter(db, {
 		provider: "pg",
 		schema,
@@ -42,6 +147,14 @@ export const auth = betterAuth({
 			},
 		},
 	},
+	account: {
+		encryptOAuthTokens: true,
+		updateAccountOnSignIn: true,
+		accountLinking: {
+			enabled: true,
+			trustedProviders: ["voidauth"],
+		},
+	},
 	plugins: [
 		jwt({ jwt: { expirationTime: "1h" } }),
 		//apiKey(),
@@ -63,6 +176,7 @@ export const auth = betterAuth({
 				return true;
 			},
 		}),
+		...oauthPlugins,
 
 		// customSession(async ({ user, session }) => {
 		// 	const roles = await db
@@ -121,7 +235,7 @@ export const auth = betterAuth({
 		},
 	},
 	cookie: {
-		path: "/lst/app",
+		path: "/lst",
 		sameSite: "lax",
 		secure: false,
 		httpOnly: true,

backend/utils/build.utils.ts

@@ -0,0 +1,91 @@
+import { spawn } from "node:child_process";
+import { createLogger } from "../logger/logger.controller.js";
+import { emitToRoom } from "../socket.io/roomEmitter.socket.js";
+import { updateAppStats } from "./updateAppStats.utils.js";
+import { zipBuild } from "./zipper.utils.js";
+
+export const emitBuildLog = (message: string, level = "info") => {
+	const payload = {
+		type: "build",
+		level,
+		message,
+		timestamp: new Date().toISOString(),
+	};
+
+	//console.log(`[BUILD][${level.toUpperCase()}] ${message}`);
+
+	emitToRoom("admin:build", payload as any);
+	if (payload.level === "info") {
+		log.info({ stack: payload }, payload.message);
+	}
+
+	// if (log) {
+	// 	log(payload);
+	// }
+};
+
+export let building = false;
+const log = createLogger({ module: "utils", subModule: "builds" });
+export const build = async () => {
+	const appDir = process.env.DEV_DIR ?? "";
+	return new Promise((resolve) => {
+		building = true;
+
+		updateAppStats({
+			lastUpdated: new Date(),
+			building: true,
+		});
+
+		emitBuildLog(`Starting build in: ${appDir}`);
+
+		const child = spawn("npm", ["run", "build"], {
+			cwd: appDir,
+			shell: true,
+		});
+
+		child.stdout.on("data", (data) => {
+			const lines = data.toString().split(/\r?\n/);
+			for (const line of lines) {
+				if (line.trim() !== "") {
+					emitBuildLog(line, "info");
+				}
+			}
+		});
+
+		child.stderr.on("data", (data) => {
+			const lines = data.toString().split(/\r?\n/);
+			for (const line of lines) {
+				if (line.trim() !== "") {
+					emitBuildLog(line, "error");
+				}
+			}
+		});
+
+		child.on("close", (code) => {
+			if (code === 0) {
+				emitBuildLog("Build completed successfully.", "info");
+				building = false;
+				zipBuild();
+				resolve(true);
+			} else {
+				building = false;
+				updateAppStats({
+					lastUpdated: new Date(),
+					building: false,
+				});
+				emitBuildLog(`Build failed with code ${code}`, "error");
+				//reject(new Error(`Build failed with code ${code}`));
+			}
+		});
+
+		child.on("error", (err) => {
+			building = false;
+			updateAppStats({
+				lastUpdated: new Date(),
+				building: false,
+			});
+			emitBuildLog(`Process error: ${err.message}`, "error");
+			// reject(err);
+		});
+	});
+};

backend/utils/deployApp.ts

@@ -0,0 +1,123 @@
+import { spawn } from "node:child_process";
+import { eq, sql } from "drizzle-orm";
+import { db } from "../db/db.controller.js";
+import { serverData } from "../db/schema/serverData.schema.js";
+import { appStats } from "../db/schema/stats.schema.js";
+//import { createLogger } from "../logger/logger.controller.js";
+import { emitBuildLog } from "./build.utils.js";
+import { returnFunc } from "./returnHelper.utils.js";
+
+// const log = createLogger({ module: "utils", subModule: "deploy" });
+export let updating = false;
+
+const updateServerBuildNumber = async (token: string) => {
+	// get the current build
+	const buildNum = await db.select().from(appStats);
+
+	// update the build now
+
+	await db
+		.update(serverData)
+		.set({ buildNumber: buildNum[0]?.currentBuild, lastUpdated: sql`NOW()` })
+		.where(eq(serverData.plantToken, token));
+};
+export const runUpdate = ({
+	server,
+	destination,
+	token,
+}: {
+	server: string;
+	destination: string;
+	token: string;
+}) => {
+	return new Promise((resolve, reject) => {
+		updating = true;
+		const scriptPath = process.env.UPDATE_SCRIPT_PATH;
+		if (!scriptPath) {
+			return returnFunc({
+				success: true,
+				level: "error",
+				module: "utils",
+				subModule: "deploy",
+				message: "UPDATE_SCRIPT_PATH please make sure you have this set.",
+				data: [],
+				notify: true,
+				room: "admin",
+			});
+		}
+
+		const args = [
+			"-ExecutionPolicy",
+			"Bypass",
+			"-File",
+			scriptPath,
+			"-Server",
+			server,
+			"-Destination",
+			destination,
+			"-Token",
+			token,
+			"-ADM_USER",
+			process.env.DEV_USER ?? "",
+			"-ADM_PASSWORD",
+			process.env.DEV_PASSWORD ?? "",
+			"-AppDir",
+			process.env.DEV_DIR ?? "",
+		];
+
+		emitBuildLog(`Starting update for ${server}`);
+
+		const child = spawn("powershell.exe", args, {
+			shell: false,
+		});
+
+		child.stdout.on("data", (data) => {
+			const lines = data.toString().split(/\r?\n/);
+			for (const line of lines) {
+				if (line.trim()) {
+					emitBuildLog(line);
+				}
+			}
+		});
+
+		child.stderr.on("data", (data) => {
+			const lines = data.toString().split(/\r?\n/);
+			for (const line of lines) {
+				if (line.trim()) {
+					emitBuildLog(line, "error");
+				}
+			}
+		});
+
+		child.on("close", (code) => {
+			if (code === 0) {
+				emitBuildLog(`Update completed for ${server}`);
+				updating = false;
+				updateServerBuildNumber(token);
+				resolve({
+					success: true,
+					message: `Update completed for ${server}`,
+					data: [],
+				});
+			} else {
+				emitBuildLog(`Update failed for ${server} (code ${code})`, "error");
+				updating = false;
+				reject({
+					success: false,
+					message: `Update failed for ${server} (code ${code})`,
+					data: [],
+				});
+			}
+		});
+
+		child.on("error", (err) => {
+			emitBuildLog(`Process error: ${err.message}`, "error");
+			updating = false;
+			reject({
+				success: false,
+				message: `${server}: Encountered an error while processing: ${err.message} `,
+				data: err,
+			});
+		});
+	});
+};

backend/utils/generateScannerPin.utils.ts

@@ -0,0 +1,39 @@
+import { db } from "../db/db.controller.js";
+import { returnFunc } from "./returnHelper.utils.js";
+
+export function generateSixDigitPin() {
+	return Math.floor(100000 + Math.random() * 900000).toString();
+}
+
+export async function generateUniquePin() {
+	for (let i = 0; i < 10; i++) {
+		const pin = generateSixDigitPin();
+
+		const existing = await db.query.scanUser.findFirst({
+			where: (u, { eq }) => eq(u.pinHash, pin), // ⚠️ we'll fix this below
+		});
+
+		if (!existing)
+			return returnFunc({
+				success: true,
+				level: "info",
+				module: "utils",
+				subModule: "genPin",
+				message: "New pin generated",
+				data: [{ pin: pin }],
+				notify: false,
+				room: "",
+			});
+	}
+
+	return returnFunc({
+		success: false,
+		level: "error",
+		module: "utils",
+		subModule: "genPin",
+		message: "Failed to generate unique PIN after 10 attempts",
+		data: [],
+		notify: true,
+		room: "",
+	});
+}

backend/utils/returnHelper.utils.ts

@@ -14,7 +14,9 @@ export interface ReturnHelper<T = unknown[]> {
 		| "email"
 		| "purchase"
 		| "tcp"
-		| "logistics";
+		| "logistics"
+		| "admin"
+		| "mobile";
 	subModule: string;
 
 	level: "info" | "error" | "debug" | "fatal" | "warn";

backend/utils/updateAppStats.utils.ts

@@ -0,0 +1,17 @@
+import { db } from "../db/db.controller.js";
+import { appStats } from "../db/schema/stats.schema.js";
+
+export const updateAppStats = async (
+	data: Partial<typeof appStats.$inferInsert>,
+) => {
+	await db
+		.insert(appStats)
+		.values({
+			id: "primary",
+			...data,
+		})
+		.onConflictDoUpdate({
+			target: appStats.id,
+			set: data,
+		});
+};

backend/utils/zipper.utils.ts

@@ -0,0 +1,177 @@
+import fs from "node:fs";
+import fsp from "node:fs/promises";
+import path from "node:path";
+import archiver from "archiver";
+import { createLogger } from "../logger/logger.controller.js";
+import { emitBuildLog } from "./build.utils.js";
+import { updateAppStats } from "./updateAppStats.utils.js";
+
+const log = createLogger({ module: "utils", subModule: "zip" });
+
+const exists = async (target: string) => {
+	try {
+		await fsp.access(target);
+		return true;
+	} catch {
+		return false;
+	}
+};
+
+const getNextBuildNumber = async (buildNumberFile: string) => {
+	if (!(await exists(buildNumberFile))) {
+		await fsp.writeFile(buildNumberFile, "1", "utf8");
+		return 1;
+	}
+
+	const raw = await fsp.readFile(buildNumberFile, "utf8");
+	const current = Number.parseInt(raw.trim(), 10);
+
+	if (Number.isNaN(current) || current < 1) {
+		await fsp.writeFile(buildNumberFile, "1", "utf8");
+		return 1;
+	}
+
+	const next = current + 1;
+
+	await fsp.writeFile(buildNumberFile, String(next), "utf8");
+
+	// update the server with the next build number
+
+	await updateAppStats({
+		currentBuild: next,
+		lastBuildAt: new Date(),
+		building: true,
+	});
+
+	return next;
+};
+
+const cleanupOldBuilds = async (buildFolder: string, maxBuilds: number) => {
+	const entries = await fsp.readdir(buildFolder, { withFileTypes: true });
+
+	const zipFiles: { fullPath: string; name: string; mtimeMs: number }[] = [];
+
+	for (const entry of entries) {
+		if (!entry.isFile()) continue;
+		if (!/^LSTV3-\d+\.zip$/i.test(entry.name)) continue;
+
+		const fullPath = path.join(buildFolder, entry.name);
+		const stat = await fsp.stat(fullPath);
+
+		zipFiles.push({
+			fullPath,
+			name: entry.name,
+			mtimeMs: stat.mtimeMs,
+		});
+	}
+
+	zipFiles.sort((a, b) => b.mtimeMs - a.mtimeMs);
+
+	const toRemove = zipFiles.slice(maxBuilds);
+
+	for (const file of toRemove) {
+		await fsp.rm(file.fullPath, { force: true });
+		emitBuildLog(`Removed old build: ${file.name}`);
+	}
+};
+
+export const zipBuild = async () => {
+	const appDir = process.env.DEV_DIR ?? "";
+	const maxBuilds = Number(process.env.MAX_BUILDS ?? 5);
+
+	if (!appDir) {
+		log.error({ notify: true }, "Forgot to add in the dev dir into the env");
+		return;
+	}
+
+	const includesFile = path.join(appDir, ".includes");
+	const buildNumberFile = path.join(appDir, ".buildNumber");
+	const buildFolder = path.join(appDir, "builds");
+	const tempFolder = path.join(appDir, "temp", "zip-temp");
+	if (!(await exists(includesFile))) {
+		log.error({ notify: true }, "Missing .includes file common");
+		return;
+	}
+
+	await fsp.mkdir(buildFolder, { recursive: true });
+
+	const buildNumber = await getNextBuildNumber(buildNumberFile);
+	const zipFileName = `LSTV3-${buildNumber}.zip`;
+	const zipFile = path.join(buildFolder, zipFileName);
+	// make the folders in case they are not created already
+	emitBuildLog(`Using build number: ${buildNumber}`);
+
+	if (await exists(tempFolder)) {
+		await fsp.rm(tempFolder, { recursive: true, force: true });
+	}
+
+	await fsp.mkdir(tempFolder, { recursive: true });
+
+	const includes = (await fsp.readFile(includesFile, "utf8"))
+		.split(/\r?\n/)
+		.map((line) => line.trim())
+		.filter(Boolean);
+
+	emitBuildLog(`Preparing zip from ${includes.length} include entries`);
+
+	for (const relPath of includes) {
+		const source = path.join(appDir, relPath);
+		const dest = path.join(tempFolder, relPath);
+
+		if (!(await exists(source))) {
+			emitBuildLog(`Skipping missing path: ${relPath}`, "error");
+			continue;
+		}
+
+		const stat = await fsp.stat(source);
+		await fsp.mkdir(path.dirname(dest), { recursive: true });
+
+		if (stat.isDirectory()) {
+			emitBuildLog(`Copying folder: ${relPath}`);
+			await fsp.cp(source, dest, { recursive: true });
+		} else {
+			emitBuildLog(`Copying file: ${relPath}`);
+			await fsp.copyFile(source, dest);
+		}
+	}
+
+	// if something crazy happens and we get the same build lets just reuse it
+	// if (await exists(zipFile)) {
+	// 	await fsp.rm(zipFile, { force: true });
+	// }
+
+	emitBuildLog(`Creating zip: ${zipFile}`);
+
+	await new Promise<void>((resolve, reject) => {
+		const output = fs.createWriteStream(zipFile);
+		const archive = archiver("zip", { zlib: { level: 9 } });
+
+		output.on("close", () => resolve());
+		output.on("error", reject);
+		archive.on("error", reject);
+
+		archive.pipe(output);
+
+		// zip contents of temp folder, not temp folder itself
+		archive.directory(tempFolder, false);
+		archive.finalize();
+	});
+
+	await fsp.rm(tempFolder, { recursive: true, force: true });
+
+	emitBuildLog(`Zip completed successfully: ${zipFile}`);
+
+	await cleanupOldBuilds(buildFolder, maxBuilds);
+
+	await updateAppStats({
+		lastUpdated: new Date(),
+		building: false,
+	});
+
+	return {
+		success: true,
+		buildNumber,
+		zipFile,
+		zipFileName,
+	};
+};

brunoApi/auth/Login.bru

@@ -1,37 +0,0 @@
-meta {
-  name: Login
-  type: http
-  seq: 1
-}
-
-post {
-  url: {{url}}/api/auth/sign-in/email
-  body: json
-  auth: inherit
-}
-
-headers {
-  Origin: http://localhost:3000
-}
-
-body:json {
-  {
-    "email": "blake.matthes@alpla.com",
-    "password": "nova0511"
-  }
-}
-
-script:post-response {
-  // // grab the raw Set-Cookie header
-  // const cookies = res.headers["set-cookie"];
-  
-  // const sessionCookie = cookies[0].split(";")[0];
-  
-  // // Save it as an environment variable
-  // bru.setEnvVar("session_cookie", sessionCookie);
-}
-
-settings {
-  encodeUrl: true
-  timeout: 0
-}

brunoApi/auth/Register.bru

@@ -1,35 +0,0 @@
-meta {
-  name: Register
-  type: http
-  seq: 2
-}
-
-post {
-  url: {{url}}/api/authentication/register
-  body: json
-  auth: inherit
-}
-
-body:json {
-  {
-    "name":"Blake", // option when in the frontend as we will pass over as username if not added
-    "username": "matthes01",
-    "email": "blake.matthes@alpla.com",
-    "password": "nova0511"
-  }
-}
-
-script:post-response {
-  // // grab the raw Set-Cookie header
-  // const cookies = res.headers["set-cookie"];
-  
-  // const sessionCookie = cookies[0].split(";")[0];
-  
-  // // Save it as an environment variable
-  // bru.setEnvVar("session_cookie", sessionCookie);
-}
-
-settings {
-  encodeUrl: true
-  timeout: 0
-}

brunoApi/auth/folder.bru

@@ -1,8 +0,0 @@
-meta {
-  name: auth
-  seq: 5
-}
-
-auth {
-  mode: inherit
-}

brunoApi/auth/getSession.bru

@@ -1,16 +0,0 @@
-meta {
-  name: getSession
-  type: http
-  seq: 3
-}
-
-get {
-  url: {{url}}/api/auth/get-session
-  body: none
-  auth: inherit
-}
-
-settings {
-  encodeUrl: true
-  timeout: 0
-}

brunoApi/bruno.json

@@ -1,9 +0,0 @@
-{
-  "version": "1",
-  "name": "lst_v3",
-  "type": "collection",
-  "ignore": [
-    "node_modules",
-    ".git"
-  ]
-}

brunoApi/collection.bru

@@ -1,3 +0,0 @@
-docs {
-  All Api endpoints to the logistics support tool
-}

brunoApi/datamart/Get queries.bru

@@ -1,16 +0,0 @@
-meta {
-  name: Get queries
-  type: http
-  seq: 1
-}
-
-get {
-  url: {{url}}/api/datamart
-  body: none
-  auth: inherit
-}
-
-settings {
-  encodeUrl: true
-  timeout: 0
-}

brunoApi/datamart/Run Query.bru

@@ -1,24 +0,0 @@
-meta {
-  name: Run Query
-  type: http
-  seq: 2
-}
-
-get {
-  url: {{url}}/api/datamart/:name?historical=x
-  body: none
-  auth: inherit
-}
-
-params:query {
-  historical: x
-}
-
-params:path {
-  name: inventory
-}
-
-settings {
-  encodeUrl: true
-  timeout: 0
-}

brunoApi/datamart/folder.bru

@@ -1,8 +0,0 @@
-meta {
-  name: datamart
-  seq: 2
-}
-
-auth {
-  mode: inherit
-}

brunoApi/environments/lstv3.bru

@@ -1,7 +0,0 @@
-vars {
-  url: http://localhost:3000/lst
-  readerIp: 10.44.14.215
-}
-vars:secret [
-  token
-]

brunoApi/notifications/Get All notifications.bru

@@ -1,20 +0,0 @@
-meta {
-  name: Get All notifications.
-  type: http
-  seq: 1
-}
-
-get {
-  url: {{url}}/api/notification
-  body: none
-  auth: inherit
-}
-
-settings {
-  encodeUrl: true
-  timeout: 0
-}
-
-docs {
-  Passing all as a query param will return all queries active and none active
-}

brunoApi/notifications/Subscribe to notification.bru

@@ -1,24 +0,0 @@
-meta {
-  name: Subscribe to notification
-  type: http
-  seq: 2
-}
-
-post {
-  url: {{url}}/api/notification/sub
-  body: json
-  auth: inherit
-}
-
-body:json {
-  {
-    "userId":"m6AbQXFwOXoX3YKLfwWgq2LIdDqS5jqv",
-    "notificationId": "0399eb2a-39df-48b7-9f1c-d233cec94d2e",
-    "emails": ["blake.matthes@alpla.com","blake.matthes@alpla.com"]
-  }
-}
-
-settings {
-  encodeUrl: true
-  timeout: 0
-}

brunoApi/notifications/folder.bru

@@ -1,8 +0,0 @@
-meta {
-  name: notifications
-  seq: 7
-}
-
-auth {
-  mode: inherit
-}

brunoApi/notifications/remove sub notification.bru

@@ -1,24 +0,0 @@
-meta {
-  name: remove sub notification
-  type: http
-  seq: 4
-}
-
-delete {
-  url: {{url}}/api/notification/sub
-  body: json
-  auth: inherit
-}
-
-body:json {
-  {
-    "userId":"0kHd6Kkdub4GW6rK1qa1yjWwqXtvykqT",
-    "notificationId": "0399eb2a-39df-48b7-9f1c-d233cec94d2e",
-    "emails": ["blake.mattes@alpla.com"]
-  }
-}
-
-settings {
-  encodeUrl: true
-  timeout: 0
-}

brunoApi/notifications/subscriptions.bru

@@ -1,16 +0,0 @@
-meta {
-  name: subscriptions
-  type: http
-  seq: 5
-}
-
-get {
-  url: {{url}}/api/notification/sub
-  body: json
-  auth: inherit
-}
-
-settings {
-  encodeUrl: true
-  timeout: 0
-}

brunoApi/notifications/update notification.bru

@@ -1,31 +0,0 @@
-meta {
-  name: update notification
-  type: http
-  seq: 6
-}
-
-patch {
-  url: {{url}}/api/notification/:id
-  body: json
-  auth: inherit
-}
-
-params:path {
-  id: 0399eb2a-39df-48b7-9f1c-d233cec94d2e
-}
-
-body:json {
-  {
-    "active" : true,
-    "options": []
-  }
-}
-
-settings {
-  encodeUrl: true
-  timeout: 0
-}
-
-docs {
-  Passing all as a query param will return all queries active and none active
-}

brunoApi/notifications/update sub notification.bru

@@ -1,24 +0,0 @@
-meta {
-  name: update sub notification
-  type: http
-  seq: 3
-}
-
-patch {
-  url: {{url}}/api/notification/sub
-  body: json
-  auth: inherit
-}
-
-body:json {
-  {
-    "userId":"m6AbQXFwOXoX3YKLfwWgq2LIdDqS5jqv",
-    "notificationId": "0399eb2a-39df-48b7-9f1c-d233cec94d2e",
-    "emails": ["cowchmonkey@gmail.com"]
-  }
-}
-
-settings {
-  encodeUrl: true
-  timeout: 0
-}

brunoApi/ocp/Printer Listenter.bru

@@ -1,22 +0,0 @@
-meta {
-  name: Printer Listenter
-  type: http
-  seq: 1
-}
-
-post {
-  url: {{url}}/api/ocp/printer/listener/line_1
-  body: json
-  auth: inherit
-}
-
-body:json {
-  {
-    "message":"xnvjdhhgsdfr"
-  }
-}
-
-settings {
-  encodeUrl: true
-  timeout: 0
-}

brunoApi/ocp/folder.bru

@@ -1,8 +0,0 @@
-meta {
-  name: ocp
-  seq: 9
-}
-
-auth {
-  mode: inherit
-}

brunoApi/opendock/GetApt.bru

@@ -1,16 +0,0 @@
-meta {
-  name: GetApt
-  type: http
-  seq: 1
-}
-
-get {
-  url: {{url}}/api/opendock
-  body: none
-  auth: inherit
-}
-
-settings {
-  encodeUrl: true
-  timeout: 0
-}

brunoApi/prodSql/Sql Start.bru

@@ -1,16 +0,0 @@
-meta {
-  name: Sql Start
-  type: http
-  seq: 4
-}
-
-post {
-  url: {{url}}/api/system/prodsql/start
-  body: none
-  auth: inherit
-}
-
-settings {
-  encodeUrl: true
-  timeout: 0
-}

brunoApi/prodSql/Sql restart.bru

@@ -1,16 +0,0 @@
-meta {
-  name: Sql restart
-  type: http
-  seq: 4
-}
-
-post {
-  url: {{url}}/api/system/prodsql/restart
-  body: none
-  auth: inherit
-}
-
-settings {
-  encodeUrl: true
-  timeout: 0
-}

brunoApi/prodSql/Sql stop.bru

@@ -1,16 +0,0 @@
-meta {
-  name: Sql stop
-  type: http
-  seq: 4
-}
-
-post {
-  url: {{url}}/api/system/prodsql/stop
-  body: none
-  auth: inherit
-}
-
-settings {
-  encodeUrl: true
-  timeout: 0
-}

brunoApi/prodSql/folder.bru

@@ -1,8 +0,0 @@
-meta {
-  name: prodSql
-  seq: 6
-}
-
-auth {
-  mode: inherit
-}

brunoApi/rfidReaders/folder.bru

@@ -1,8 +0,0 @@
-meta {
-  name: rfidReaders
-  seq: 8
-}
-
-auth {
-  mode: inherit
-}

brunoApi/rfidReaders/reader.bru

@@ -1,20 +0,0 @@
-meta {
-  name: reader
-  type: http
-  seq: 2
-}
-
-post {
-  url: https://usday1prod.alpla.net/lst/old/api/rfid/mgtevents/line3.1
-  body: json
-  auth: inherit
-}
-
-body:json {
-  {}
-}
-
-settings {
-  encodeUrl: true
-  timeout: 0
-}

brunoApi/rfidReaders/readerSpecific/Config.bru

@@ -1,20 +0,0 @@
-meta {
-  name: Config
-  type: http
-  seq: 2
-}
-
-get {
-  url: https://{{readerIp}}/cloud/config
-  body: none
-  auth: bearer
-}
-
-auth:bearer {
-  token: {{token}}
-}
-
-settings {
-  encodeUrl: true
-  timeout: 0
-}

brunoApi/rfidReaders/readerSpecific/Login.bru

@@ -1,32 +0,0 @@
-meta {
-  name: Login
-  type: http
-  seq: 1
-}
-
-get {
-  url: https://{{readerIp}}/cloud/localRestLogin
-  body: none
-  auth: basic
-}
-
-auth:basic {
-  username: admin
-  password: Zebra123!
-}
-
-script:post-response {
-  const body = res.getBody();
-  
-  if (body.message) {
-    bru.setEnvVar("token", body.message);
-  } else {
-    bru.setEnvVar("token", "error");
-  }
-  
-}
-
-settings {
-  encodeUrl: true
-  timeout: 0
-}

brunoApi/rfidReaders/readerSpecific/Update Config.bru

@@ -1,237 +0,0 @@
-meta {
-  name: Update Config
-  type: http
-  seq: 3
-}
-
-put {
-  url: https://{{readerIp}}/cloud/config
-  body: json
-  auth: bearer
-}
-
-headers {
-  Content-Type: application/json
-}
-
-auth:bearer {
-  token: {{token}}
-}
-
-body:json {
-  {
-    "GPIO-LED": {
-      "GPODefaults": {
-        "1": "HIGH",
-        "2": "HIGH",
-        "3": "HIGH",
-        "4": "HIGH"
-      },
-      "LEDDefaults": {
-        "3": "GREEN"
-      },
-      "TAG_READ": [
-        {
-          "pin": 1,
-          "state": "HIGH",
-          "type": "GPO"
-        }
-      ]
-    },
-    "READER-GATEWAY": {
-      "batching": [
-        {
-          "maxPayloadSizePerReport": 256000,
-          "reportingInterval": 2000
-        },
-        {
-          "maxPayloadSizePerReport": 256000,
-          "reportingInterval": 2000
-        }
-      ],
-      "endpointConfig": {
-        "data": {
-          "event": {
-            "connections": [
-              {
-                "additionalOptions": {
-                  "retention": {
-                    "maxEventRetentionTimeInMin": 500,
-                    "maxNumEvents": 150000,
-                    "throttle": 100
-                  }
-                },
-                "description": "",
-                "name": "LST",
-                "options": {
-                  "URL": "https://usday1prod.alpla.net/lst/old/api/rfid/taginfo/line3.4",
-                  "security": {
-                    "CACertificateFileLocation": "",
-                    "authenticationOptions": {},
-                    "authenticationType": "NONE",
-                    "verifyHost": false,
-                    "verifyPeer": false
-                  }
-                },
-                "type": "httpPost"
-              },
-              {
-                "additionalOptions": {
-                  "retention": {
-                    "maxEventRetentionTimeInMin": 500,
-                    "maxNumEvents": 150000,
-                    "throttle": 100
-                  }
-                },
-                "description": "",
-                "name": "mgt",
-                "options": {
-                  "URL": "https://usday1prod.alpla.net/lst/old/api/rfid/mgtevents/line3.4",
-                  "security": {
-                    "CACertificateFileLocation": "",
-                    "authenticationOptions": {},
-                    "authenticationType": "NONE",
-                    "verifyHost": false,
-                    "verifyPeer": false
-                  }
-                },
-                "type": "httpPost"
-              }
-            ]
-          }
-        }
-      },
-      "managementEventConfig": {
-        "errors": {
-          "antenna": false,
-          "cpu": {
-            "reportIntervalInSec": 1800,
-            "threshold": 90
-          },
-          "database": true,
-          "flash": {
-            "reportIntervalInSec": 1800,
-            "threshold": 90
-          },
-          "ntp": true,
-          "radio": true,
-          "radio_control": true,
-          "ram": {
-            "reportIntervalInSec": 1800,
-            "threshold": 90
-          },
-          "reader_gateway": true,
-          "userApp": {
-            "reportIntervalInSec": 1800,
-            "threshold": 120
-          }
-        },
-        "gpiEvents": true,
-        "gpoEvents": true,
-        "heartbeat": {
-          "fields": {
-            "radio_control": [
-              "ANTENNAS",
-              "RADIO_ACTIVITY",
-              "RADIO_CONNECTION",
-              "CPU",
-              "RAM",
-              "UPTIME",
-              "NUM_ERRORS",
-              "NUM_WARNINGS",
-              "NUM_TAG_READS",
-              "NUM_TAG_READS_PER_ANTENNA",
-              "NUM_DATA_MESSAGES_TXED",
-              "NUM_RADIO_PACKETS_RXED"
-            ],
-            "reader_gateway": [
-              "NUM_DATA_MESSAGES_RXED",
-              "NUM_MANAGEMENT_EVENTS_TXED",
-              "NUM_DATA_MESSAGES_TXED",
-              "NUM_DATA_MESSAGES_RETAINED",
-              "NUM_DATA_MESSAGES_DROPPED",
-              "CPU",
-              "RAM",
-              "UPTIME",
-              "NUM_ERRORS",
-              "NUM_WARNINGS",
-              "INTERFACE_CONNECTION_STATUS",
-              "NOLOCKQ_DEPTH"
-            ],
-            "system": [
-              "CPU",
-              "FLASH",
-              "NTP",
-              "RAM",
-              "SYSTEMTIME",
-              "TEMPERATURE",
-              "UPTIME",
-              "GPO",
-              "GPI",
-              "POWER_NEGOTIATION",
-              "POWER_SOURCE",
-              "MAC_ADDRESS",
-              "HOSTNAME"
-            ],
-            "userapps": [
-              "STATUS",
-              "CPU",
-              "RAM",
-              "UPTIME",
-              "NUM_DATA_MESSAGES_RXED",
-              "NUM_DATA_MESSAGES_TXED",
-              "INCOMING_DATA_BUFFER_PERCENTAGE_REMAINING",
-              "OUTGOING_DATA_BUFFER_PERCENTAGE_REMAINING"
-            ]
-          },
-          "interval": 60
-        },
-        "userappEvents": true,
-        "warnings": {
-          "cpu": {
-            "reportIntervalInSec": 1800,
-            "threshold": 80
-          },
-          "database": true,
-          "flash": {
-            "reportIntervalInSec": 1800,
-            "threshold": 80
-          },
-          "ntp": true,
-          "radio_api": true,
-          "radio_control": true,
-          "ram": {
-            "reportIntervalInSec": 1800,
-            "threshold": 80
-          },
-          "reader_gateway": true,
-          "temperature": {
-            "ambient": 75,
-            "pa": 105
-          },
-          "userApp": {
-            "reportIntervalInSec": 1800,
-            "threshold": 60
-          }
-        }
-      },
-      "retention": [
-        {
-          "maxEventRetentionTimeInMin": 500,
-          "maxNumEvents": 150000,
-          "throttle": 100
-        },
-        {
-          "maxEventRetentionTimeInMin": 500,
-          "maxNumEvents": 150000,
-          "throttle": 100
-        }
-      ]
-    }
-  }
-}
-
-settings {
-  encodeUrl: true
-  timeout: 0
-}

brunoApi/rfidReaders/readerSpecific/folder.bru

@@ -1,12 +0,0 @@
-meta {
-  name: readerSpecific
-}
-
-auth {
-  mode: basic
-}
-
-auth:basic {
-  username: admin
-  password: Zebra123!
-}

brunoApi/system/Get Settings.bru

@@ -1,20 +0,0 @@
-meta {
-  name: Get Settings
-  type: http
-  seq: 3
-}
-
-get {
-  url: {{url}}/api/settings
-  body: none
-  auth: inherit
-}
-
-settings {
-  encodeUrl: true
-  timeout: 0
-}
-
-docs {
-  returns all settings
-}

brunoApi/system/Status.bru

@@ -1,16 +0,0 @@
-meta {
-  name: Status
-  type: http
-  seq: 1
-}
-
-get {
-  url: {{url}}/api/stats
-  body: none
-  auth: inherit
-}
-
-settings {
-  encodeUrl: true
-  timeout: 0
-}

brunoApi/system/updateSetting.bru

@@ -1,33 +0,0 @@
-meta {
-  name: updateSetting
-  type: http
-  seq: 2
-}
-
-patch {
-  url: {{url}}/api/settings/opendock_sync
-  body: json
-  auth: inherit
-}
-
-body:json {
-  {
-    "value" : "1",
-    "active": "true"
-  }
-}
-
-settings {
-  encodeUrl: true
-  timeout: 0
-}
-
-docs {
-  Allows the changing of a setting based on the parameter.
-  
-  * when a setting that is being changed is a feature there will be some backgound logic that will stop that features processes and no long work.
-  
-  * when the setting is being changed is system the entire app will do a full restart
-  
-  * when a seeting is being changed and is standard nothing will happen until the next action is completed. example someone prints a label and you changed the default to 120 second from 90 seconds
-}

brunoApi/utils/Active Jobs.bru

@@ -1,16 +0,0 @@
-meta {
-  name: Active Jobs
-  type: http
-  seq: 5
-}
-
-get {
-  url: {{url}}/api/utils/croner
-  body: none
-  auth: inherit
-}
-
-settings {
-  encodeUrl: true
-  timeout: 0
-}

brunoApi/utils/Change job status.bru

@@ -1,22 +0,0 @@
-meta {
-  name: Change job status
-  type: http
-  seq: 2
-}
-
-patch {
-  url: {{url}}/api/utils/croner/stop
-  body: json
-  auth: inherit
-}
-
-body:json {
-  {
-    "name": "open-dock-monitor"
-  }
-}
-
-settings {
-  encodeUrl: true
-  timeout: 0
-}

docker-compose.yml

@@ -12,48 +12,39 @@ services:
             #- "${VITE_PORT:-4200}:4200"
             - "3600:3000"
         dns:
-            - 10.193.9.250
+            - 10.44.9.250
-            - 10.193.9.251   # your internal DNS server
+            - 10.44.9.251   # your internal DNS server
-        dns_search:
+            - 1.1.1.1
-            - alpla.net      # or your internal search suffix
         environment:
             - NODE_ENV=production
             - LOG_LEVEL=info
-            - EXTERNAL_URL=http://192.168.8.222:3600
+            - URL=http://localhost:3600
-            - DATABASE_HOST=host.docker.internal # if running on the same docker then do this
+            - DATABASE_HOST=postgres # if running on the same docker then do this
-            - DATABASE_PORT=5433
+            - DATABASE_PORT=5432
             - DATABASE_USER=${DATABASE_USER}
             - DATABASE_PASSWORD=${DATABASE_PASSWORD}
             - DATABASE_DB=${DATABASE_DB}
-            - PROD_SERVER=${PROD_SERVER}
+            - PROD_SERVER=10.75.9.56 #${PROD_SERVER}
             - PROD_PLANT_TOKEN=${PROD_PLANT_TOKEN}
             - PROD_USER=${PROD_USER}
             - PROD_PASSWORD=${PROD_PASSWORD}
+            - GP_SERVER=10.193.9.31
+            - SQL_PORT=1433
             - BETTER_AUTH_SECRET=${BETTER_AUTH_SECRET}
             - BETTER_AUTH_URL=${URL}
-        # for all host including prod servers, plc's, printers, or other de
+            - OPENDOCK_URL=${OPENDOCK_URL}
-#         extra_hosts:
+            - OPENDOCK_PASSWORD=${OPENDOCK_PASSWORD}
-#             - "${PROD_SERVER}:${PROD_IP}"
+            - DEFAULT_DOCK=${DEFAULT_DOCK}
+            - DEFAULT_LOAD_TYPE=${DEFAULT_LOAD_TYPE}
+            - DEFAULT_CARRIER=${DEFAULT_CARRIER}
 
-#         networks:
+        #for all host including prod servers, plc's, printers, or other de
-#             - default
+        networks:
-#             - logisticsNetwork
+            - docker-network 
-#             #- mlan1
+            - pgNetwork
-# networks:
-#     logisticsNetwork:
-#         driver: macvlan
-#         driver_opts:
-#             parent: eth0
-#         ipam:
-#             config:
-#                 - subnet: ${LOGISTICS_NETWORK}
-#                   gateway: ${LOGISTICS_GATEWAY}
 
-#     mlan1:
+networks:
-#         driver: macvlan
+  docker-network:
-#         driver_opts:
+    external: true
-#             parent: eth0
+  pgNetwork:
-#         ipam:
+    external: true
-#             config:
-#                 - subnet: ${MLAN1_NETWORK}
-#                   gateway: ${MLAN1_GATEWAY}

frontend/package-lock.json

@@ -19,6 +19,8 @@
         "better-auth": "^1.5.5",
         "class-variance-authority": "^0.7.1",
         "clsx": "^2.1.1",
+        "date-fns": "^4.1.0",
+        "date-fns-tz": "^3.2.0",
         "lucide-react": "^0.577.0",
         "next-themes": "^0.4.6",
         "radix-ui": "^1.4.3",
@@ -6016,6 +6018,25 @@
         "node": ">= 12"
       }
     },
+    "node_modules/date-fns": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/date-fns/-/date-fns-4.1.0.tgz",
+      "integrity": "sha512-Ukq0owbQXxa/U3EGtsdVBkR1w7KOQ5gIBqdH2hkvknzZPYvBxb/aa6E8L7tmjFtkwZBu3UXBbjIgPo/Ez4xaNg==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "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.3",
       "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",

frontend/package.json

@@ -34,7 +34,9 @@
     "tailwind-merge": "^3.5.0",
     "tailwindcss": "^4.2.1",
     "tw-animate-css": "^1.4.0",
-    "zod": "^4.3.6"
+    "zod": "^4.3.6",
+    "date-fns": "^4.1.0",
+		"date-fns-tz": "^3.2.0"
   },
   "devDependencies": {
     "@eslint/js": "^9.36.0",

frontend/src/components/Sidebar/AdminBar.tsx

@@ -1,5 +1,5 @@
 import { Link } from "@tanstack/react-router";
-import { Bell, Logs, Settings } from "lucide-react";
+import { Bell, Logs, Server, Settings, UsersRound } from "lucide-react";
 
 import {
 	SidebarGroup,
@@ -40,6 +40,14 @@ export default function AdminSidebar({ session }: any) {
 			module: "admin",
 			active: true,
 		},
+		{
+			title: "Servers",
+			url: "/admin/servers",
+			icon: Server,
+			role: ["systemAdmin", "admin"],
+			module: "admin",
+			active: true,
+		},
 		{
 			title: "Logs",
 			url: "/admin/logs",
@@ -48,22 +56,22 @@ export default function AdminSidebar({ session }: any) {
 			module: "admin",
 			active: true,
 		},
-		// {
+		{
-		// 	title: "Modules",
+			title: "Users",
-		// 	url: "/admin/modules",
+			url: "/admin/users",
-		// 	icon: Settings,
+			icon: UsersRound,
-		// 	role: ["systemAdmin", "admin"],
+			role: ["systemAdmin", "admin"],
-		// 	module: "admin",
+			module: "admin",
-		// 	active: true,
+			active: true,
-		// },
+		},
-		// {
+		{
-		// 	title: "Servers",
+			title: "Scan users",
-		// 	url: "/admin/servers",
+			url: "/admin/scanUsers",
-		// 	icon: Server,
+			icon: UsersRound,
-		// 	role: ["systemAdmin", "admin"],
+			role: ["systemAdmin", "admin"],
-		// 	module: "admin",
+			module: "admin",
-		// 	active: true,
+			active: true,
-		// },
+		},
 	];
 	return (
 		<SidebarGroup>

frontend/src/components/Sidebar/DocBar.tsx

@@ -36,6 +36,17 @@ const docs = [
 			},
 		],
 	},
+	{
+		title: "Mobile",
+		url: "/updateInstructions",
+		isActive: false,
+		items: [
+			{
+				title: "Settings",
+				url: "/mobile-settings",
+			},
+		],
+	},
 ];
 export default function DocBar() {
 	const { setOpen } = useSidebar();

frontend/src/components/Sidebar/MobileBar.tsx

@@ -0,0 +1,49 @@
+import { Link } from "@tanstack/react-router";
+import { ScanText, ScrollText } from "lucide-react";
+import {
+	SidebarGroup,
+	SidebarGroupContent,
+	SidebarGroupLabel,
+	SidebarMenu,
+	SidebarMenuButton,
+	SidebarMenuItem,
+	useSidebar,
+} from "../ui/sidebar";
+
+export default function MobileBar({ session }: any) {
+	const { setOpen } = useSidebar();
+	const items = [
+		{
+			title: "Update Instructions",
+			url: "/",
+			icon: ScrollText,
+		},
+		{
+			title: "Scan Log",
+			url: "/",
+			icon: ScanText,
+		},
+	];
+
+	console.log(session);
+
+	return (
+		<SidebarGroup>
+			<SidebarGroupLabel>Mobile</SidebarGroupLabel>
+			<SidebarGroupContent>
+				<SidebarMenu>
+					{items.map((item) => (
+						<SidebarMenuItem key={item.title}>
+							<SidebarMenuButton asChild>
+								<Link to={item.url} onClick={() => setOpen(false)}>
+									<item.icon />
+									<span>{item.title}</span>
+								</Link>
+							</SidebarMenuButton>
+						</SidebarMenuItem>
+					))}
+				</SidebarMenu>
+			</SidebarGroupContent>
+		</SidebarGroup>
+	);
+}

frontend/src/components/Sidebar/sidebar.tsx

@@ -8,6 +8,7 @@ import {
 import { useSession } from "@/lib/auth-client";
 import AdminSidebar from "./AdminBar";
 import DocBar from "./DocBar";
+import MobileBar from "./MobileBar";
 
 export function AppSidebar() {
 	const { data: session } = useSession();
@@ -22,7 +23,8 @@ export function AppSidebar() {
 				<SidebarMenu>
 					<SidebarMenuItem>
 						<SidebarContent>
-							<DocBar/>
+							<DocBar />
+							<MobileBar session={session} />
 							{session &&
 								(session.user.role === "admin" ||
 									session.user.role === "systemAdmin") && (

frontend/src/docs/notifications/updateInstructions.tsx

@@ -0,0 +1,3 @@
+export default function updateInstructions() {
+	return <div>updateInstructions</div>;
+}

frontend/src/hooks/socket.io.hook.ts

@@ -1,22 +1,55 @@
-import { useEffect, useState } from "react";
+import { useCallback, useEffect, useState } from "react";
 import socket from "@/lib/socket.io";
 
-export function useSocketRoom<T>(roomId: string) {
+type RoomUpdatePayload<T> = {
+	roomId: string;
+	payloads: T[];
+};
+
+type RoomErrorPayload = {
+	roomId?: string;
+	message?: string;
+};
+
+export function useSocketRoom<T>(
+	roomId: string,
+	getKey?: (item: T) => string | number,
+) {
 	const [data, setData] = useState<T[]>([]);
 	const [info, setInfo] = useState(
 		"No data yet — join the room to start receiving",
 	);
 
+	const clearRoom = useCallback(
+		(id?: string | number) => {
+			if (id !== undefined && getKey) {
+				setData((prev) => prev.filter((item) => getKey(item) !== id));
+				setInfo(`Removed item ${id}`);
+				return;
+			}
+
+			setData([]);
+			setInfo("Room data cleared");
+		},
+		[getKey],
+	);
+
 	useEffect(() => {
 		function handleConnect() {
 			socket.emit("join-room", roomId);
+			setInfo(`Joined room: ${roomId}`);
 		}
 
-		function handleUpdate(payload: any) {
+		function handleUpdate(payload: RoomUpdatePayload<T>) {
+			// protects against other room updates hitting this hook
+			if (payload.roomId !== roomId) return;
+
 			setData((prev) => [...payload.payloads, ...prev]);
+			setInfo("");
 		}
 
-		function handleError(err: any) {
+		function handleError(err: RoomErrorPayload) {
+			if (err.roomId && err.roomId !== roomId) return;
 			setInfo(err.message ?? "Room error");
 		}
 
@@ -31,6 +64,7 @@ export function useSocketRoom<T>(roomId: string) {
 		// If already connected, join immediately
 		if (socket.connected) {
 			socket.emit("join-room", roomId);
+			setInfo(`Joined room: ${roomId}`);
 		}
 
 		return () => {
@@ -42,5 +76,5 @@ export function useSocketRoom<T>(roomId: string) {
 		};
 	}, [roomId]);
 
-	return { data, info };
+	return { data, info, clearRoom };
 }

frontend/src/lib/auth-client.ts

@@ -1,4 +1,4 @@
-import { adminClient } from "better-auth/client/plugins";
+import { adminClient, genericOAuthClient } from "better-auth/client/plugins";
 import { createAuthClient } from "better-auth/react";
 import { ac, admin, systemAdmin, user } from "./auth-permissions";
 
@@ -13,6 +13,7 @@ export const authClient = createAuthClient({
 				systemAdmin,
 			},
 		}),
+		genericOAuthClient(),
 	],
 });
 

frontend/src/lib/queries/servers.ts

@@ -0,0 +1,22 @@
+import { keepPreviousData, queryOptions } from "@tanstack/react-query";
+import axios from "axios";
+
+export function servers() {
+	return queryOptions({
+		queryKey: ["servers"],
+		queryFn: () => fetch(),
+		staleTime: 5000,
+		refetchOnWindowFocus: true,
+		placeholderData: keepPreviousData,
+	});
+}
+
+const fetch = async () => {
+	if (window.location.hostname === "localhost") {
+		await new Promise((res) => setTimeout(res, 1500));
+	}
+
+	const { data } = await axios.get("/lst/api/servers");
+
+	return data.data;
+};

frontend/src/lib/tableStuff/LstTable.tsx

@@ -11,6 +11,15 @@ import {
 import React, { useState } from "react";
 import { Button } from "../../components/ui/button";
 import { ScrollArea, ScrollBar } from "../../components/ui/scroll-area";
+import {
+	Select,
+	SelectContent,
+	SelectGroup,
+	SelectItem,
+	SelectLabel,
+	SelectTrigger,
+	SelectValue,
+} from "../../components/ui/select";
 import {
 	Table,
 	TableBody,
@@ -26,15 +35,23 @@ type LstTableType = {
 	tableClassName?: string;
 	data: any;
 	columns: any;
+	height?: string;
+	pageSize?: number;
 };
 export default function LstTable({
 	className = "",
 	tableClassName = "",
 	data,
 	columns,
+	height = "h-full",
+	pageSize = 5,
 }: LstTableType) {
 	const [sorting, setSorting] = useState<SortingState>([]);
 	const [columnFilters, setColumnFilters] = useState<ColumnFiltersState>([]);
+	const [pagination, setPagination] = useState({
+		pageIndex: 0, //initial page index
+		pageSize: pageSize, //default page size
+	});
 	//console.log(data);
 
 	const table = useReactTable({
@@ -46,24 +63,33 @@ export default function LstTable({
 		getSortedRowModel: getSortedRowModel(),
 		onColumnFiltersChange: setColumnFilters,
 		getFilteredRowModel: getFilteredRowModel(),
+		onPaginationChange: setPagination,
 		//renderSubComponent: ({ row }: { row: any }) => <ExpandedRow row={row} />,
 		//getRowCanExpand: () => true,
+		// columnResizeMode: "onChange",
 		filterFns: {},
 		state: {
 			sorting,
+			pagination,
 			columnFilters,
 		},
 	});
 	return (
 		<div className={className}>
-			<ScrollArea className="w-full rounded-md border whitespace-nowrap">
+			<div>{/* TODO: Add table header in here like title */}</div>
+			<ScrollArea
+				className={`w-full rounded-md border whitespace-nowrap ${height}`}
+			>
 				<Table className={cn("w-full", tableClassName)}>
 					<TableHeader>
 						{table.getHeaderGroups().map((headerGroup) => (
 							<TableRow key={headerGroup.id}>
 								{headerGroup.headers.map((header) => {
 									return (
-										<TableHead key={header.id}>
+										<TableHead
+											key={header.id}
+											className="sticky top-0 z-20 bg-background"
+										>
 											{header.isPlaceholder
 												? null
 												: flexRender(
@@ -76,6 +102,7 @@ export default function LstTable({
 							</TableRow>
 						))}
 					</TableHeader>
+
 					<TableBody>
 						{table.getRowModel().rows.length ? (
 							table.getRowModel().rows.map((row) => (
@@ -105,15 +132,25 @@ export default function LstTable({
 					</TableBody>
 				</Table>
 				<ScrollBar orientation="horizontal" />
+				<ScrollBar orientation="vertical" />
 			</ScrollArea>
+
 			<div className="flex items-center justify-end space-x-2 py-4">
+				<Button
+					variant="outline"
+					size="sm"
+					onClick={() => table.firstPage()}
+					disabled={!table.getCanPreviousPage()}
+				>
+					{"<<"}
+				</Button>
 				<Button
 					variant="outline"
 					size="sm"
 					onClick={() => table.previousPage()}
 					disabled={!table.getCanPreviousPage()}
 				>
-					Previous
+					{"<"}
 				</Button>
 				<Button
 					variant="outline"
@@ -121,8 +158,42 @@ export default function LstTable({
 					onClick={() => table.nextPage()}
 					disabled={!table.getCanNextPage()}
 				>
-					Next
+					{">"}
 				</Button>
+				<Button
+					variant="outline"
+					size="sm"
+					onClick={() => table.lastPage()}
+					disabled={!table.getCanNextPage()}
+				>
+					{">>"}
+				</Button>
+				<Select
+					value={pagination.pageSize.toString()}
+					onValueChange={(e) =>
+						setPagination({
+							...pagination,
+							pageSize: e === "all" ? data.length : parseInt(e, 10),
+						})
+					}
+				>
+					<SelectTrigger className="w-16">
+						<SelectValue
+							//id={field.name}
+							placeholder="Select Page"
+						/>
+					</SelectTrigger>
+					<SelectContent>
+						<SelectGroup>
+							<SelectLabel>Page Size</SelectLabel>
+							<SelectItem value="5">5</SelectItem>
+							<SelectItem value="10">10</SelectItem>
+							<SelectItem value="50">50</SelectItem>
+							<SelectItem value="100">100</SelectItem>
+							<SelectItem value="all">All</SelectItem>
+						</SelectGroup>
+					</SelectContent>
+				</Select>
 			</div>
 		</div>
 	);

frontend/src/routeTree.gen.ts

@@ -14,6 +14,8 @@ import { Route as IndexRouteImport } from './routes/index'
 import { Route as DocsIndexRouteImport } from './routes/docs/index'
 import { Route as DocsSplatRouteImport } from './routes/docs/$'
 import { Route as AdminSettingsRouteImport } from './routes/admin/settings'
+import { Route as AdminServersRouteImport } from './routes/admin/servers'
+import { Route as AdminScanUsersRouteImport } from './routes/admin/scanUsers'
 import { Route as AdminNotificationsRouteImport } from './routes/admin/notifications'
 import { Route as AdminLogsRouteImport } from './routes/admin/logs'
 import { Route as authLoginRouteImport } from './routes/(auth)/login'
@@ -46,6 +48,16 @@ const AdminSettingsRoute = AdminSettingsRouteImport.update({
   path: '/admin/settings',
   getParentRoute: () => rootRouteImport,
 } as any)
+const AdminServersRoute = AdminServersRouteImport.update({
+  id: '/admin/servers',
+  path: '/admin/servers',
+  getParentRoute: () => rootRouteImport,
+} as any)
+const AdminScanUsersRoute = AdminScanUsersRouteImport.update({
+  id: '/admin/scanUsers',
+  path: '/admin/scanUsers',
+  getParentRoute: () => rootRouteImport,
+} as any)
 const AdminNotificationsRoute = AdminNotificationsRouteImport.update({
   id: '/admin/notifications',
   path: '/admin/notifications',
@@ -83,6 +95,8 @@ export interface FileRoutesByFullPath {
   '/login': typeof authLoginRoute
   '/admin/logs': typeof AdminLogsRoute
   '/admin/notifications': typeof AdminNotificationsRoute
+  '/admin/scanUsers': typeof AdminScanUsersRoute
+  '/admin/servers': typeof AdminServersRoute
   '/admin/settings': typeof AdminSettingsRoute
   '/docs/$': typeof DocsSplatRoute
   '/docs/': typeof DocsIndexRoute
@@ -96,6 +110,8 @@ export interface FileRoutesByTo {
   '/login': typeof authLoginRoute
   '/admin/logs': typeof AdminLogsRoute
   '/admin/notifications': typeof AdminNotificationsRoute
+  '/admin/scanUsers': typeof AdminScanUsersRoute
+  '/admin/servers': typeof AdminServersRoute
   '/admin/settings': typeof AdminSettingsRoute
   '/docs/$': typeof DocsSplatRoute
   '/docs': typeof DocsIndexRoute
@@ -110,6 +126,8 @@ export interface FileRoutesById {
   '/(auth)/login': typeof authLoginRoute
   '/admin/logs': typeof AdminLogsRoute
   '/admin/notifications': typeof AdminNotificationsRoute
+  '/admin/scanUsers': typeof AdminScanUsersRoute
+  '/admin/servers': typeof AdminServersRoute
   '/admin/settings': typeof AdminSettingsRoute
   '/docs/$': typeof DocsSplatRoute
   '/docs/': typeof DocsIndexRoute
@@ -125,6 +143,8 @@ export interface FileRouteTypes {
     | '/login'
     | '/admin/logs'
     | '/admin/notifications'
+    | '/admin/scanUsers'
+    | '/admin/servers'
     | '/admin/settings'
     | '/docs/$'
     | '/docs/'
@@ -138,6 +158,8 @@ export interface FileRouteTypes {
     | '/login'
     | '/admin/logs'
     | '/admin/notifications'
+    | '/admin/scanUsers'
+    | '/admin/servers'
     | '/admin/settings'
     | '/docs/$'
     | '/docs'
@@ -151,6 +173,8 @@ export interface FileRouteTypes {
     | '/(auth)/login'
     | '/admin/logs'
     | '/admin/notifications'
+    | '/admin/scanUsers'
+    | '/admin/servers'
     | '/admin/settings'
     | '/docs/$'
     | '/docs/'
@@ -165,6 +189,8 @@ export interface RootRouteChildren {
   authLoginRoute: typeof authLoginRoute
   AdminLogsRoute: typeof AdminLogsRoute
   AdminNotificationsRoute: typeof AdminNotificationsRoute
+  AdminScanUsersRoute: typeof AdminScanUsersRoute
+  AdminServersRoute: typeof AdminServersRoute
   AdminSettingsRoute: typeof AdminSettingsRoute
   DocsSplatRoute: typeof DocsSplatRoute
   DocsIndexRoute: typeof DocsIndexRoute
@@ -210,6 +236,20 @@ declare module '@tanstack/react-router' {
       preLoaderRoute: typeof AdminSettingsRouteImport
       parentRoute: typeof rootRouteImport
     }
+    '/admin/servers': {
+      id: '/admin/servers'
+      path: '/admin/servers'
+      fullPath: '/admin/servers'
+      preLoaderRoute: typeof AdminServersRouteImport
+      parentRoute: typeof rootRouteImport
+    }
+    '/admin/scanUsers': {
+      id: '/admin/scanUsers'
+      path: '/admin/scanUsers'
+      fullPath: '/admin/scanUsers'
+      preLoaderRoute: typeof AdminScanUsersRouteImport
+      parentRoute: typeof rootRouteImport
+    }
     '/admin/notifications': {
       id: '/admin/notifications'
       path: '/admin/notifications'
@@ -261,6 +301,8 @@ const rootRouteChildren: RootRouteChildren = {
   authLoginRoute: authLoginRoute,
   AdminLogsRoute: AdminLogsRoute,
   AdminNotificationsRoute: AdminNotificationsRoute,
+  AdminScanUsersRoute: AdminScanUsersRoute,
+  AdminServersRoute: AdminServersRoute,
   AdminSettingsRoute: AdminSettingsRoute,
   DocsSplatRoute: DocsSplatRoute,
   DocsIndexRoute: DocsIndexRoute,

frontend/src/routes/(auth)/-components/LoginForm.tsx

@@ -1,4 +1,5 @@
 import { Link, useNavigate } from "@tanstack/react-router";
+import { Cat } from "lucide-react";
 import { toast } from "sonner";
 import {
 	Card,
@@ -9,13 +10,23 @@ import {
 } from "@/components/ui/card";
 import { authClient } from "@/lib/auth-client";
 import { useAppForm } from "@/lib/formSutff";
+import { Button } from "../../../components/ui/button";
 import socket from "../../../lib/socket.io";
 
 export default function LoginForm({ redirectPath }: { redirectPath: string }) {
 	const loginEmail = localStorage.getItem("loginEmail") || "";
 	const rememberMe = localStorage.getItem("rememberMe") === "true";
+
 	const navigate = useNavigate();
 
+	const oauthLogin = async () => {
+		await authClient.signIn.oauth2({
+			providerId: "voidauth",
+			callbackURL: "/lst/app",
+			errorCallbackURL: "/lst/app/login",
+		});
+	};
+
 	const form = useAppForm({
 		defaultValues: {
 			email: loginEmail,
@@ -26,7 +37,7 @@ export default function LoginForm({ redirectPath }: { redirectPath: string }) {
 			// set remember me incase we want it later
 			if (value.rememberMe) {
 				localStorage.setItem("rememberMe", value.rememberMe.toString());
-				localStorage.setItem("loginEmail", value.email);
+				localStorage.setItem("loginEmail", value.email.toLocaleLowerCase());
 			} else {
 				localStorage.removeItem("rememberMe");
 				localStorage.removeItem("loginEmail");
@@ -62,7 +73,17 @@ export default function LoginForm({ redirectPath }: { redirectPath: string }) {
 		<div>
 			<Card className="p-3 w-96">
 				<CardHeader>
-					<CardTitle>Login to your account</CardTitle>
+					<CardTitle>
+						<div className="flex flex-row justify-center">
+							<Button onClick={oauthLogin} size="lg" variant="ghost">
+								<Cat />
+							</Button>
+							<span className="mt-2">Login to your account</span>{" "}
+							<Button size="lg" variant="ghost">
+								<Cat />
+							</Button>
+						</div>
+					</CardTitle>
 					<CardDescription>
 						Enter your username and password below
 					</CardDescription>
@@ -76,12 +97,19 @@ export default function LoginForm({ redirectPath }: { redirectPath: string }) {
 					>
 						<form.AppField name="email">
 							{(field) => (
-								<field.InputField label="Email" inputType="email" required />
+								<field.InputField
+									label="Email"
+									inputType="email"
+									required={rememberMe}
+								/>
 							)}
 						</form.AppField>
 						<form.AppField name="password">
 							{(field) => (
-								<field.InputPasswordField label="Password" required={true} />
+								<field.InputPasswordField
+									label="Password"
+									required={rememberMe}
+								/>
 							)}
 						</form.AppField>
 
@@ -98,7 +126,7 @@ export default function LoginForm({ redirectPath }: { redirectPath: string }) {
 							</Link>
 						</div>
 
-						<div className="flex justify-end mt-2">
+						<div className="flex justify-between mt-2 ">
 							<form.AppForm>
 								<form.SubmitButton>Login</form.SubmitButton>
 							</form.AppForm>

frontend/src/routes/__root.tsx

@@ -3,30 +3,36 @@ import { TanStackRouterDevtools } from "@tanstack/react-router-devtools";
 import { Toaster } from "sonner";
 import Header from "@/components/Header";
 import { AppSidebar } from "@/components/Sidebar/sidebar";
-import {  SidebarProvider } from "@/components/ui/sidebar";
+import { SidebarProvider } from "@/components/ui/sidebar";
 import { ThemeProvider } from "@/lib/theme-provider";
+import { useSession } from "../lib/auth-client";
 
-const RootLayout = () => (
+const RootLayout = () => {
-	<div className="[--header-height:calc(--spacing(14))]">
+	const { data: session } = useSession();
-		<ThemeProvider>
+	return (
-			<SidebarProvider className="flex flex-col" defaultOpen={false}>
+		<div className="[--header-height:calc(--spacing(14))]">
-				<Header />
+			<ThemeProvider>
+				<SidebarProvider className="flex flex-col" defaultOpen={false}>
+					<Header />
 
-				<div className="relative min-h-[calc(100svh-var(--header-height))]">
+					<div className="relative min-h-[calc(100svh-var(--header-height))]">
-					<AppSidebar />
+						<AppSidebar />
 
-					<main className="w-full p-4">
+						<main className="w-full p-4">
-						<div className="mx-auto w-full max-w-7xl">
+							<div className="mx-auto w-full max-w-7xl">
-							<Outlet />
+								<Outlet />
-						</div>
+							</div>
-					</main>
+						</main>
-				</div>
+					</div>
 
-				<Toaster expand richColors closeButton />
+					<Toaster expand richColors closeButton />
-			</SidebarProvider>
+				</SidebarProvider>
-		</ThemeProvider>
+			</ThemeProvider>
-		<TanStackRouterDevtools />
+			{session && session.user.role === "systemAdmin" && (
-	</div>
+				<TanStackRouterDevtools />
-);
+			)}
+		</div>
+	);
+};
 
 export const Route = createRootRoute({ component: RootLayout });

frontend/src/routes/admin/scanUsers.tsx

@@ -0,0 +1,9 @@
+import { createFileRoute } from '@tanstack/react-router'
+
+export const Route = createFileRoute('/admin/scanUsers')({
+  component: RouteComponent,
+})
+
+function RouteComponent() {
+  return <div>Hello "/admin/scanUsers"!</div>
+}

frontend/src/routes/admin/servers.tsx

@@ -0,0 +1,251 @@
+import { useSuspenseQuery } from "@tanstack/react-query";
+import { createFileRoute, redirect } from "@tanstack/react-router";
+import { createColumnHelper } from "@tanstack/react-table";
+import axios from "axios";
+import { format } from "date-fns-tz";
+import { CircleFadingArrowUp, Trash } from "lucide-react";
+import { Suspense, useState } from "react";
+import { toast } from "sonner";
+import { Button } from "../../components/ui/button";
+import { Spinner } from "../../components/ui/spinner";
+import {
+	Tooltip,
+	TooltipContent,
+	TooltipTrigger,
+} from "../../components/ui/tooltip";
+import { useSocketRoom } from "../../hooks/socket.io.hook";
+import { authClient } from "../../lib/auth-client";
+import { servers } from "../../lib/queries/servers";
+import LstTable from "../../lib/tableStuff/LstTable";
+import SearchableHeader from "../../lib/tableStuff/SearchableHeader";
+import SkellyTable from "../../lib/tableStuff/SkellyTable";
+
+export const Route = createFileRoute("/admin/servers")({
+	beforeLoad: async ({ location }) => {
+		const { data: session } = await authClient.getSession();
+		const allowedRole = ["systemAdmin", "admin"];
+
+		if (!session?.user) {
+			throw redirect({
+				to: "/",
+				search: {
+					redirect: location.href,
+				},
+			});
+		}
+
+		if (!allowedRole.includes(session.user.role as string)) {
+			throw redirect({
+				to: "/",
+			});
+		}
+
+		return { user: session.user };
+	},
+	component: RouteComponent,
+});
+
+const ServerTable = () => {
+	const { data, refetch } = useSuspenseQuery(servers());
+	const columnHelper = createColumnHelper<any>();
+	const okToUpdate = ["localhost", "usmcd1olp082"];
+	const columns = [
+		columnHelper.accessor("name", {
+			header: ({ column }) => (
+				<SearchableHeader column={column} title="Name" searchable={true} />
+			),
+			filterFn: "includesString",
+			cell: (i) => i.getValue(),
+		}),
+		columnHelper.accessor("greatPlainsPlantCode", {
+			header: ({ column }) => (
+				<SearchableHeader column={column} title="GP Code" />
+			),
+			cell: (i) => <span>{i.getValue().toUpperCase()}</span>,
+		}),
+		columnHelper.accessor("server", {
+			header: ({ column }) => (
+				<SearchableHeader column={column} title="server" />
+			),
+			cell: (i) => <span>{i.getValue().toUpperCase()}</span>,
+		}),
+		columnHelper.accessor("idAddress", {
+			header: ({ column }) => (
+				<SearchableHeader column={column} title="IP Address" />
+			),
+			cell: (i) => <span>{i.getValue()}</span>,
+		}),
+	];
+
+	if (okToUpdate.includes(window.location.hostname)) {
+		columns.push(
+			columnHelper.accessor("lastUpdated", {
+				header: ({ column }) => (
+					<SearchableHeader column={column} title="Last Update" />
+				),
+				cell: (i) => <span>{format(i.getValue(), "M/d/yyyy HH:mm")}</span>,
+			}),
+			columnHelper.accessor("buildNumber", {
+				header: ({ column }) => (
+					<SearchableHeader column={column} title="Build" />
+				),
+				cell: (i) => <span>{i.getValue()}</span>,
+			}),
+			columnHelper.accessor("update", {
+				header: ({ column }) => (
+					<SearchableHeader column={column} title="Update" searchable={false} />
+				),
+				filterFn: "includesString",
+				cell: (i) => {
+					// biome-ignore lint: just removing the lint for now to get this going will maybe fix later
+					const [activeToggle, setActiveToggle] = useState(false);
+
+					const onToggle = async () => {
+						setActiveToggle(true);
+						toast.success(
+							`${i.row.original.name} just started the upgrade monitor logs for errors.`,
+						);
+						try {
+							const res = await axios.post(
+								`/lst/api/admin/build/updateServer`,
+								{
+									server: i.row.original.server,
+									destination: i.row.original.serverLoc,
+									token: i.row.original.plantToken,
+								},
+								{ withCredentials: true },
+							);
+
+							if (res.data.success) {
+								toast.success(
+									`${i.row.original.name} has completed its upgrade.`,
+								);
+								refetch();
+								setActiveToggle(false);
+							}
+						} catch (error) {
+							setActiveToggle(false);
+							console.error(error);
+						}
+					};
+
+					return (
+						<div>
+							<div className="flex items-center space-x-2">
+								<Button
+									variant="ghost"
+									disabled={activeToggle}
+									onClick={() => onToggle()}
+								>
+									{activeToggle ? (
+										<span>
+											<Spinner />
+										</span>
+									) : (
+										<span>
+											<CircleFadingArrowUp />
+										</span>
+									)}
+								</Button>
+							</div>
+						</div>
+					);
+				},
+			}),
+		);
+	}
+
+	return <LstTable data={data} columns={columns} pageSize={50} />;
+};
+
+function RouteComponent() {
+	const { data: logs = [], clearRoom } = useSocketRoom<any>("admin:build");
+
+	const columnHelper = createColumnHelper<any>();
+
+	console.log(window.location);
+	const logColumns = [
+		columnHelper.accessor("timestamp", {
+			header: ({ column }) => (
+				<SearchableHeader column={column} title="Time" searchable={false} />
+			),
+			filterFn: "includesString",
+			cell: (i) => format(i.getValue(), "M/d/yyyy HH:mm"),
+		}),
+		columnHelper.accessor("message", {
+			header: ({ column }) => (
+				<SearchableHeader column={column} title="Message" />
+			),
+			cell: (i) => (
+				<Tooltip>
+					<TooltipTrigger>
+						{i.getValue()?.length > 250 ? (
+							<span>{i.getValue().slice(0, 250)}...</span>
+						) : (
+							<span>{i.getValue()}</span>
+						)}
+					</TooltipTrigger>
+					<TooltipContent>{i.getValue()}</TooltipContent>
+				</Tooltip>
+			),
+		}),
+		columnHelper.accessor("clearLog", {
+			header: ({ column }) => (
+				<SearchableHeader column={column} title="Clear" />
+			),
+			cell: ({ row }) => {
+				const x = row.original;
+				return (
+					<Button
+						size="icon"
+						variant={"destructive"}
+						onClick={() => clearRoom(x.timestamp)}
+					>
+						<Trash />
+					</Button>
+				);
+			},
+		}),
+	];
+	const triggerBuild = async () => {
+		try {
+			const res = await axios.post(
+				`/lst/api/admin/build/release`,
+
+				{
+					withCredentials: true,
+				},
+			);
+
+			if (res.data.success) {
+				toast.success(res.data.message);
+			}
+
+			if (!res.data.success) {
+				toast.error(res.data.message);
+			}
+		} catch (err) {
+			console.log(err);
+			//toast.error(err?.message);
+		}
+	};
+	//console.log(logs);
+	return (
+		<div className="flex flex-col gap-1">
+			<div className="flex gap-1 justify-end">
+				<Button onClick={triggerBuild}>Trigger Build</Button>
+				<Button onClick={() => clearRoom()}>Clear Logs</Button>
+			</div>
+			<div className="flex gap-1 w-full">
+				<div className="w-full">
+					<Suspense fallback={<SkellyTable />}>
+						<ServerTable />
+					</Suspense>
+				</div>
+				<div className="w-1/2">
+					<LstTable data={logs} columns={logColumns} />
+				</div>
+			</div>
+		</div>
+	);
+}

frontend/src/routes/docs/index.tsx

@@ -59,6 +59,33 @@ function RouteComponent() {
 						Only shows machines that are attached to the silo.
 					</ul>
 				</ul>
+				{/* Mobile stuff */}
+				<li>Mobile App</li>
+				<ul className="list-disc list-inside indent-8">
+					<li>Rewrite of Alpla scan</li>
+					<ul className="list-disc list-inside indent-16">
+						<li>All old settings same as before id, ip, port</li>
+						<li>Currently scanned pallets will show now as well</li>
+					</ul>
+					<li>
+						Custom addition - login and more features NOTE: This is activated
+						based on how you enter the settings
+					</li>
+					<ul className="list-disc list-inside indent-16">
+						<li>Pin numbers login</li>
+						<li>
+							Scan a lane barcode and it returns whats in the lane and its
+							current status
+						</li>
+						<li>Command restrictions per pin login</li>
+						<li>Dock Door scanning</li>
+						<li>
+							More details on the pallet that is scanned by touching the running
+							number on the scanner.
+						</li>
+					</ul>
+				</ul>
+				{/* TMS integration */}
 				<li>TMS integration</li>
 				<ul className="list-disc list-inside indent-8">
 					<li>integration with TI to auto add in orders</li>

lstMobile/app.json

@@ -2,9 +2,9 @@
   "expo": {
     "name": "LST mobile",
     "slug": "lst-mobile",
-    "version": "0.0.1-alpha",
+    "version": "0.11.1-alpha",
     "orientation": "portrait",
-    "icon": "./assets/images/icon.png",
+    "icon": "./assets/icon_white.png",
     "scheme": "lstmobile",
     "userInterfaceStyle": "automatic",
     "ios": {
@@ -12,29 +12,44 @@
     },
     "android": {
       "adaptiveIcon": {
-        "backgroundColor": "#E6F4FE",
+        "foregroundImage": "./assets/adaptive-icon-white.png",
-        "foregroundImage": "./assets/images/android-icon-foreground.png",
+        "backgroundColor": "#ffffff"
-        "backgroundImage": "./assets/images/android-icon-background.png",
-        "monochromeImage": "./assets/images/android-icon-monochrome.png",
-        "package": "net.alpla.lst.mobile",
-        "versionCode": 1
       },
+      "versionCode": 24,
+      "minSupportedVersionCode": 21,
       "predictiveBackGestureEnabled": false,
-      "package": "com.anonymous.lstMobile"
+      "package": "net.alpla.lst.mobile"
     },
     "web": {
       "output": "static",
-      "favicon": "./assets/images/favicon.png"
+      "favicon": "./assets/images/favicon.png",
+      "bundler": "metro"
     },
     "plugins": [
+      "./plugins/withZebraDataWedge",
       "expo-router",
       [
         "expo-splash-screen",
         {
           "backgroundColor": "#208AEF",
           "android": {
-            "image": "./assets/images/splash-icon.png",
+            "resizeMode": "cover",
-            "imageWidth": 76
+            "image": "./assets/splash_white.png",
+            "backgroundColor": "#ffffff",
+            "dark": {
+              "image": "./assets/splash.png",
+              "backgroundColor": "#000000"
+            },
+            "imageWidth": 200
+          }
+        }
+      ],
+      "expo-audio",
+      [
+        "expo-build-properties",
+        {
+          "android": {
+            "usesCleartextTraffic": true
           }
         }
       ]
@@ -44,4 +59,4 @@
       "reactCompiler": true
     }
   }
-}
+}