fix(anaylistics): changes to the daily section so it populates correctly now

closes #16

.gitea/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,66 @@
+---
+name: Bug Report
+about: Report something that is broken or not working correctly
+title: "[BUG] "
+ref: "main"
+labels:
+
+- bug
+
+---
+
+# Summary
+
+Briefly explain the issue.
+
+---
+
+# Steps To Reproduce
+
+1. Go to ...
+2. Click ...
+3. Scan ...
+4. Error occurs ...
+
+---
+
+# Expected Behavior
+
+What should have happened?
+
+---
+
+# Actual Behavior
+
+What actually happened instead?
+
+---
+
+# Severity
+
+- [ ] Low
+- [ ] Medium
+- [ ] High
+- [ ] Critical
+
+---
+
+# Environment
+
+Example:
+
+- Production
+- Development
+- Zebra Scanner
+- Mobile Device
+- Windows Server
+- Docker
+
+---
+
+# Logs / Screenshots
+
+Paste logs or upload screenshots here.
+
+```txt
+Paste logs here

.gitea/ISSUE_TEMPLATE/config.yaml

@@ -0,0 +1 @@
+blank_issues_enabled: false

.gitea/ISSUE_TEMPLATE/enhancement.md

@@ -0,0 +1,47 @@
+---
+name: Enhancement
+about: Improve or refine an existing feature
+title: "[ENHANCEMENT] "
+ref: "main"
+labels: 
+
+- enhancement
+---
+
+# Existing Feature
+
+What current feature or workflow is being improved?
+
+Example:
+
+- Notifications
+- Scanner Login
+- Release Monitor
+- Printing
+- Auth
+
+---
+
+# Proposed Improvement
+
+Describe the improvement.
+
+---
+
+# Expected Benefit
+
+Why would this improvement help?
+
+---
+
+# Impact
+
+- [ ] Small
+- [ ] Medium
+- [ ] Large
+
+---
+
+# Additional Notes
+
+Anything else worth mentioning.

.gitea/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,40 @@
+---
+name: Feature Request
+about: Suggest a brand new feature or module
+title: "[FEATURE] "
+ref: "main"
+labels: 
+
+- feature
+---
+
+# Problem Statement
+
+What problem are you trying to solve?
+
+---
+
+# Proposed Solution
+
+Describe the feature you would like added.
+
+---
+
+# Alternatives Considered
+
+Any other ideas, workarounds, or approaches?
+
+---
+
+# Priority
+
+- [ ] Nice to Have
+- [ ] Medium Priority
+- [ ] High Priority
+- [ ] Critical
+
+---
+
+# Additional Context
+
+Add mockups, screenshots, examples, or notes here.

.gitea/workflows/docker-build.yml

@@ -12,20 +12,20 @@ jobs:
     steps:
       - name: Checkout (local)
         run: |
-          git clone https://git.tuffraid.net/cowch/lst_v3.git .
+          git clone http://10.75.9.150:3100/cowch/lst_v3.git .
           git checkout ${{ gitea.sha }}
 
       - name: Login to registry
-        run: echo "${{ secrets.PASSWORD }}" | docker login git.tuffraid.net -u "cowch" --password-stdin
+        run: echo "${{ secrets.PASSWORD }}" | docker login 10.75.9.150:3100 -u "cowch" --password-stdin
 
       - name: Build image
         run: |
           docker build \
-            -t git.tuffraid.net/cowch/lst_v3:latest \
-            -t git.tuffraid.net/cowch/lst_v3:${{ gitea.sha }} \
+            -t 10.75.9.150:3100/cowch/lst_v3:latest \
+            -t 10.75.9.150:3100/cowch/lst_v3:${{ gitea.sha }} \
             .
 
       - name: Push
         run: |
-          docker push git.tuffraid.net/cowch/lst_v3:latest
-          docker push git.tuffraid.net/cowch/lst_v3:${{ gitea.sha }}
+          docker push 10.75.9.150:3100/cowch/lst_v3:latest
+          docker push 10.75.9.150:3100/cowch/lst_v3:${{ gitea.sha }}

.gitea/workflows/release.yml

@@ -14,12 +14,12 @@ jobs:
       # Examples:
       #   http://gitea.internal.lan:3000
       #   https://gitea-origin.yourdomain.local
-      GITEA_INTERNAL_URL: "https://git.tuffraid.net"
+      GITEA_INTERNAL_URL: "http://10.75.9.150:3100" #"https://git.tuffraid.net"
 
       # Internal/origin registry host. Usually same host as above, but without protocol.
       # Example:
       #   gitea.internal:3000
-      REGISTRY_HOST: "git.tuffraid.net"
+      REGISTRY_HOST:  "10.75.9.150:3100" #"git.tuffraid.net"
 
     steps:
       - name: Check out repository

.gitignore

@@ -11,6 +11,7 @@ node-v24.14.0-x64.msi
 postgresql-17.9-2-windows-x64.exe
 VSCodeUserSetup-x64-1.112.0.exe
 nssm.exe
+frontend/.tanstack
 
 # Logs
 logs

CHANGELOG.md

@@ -1,5 +1,110 @@
 # All Changes to LST can be found below.
 
+## [0.0.2-alpha.10](https://git.tuffraid.net/cowch/lst_v3/compare/v0.0.2-alpha.9...v0.0.2-alpha.10) (2026-05-08)
+
+
+### 🌟 Enhancements
+
+* **analytics:** added in backend anaylitics ([9edafc9](https://git.tuffraid.net/cowch/lst_v3/commits/9edafc9d2810f339d197c10dfc6a037b3352d81f))
+* **api hits:** added in api hits for monitoring ([2721bb2](https://git.tuffraid.net/cowch/lst_v3/commits/2721bb2a3bf1f829591d26a0716f74c4f7fc0c79))
+* **scanner:** added in lanechecks ([87803ee](https://git.tuffraid.net/cowch/lst_v3/commits/87803eed43069b73de3f66e6524bb45da9c46334))
+
+
+### 🐛 Bug fixes
+
+* **scan user:** typo ([d8869b1](https://git.tuffraid.net/cowch/lst_v3/commits/d8869b103b80e4208b3928a370a9524ef33d25cd))
+* **schema:** typo in add_date ([7d7d991](https://git.tuffraid.net/cowch/lst_v3/commits/7d7d9911223905d6767b87d2471b6607a90f1ea7))
+* **spelling:** corrected the spelling on the file ([0459cd7](https://git.tuffraid.net/cowch/lst_v3/commits/0459cd788aaad6ac54a67e23f798ce5e5a437394))
+
+
+### 📝 Chore
+
+* **file:** name changes.. spelled wrong ([5fa70da](https://git.tuffraid.net/cowch/lst_v3/commits/5fa70da90ca290ee45088e9c8eb06ba48a6677af))
+* **server:** removed a console log that shouldnt be there ([1dba774](https://git.tuffraid.net/cowch/lst_v3/commits/1dba774abc54bf20850c3f26d49926e86d59712d))
+
+
+### 🛠️ Code Refactor
+
+* **analyitics:** finished analyitics as a base ([4424c74](https://git.tuffraid.net/cowch/lst_v3/commits/4424c742d24dc230b2bc1782e33535184c378cf0))
+* **scan:** bump in build and style update ([505d7ce](https://git.tuffraid.net/cowch/lst_v3/commits/505d7cea5d2f52fc4a3ec1edff1878be703c4034))
+* **scanner:** added toasts in to make it look better ([edb3668](https://git.tuffraid.net/cowch/lst_v3/commits/edb366854825f4c24ab5d77cf88759465d067f00))
+
+
+### 📝 Testing Code
+
+* **scanusers:** added in scan users as test ([1ff5e50](https://git.tuffraid.net/cowch/lst_v3/commits/1ff5e5032f9c8bf81f972dc99d6c86ba8d3936c6))
+
+
+### 📈 Project changes
+
+* **template:** bug in getting the template to work correctly ([e9b0101](https://git.tuffraid.net/cowch/lst_v3/commits/e9b01010954624aed738cd6e4b82fccbba195cc4))
+* **templates:** added in templates for the repo to make it more easy to manage and add in new ideas ([ca885fb](https://git.tuffraid.net/cowch/lst_v3/commits/ca885fb01a3c8bc22694c2e05269c43fcd4de70e))
+* **templates:** force useage ([6d8499b](https://git.tuffraid.net/cowch/lst_v3/commits/6d8499bfb85f7b9131b1ec7b31a17c4256d0f0cf))
+
+## [0.0.2-alpha.9](https://git.tuffraid.net/cowch/lst_v3/compare/v0.0.2-alpha.8...v0.0.2-alpha.9) (2026-05-06)
+
+
+### 🛠️ Code Refactor
+
+* **mobile:** valildation of server after each scan ([4ca74de](https://git.tuffraid.net/cowch/lst_v3/commits/4ca74de2795cea7244e38697d16afe2822164ed6))
+* **scanner:** added in running number ([a38e2e0](https://git.tuffraid.net/cowch/lst_v3/commits/a38e2e033977b725538e9a9046098d94194d549e))
+* **scanner:** finished login stuff for current routes ([1241253](https://git.tuffraid.net/cowch/lst_v3/commits/12412536d10981013053c39d156c6c9cb0babd11))
+
+
+### 📝 Testing Code
+
+* **scanner:** lane check ([d99449d](https://git.tuffraid.net/cowch/lst_v3/commits/d99449ddc4e2777c1b0fe9189ba0a7c01fe1dd8f))
+
+
+### 📈 Project Builds
+
+* **builds:** changed to ip as its on the same server ([3552ca3](https://git.tuffraid.net/cowch/lst_v3/commits/3552ca31f9f7b3bcbe557a145e7eb154bfdae79c))
+* **release:** bypass cloudflare upload limit ([b578f05](https://git.tuffraid.net/cowch/lst_v3/commits/b578f05d6482f9b6f30febeee6ab0b708a70f68b))
+
+## [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)
 
 

backend/admin/admin.routes.ts

@@ -1,12 +1,18 @@
 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);
+	app.use(
+		`${baseUrl}/api/admin/build`,
+		requireAuth,
+
+		update,
+	);
 
 	// all other system should be under /api/system/*
 };

backend/app.ts

@@ -3,7 +3,9 @@ import { fileURLToPath } from "node:url";
 import { toNodeHandler } from "better-auth/node";
 import express from "express";
 import morgan from "morgan";
+import { umamiConfig } from "./configs/umami.config.js";
 import { createLogger } from "./logger/logger.controller.js";
+import { routeHitMiddleware } from "./middleware/routeHit.middleware.js";
 import { setupRoutes } from "./routeHandler.routes.js";
 import { auth } from "./utils/auth.utils.js";
 import { lstCors } from "./utils/cors.utils.js";
@@ -29,10 +31,27 @@ const createApp = async () => {
 	app.use(morgan("dev"));
 	app.set("trust proxy", true);
 	app.use(lstCors());
+	app.use(routeHitMiddleware);
 	app.all(`${baseUrl}/api/auth/*splat`, toNodeHandler(auth));
 	app.use(express.json());
 	setupRoutes(baseUrl, app);
 
+	app.get(`${baseUrl}/api/lst-config.js`, (_, res) => {
+		res.type("application/javascript");
+		res.setHeader("Cache-Control", "no-store");
+
+		res.send(`
+		window.LST_CONFIG = {
+			appName: ${JSON.stringify(umamiConfig.appName ?? "LST")},
+			site: ${JSON.stringify(umamiConfig.site ?? "unknown")},
+			server: ${JSON.stringify(umamiConfig.server ?? "unknown")},
+			appVersion: ${JSON.stringify(umamiConfig.appVersion ?? "dev")},
+			umamiHost: ${JSON.stringify(umamiConfig.umamiHost ?? "")},
+			umamiWebsiteId: ${JSON.stringify(umamiConfig.umamiWebsiteId ?? "")}
+		};
+	`);
+	});
+
 	app.use(
 		`${baseUrl}/app`,
 		express.static(join(__dirname, "../frontend/dist")),

backend/auth/auth.routes.ts

@@ -1,9 +1,11 @@
 import type { Express } from "express";
+
 import login from "./login.route.js";
 import register from "./register.route.js";
 
 export const setupAuthRoutes = (baseUrl: string, app: Express) => {
 	//setup all the routes
+
 	app.use(`${baseUrl}/api/authentication/login`, login);
 	app.use(`${baseUrl}/api/authentication/register`, register);
 };

backend/configs/umami.config.ts

@@ -0,0 +1,21 @@
+export type UmamiRuntimeConfig = {
+	appName: string;
+	site: string;
+	server: string;
+	appVersion: string;
+	umamiHost: string;
+	umamiWebsiteId: string;
+};
+
+export const umamiConfig: UmamiRuntimeConfig = {
+	appName: process.env.APP_NAME ?? "LST",
+	site: process.env.URL ?? "unknown",
+	server: process.env.PROD_PLANT_TOKEN ?? "unknown", // could also be server name based on our setup.
+	appVersion: process.env.NODE_ENV ?? "dev",
+	umamiHost: process.env.UMAMI_HOST ?? "",
+	umamiWebsiteId: process.env.UMAMI_WEBSITE_ID ?? "",
+};
+
+export function isUmamiEnabled() {
+	return Boolean(umamiConfig.umamiHost && umamiConfig.umamiWebsiteId);
+}

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/analytics.schema.ts

@@ -0,0 +1,21 @@
+import { integer, pgTable, text, timestamp, uuid } from "drizzle-orm/pg-core";
+
+export const analytics = pgTable("analytics", {
+	id: uuid("id").defaultRandom().primaryKey(),
+
+	createdAt: timestamp("created_at").defaultNow().notNull(),
+
+	method: text("method").notNull(),
+	routePattern: text("route_pattern").notNull(),
+	actualPath: text("actual_path").notNull(),
+
+	statusCode: integer("status_code").notNull(),
+	durationMs: integer("duration_ms").notNull(),
+
+	module: text("module"),
+	userId: text("user_id"),
+	userEmail: text("user_email"),
+
+	ipAddress: text("ip_address"),
+	userAgent: text("user_agent"),
+});

backend/db/schema/dailyAnalytics.schema.ts

@@ -0,0 +1,45 @@
+import {
+	date,
+	integer,
+	pgTable,
+	text,
+	timestamp,
+	unique,
+	uuid,
+} from "drizzle-orm/pg-core";
+
+export const analyticsDaily = pgTable(
+	"analytics_daily",
+	{
+		id: uuid("id").defaultRandom().primaryKey(),
+
+		businessDate: date("business_date", { mode: "string" }).notNull(),
+
+		method: text("method").notNull(),
+		routePattern: text("route_pattern").notNull(),
+		module: text("module").notNull(),
+
+		totalHits: integer("total_hits").notNull(),
+		uniqueUsers: integer("unique_users").notNull(),
+
+		successCount: integer("success_count").notNull(),
+		errorCount: integer("error_count").notNull(),
+
+		avgDurationMs: integer("avg_duration_ms").notNull(),
+		maxDurationMs: integer("max_duration_ms").notNull(),
+
+		firstHitAt: timestamp("first_hit_at").notNull(),
+		lastHitAt: timestamp("last_hit_at").notNull(),
+
+		createdAt: timestamp("created_at").defaultNow().notNull(),
+		updatedAt: timestamp("updated_at").defaultNow().notNull(),
+	},
+	(table) => [
+		unique("analytics_daily_business_route_unique").on(
+			table.businessDate,
+			table.method,
+			table.routePattern,
+			table.module,
+		),
+	],
+);

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,22 @@
+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"),
+	runningNumber: text("running_number").default("0"),
+	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/gpSql/gpSql.routes.ts

@@ -1,5 +1,6 @@
 import { type Express, Router } from "express";
 import { requireAuth } from "../middleware/auth.middleware.js";
+
 import restart from "./gpSqlRestart.route.js";
 import start from "./gpSqlStart.route.js";
 import stop from "./gpSqlStop.route.js";

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;
@@ -119,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/middleware/routeHit.middleware.ts

@@ -0,0 +1,83 @@
+// routeHit.middleware.ts
+
+import type { NextFunction, Request, Response } from "express";
+import {
+	createRouteHit,
+	shouldIgnoreRoute,
+} from "../utils/analyticRouteHits.utils.js";
+
+export function routeHitMiddleware(
+	req: Request,
+	res: Response,
+	next: NextFunction,
+) {
+	const start = performance.now();
+
+	res.on("finish", () => {
+		const actualPath = getActualPath(req);
+
+		if (shouldIgnoreRoute(actualPath)) {
+			return;
+		}
+
+		const durationMs = Math.round(performance.now() - start);
+
+		const routePattern = getRoutePattern(req) as string;
+		const module = getModuleName(req);
+
+		void createRouteHit({
+			method: req.method,
+			routePattern,
+			actualPath,
+			statusCode: res.statusCode,
+			durationMs,
+			module,
+
+			// adjust these names to your Better Auth/session shape
+			userId: req.user?.id ?? null,
+			userEmail: req.user?.email ?? null,
+
+			ipAddress: req.ip ?? null,
+			userAgent: req.get("user-agent") ?? null,
+		}).catch((err) => {
+			console.error("Failed to save route hit", err);
+		});
+	});
+
+	next();
+}
+
+function getActualPath(req: Request) {
+	return req.originalUrl.split("?")[0] ?? req.path ?? "unknown";
+}
+
+function getRoutePattern(req: Request) {
+	const baseUrl = req.baseUrl || "";
+	const routePath = req.route?.path;
+
+	if (typeof routePath === "string") {
+		return `${baseUrl}${routePath}`;
+	}
+
+	return getActualPath(req);
+}
+
+function getModuleName(req: Request) {
+	const path = req.originalUrl.split("?")[0];
+
+	if (path?.includes("/printers")) return "printers";
+	if (path?.includes("/releases")) return "releases";
+	if (path?.includes("/quality")) return "quality";
+	if (path?.includes("/scanner")) return "scanner";
+	if (path?.includes("/settings")) return "settings";
+	if (path?.includes("/users")) return "users";
+	if (path?.includes("/mobile")) return "mobile";
+	if (path?.includes("/servers")) return "servers";
+	if (path?.includes("/logistics")) return "servers";
+	if (path?.includes("/ocp")) return "ocp";
+	if (path?.includes("/auth")) return "auth";
+	if (path?.includes("/datamart")) return "datamart";
+	if (path?.includes("/opendock")) return "opendock";
+
+	return "unknown";
+}

backend/mobile/availableScanIds.route.ts

@@ -0,0 +1,54 @@
+import { eq } from "drizzle-orm";
+import { Router } from "express";
+import { db } from "../db/db.controller.js";
+import { scanUser } from "../db/schema/scanUsers.js";
+import { settings } from "../db/schema/settings.schema.js";
+import { apiReturn } from "../utils/returnHelper.utils.js";
+
+const r = Router();
+
+// scanners that are dedicated to specific users.
+const SPECIAL_SCANNERS = [69, 98];
+
+const buildAllowedScannerIds = (scannerCount: number) => {
+	const generatedIds = Array.from({ length: scannerCount }, (_, i) => i + 1);
+
+	return Array.from(new Set([...generatedIds, ...SPECIAL_SCANNERS])).sort(
+		(a, b) => a - b,
+	);
+};
+
+r.get("/", async (_, res) => {
+	// get the scan users and setting
+	const scanusers = await db.select().from(scanUser);
+	const scannerIdSetting = await db
+		.select()
+		.from(settings)
+		.where(eq(settings.name, "scannerIds"));
+
+	const usedScannerIds = scanusers.map((x) => Number(x.scannerId));
+	const allowedScannerIds = buildAllowedScannerIds(
+		Number(scannerIdSetting[0]?.value ?? 0),
+	);
+
+	const availableScannerIds = allowedScannerIds.filter(
+		(id) => !usedScannerIds.includes(id),
+	);
+
+	const data = availableScannerIds.map((id) => ({
+		label: `${id}`,
+		value: id,
+	}));
+
+	return apiReturn(res, {
+		success: true,
+		level: "info",
+		module: "mobile",
+		subModule: "scanner",
+		message: `There are ${availableScannerIds.length} scanner id's`,
+		data,
+		status: 200,
+	});
+});
+
+export default r;

backend/mobile/downloadApps.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) => {
-	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) => {
+router.get("/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/laneCheck.ts

@@ -0,0 +1,34 @@
+import { Router } from "express";
+import { runProdApi } from "../utils/prodEndpoint.utils.js";
+import { apiReturn } from "../utils/returnHelper.utils.js";
+
+const router = Router();
+
+router.post("/", async (req, res) => {
+	const body = req.body;
+
+	const lane = body.lane.split("#");
+
+	console.log(lane[2]);
+	const laneData = await runProdApi({
+		method: "post",
+		endpoint: "/public/v1.1/Warehousing/GetWarehouseUnits",
+		data: [
+			{
+				laneIds: [lane[2]],
+			},
+		],
+	});
+
+	return apiReturn(res, {
+		success: true,
+		level: "info",
+		module: "mobile",
+		subModule: "lane check",
+		message: `all data for lane Id: ${lane}`,
+		data: laneData?.data ?? [],
+		status: 200,
+	});
+});
+
+export default router;

backend/mobile/mobile.routes.ts

@@ -0,0 +1,22 @@
+import type { Express } from "express";
+import available from "./availableScanIds.route.js";
+import downloads from "./downloadApps.route.js";
+import lanes from "./laneCheck.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);
+	app.use(`${baseUrl}/api/mobile/laneCheck`, lanes);
+	app.use(`${baseUrl}/api/mobile/available`, available);
+
+	// all other system should be under /api/system/*
+};

backend/mobile/mobileAuth.route.ts

@@ -0,0 +1,343 @@
+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));
+
+	// await trackLstEvent({
+	// 	eventName: "mobile_get_users",
+	// 	url: "/mobile/users",
+	// 	eventData: {
+	// 		module: "mobile",
+	// 	},
+	// });
+
+	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?.excludedCommand !== undefined) {
+		updates.excludedCommand = req.body.excludedCommand;
+	}
+
+	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,37 @@
+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 ?? "",
+			user: body.user ?? "",
+			runningNumber: body.runningNumber ?? "",
+		})
+		.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,40 @@
+import fs from "node:fs";
+import { and, eq } from "drizzle-orm";
+import { Router } from "express";
+import path from "path";
+import { db } from "../db/db.controller.js";
+import { settings } from "../db/schema/settings.schema.js";
+
+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 mobileSettings = await db
+		.select()
+		.from(settings)
+		.where(
+			and(
+				eq(settings.moduleName, "mobile"),
+				eq(settings.settingType, "standard"),
+			),
+		);
+
+	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`,
+		settings: mobileSettings,
+	});
+});
+
+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/notification/notification.routes.ts

@@ -1,5 +1,6 @@
 import type { Express } from "express";
 import { requireAuth } from "../middleware/auth.middleware.js";
+
 import manual from "./notification.manualTrigger.js";
 import getNotifications from "./notification.route.js";
 import updateNote from "./notification.update.route.js";
@@ -10,13 +11,48 @@ import updateSub from "./notificationSub.update.route.js";
 
 export const setupNotificationRoutes = (baseUrl: string, app: Express) => {
 	//stats will be like this as we dont need to change this
-	app.use(`${baseUrl}/api/notification`, requireAuth, getNotifications);
-	app.use(`${baseUrl}/api/notification`, requireAuth, updateNote);
-	app.use(`${baseUrl}/api/notification/manual`, requireAuth, manual);
-	app.use(`${baseUrl}/api/notification/sub`, requireAuth, subs);
-	app.use(`${baseUrl}/api/notification/sub`, requireAuth, newSub);
-	app.use(`${baseUrl}/api/notification/sub`, requireAuth, updateSub);
-	app.use(`${baseUrl}/api/notification/sub`, requireAuth, deleteSub);
+	app.use(
+		`${baseUrl}/api/notification`,
+		requireAuth,
+
+		getNotifications,
+	);
+	app.use(
+		`${baseUrl}/api/notification`,
+		requireAuth,
+
+		updateNote,
+	);
+	app.use(
+		`${baseUrl}/api/notification/manual`,
+		requireAuth,
+
+		manual,
+	);
+	app.use(
+		`${baseUrl}/api/notification/sub`,
+		requireAuth,
+
+		subs,
+	);
+	app.use(
+		`${baseUrl}/api/notification/sub`,
+		requireAuth,
+
+		newSub,
+	);
+	app.use(
+		`${baseUrl}/api/notification/sub`,
+		requireAuth,
+
+		updateSub,
+	);
+	app.use(
+		`${baseUrl}/api/notification/sub`,
+		requireAuth,
+
+		deleteSub,
+	);
 
 	// all other system should be under /api/system/*
 };

backend/ocp/ocp.routes.ts

@@ -1,6 +1,7 @@
 import { type Express, Router } from "express";
 import { requireAuth } from "../middleware/auth.middleware.js";
 import { featureCheck } from "../middleware/featureActive.middleware.js";
+
 import listener from "./ocp.printer.listener.js";
 import update from "./ocp.printer.update.js";
 

backend/opendock/opendock.routes.ts

@@ -1,6 +1,7 @@
 import { type Express, Router } from "express";
 import { requireAuth } from "../middleware/auth.middleware.js";
 import { featureCheck } from "../middleware/featureActive.middleware.js";
+
 import getApt from "./opendockGetRelease.route.js";
 
 export const setupOpendockRoutes = (baseUrl: string, app: Express) => {

backend/prodSql/prodSql.routes.ts

@@ -1,5 +1,6 @@
 import { type Express, Router } from "express";
 import { requireAuth } from "../middleware/auth.middleware.js";
+
 import restart from "./prodSqlRestart.route.js";
 import start from "./prodSqlStart.route.js";
 import stop from "./prodSqlStop.route.js";

backend/routeHandler.routes.ts

@@ -5,6 +5,7 @@ import { setupAuthRoutes } from "./auth/auth.routes.js";
 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";
@@ -27,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

@@ -18,6 +18,11 @@ 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 {
+	aggregateRouteHitsForBusinessDay,
+	cleanupOldRouteHits,
+	runRouteHitAnalyticsCron,
+} from "./utils/analyticRouteHits.utils.js";
 import { createCronJob } from "./utils/croner.utils.js";
 import { sendEmail } from "./utils/sendEmail.utils.js";
 
@@ -68,10 +73,16 @@ const start = async () => {
 		createCronJob("logsCleanup", "0 15 5 * * *", () => dbCleanup("logs", 120));
 		historicalSchedule();
 
+		createCronJob("aggregateHits", "0 0 7 * * *", async () =>
+			runRouteHitAnalyticsCron(),
+		);
+
+		createCronJob("cleanHitsUp", "0 0 7 * * *", () => cleanupOldRouteHits());
 		// one shots only needed to run on server startups
 		createNotifications();
 		startNotifications();
 		serversChecks();
+		aggregateRouteHitsForBusinessDay();
 	}, 5 * 1000);
 
 	process.on("uncaughtException", async (err) => {

backend/system/serverData.controller.ts

@@ -34,7 +34,7 @@ const servers: NewServerData[] = [
 		name: "Lima",
 		server: "USLIM1VMS006",
 		plantToken: "uslim1",
-		idAddress: "10.53.0.26",
+		idAddress: "10.53.0.26", // port opened 3000 2222
 		greatPlainsPlantCode: "50",
 		contactEmail: "",
 		contactPhone: "",
@@ -56,7 +56,7 @@ const servers: NewServerData[] = [
 		name: "Dayton",
 		server: "usday1VMS006",
 		plantToken: "usday1",
-		idAddress: "10.44.0.56",
+		idAddress: "10.44.0.56", // ports opened 3000 and 2222
 		greatPlainsPlantCode: "80",
 		contactEmail: "",
 		contactPhone: "",
@@ -122,13 +122,46 @@ const servers: NewServerData[] = [
 		name: "Marked Tree",
 		server: "USMAR1VMS006",
 		plantToken: "usmar1",
-		idAddress: "10.206.9.26",
+		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

backend/system/settingsBase.controller.ts

@@ -76,6 +76,16 @@ const newSettings: NewSetting[] = [
 		roles: ["admin"],
 		seedVersion: 1,
 	},
+	{
+		name: "mobile",
+		value: "0",
+		active: false,
+		description: "LST Android Mobile app",
+		moduleName: "mobile",
+		settingType: "feature",
+		roles: ["admin"],
+		seedVersion: 1,
+	},
 
 	// standard settings
 	{
@@ -304,6 +314,49 @@ const newSettings: NewSetting[] = [
 		roles: ["admin"],
 		seedVersion: 1,
 	},
+	{
+		name: "laneCheck",
+		value: "0",
+		active: false,
+		description:
+			"Allows the driver to scan a lane and see what is in the lane and details about each pallet.",
+		moduleName: "mobile",
+		settingType: "standard",
+		roles: ["admin"],
+		seedVersion: 1,
+	},
+	{
+		name: "dockScan",
+		value: "0",
+		active: false,
+		description:
+			"Enables dock door scanning, must have a dock scanner setup for this to work.",
+		moduleName: "mobile",
+		settingType: "standard",
+		roles: ["admin"],
+		seedVersion: 1,
+	},
+	{
+		name: "cycleCounting",
+		value: "0",
+		active: false,
+		description: "Enables a cycle count to be triggered from the scanner.",
+		moduleName: "mobile",
+		settingType: "standard",
+		roles: ["admin"],
+		seedVersion: 1,
+	},
+	{
+		name: "scannerIds",
+		value: "10",
+		active: false,
+		description:
+			"How many scanners ids are setup for this, there should be a lst_scanner instance created.",
+		moduleName: "mobile",
+		settingType: "standard",
+		roles: ["admin"],
+		seedVersion: 1,
+	},
 ];
 
 export const baseSettingValidationCheck = async () => {

backend/system/system.routes.ts

@@ -1,15 +1,14 @@
 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);

backend/tcpServer/tcp.routes.ts

@@ -1,14 +1,21 @@
 import type { Express } from "express";
 import { requireAuth } from "../middleware/auth.middleware.js";
+
 import restart from "./tcpRestart.route.js";
 import start from "./tcpStart.route.js";
 import stop from "./tcpStop.route.js";
 
 export const setupTCPRoutes = (baseUrl: string, app: Express) => {
 	//stats will be like this as we dont need to change this
+
 	app.use(`${baseUrl}/api/tcp/start`, requireAuth, start);
 	app.use(`${baseUrl}/api/tcp/stop`, requireAuth, stop);
-	app.use(`${baseUrl}/api/tcp/restart`, requireAuth, restart);
+	app.use(
+		`${baseUrl}/api/tcp/restart`,
+		requireAuth,
+
+		restart,
+	);
 
 	// all other system should be under /api/system/*
 };

backend/utils/analyticRouteHits.utils.ts

@@ -0,0 +1,148 @@
+import { and, count, countDistinct, gte, lt, sql } from "drizzle-orm";
+import { db } from "../db/db.controller.js";
+import { analytics } from "../db/schema/analytics.schema.js";
+import { analyticsDaily } from "../db/schema/dailyAnalytics.schema.js";
+
+export const ignoredRoutePrefixes = [
+	"/health",
+	"/favicon.ico",
+	"/socket.io",
+	"/lst/api/ws",
+	"/lst-config.js",
+];
+
+export function shouldIgnoreRoute(path: string) {
+	return ignoredRoutePrefixes.some((prefix) => path.startsWith(prefix));
+}
+
+type CreateRouteHitInput = {
+	method: string;
+	routePattern: string;
+	actualPath: string;
+	statusCode: number;
+	durationMs: number;
+	module?: string | null;
+	userId?: string | null;
+	userEmail?: string | null;
+	ipAddress?: string | null;
+	userAgent?: string | null;
+};
+
+export async function createRouteHit(input: CreateRouteHitInput) {
+	await db.insert(analytics).values(input);
+}
+
+function getPreviousBusinessDayWindow(date = new Date()) {
+	const end = new Date(date);
+	end.setHours(7, 0, 0, 0);
+
+	const start = new Date(end);
+	start.setDate(start.getDate() - 1);
+
+	const businessDate = start.toISOString().slice(0, 10);
+
+	return {
+		start,
+		end,
+		businessDate,
+	};
+}
+
+export async function runRouteHitAnalyticsCron(): Promise<void> {
+	const result = await aggregateRouteHitsForBusinessDay();
+
+	await cleanupOldRouteHits();
+
+	console.log("Route hit analytics aggregated", result);
+}
+
+export async function aggregateRouteHitsForBusinessDay() {
+	const { start, end, businessDate } = getPreviousBusinessDayWindow();
+
+	const rows = await db
+		.select({
+			businessDate: sql<string>`CAST(${businessDate} AS date)`,
+			method: analytics.method,
+			routePattern: analytics.routePattern,
+			module: sql<string>`COALESCE(${analytics.module}, 'unknown')`,
+
+			totalHits: count(),
+			uniqueUsers: countDistinct(analytics.userId),
+
+			successCount: sql<number>`
+			COUNT(*) FILTER (WHERE ${analytics.statusCode} < 400)
+		`,
+			errorCount: sql<number>`
+			COUNT(*) FILTER (WHERE ${analytics.statusCode} >= 400)
+		`,
+
+			avgDurationMs: sql<number>`
+			COALESCE(ROUND(AVG(${analytics.durationMs})), 0)
+		`,
+			maxDurationMs: sql<number>`
+			COALESCE(MAX(${analytics.durationMs}), 0)
+		`,
+
+			firstHitAt: sql<Date>`
+			COALESCE(MIN(${analytics.createdAt}), NOW())
+		`,
+			lastHitAt: sql<Date>`
+			COALESCE(MAX(${analytics.createdAt}), NOW())
+		`,
+		})
+		.from(analytics)
+		.where(and(gte(analytics.createdAt, start), lt(analytics.createdAt, end)))
+		.groupBy(
+			analytics.method,
+			analytics.routePattern,
+			sql`COALESCE(${analytics.module}, 'unknown')`,
+		);
+
+	if (rows.length === 0) {
+		return {
+			businessDate,
+			inserted: 0,
+		};
+	}
+
+	const values = rows.map((row) => ({
+		...row,
+		businessDate: row.businessDate,
+		firstHitAt: new Date(row.firstHitAt),
+		lastHitAt: new Date(row.lastHitAt),
+	}));
+
+	await db
+		.insert(analyticsDaily)
+		.values(values)
+		.onConflictDoUpdate({
+			target: [
+				analyticsDaily.businessDate,
+				analyticsDaily.method,
+				analyticsDaily.routePattern,
+				analyticsDaily.module,
+			],
+			set: {
+				totalHits: sql`excluded.total_hits`,
+				uniqueUsers: sql`excluded.unique_users`,
+				successCount: sql`excluded.success_count`,
+				errorCount: sql`excluded.error_count`,
+				avgDurationMs: sql`excluded.avg_duration_ms`,
+				maxDurationMs: sql`excluded.max_duration_ms`,
+				firstHitAt: sql`excluded.first_hit_at`,
+				lastHitAt: sql`excluded.last_hit_at`,
+				updatedAt: sql`now()`,
+			},
+		});
+
+	return {
+		businessDate,
+		inserted: rows.length,
+	};
+}
+
+export async function cleanupOldRouteHits() {
+	await db
+		.delete(analytics)
+		.where(lt(analytics.createdAt, sql`now() - interval '4 days'`));
+}

backend/utils/generateScannerPin.utils.ts

@@ -0,0 +1,49 @@
+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),
+		});
+
+		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: "",
+	});
+}
+
+// export const pinExists = async (pin: string | number) => {
+// 	const existing = await db.query.scanUser.findFirst({
+// 		where: (u, { eq }) => eq(u.pinHash, pin),
+// 	});
+
+// 	if (!existing) return true;
+
+// 	return false;
+// };

backend/utils/returnHelper.utils.ts

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

backend/utils/umami.utils.ts

@@ -0,0 +1,61 @@
+import { isUmamiEnabled, umamiConfig } from "../configs/umami.config.js";
+
+type TrackLstEventInput = {
+	eventName: string;
+	eventData?: Record<string, unknown>;
+	url?: string;
+	hostname?: string;
+};
+
+export async function trackLstEvent({
+	eventName,
+	eventData,
+	url = "/backend",
+	hostname = umamiConfig.server,
+}: TrackLstEventInput): Promise<void> {
+	if (!isUmamiEnabled()) return;
+
+	try {
+		await fetch(`${umamiConfig.umamiHost}/api/send`, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				"User-Agent": "LST-Backend",
+			},
+			body: JSON.stringify({
+				type: "event",
+				payload: {
+					website: umamiConfig.umamiWebsiteId,
+					name: eventName,
+					url,
+					hostname,
+					language: "en-US",
+					screen: "backend",
+					data: {
+						app: umamiConfig.appName,
+						site: umamiConfig.site,
+						server: umamiConfig.server,
+						appVersion: umamiConfig.appVersion,
+						source: "backend",
+						...eventData,
+					},
+				},
+			}),
+		});
+	} catch (err) {
+		console.error("Failed to send Umami backend event", err);
+	}
+}
+
+/*
+await trackLstEvent({
+	eventName: "label_print_completed",
+	url: "/backend/printers",
+	eventData: {
+		module: "printers",
+		printerName,
+		labelType,
+	},
+});
+
+*/

backend/utils/utils.routes.ts

@@ -1,4 +1,5 @@
 import type { Express } from "express";
+
 import getActiveJobs from "./cronerActiveJobs.route.js";
 import jobStatusChange from "./cronerStatusChange.route.js";
 export const setupUtilsRoutes = (baseUrl: string, app: Express) => {

docker-compose.yml

@@ -18,7 +18,7 @@ services:
         environment:
             - NODE_ENV=production
             - LOG_LEVEL=info
-            - EXTERNAL_URL=http://192.168.8.222:3600
+            - URL=http://localhost:3600
             - DATABASE_HOST=postgres # if running on the same docker then do this
             - DATABASE_PORT=5432
             - DATABASE_USER=${DATABASE_USER}
@@ -41,7 +41,10 @@ services:
         #for all host including prod servers, plc's, printers, or other de
         networks:
             - docker-network 
+            - pgNetwork
 
 networks:
   docker-network:
+    external: true
+  pgNetwork:
     external: true

frontend/index.html

@@ -7,7 +7,15 @@
     <title>Logistics Support Tool</title>
   </head>
   <body>
+<script>
+	const configScript = document.createElement("script");
+	configScript.src = `${window.location.origin}/lst/api/lst-config.js`;
+	configScript.defer = false;
+	document.head.appendChild(configScript);
+</script>
     <div id="root"></div>
+    <script defer src="https://stats.tuffraid.net/script.js" data-website-id="49bc2489-3930-4358-a13d-1cc609336572"></script>
+    
     <script type="module" src="/src/main.tsx"></script>
   </body>
 </html>

frontend/src/components/Sidebar/AdminBar.tsx

@@ -1,5 +1,5 @@
 import { Link } from "@tanstack/react-router";
-import { Bell, Logs, Server, Settings } from "lucide-react";
+import { Bell, Logs, Server, Settings, UsersRound } from "lucide-react";
 
 import {
 	SidebarGroup,
@@ -56,22 +56,22 @@ export default function AdminSidebar({ session }: any) {
 			module: "admin",
 			active: true,
 		},
-		// {
-		// 	title: "Modules",
-		// 	url: "/admin/modules",
-		// 	icon: Settings,
-		// 	role: ["systemAdmin", "admin"],
-		// 	module: "admin",
-		// 	active: true,
-		// },
-		// {
-		// 	title: "Servers",
-		// 	url: "/admin/servers",
-		// 	icon: Server,
-		// 	role: ["systemAdmin", "admin"],
-		// 	module: "admin",
-		// 	active: true,
-		// },
+		{
+			title: "Users",
+			url: "/admin/users",
+			icon: UsersRound,
+			role: ["systemAdmin", "admin"],
+			module: "admin",
+			active: true,
+		},
+		{
+			title: "Scan users",
+			url: "/admin/scanUsers",
+			icon: UsersRound,
+			role: ["systemAdmin", "admin", "manager"],
+			module: "admin",
+			active: true,
+		},
 	];
 	return (
 		<SidebarGroup>
@@ -79,9 +79,9 @@ export default function AdminSidebar({ session }: any) {
 			<SidebarGroupContent>
 				<SidebarMenu>
 					{items.map((item) => (
-						<>
+						<div key={item.title}>
 							{item.role.includes(session.user.role) && (
-								<SidebarMenuItem key={item.title}>
+								<SidebarMenuItem>
 									<SidebarMenuButton asChild>
 										<Link to={item.url} onClick={() => setOpen(false)}>
 											<item.icon />
@@ -90,7 +90,7 @@ export default function AdminSidebar({ session }: any) {
 									</SidebarMenuButton>
 								</SidebarMenuItem>
 							)}
-						</>
+						</div>
 					))}
 				</SidebarMenu>
 			</SidebarGroupContent>

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,47 @@
+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,
+		},
+	];
+
+	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,10 +23,12 @@ export function AppSidebar() {
 				<SidebarMenu>
 					<SidebarMenuItem>
 						<SidebarContent>
-							<DocBar/>
+							<DocBar />
+							<MobileBar session={session} />
 							{session &&
 								(session.user.role === "admin" ||
-									session.user.role === "systemAdmin") && (
+									session.user.role === "systemAdmin" ||
+									session.user.role === "manager") && (
 									<AdminSidebar session={session} />
 								)}
 						</SidebarContent>

frontend/src/components/ui/button.tsx

@@ -1,64 +1,67 @@
-import { cva, type VariantProps } from "class-variance-authority";
-import { Slot } from "radix-ui";
-import type * as React from "react";
+import * as React from "react"
+import { cva, type VariantProps } from "class-variance-authority"
+import { Slot } from "radix-ui"
 
-import { cn } from "@/lib/utils";
+import { cn } from "@/lib/utils"
 
 const buttonVariants = cva(
-	"inline-flex shrink-0 items-center justify-center gap-2 rounded-md text-sm font-medium whitespace-nowrap transition-all outline-none focus-visible:border-ring focus-visible:ring-[3px] focus-visible:ring-ring/50 disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
-	{
-		variants: {
-			variant: {
-				default: "bg-primary text-primary-foreground hover:bg-primary/90",
-				destructive:
-					"bg-destructive text-white hover:bg-destructive/90 focus-visible:ring-destructive/20 dark:bg-destructive/60 dark:focus-visible:ring-destructive/40",
-				outline:
-					"border bg-background shadow-xs hover:bg-accent hover:text-accent-foreground dark:border-input dark:bg-input/30 dark:hover:bg-input/50",
-				secondary:
-					"bg-secondary text-secondary-foreground hover:bg-secondary/80",
-				ghost:
-					"hover:bg-accent hover:text-accent-foreground dark:hover:bg-accent/50",
-				link: "text-primary underline-offset-4 hover:underline",
-			},
-			size: {
-				default: "h-9 px-4 py-2 has-[>svg]:px-3",
-				xs: "h-6 gap-1 rounded-md px-2 text-xs has-[>svg]:px-1.5 [&_svg:not([class*='size-'])]:size-3",
-				sm: "h-8 gap-1.5 rounded-md px-3 has-[>svg]:px-2.5",
-				lg: "h-10 rounded-md px-6 has-[>svg]:px-4",
-				icon: "size-9",
-				"icon-xs": "size-6 rounded-md [&_svg:not([class*='size-'])]:size-3",
-				"icon-sm": "size-8",
-				"icon-lg": "size-10",
-			},
-		},
-		defaultVariants: {
-			variant: "default",
-			size: "default",
-		},
-	},
-);
+  "group/button inline-flex shrink-0 items-center justify-center rounded-lg border border-transparent bg-clip-padding text-sm font-medium whitespace-nowrap transition-all outline-none select-none focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 active:not-aria-[haspopup]:translate-y-px disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
+  {
+    variants: {
+      variant: {
+        default: "bg-primary text-primary-foreground [a]:hover:bg-primary/80",
+        outline:
+          "border-border bg-background hover:bg-muted hover:text-foreground aria-expanded:bg-muted aria-expanded:text-foreground dark:border-input dark:bg-input/30 dark:hover:bg-input/50",
+        secondary:
+          "bg-secondary text-secondary-foreground hover:bg-secondary/80 aria-expanded:bg-secondary aria-expanded:text-secondary-foreground",
+        ghost:
+          "hover:bg-muted hover:text-foreground aria-expanded:bg-muted aria-expanded:text-foreground dark:hover:bg-muted/50",
+        destructive:
+          "bg-destructive/10 text-destructive hover:bg-destructive/20 focus-visible:border-destructive/40 focus-visible:ring-destructive/20 dark:bg-destructive/20 dark:hover:bg-destructive/30 dark:focus-visible:ring-destructive/40",
+        link: "text-primary underline-offset-4 hover:underline",
+      },
+      size: {
+        default:
+          "h-8 gap-1.5 px-2.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2",
+        xs: "h-6 gap-1 rounded-[min(var(--radius-md),10px)] px-2 text-xs in-data-[slot=button-group]:rounded-lg has-data-[icon=inline-end]:pr-1.5 has-data-[icon=inline-start]:pl-1.5 [&_svg:not([class*='size-'])]:size-3",
+        sm: "h-7 gap-1 rounded-[min(var(--radius-md),12px)] px-2.5 text-[0.8rem] in-data-[slot=button-group]:rounded-lg has-data-[icon=inline-end]:pr-1.5 has-data-[icon=inline-start]:pl-1.5 [&_svg:not([class*='size-'])]:size-3.5",
+        lg: "h-9 gap-1.5 px-2.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2",
+        icon: "size-8",
+        "icon-xs":
+          "size-6 rounded-[min(var(--radius-md),10px)] in-data-[slot=button-group]:rounded-lg [&_svg:not([class*='size-'])]:size-3",
+        "icon-sm":
+          "size-7 rounded-[min(var(--radius-md),12px)] in-data-[slot=button-group]:rounded-lg",
+        "icon-lg": "size-9",
+      },
+    },
+    defaultVariants: {
+      variant: "default",
+      size: "default",
+    },
+  }
+)
 
 function Button({
-	className,
-	variant = "default",
-	size = "default",
-	asChild = false,
-	...props
+  className,
+  variant = "default",
+  size = "default",
+  asChild = false,
+  ...props
 }: React.ComponentProps<"button"> &
-	VariantProps<typeof buttonVariants> & {
-		asChild?: boolean;
-	}) {
-	const Comp = asChild ? Slot.Root : "button";
+  VariantProps<typeof buttonVariants> & {
+    asChild?: boolean
+  }) {
+  const Comp = asChild ? Slot.Root : "button"
 
-	return (
-		<Comp
-			data-slot="button"
-			data-variant={variant}
-			data-size={size}
-			className={cn(buttonVariants({ variant, size, className }))}
-			{...props}
-		/>
-	);
+  return (
+    <Comp
+      data-slot="button"
+      data-variant={variant}
+      data-size={size}
+      className={cn(buttonVariants({ variant, size, className }))}
+      {...props}
+    />
+  )
 }
 
-export { Button, buttonVariants };
+export { Button, buttonVariants }

frontend/src/components/ui/dialog.tsx

@@ -0,0 +1,166 @@
+import * as React from "react"
+import { Dialog as DialogPrimitive } from "radix-ui"
+
+import { cn } from "@/lib/utils"
+import { Button } from "@/components/ui/button"
+import { XIcon } from "lucide-react"
+
+function Dialog({
+  ...props
+}: React.ComponentProps<typeof DialogPrimitive.Root>) {
+  return <DialogPrimitive.Root data-slot="dialog" {...props} />
+}
+
+function DialogTrigger({
+  ...props
+}: React.ComponentProps<typeof DialogPrimitive.Trigger>) {
+  return <DialogPrimitive.Trigger data-slot="dialog-trigger" {...props} />
+}
+
+function DialogPortal({
+  ...props
+}: React.ComponentProps<typeof DialogPrimitive.Portal>) {
+  return <DialogPrimitive.Portal data-slot="dialog-portal" {...props} />
+}
+
+function DialogClose({
+  ...props
+}: React.ComponentProps<typeof DialogPrimitive.Close>) {
+  return <DialogPrimitive.Close data-slot="dialog-close" {...props} />
+}
+
+function DialogOverlay({
+  className,
+  ...props
+}: React.ComponentProps<typeof DialogPrimitive.Overlay>) {
+  return (
+    <DialogPrimitive.Overlay
+      data-slot="dialog-overlay"
+      className={cn(
+        "fixed inset-0 isolate z-50 bg-black/10 duration-100 supports-backdrop-filter:backdrop-blur-xs data-open:animate-in data-open:fade-in-0 data-closed:animate-out data-closed:fade-out-0",
+        className
+      )}
+      {...props}
+    />
+  )
+}
+
+function DialogContent({
+  className,
+  children,
+  showCloseButton = true,
+  ...props
+}: React.ComponentProps<typeof DialogPrimitive.Content> & {
+  showCloseButton?: boolean
+}) {
+  return (
+    <DialogPortal>
+      <DialogOverlay />
+      <DialogPrimitive.Content
+        data-slot="dialog-content"
+        className={cn(
+          "fixed top-1/2 left-1/2 z-50 grid w-full max-w-[calc(100%-2rem)] -translate-x-1/2 -translate-y-1/2 gap-4 rounded-xl bg-popover p-4 text-sm text-popover-foreground ring-1 ring-foreground/10 duration-100 outline-none sm:max-w-sm data-open:animate-in data-open:fade-in-0 data-open:zoom-in-95 data-closed:animate-out data-closed:fade-out-0 data-closed:zoom-out-95",
+          className
+        )}
+        {...props}
+      >
+        {children}
+        {showCloseButton && (
+          <DialogPrimitive.Close data-slot="dialog-close" asChild>
+            <Button
+              variant="ghost"
+              className="absolute top-2 right-2"
+              size="icon-sm"
+            >
+              <XIcon
+              />
+              <span className="sr-only">Close</span>
+            </Button>
+          </DialogPrimitive.Close>
+        )}
+      </DialogPrimitive.Content>
+    </DialogPortal>
+  )
+}
+
+function DialogHeader({ className, ...props }: React.ComponentProps<"div">) {
+  return (
+    <div
+      data-slot="dialog-header"
+      className={cn("flex flex-col gap-2", className)}
+      {...props}
+    />
+  )
+}
+
+function DialogFooter({
+  className,
+  showCloseButton = false,
+  children,
+  ...props
+}: React.ComponentProps<"div"> & {
+  showCloseButton?: boolean
+}) {
+  return (
+    <div
+      data-slot="dialog-footer"
+      className={cn(
+        "-mx-4 -mb-4 flex flex-col-reverse gap-2 rounded-b-xl border-t bg-muted/50 p-4 sm:flex-row sm:justify-end",
+        className
+      )}
+      {...props}
+    >
+      {children}
+      {showCloseButton && (
+        <DialogPrimitive.Close asChild>
+          <Button variant="outline">Close</Button>
+        </DialogPrimitive.Close>
+      )}
+    </div>
+  )
+}
+
+function DialogTitle({
+  className,
+  ...props
+}: React.ComponentProps<typeof DialogPrimitive.Title>) {
+  return (
+    <DialogPrimitive.Title
+      data-slot="dialog-title"
+      className={cn(
+        "text-base leading-none font-medium",
+        className
+      )}
+      {...props}
+    />
+  )
+}
+
+function DialogDescription({
+  className,
+  ...props
+}: React.ComponentProps<typeof DialogPrimitive.Description>) {
+  return (
+    <DialogPrimitive.Description
+      data-slot="dialog-description"
+      className={cn(
+        "text-sm text-muted-foreground *:[a]:underline *:[a]:underline-offset-3 *:[a]:hover:text-foreground",
+        className
+      )}
+      {...props}
+    />
+  )
+}
+
+export {
+  Dialog,
+  DialogClose,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogOverlay,
+  DialogPortal,
+  DialogTitle,
+  DialogTrigger,
+}

frontend/src/docs/notifications/updateInstructions.tsx

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

frontend/src/lib/queries/getScanUsers.ts

@@ -0,0 +1,25 @@
+import { keepPreviousData, queryOptions } from "@tanstack/react-query";
+import axios from "axios";
+
+export function getScanUsers() {
+	return queryOptions({
+		queryKey: ["getScanUsers"],
+		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/mobile/auth/user", {
+		withCredentials: true,
+		timeout: 5000,
+	});
+
+	return data.data;
+};

frontend/src/lib/queries/getScannerIds.ts

@@ -0,0 +1,25 @@
+import { keepPreviousData, queryOptions } from "@tanstack/react-query";
+import axios from "axios";
+
+export function getScannerIds() {
+	return queryOptions({
+		queryKey: ["getScannerIds"],
+		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/mobile/available", {
+		withCredentials: true,
+		timeout: 5000,
+	});
+
+	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) => (
@@ -107,14 +134,23 @@ export default function LstTable({
 				<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"
@@ -122,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/lib/tableStuff/SkellyTable.tsx

@@ -17,11 +17,13 @@ export default function SkellyTable({ rows = 5, columns = 4 }: TableSkelly) {
 		<div className="rounded-md border">
 			<Table>
 				<TableHeader>
-					{Array.from({ length: columns }).map((_, i) => (
-						<TableHead key={i}>
-							<Skeleton className="h-4 w-[80px]" />
-						</TableHead>
-					))}
+					<TableRow>
+						{Array.from({ length: columns }).map((_, i) => (
+							<TableHead key={i}>
+								<Skeleton className="h-4 w-[80px]" />
+							</TableHead>
+						))}
+					</TableRow>
 				</TableHeader>
 				<TableBody>
 					{Array.from({ length: rows }).map((_, r) => (

frontend/src/lib/umami.utils.ts

@@ -0,0 +1,65 @@
+type RuntimeConfig = {
+	appName: string;
+	site: string;
+	server: string;
+	appVersion: string;
+	umamiHost: string;
+	umamiWebsiteId: string;
+};
+
+declare global {
+	interface Window {
+		LST_CONFIG?: RuntimeConfig;
+		umami?: {
+			track: (eventName: string, eventData?: Record<string, unknown>) => void;
+		};
+	}
+}
+
+export const runtimeConfig: RuntimeConfig = {
+	appName: window.LST_CONFIG?.appName ?? "LST",
+	site: window.LST_CONFIG?.site ?? "unknown",
+	server: window.LST_CONFIG?.server ?? "unknown",
+	appVersion: window.LST_CONFIG?.appVersion ?? "dev",
+	umamiHost: window.LST_CONFIG?.umamiHost ?? "",
+	umamiWebsiteId: window.LST_CONFIG?.umamiWebsiteId ?? "",
+};
+
+export function loadUmami() {
+	if (!runtimeConfig.umamiHost) return;
+	if (!runtimeConfig.umamiWebsiteId) return;
+	if (document.querySelector("script[data-website-id]")) return;
+
+	const script = document.createElement("script");
+	script.defer = true;
+	script.src = `${runtimeConfig.umamiHost}/script.js`;
+	script.setAttribute("data-website-id", runtimeConfig.umamiWebsiteId);
+
+	document.head.appendChild(script);
+}
+
+export function trackLstEvent(
+	eventName: string,
+	eventData?: Record<string, unknown>,
+) {
+	window.umami?.track(eventName, {
+		app: runtimeConfig.appName,
+		site: runtimeConfig.site,
+		server: runtimeConfig.server,
+		appVersion: runtimeConfig.appVersion,
+		...eventData,
+	});
+}
+
+/*
+
+event type
+
+		trackLstEvent("exampleClick", {
+			module: "example",
+			action: "test_click",
+			label: "Example Button",
+			page: window.location.pathname,
+		});
+
+*/

frontend/src/main.tsx

@@ -4,6 +4,7 @@ import ReactDOM from "react-dom/client";
 import "./index.css";
 import { createRouter, RouterProvider } from "@tanstack/react-router";
 import socket from "./lib/socket.io";
+import { loadUmami } from "./lib/umami.utils";
 // Import the generated route tree
 import { routeTree } from "./routeTree.gen";
 
@@ -38,6 +39,7 @@ declare module "@tanstack/react-router" {
 // Render the app
 const rootElement = document.getElementById("root")!;
 if (!rootElement.innerHTML) {
+	loadUmami();
 	const root = ReactDOM.createRoot(rootElement);
 	root.render(
 		<StrictMode>

frontend/src/routeTree.gen.ts

@@ -13,8 +13,10 @@ import { Route as AboutRouteImport } from './routes/about'
 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 AdminUsersRouteImport } from './routes/admin/users'
 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'
@@ -42,6 +44,11 @@ const DocsSplatRoute = DocsSplatRouteImport.update({
   path: '/docs/$',
   getParentRoute: () => rootRouteImport,
 } as any)
+const AdminUsersRoute = AdminUsersRouteImport.update({
+  id: '/admin/users',
+  path: '/admin/users',
+  getParentRoute: () => rootRouteImport,
+} as any)
 const AdminSettingsRoute = AdminSettingsRouteImport.update({
   id: '/admin/settings',
   path: '/admin/settings',
@@ -52,6 +59,11 @@ const AdminServersRoute = AdminServersRouteImport.update({
   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',
@@ -89,8 +101,10 @@ 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
+  '/admin/users': typeof AdminUsersRoute
   '/docs/$': typeof DocsSplatRoute
   '/docs/': typeof DocsIndexRoute
   '/user/profile': typeof authUserProfileRoute
@@ -103,8 +117,10 @@ 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
+  '/admin/users': typeof AdminUsersRoute
   '/docs/$': typeof DocsSplatRoute
   '/docs': typeof DocsIndexRoute
   '/user/profile': typeof authUserProfileRoute
@@ -118,8 +134,10 @@ 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
+  '/admin/users': typeof AdminUsersRoute
   '/docs/$': typeof DocsSplatRoute
   '/docs/': typeof DocsIndexRoute
   '/(auth)/user/profile': typeof authUserProfileRoute
@@ -134,8 +152,10 @@ export interface FileRouteTypes {
     | '/login'
     | '/admin/logs'
     | '/admin/notifications'
+    | '/admin/scanUsers'
     | '/admin/servers'
     | '/admin/settings'
+    | '/admin/users'
     | '/docs/$'
     | '/docs/'
     | '/user/profile'
@@ -148,8 +168,10 @@ export interface FileRouteTypes {
     | '/login'
     | '/admin/logs'
     | '/admin/notifications'
+    | '/admin/scanUsers'
     | '/admin/servers'
     | '/admin/settings'
+    | '/admin/users'
     | '/docs/$'
     | '/docs'
     | '/user/profile'
@@ -162,8 +184,10 @@ export interface FileRouteTypes {
     | '/(auth)/login'
     | '/admin/logs'
     | '/admin/notifications'
+    | '/admin/scanUsers'
     | '/admin/servers'
     | '/admin/settings'
+    | '/admin/users'
     | '/docs/$'
     | '/docs/'
     | '/(auth)/user/profile'
@@ -177,8 +201,10 @@ export interface RootRouteChildren {
   authLoginRoute: typeof authLoginRoute
   AdminLogsRoute: typeof AdminLogsRoute
   AdminNotificationsRoute: typeof AdminNotificationsRoute
+  AdminScanUsersRoute: typeof AdminScanUsersRoute
   AdminServersRoute: typeof AdminServersRoute
   AdminSettingsRoute: typeof AdminSettingsRoute
+  AdminUsersRoute: typeof AdminUsersRoute
   DocsSplatRoute: typeof DocsSplatRoute
   DocsIndexRoute: typeof DocsIndexRoute
   authUserProfileRoute: typeof authUserProfileRoute
@@ -216,6 +242,13 @@ declare module '@tanstack/react-router' {
       preLoaderRoute: typeof DocsSplatRouteImport
       parentRoute: typeof rootRouteImport
     }
+    '/admin/users': {
+      id: '/admin/users'
+      path: '/admin/users'
+      fullPath: '/admin/users'
+      preLoaderRoute: typeof AdminUsersRouteImport
+      parentRoute: typeof rootRouteImport
+    }
     '/admin/settings': {
       id: '/admin/settings'
       path: '/admin/settings'
@@ -230,6 +263,13 @@ declare module '@tanstack/react-router' {
       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'
@@ -281,8 +321,10 @@ const rootRouteChildren: RootRouteChildren = {
   authLoginRoute: authLoginRoute,
   AdminLogsRoute: AdminLogsRoute,
   AdminNotificationsRoute: AdminNotificationsRoute,
+  AdminScanUsersRoute: AdminScanUsersRoute,
   AdminServersRoute: AdminServersRoute,
   AdminSettingsRoute: AdminSettingsRoute,
+  AdminUsersRoute: AdminUsersRoute,
   DocsSplatRoute: DocsSplatRoute,
   DocsIndexRoute: DocsIndexRoute,
   authUserProfileRoute: authUserProfileRoute,

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

@@ -51,6 +51,8 @@ export default function NotificationsSubCard({ user }: any) {
 		}));
 	}
 
+	console.log(n);
+
 	return (
 		<div>
 			<Card className="p-3 w-lg">

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 = () => (
-	<div className="[--header-height:calc(--spacing(14))]">
-		<ThemeProvider>
-			<SidebarProvider className="flex flex-col" defaultOpen={false}>
-				<Header />
+const RootLayout = () => {
+	const { data: session } = useSession();
+	return (
+		<div className="[--header-height:calc(--spacing(14))]">
+			<ThemeProvider>
+				<SidebarProvider className="flex flex-col" defaultOpen={false}>
+					<Header />
 
-				<div className="relative min-h-[calc(100svh-var(--header-height))]">
-					<AppSidebar />
+					<div className="relative min-h-[calc(100svh-var(--header-height))]">
+						<AppSidebar />
 
-					<main className="w-full p-4">
-						<div className="mx-auto w-full max-w-7xl">
-							<Outlet />
-						</div>
-					</main>
-				</div>
+						<main className="w-full p-4">
+							<div className="mx-auto w-full max-w-7xl">
+								<Outlet />
+							</div>
+						</main>
+					</div>
 
-				<Toaster expand richColors closeButton />
-			</SidebarProvider>
-		</ThemeProvider>
-		<TanStackRouterDevtools />
-	</div>
-);
+					<Toaster expand richColors closeButton />
+				</SidebarProvider>
+			</ThemeProvider>
+			{session && session.user.role === "systemAdmin" && (
+				<TanStackRouterDevtools />
+			)}
+		</div>
+	);
+};
 
 export const Route = createRootRoute({ component: RootLayout });

frontend/src/routes/admin/-components/NewScanUser.tsx

@@ -0,0 +1,161 @@
+import { useSuspenseQuery } from "@tanstack/react-query";
+import axios from "axios";
+import { useState } from "react";
+import { toast } from "sonner";
+import { Button } from "../../../components/ui/button";
+import {
+	Dialog,
+	DialogContent,
+	DialogDescription,
+	DialogHeader,
+	DialogTitle,
+} from "../../../components/ui/dialog";
+import { useAppForm } from "../../../lib/formSutff";
+import { getScannerIds } from "../../../lib/queries/getScannerIds";
+
+export default function NewScanUser({ refetch }: { refetch: any }) {
+	const [open, setOpen] = useState(false);
+	const { data, refetch: scannerFetch } = useSuspenseQuery(getScannerIds());
+	const form = useAppForm({
+		defaultValues: {
+			name: "",
+			scannerId: "",
+			pinNumber: "",
+		},
+		onSubmit: async ({ value }) => {
+			if (value.scannerId === "") {
+				toast.error(
+					"Scanner id is required please select a scanner id before submitting ",
+				);
+				return;
+			}
+
+			try {
+				const { data } = await axios.post(
+					"/lst/api/mobile/auth/user",
+					{
+						name: value.name,
+						pinNumber: value.pinNumber,
+						scannerId: value.scannerId,
+					},
+					{
+						withCredentials: true,
+						timeout: 15000,
+						validateStatus: () => true,
+					},
+				);
+
+				if (data.success) {
+					toast.success(
+						`${value.name}, was just created and can now log into the scanner with PIN: ${value.pinNumber}`,
+					);
+					form.reset();
+					setOpen(false);
+					refetch();
+				}
+
+				if (!data.success) {
+					toast.error(data.message);
+					return;
+				}
+			} catch (error) {
+				console.error(error);
+			}
+		},
+	});
+
+	const closeModel = (e: boolean) => {
+		setOpen(e);
+
+		if (!e) {
+			form.reset();
+			scannerFetch();
+		}
+	};
+
+	const openForm = () => {
+		setOpen(true);
+		scannerFetch();
+	};
+
+	let n: any = [];
+	if (data) {
+		n = data.map((i: any) => ({
+			label: i.label,
+			value: i.value.toString(),
+		}));
+	}
+
+	return (
+		<Dialog onOpenChange={(e) => closeModel(e)} open={open}>
+			<Button onClick={openForm}>Create new user</Button>
+
+			<DialogContent showCloseButton={false}>
+				<DialogHeader>
+					<DialogTitle>Create New Scan user.</DialogTitle>
+					<DialogDescription></DialogDescription>
+				</DialogHeader>
+				<form
+					onSubmit={(e) => {
+						e.preventDefault();
+						form.handleSubmit();
+					}}
+				>
+					<div className="mb-2">
+						<form.AppField name="name">
+							{(field) => (
+								<field.InputField
+									label="Name"
+									inputType="text"
+									required={true}
+								/>
+							)}
+						</form.AppField>
+					</div>
+
+					<div className="w-32">
+						<form.AppField name="scannerId">
+							{(field) => (
+								<field.SelectField
+									label="Scanner Id"
+									placeholder="Select New scanner Id"
+									options={n}
+								/>
+							)}
+						</form.AppField>
+					</div>
+					<div className="flex flex-row">
+						<div>
+							<form.AppField name="pinNumber">
+								{(field) => (
+									<field.InputField
+										label="Pin Number"
+										inputType="number"
+										required={true}
+									/>
+								)}
+							</form.AppField>
+						</div>
+						<div className="mt-9 ml-2">
+							<Button
+								type="button"
+								onClick={async () => {
+									const { data } = await axios.get("/lst/api/mobile/pin/new");
+
+									form.setFieldValue("pinNumber", data.data[0].pin);
+								}}
+							>
+								New Pin
+							</Button>
+						</div>
+					</div>
+					<div className="flex justify-end mt-2 ">
+						<form.AppForm>
+							<form.SubmitButton>Submit</form.SubmitButton>
+						</form.AppForm>
+					</div>
+				</form>
+			</DialogContent>
+		</Dialog>
+	);
+}

frontend/src/routes/admin/scanUsers.tsx

@@ -0,0 +1,258 @@
+import { useMutation, 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 { authClient } from "../../lib/auth-client";
+import { getScanUsers } from "../../lib/queries/getScanUsers";
+import EditableCellInput from "../../lib/tableStuff/EditableCellInput";
+import LstTable from "../../lib/tableStuff/LstTable";
+import SearchableHeader from "../../lib/tableStuff/SearchableHeader";
+import SkellyTable from "../../lib/tableStuff/SkellyTable";
+import NewScanUser from "./-components/NewScanUser";
+
+export const Route = createFileRoute("/admin/scanUsers")({
+	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 updateSettings = async (
+	id: string,
+	data: Record<string, string | number | boolean | null>,
+) => {
+	//console.log(id, data);
+	try {
+		const res = await axios.patch(`/lst/api/mobile/auth/user/${id}`, data, {
+			withCredentials: true,
+			timeout: 15000,
+			validateStatus: () => true,
+		});
+		toast.success(`User was just updated`);
+		return res;
+	} catch (err) {
+		toast.error("Error in updating the user");
+		return err;
+	}
+};
+
+const ScanUserTable = () => {
+	const { data, refetch } = useSuspenseQuery(getScanUsers());
+	const columnHelper = createColumnHelper<any>();
+
+	const updateSetting = useMutation({
+		mutationFn: ({
+			id,
+			field,
+			value,
+		}: {
+			id: string;
+			field: string;
+			value: string | number | boolean | null;
+		}) => updateSettings(id, { [field]: value }),
+
+		onSuccess: () => {
+			// refetch or update cache
+			refetch();
+		},
+	});
+
+	const columns = [
+		columnHelper.accessor("name", {
+			header: ({ column }) => (
+				<SearchableHeader column={column} title="Name" searchable={true} />
+			),
+			filterFn: "includesString",
+			cell: (i) => i.getValue(),
+		}),
+		columnHelper.accessor("scannerId", {
+			header: ({ column }) => (
+				<SearchableHeader
+					column={column}
+					title="Scanner ID"
+					searchable={false}
+				/>
+			),
+			filterFn: "includesString",
+			cell: (i) => i.getValue(),
+		}),
+		columnHelper.accessor("pinNumber", {
+			header: ({ column }) => (
+				<SearchableHeader column={column} title="Pin Number" />
+			),
+
+			filterFn: "includesString",
+			cell: ({ row, getValue }) => (
+				<div className="flex flex-row gap-2">
+					<div>
+						<EditableCellInput
+							value={getValue()}
+							id={row.original.name}
+							field="value"
+							onSubmit={({ id, field, value }) => {
+								updateSetting.mutate({ id, field, value });
+							}}
+						/>
+					</div>
+
+					<div className="">
+						<Button
+							type="button"
+							onClick={async () => {
+								const { data } = await axios.get("/lst/api/mobile/pin/new");
+								updateSetting.mutate({
+									id: row.original.id,
+									field: "pinNumber",
+									value: data.data[0].pin,
+								});
+							}}
+						>
+							New Pin
+						</Button>
+					</div>
+				</div>
+			),
+		}),
+		columnHelper.accessor("lastScan", {
+			header: ({ column }) => (
+				<SearchableHeader column={column} title="Last Scan" />
+			),
+			cell: (i) => <span>{format(i.getValue(), "M/d/yyyy HH:mm")}</span>,
+		}),
+		columnHelper.accessor("excludedCommand", {
+			header: ({ column }) => (
+				<SearchableHeader column={column} title="Command id's Not Allowed" />
+			),
+			cell: (i) => {
+				const commands = i.getValue().join();
+				return (
+					<span>{commands === "" ? "All commands allowed" : commands}</span>
+				);
+			},
+		}),
+		columnHelper.accessor("deleteUser", {
+			header: ({ column }) => (
+				<SearchableHeader
+					column={column}
+					title="Delete User"
+					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 onTrigger = async () => {
+					setActiveToggle(true);
+
+					try {
+						const res = await axios.delete(
+							`/lst/api/mobile/auth/user/${i.row.original.id}`,
+
+							{
+								withCredentials: true,
+								timeout: 5000,
+								validateStatus: () => true,
+							},
+						);
+
+						if (res.data.success) {
+							toast.success(`${i.row.original.name} was deleted.`);
+							refetch();
+							setActiveToggle(false);
+						}
+
+						if (!res.data.success) {
+							toast.error(
+								`${i.row.original.name} encountered an error when trying to delete: ${res.data.message}`,
+							);
+							refetch();
+							setActiveToggle(false);
+						}
+					} catch (error) {
+						setActiveToggle(false);
+						console.error(error);
+					}
+				};
+
+				return (
+					<div>
+						<div className="flex items-center space-x-2">
+							<Button
+								variant="destructive"
+								disabled={activeToggle}
+								onClick={onTrigger}
+							>
+								{activeToggle ? (
+									<span>
+										<Spinner />
+									</span>
+								) : (
+									<span>
+										<Trash />
+									</span>
+								)}
+							</Button>
+						</div>
+					</div>
+				);
+			},
+		}),
+	];
+
+	return (
+		<div>
+			<div className="flex justify-end m-2">
+				<Suspense
+					fallback={
+						<div>
+							<p>Loading...</p>
+						</div>
+					}
+				>
+					<NewScanUser refetch={refetch} />
+				</Suspense>
+			</div>
+			<div>
+				<LstTable data={data} columns={columns} pageSize={50} />
+			</div>
+		</div>
+	);
+};
+
+// const NewUserForm = ()=>{
+// 	const { data, refetch } = useSuspenseQuery(getScanUsers());
+// }
+function RouteComponent() {
+	//const { data: session } = useSession();
+	return (
+		<Suspense fallback={<SkellyTable />}>
+			<ScanUserTable />
+		</Suspense>
+	);
+}

frontend/src/routes/admin/servers.tsx

@@ -155,7 +155,7 @@ const ServerTable = () => {
 		);
 	}
 
-	return <LstTable data={data} columns={columns} />;
+	return <LstTable data={data} columns={columns} pageSize={50} />;
 };
 
 function RouteComponent() {
@@ -163,7 +163,6 @@ function RouteComponent() {
 
 	const columnHelper = createColumnHelper<any>();
 
-	console.log(window.location);
 	const logColumns = [
 		columnHelper.accessor("timestamp", {
 			header: ({ column }) => (

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>

frontend/src/routes/index.tsx

@@ -3,6 +3,7 @@ import { createFileRoute } from "@tanstack/react-router";
 import z from "zod";
 
 import { useSession } from "../lib/auth-client";
+import { trackLstEvent } from "../lib/umami.utils";
 
 export const Route = createFileRoute("/")({
 	validateSearch: z.object({
@@ -27,6 +28,16 @@ function Index() {
 		url = "https://www.youtube.com/watch?v=dQw4w9WgXcQ";
 	}
 
+	//test tracking
+	const click = () => {
+		trackLstEvent("silly_click", {
+			module: "silly",
+			action: "click",
+			label: "rick rolled",
+			page: window.location.pathname,
+		});
+	};
+
 	return (
 		<div className="flex justify-center m-10 flex-col">
 			<h3 className="w-2xl text-3xl">Welcome Lst - V3</h3>
@@ -43,16 +54,18 @@ function Index() {
 					<b>
 						<strong>Click</strong>
 					</b>
-				</a>
-				<a
-					href={`https://www.youtube.com/watch?v=dQw4w9WgXcQ`}
-					target="_blank"
-					rel="noopener"
-				>
-					<b>
-						<strong> Here</strong>
-					</b>
-				</a>
+				</a>{" "}
+				<button onClick={click}>
+					<a
+						href={`https://www.youtube.com/watch?v=dQw4w9WgXcQ`}
+						target="_blank"
+						rel="noopener"
+					>
+						<b>
+							<strong> Here</strong>
+						</b>
+					</a>
+				</button>
 			</p>
 		</div>
 	);

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/images/android-icon-foreground.png",
-        "backgroundImage": "./assets/images/android-icon-background.png",
-        "monochromeImage": "./assets/images/android-icon-monochrome.png",
-        "package": "net.alpla.lst.mobile",
-        "versionCode": 1
+        "foregroundImage": "./assets/adaptive-icon-white.png",
+        "backgroundColor": "#ffffff"
       },
+      "versionCode": 33,
+      "minSupportedVersionCode": 33,
       "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",
-            "imageWidth": 76
+            "resizeMode": "cover",
+            "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
     }
   }
-}
+}

lstMobile/babel.config.js

@@ -0,0 +1,9 @@
+module.exports = (api) => {
+	api.cache(true);
+	return {
+		presets: [
+			["babel-preset-expo", { jsxImportSource: "nativewind" }],
+			"nativewind/babel",
+		],
+	};
+};

lstMobile/components.json

@@ -0,0 +1,19 @@
+{
+  "$schema": "https://ui.shadcn.com/schema.json",
+  "style": "new-york",
+  "rsc": false,
+  "tsx": true,
+  "tailwind": {
+    "config": "tailwind.config.js",
+    "css": "global.css",
+    "baseColor": "neutral",
+    "cssVariables": true
+  },
+  "aliases": {
+    "components": "@/components",
+    "utils": "@/lib/utils",
+    "ui": "@/components/ui",
+    "lib": "@/lib",
+    "hooks": "@/hooks"
+  }
+}

lstMobile/global.css

@@ -0,0 +1,58 @@
+@tailwind base;
+@tailwind components;
+@tailwind utilities;
+
+@layer base {
+	:root {
+		--background: 0 0% 100%;
+		--foreground: 0 0% 3.9%;
+		--card: 0 0% 100%;
+		--card-foreground: 0 0% 3.9%;
+		--popover: 0 0% 100%;
+		--popover-foreground: 0 0% 3.9%;
+		--primary: 0 0% 9%;
+		--primary-foreground: 0 0% 98%;
+		--secondary: 0 0% 96.1%;
+		--secondary-foreground: 0 0% 9%;
+		--muted: 0 0% 96.1%;
+		--muted-foreground: 0 0% 45.1%;
+		--accent: 0 0% 96.1%;
+		--accent-foreground: 0 0% 9%;
+		--destructive: 0 84.2% 60.2%;
+		--border: 0 0% 89.8%;
+		--input: 0 0% 89.8%;
+		--ring: 0 0% 63%;
+		--radius: 0.625rem;
+		--chart-1: 12 76% 61%;
+		--chart-2: 173 58% 39%;
+		--chart-3: 197 37% 24%;
+		--chart-4: 43 74% 66%;
+		--chart-5: 27 87% 67%;
+	}
+
+	.dark:root {
+		--background: 0 0% 3.9%;
+		--foreground: 0 0% 98%;
+		--card: 0 0% 3.9%;
+		--card-foreground: 0 0% 98%;
+		--popover: 0 0% 3.9%;
+		--popover-foreground: 0 0% 98%;
+		--primary: 0 0% 98%;
+		--primary-foreground: 0 0% 9%;
+		--secondary: 0 0% 14.9%;
+		--secondary-foreground: 0 0% 98%;
+		--muted: 0 0% 14.9%;
+		--muted-foreground: 0 0% 63.9%;
+		--accent: 0 0% 14.9%;
+		--accent-foreground: 0 0% 98%;
+		--destructive: 0 70.9% 59.4%;
+		--border: 0 0% 14.9%;
+		--input: 0 0% 14.9%;
+		--ring: 300 0% 45%;
+		--chart-1: 220 70% 50%;
+		--chart-2: 160 60% 45%;
+		--chart-3: 30 80% 55%;
+		--chart-4: 280 65% 60%;
+		--chart-5: 340 75% 55%;
+	}
+}

lstMobile/metro.config.js

@@ -0,0 +1,9 @@
+const { getDefaultConfig } = require("expo/metro-config");
+const { withNativeWind } = require("nativewind/metro");
+
+const config = getDefaultConfig(__dirname);
+
+module.exports = withNativeWind(config, {
+	input: "./global.css",
+	inlineRem: 16,
+});

lstMobile/nativewind-env.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="nativewind/types" />
+
+// NOTE: This file should not be edited and should be committed with your source code. It is generated by NativeWind.

lstMobile/package.json

@@ -1,7 +1,7 @@
 {
   "name": "lstmobile",
   "main": "expo-router/entry",
-  "version": "0.0.1-alpha",
+  "version": "0.0.2-alpha",
   "scripts": {
     "start": "expo start",
     "reset-project": "node ./scripts/reset-project.js",
@@ -9,22 +9,39 @@
     "ios": "expo run:ios",
     "web": "expo start --web",
     "lint": "expo lint",
-    "build:apk": "expo prebuild --clean && cd android && gradlew.bat assembleRelease ",
-    "update": "adb install android/app/build/outputs/apk/release/app-release.apk"
+    "build:apk:clean": "expo prebuild --clean && cd android && gradlew.bat assembleRelease && npm run copy:apk",
+    "build:apk": "expo prebuild && cd android && gradlew.bat assembleRelease && npm run copy:apk",
+    "build:mobile": "cd scripts && node runBuild.ts",
+    "build:mobile:bump": "cd scripts && node runBuild.ts --bump",
+    "copy:apk": "cd android && copy /Y app\\build\\outputs\\apk\\release\\app-release.apk ..\\..\\downloads\\mobile\\lst-mobile.apk",
+    "update": "adb install android/app/build/outputs/apk/release/app-release.apk",
+    "checklogs": "adb logcat -v time -s ReactNativeJS"
   },
   "dependencies": {
     "@react-native-async-storage/async-storage": "2.2.0",
     "@react-navigation/bottom-tabs": "^7.15.5",
     "@react-navigation/elements": "^2.9.10",
     "@react-navigation/native": "^7.1.33",
+    "@rn-primitives/dialog": "^1.4.0",
+    "@rn-primitives/portal": "^1.4.0",
+    "@rn-primitives/separator": "^1.4.0",
+    "@rn-primitives/slot": "^1.4.0",
     "@tanstack/react-query": "^5.99.0",
     "axios": "^1.15.0",
+    "babel-preset-expo": "^55.0.18",
+    "class-variance-authority": "^0.7.1",
+    "clsx": "^2.1.1",
+    "date-fns-tz": "^3.2.0",
     "expo": "~55.0.15",
     "expo-application": "~55.0.14",
+    "expo-audio": "~55.0.14",
+    "expo-av": "^16.0.8",
+    "expo-build-properties": "~55.0.13",
     "expo-constants": "~55.0.14",
     "expo-device": "~55.0.15",
     "expo-font": "~55.0.6",
     "expo-glass-effect": "~55.0.10",
+    "expo-haptics": "~55.0.14",
     "expo-image": "~55.0.8",
     "expo-linking": "~55.0.13",
     "expo-router": "~55.0.12",
@@ -34,6 +51,8 @@
     "expo-system-ui": "~55.0.15",
     "expo-web-browser": "~55.0.14",
     "lucide-react-native": "^1.8.0",
+    "nativewind": "^4.2.3",
+    "prettier-plugin-tailwindcss": "^0.5.14",
     "react": "19.2.0",
     "react-dom": "19.2.0",
     "react-native": "0.83.4",
@@ -41,9 +60,14 @@
     "react-native-reanimated": "4.2.1",
     "react-native-safe-area-context": "~5.6.2",
     "react-native-screens": "~4.23.0",
+    "react-native-tcp-socket": "^6.4.1",
+    "react-native-toast-message": "^2.3.3",
     "react-native-web": "~0.21.0",
     "react-native-worklets": "0.7.2",
     "socket.io-client": "^4.8.3",
+    "tailwind-merge": "^3.5.0",
+    "tailwindcss": "^3.4.19",
+    "tailwindcss-animate": "^1.0.7",
     "zod": "^4.3.6",
     "zustand": "^5.0.12"
   },

lstMobile/plugins/withZebraDataWedge.js

@@ -0,0 +1,317 @@
+const { withDangerousMod } = require("@expo/config-plugins");
+const fs = require("fs");
+const path = require("path");
+
+// const packageName = "net.alpla.lst.mobile";
+// const packagePath = "com/alpla/lst/mobile";
+const packageName = "net.alpla.lst.mobile";
+const packagePath = "net/alpla/lst/mobile";
+// const packageName = config.android?.package;
+// const packagePath = packageName.replace(/\./g, "/");
+
+const moduleCode = `package ${packageName}.scanner
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.os.Bundle
+import com.facebook.react.bridge.*
+import com.facebook.react.modules.core.DeviceEventManagerModule
+
+class ZebraScannerModule(
+    private val reactContext: ReactApplicationContext
+) : ReactContextBaseJavaModule(reactContext) {
+
+    override fun getName(): String = "ZebraScanner"
+
+    private val scanAction = "com.lst.mobile.SCAN"
+    private var receiverRegistered = false
+
+    private val scanReceiver = object : BroadcastReceiver() {
+       override fun onReceive(context: Context?, intent: Intent?) {
+            println("LST SCANNER: received intent -> \${intent?.action}")
+
+            if (intent?.action != scanAction) {
+                println("LST SCANNER: wrong action")
+                return
+            }
+
+            val barcodeData: String? =
+                intent.getStringExtra("com.symbol.datawedge.data_string")
+
+            val labelType: String? =
+                intent.getStringExtra("com.symbol.datawedge.label_type")
+
+            val source: String? =
+                intent.getStringExtra("com.symbol.datawedge.source")
+
+            println("LST SCANNER: data=$barcodeData label=$labelType source=$source")
+
+            if (barcodeData.isNullOrBlank()) {
+                println("LST SCANNER: empty barcode")
+                return
+            }
+
+            val payload = Arguments.createMap().apply {
+                putString("data", barcodeData)
+                putString("labelType", labelType)
+                putString("source", source)
+                putDouble("timestamp", System.currentTimeMillis().toDouble())
+            }
+
+            sendEvent("barcodeScanned", payload)
+        }
+    }
+
+    @ReactMethod
+    fun startListening() {
+        if (receiverRegistered) return
+
+        reactContext.registerReceiver(
+            scanReceiver,
+            IntentFilter(scanAction),
+            Context.RECEIVER_EXPORTED
+        )
+
+        receiverRegistered = true
+    }
+
+    @ReactMethod
+    fun stopListening() {
+        if (!receiverRegistered) return
+
+        try {
+            reactContext.unregisterReceiver(scanReceiver)
+        } catch (_: Exception) {}
+
+        receiverRegistered = false
+    }
+    
+    /**
+     * Required for React Native NativeEventEmitter
+     */
+    @ReactMethod
+    fun addListener(eventName: String) {
+        // No-op
+    }
+
+    /**
+     * Required for React Native NativeEventEmitter
+     */
+    @ReactMethod
+    fun removeListeners(count: Int) {
+        // No-op
+    }
+
+    @ReactMethod
+    fun triggerScan() {
+        val intent = Intent().apply {
+            action = "com.symbol.datawedge.api.ACTION"
+            putExtra("com.symbol.datawedge.api.SOFT_SCAN_TRIGGER", "TOGGLE_SCANNING")
+        }
+
+        reactContext.sendBroadcast(intent)
+    }
+
+    private fun sendCommand(command: String, value: Any) {
+        val intent = Intent().apply {
+            action = "com.symbol.datawedge.api.ACTION"
+
+            when (value) {
+                is String -> putExtra(command, value)
+                is Bundle -> putExtra(command, value)
+            }
+        }
+
+        reactContext.sendBroadcast(intent)
+    }
+
+    private fun sendEvent(eventName: String, payload: WritableMap) {
+        reactContext
+            .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            .emit(eventName, payload)
+    }
+    
+    //
+    @ReactMethod
+    fun ensureProfile() {
+        val profileName = "LST_MOBILE"
+
+        sendCommand(
+            "com.symbol.datawedge.api.CREATE_PROFILE",
+            profileName
+        )
+
+        Thread.sleep(500)
+
+        val barcodeConfig = Bundle().apply {
+            putString("PLUGIN_NAME", "BARCODE")
+            putString("RESET_CONFIG", "true")
+
+            val props = Bundle().apply {
+                putString("scanner_input_enabled", "true")
+
+                // Auto-select internal scanner
+                putString("scanner_selection", "auto")
+                putString("scanner_selection_by_identifier", "AUTO")
+
+                // Hardware trigger behavior
+                putString("hardware_trigger_enabled", "true")
+                putString("trigger_mode", "2") // 2 = HARD trigger
+
+                // Disable Zebra's loud initial decode feedback
+                putString("decode_audio_feedback_uri", "")
+                putString("decode_haptic_feedback", "false")
+                putString("decode_led_feedback", "false")
+
+                // add in wake on trigger
+                putString("trigger_wakeup_scan", "true");
+            }
+
+            putBundle("PARAM_LIST", props)
+        }
+
+        val intentConfig = Bundle().apply {
+            putString("PLUGIN_NAME", "INTENT")
+            putString("RESET_CONFIG", "true")
+
+            val props = Bundle().apply {
+                putString("intent_output_enabled", "true")
+                putString("intent_action", scanAction)
+                putString("intent_delivery", "2") // broadcast
+                putString("intent_use_content_provider", "false")
+            }
+
+            putBundle("PARAM_LIST", props)
+        }
+
+        val keystrokeConfig = Bundle().apply {
+            putString("PLUGIN_NAME", "KEYSTROKE")
+            putString("RESET_CONFIG", "true")
+
+            val props = Bundle().apply {
+                putString("keystroke_output_enabled", "false")
+            }
+
+            putBundle("PARAM_LIST", props)
+        }
+
+        val profileConfig = Bundle().apply {
+            putString("PROFILE_NAME", profileName)
+            putString("PROFILE_ENABLED", "true")
+            putString("CONFIG_MODE", "CREATE_IF_NOT_EXIST")
+
+            putParcelableArrayList(
+                "PLUGIN_CONFIG",
+                arrayListOf(barcodeConfig, intentConfig, keystrokeConfig)
+            )
+        }
+
+        sendCommand("com.symbol.datawedge.api.SET_CONFIG", profileConfig)
+
+        val appConfig = Bundle().apply {
+            putString("PACKAGE_NAME", reactContext.packageName)
+            putStringArray("ACTIVITY_LIST", arrayOf("*"))
+        }
+
+        val associateConfig = Bundle().apply {
+            putString("PROFILE_NAME", profileName)
+            putString("CONFIG_MODE", "UPDATE")
+            putParcelableArray("APP_LIST", arrayOf(appConfig))
+        }
+
+        sendCommand("com.symbol.datawedge.api.SET_CONFIG", associateConfig)
+
+        // Runtime nudge: make sure scanner input is enabled for the active profile
+        sendCommand(
+            "com.symbol.datawedge.api.SCANNER_INPUT_PLUGIN",
+            "ENABLE_PLUGIN"
+        )
+    }
+}
+`;
+
+const packageCode = `package ${packageName}.scanner
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+class ZebraScannerPackage : ReactPackage {
+
+    override fun createNativeModules(
+        reactContext: ReactApplicationContext
+    ): List<NativeModule> {
+        return listOf(ZebraScannerModule(reactContext))
+    }
+
+    override fun createViewManagers(
+        reactContext: ReactApplicationContext
+    ): List<ViewManager<*, *>> {
+        return emptyList()
+    }
+}
+`;
+
+function patchMainApplication(mainApplicationPath) {
+	let contents = fs.readFileSync(mainApplicationPath, "utf8");
+
+	const importLine = `import ${packageName}.scanner.ZebraScannerPackage`;
+
+	if (!contents.includes(importLine)) {
+		contents = contents.replace(
+			/import com\.facebook\.react\.PackageList/,
+			`import com.facebook.react.PackageList\n${importLine}`,
+		);
+	}
+
+	if (!contents.includes("add(ZebraScannerPackage())")) {
+		contents = contents.replace(
+			/PackageList\(this\)\.packages\.apply\s*\{/,
+			`PackageList(this).packages.apply {\n          add(ZebraScannerPackage())`,
+		);
+	}
+
+	fs.writeFileSync(mainApplicationPath, contents);
+}
+
+module.exports = function withZebraScanner(config) {
+	return withDangerousMod(config, [
+		"android",
+		async (config) => {
+			const androidRoot = config.modRequest.platformProjectRoot;
+
+			const scannerDir = path.join(
+				androidRoot,
+				"app/src/main/java",
+				packagePath,
+				"scanner",
+			);
+
+			fs.mkdirSync(scannerDir, { recursive: true });
+
+			fs.writeFileSync(
+				path.join(scannerDir, "ZebraScannerModule.kt"),
+				moduleCode,
+			);
+
+			fs.writeFileSync(
+				path.join(scannerDir, "ZebraScannerPackage.kt"),
+				packageCode,
+			);
+
+			const mainApplicationPath = path.join(
+				androidRoot,
+				"app/src/main/java",
+				packagePath,
+				"MainApplication.kt",
+			);
+
+			patchMainApplication(mainApplicationPath);
+
+			return config;
+		},
+	]);
+};

lstMobile/scripts/runBuild.ts

@@ -0,0 +1,57 @@
+import { execSync } from "child_process";
+import fs from "fs";
+import path from "path";
+
+const appJsonPath = path.resolve("../app.json");
+
+// detect flags
+const args = process.argv.slice(2);
+const shouldBumpMin = args.includes("--bump");
+
+try {
+	// 📖 read file
+	const raw = fs.readFileSync(appJsonPath, "utf-8");
+	const json = JSON.parse(raw);
+
+	const expo = json.expo ?? json; // supports both formats
+
+	if (!expo.android) {
+		throw new Error("No android config found in app.json");
+	}
+
+	// 🔢 current values
+	const currentVersionCode = expo.android.versionCode ?? 1;
+	const currentMin = expo.android.minSupportedVersionCode ?? 1;
+
+	// 🚀 increment version
+	const newVersionCode = currentVersionCode + 1;
+
+	expo.android.versionCode = newVersionCode;
+
+	if (shouldBumpMin) {
+		expo.android.minSupportedVersionCode = newVersionCode;
+	} else {
+		// keep existing min if not bumping
+		expo.android.minSupportedVersionCode = currentMin;
+	}
+
+	// 💾 write back
+	fs.writeFileSync(appJsonPath, JSON.stringify(json, null, 2));
+
+	console.log("✅ app.json updated:");
+	console.log("   versionCode:", newVersionCode);
+	console.log(
+		"   minSupportedVersionCode:",
+		expo.android.minSupportedVersionCode,
+	);
+
+	// 🏗 run build
+	console.log("\n🚧 Running build:apk...\n");
+	execSync("npm run build:apk", { stdio: "inherit" });
+
+	console.log("\n🎉 Build complete!");
+} catch (err) {
+	console.error("❌ Build script failed:");
+	console.error(err);
+	process.exit(1);
+}

lstMobile/src/app/(tabs)/_layout.tsx

@@ -0,0 +1,120 @@
+import { Redirect, Tabs } from "expo-router";
+import {
+	Boxes,
+	Container,
+	Home,
+	Logs,
+	Rows4,
+	Settings,
+} from "lucide-react-native";
+import { useAppStore } from "../../hooks/useAppStore";
+import { useMobileAuthStore } from "../../hooks/useMobileAuth";
+
+// const roles = {
+// 	adminOnly: ["admin"],
+// 	management: ["admin", "manager"],
+// 	allStaff: ["admin", "manager", "driver", "lead", "user"],
+// };
+
+export default function TabsLayout() {
+	const serverPort = useAppStore((s) => s.serverPort);
+	const user = useMobileAuthStore((s) => s.user);
+	const isUnlocked = useMobileAuthStore((s) => s.isUnlocked);
+
+	const port = parseInt(serverPort || "0", 10) >= 50000;
+	console.log(port);
+	if (!port) {
+		if (!user || !isUnlocked) {
+			return <Redirect href="/login" />;
+		}
+	}
+
+	const isNormalScanner = parseInt(serverPort || "0", 10) >= 50000;
+
+	const hasRole = (allowed: string[] = []) => {
+		const role = user?.role?.toLowerCase();
+		return role ? allowed.includes(role) : false;
+	};
+
+	return (
+		<Tabs
+			screenOptions={{
+				headerShown: false, // Hides the header for all screens in this navigator
+			}}
+		>
+			<Tabs.Screen
+				name="scanner"
+				options={{
+					title: "Scan",
+					tabBarIcon: ({ color, size }) => <Home size={size} color={color} />,
+					// header: ({ route }) => {
+					// 	const version = serverVersion?.versionCode;
+
+					// 	const hasUpdate = version && version > build;
+
+					// 	if (!hasUpdate) return null; // 👈 hides header completely
+
+					// 	return <GlobalHeader title={route.name} />;
+					// },
+				}}
+			/>
+			<Tabs.Screen
+				name="ppoo"
+				options={{
+					title: "PPOO",
+					href: isNormalScanner ? null : "/(tabs)/ppoo",
+					tabBarIcon: ({ color, size }) => <Boxes size={size} color={color} />,
+				}}
+			/>
+			<Tabs.Screen
+				name="laneCheck"
+				options={{
+					title: "Lane Check",
+					href: isNormalScanner ? null : "/(tabs)/laneCheck",
+					tabBarIcon: ({ color, size }) => <Rows4 size={size} color={color} />,
+				}}
+			/>
+			<Tabs.Screen
+				name="dockScan"
+				options={{
+					title: "Dock scan",
+					href:
+						isNormalScanner || !hasRole(["admin", "manager"])
+							? null
+							: "/(tabs)/dockScan",
+					tabBarIcon: ({ color, size }) => (
+						<Container size={size} color={color} />
+					),
+				}}
+			/>
+			<Tabs.Screen
+				name="logs"
+				options={{
+					title: "Logs",
+					href:
+						isNormalScanner || !hasRole(["admin", "manager"])
+							? null
+							: "/(tabs)/logs",
+					tabBarIcon: ({ color, size }) => <Logs size={size} color={color} />,
+				}}
+			/>
+			{/* <Tabs.Screen
+				name="lanes"
+				options={{
+					title: "Lanes",
+					href:
+						parseInt(serverPort || "0", 10) >= 50000 ? null : "/(tabs)/logs",
+				}}
+			/> */}
+			<Tabs.Screen
+				name="config"
+				options={{
+					title: "settings",
+					tabBarIcon: ({ color, size }) => (
+						<Settings size={size} color={color} />
+					),
+				}}
+			/>
+		</Tabs>
+	);
+}

lstMobile/src/app/(tabs)/config.tsx

@@ -0,0 +1,5 @@
+import Setup from "../setup";
+
+export default function SettingsTab() {
+	return <Setup />;
+}

lstMobile/src/app/(tabs)/dockScan.tsx

@@ -0,0 +1,26 @@
+import React from "react";
+import { Text, View } from "react-native";
+import { Button } from "../../components/ui/button";
+
+export default function LaneCheck() {
+	const getInfo = async () => {
+		const info = "ho";
+
+		console.log(info);
+	};
+	return (
+		<View
+			style={{
+				flex: 1,
+				//justifyContent: "center",
+				alignItems: "center",
+				marginTop: 50,
+			}}
+		>
+			<Text>Dock Scanning</Text>
+			<Button onPress={getInfo}>
+				<Text>Check info</Text>
+			</Button>
+		</View>
+	);
+}

lstMobile/src/app/(tabs)/laneCheck.tsx

@@ -0,0 +1,210 @@
+import axios from "axios";
+import { format } from "date-fns-tz";
+import { useFocusEffect } from "expo-router";
+import type React from "react";
+import { useCallback, useEffect, useState } from "react";
+import { ScrollView, Text, View } from "react-native";
+import { SafeAreaView } from "react-native-safe-area-context";
+import Toast from "react-native-toast-message";
+import { GlobalFooter } from "../../components/UpdateFooter";
+import { Button } from "../../components/ui/button";
+import { Card, CardContent, CardHeader } from "../../components/ui/card";
+import {
+	Dialog,
+	DialogContent,
+	DialogDescription,
+	DialogHeader,
+	DialogTitle,
+	DialogTrigger,
+} from "../../components/ui/dialog";
+import { useAppStore } from "../../hooks/useAppStore";
+import { scannerFeedback } from "../../lib/feedbackScan";
+import { type ZebraScanResult, zebraScanner } from "../../lib/ZebraScanner";
+
+const InfoRow = ({
+	label,
+	value,
+}: {
+	label: string;
+	value: React.ReactNode;
+}) => {
+	return (
+		<View className="flex-row justify-between gap-4 py-2 border-b border-gray-200">
+			<Text className="text-sm text-gray-500">{label}</Text>
+			<Text className="text-sm font-medium text-gray-900 text-right flex-1">
+				{value}
+			</Text>
+		</View>
+	);
+};
+
+export default function LaneCheck() {
+	const [units, setUnits] = useState<any>(null);
+	const serverIp = useAppStore((s) => s.serverIp);
+
+	const handleScan = useCallback(
+		async (scan: ZebraScanResult) => {
+			setUnits(null);
+			await scannerFeedback({
+				type: "scan",
+				sound: true,
+				vibrate: true,
+				led: true,
+			});
+			if (!scan.data.startsWith("loc")) {
+				Toast.show({
+					type: "error",
+					text1: "Scan error",
+					text2: "The last scan was not a lane please try again",
+				});
+
+				return;
+			}
+			try {
+				const res = await axios.post(
+					`http://${serverIp.trim()}:3000/lst/api/mobile/lanecheck`,
+					{
+						lane: scan.data,
+					},
+					{
+						timeout: 5000,
+					},
+				);
+				if (res.status === 200) {
+					setUnits(res.data);
+					Toast.show({
+						type: "info",
+						text1: "Lane Data",
+						text2: "All Loading Units from this lane will be listed below",
+					});
+				}
+			} catch (error) {
+				console.log(error);
+				Toast.show({
+					type: "error",
+					text1: "Lane Data",
+					text2: "Error getting lane data please try again",
+				});
+			}
+		},
+		[serverIp.trim],
+	);
+
+	useFocusEffect(
+		useCallback(() => {
+			zebraScanner.startListening();
+
+			const sub = zebraScanner.addScanListener((scan) => {
+				//console.log("SCAN:", scan);
+				handleScan(scan);
+			});
+
+			return () => {
+				sub.remove();
+				zebraScanner.stopListening();
+				//setUnits(null);
+			};
+		}, [handleScan]),
+	);
+
+	return (
+		<View
+			style={{
+				//justifyContent: "center",
+				alignItems: "center",
+				marginTop: 50,
+			}}
+		>
+			{units ? (
+				// <SafeAreaView className={`flex-1 w-full items-center`}>
+				// 	<ScrollView className="w-full flex-1">
+				// 		<View className="flex items-center gap-2 w-full">
+				// 			{units.data?.map((i: any, index: any) => (
+				// 				<View key={`${i.runningNumber}-${index}`}>
+				// 					<Text>example</Text>
+				// 				</View>
+				// 			))}
+				// 		</View>
+				// 	</ScrollView>
+				// </SafeAreaView>
+				<SafeAreaView className={`w-full items-center`}>
+					<View style={{ padding: 2 }}>
+						<Text>There Are {units.data.length} units in this lane</Text>
+					</View>
+					<ScrollView className="w-full" style={{ marginBottom: 20 }}>
+						<View>
+							{units.data.map((i, index) => (
+								<View
+									key={`${i.runningNumber}-${index}`}
+									style={{
+										justifyContent: "center",
+										margin: 2,
+									}}
+								>
+									<Dialog>
+										<DialogTrigger>
+											<Card
+												className="w-full"
+												style={{
+													borderColor:
+														i.state === "QualityBlocked" ? "red" : undefined,
+													borderWidth: 4,
+												}}
+											>
+												<CardContent>
+													<Text>
+														{i.articleId} - {i.articleName}
+													</Text>
+
+													<Text>
+														Running Number: {i.runningNumber ?? "Non barcoded"}
+													</Text>
+												</CardContent>
+											</Card>
+										</DialogTrigger>
+										<DialogContent>
+											<DialogHeader>
+												<DialogTitle>
+													Details for Article {i.articleId}, Rn:
+													{i.runningNumber ?? "Non barcoded"}{" "}
+												</DialogTitle>
+												<DialogDescription>
+													<InfoRow
+														label="Production Date"
+														value={format(i.productionDate, "MM/dd/yyyy HH:mm")}
+													/>
+													<InfoRow label="Quantity" value={i.quantity} />
+													{i.state === "QualityBlocked" && (
+														<InfoRow
+															label="Defect"
+															value={i.mainDefectGroupDescription}
+														/>
+													)}
+													{i.state === "QualityBlocked" && (
+														<InfoRow
+															label="Description"
+															value={i.mainDefectDescription}
+														/>
+													)}
+												</DialogDescription>
+											</DialogHeader>
+										</DialogContent>
+									</Dialog>
+								</View>
+							))}
+						</View>
+					</ScrollView>
+				</SafeAreaView>
+			) : (
+				<View className="mt-50">
+					<Text className="text-2xl text-center">
+						Please scan a lane to see all Units that are in the lane.
+					</Text>
+				</View>
+			)}
+			<View>
+				<GlobalFooter />
+			</View>
+		</View>
+	);
+}

lstMobile/src/app/(tabs)/logs.tsx

@@ -0,0 +1,26 @@
+import React from "react";
+import { Text, View } from "react-native";
+import { Button } from "../../components/ui/button";
+
+export default function Logs() {
+	const getInfo = async () => {
+		const info = "ho";
+
+		console.log(info);
+	};
+	return (
+		<View
+			style={{
+				flex: 1,
+				//justifyContent: "center",
+				alignItems: "center",
+				marginTop: 50,
+			}}
+		>
+			<Text>Logs</Text>
+			<Button onPress={getInfo}>
+				<Text>Check info</Text>
+			</Button>
+		</View>
+	);
+}

lstMobile/src/app/(tabs)/ppoo.tsx

@@ -0,0 +1,18 @@
+import React from "react";
+import { Text, View } from "react-native";
+import { Button } from "../../components/ui/button";
+
+export default function PPOO() {
+	return (
+		<View
+			style={{
+				flex: 1,
+				//justifyContent: "center",
+				alignItems: "center",
+				marginTop: 50,
+			}}
+		>
+			<Text>Ppo checks</Text>
+		</View>
+	);
+}

lstMobile/src/app/(tabs)/scanner.tsx

@@ -0,0 +1,24 @@
+import { View } from "react-native";
+import LSTScanner from "../../components/LSTScanner";
+import ProdScanner from "../../components/ProdScanner";
+import { useAppStore } from "../../hooks/useAppStore";
+
+export default function Scanner() {
+	const serverPort = useAppStore((s) => s.serverPort);
+	return (
+		<View
+			style={{
+				flex: 1,
+				//justifyContent: "center",
+				alignItems: "center",
+				marginTop: 50,
+			}}
+		>
+			{parseInt(serverPort || "0", 10) >= 50000 ? (
+				<ProdScanner />
+			) : (
+				<LSTScanner />
+			)}
+		</View>
+	);
+}

lstMobile/src/app/_layout.tsx

@@ -1,14 +1,30 @@
+import { PortalHost } from "@rn-primitives/portal";
 import { Stack } from "expo-router";
 import { StatusBar } from "expo-status-bar";
+import "../../global.css";
+import { useEffect } from "react";
+import Toast from "react-native-toast-message";
+import useDeviceLock from "../hooks/useDeviceCheck";
+import { zebraScanner } from "../lib/ZebraScanner";
 
 export default function RootLayout() {
+	useDeviceLock();
+	useEffect(() => {
+		zebraScanner.ensureProfile();
+	}, []);
+
 	return (
 		<>
 			<StatusBar style="dark" />
 			<Stack screenOptions={{ headerShown: false }}>
 				<Stack.Screen name="index" />
-				{/* <Stack.Screen name="(tabs)" /> */}
+				<Stack.Screen name="login" />
+				<Stack.Screen name="setup" />
+				<Stack.Screen name="updateScreen" />
+				<Stack.Screen name="(tabs)" />
 			</Stack>
+			<PortalHost />
+			<Toast />
 		</>
 	);
 }

lstMobile/src/app/blocked.tsx

@@ -1,9 +0,0 @@
-import { Text, View } from "react-native";
-
-export default function blocked() {
-	return (
-		<View>
-			<Text>Blocked</Text>
-		</View>
-	);
-}

lstMobile/src/app/index.tsx

@@ -1,71 +1,31 @@
-import { useRouter } from "expo-router";
-import { useEffect, useState } from "react";
+import { Redirect } from "expo-router";
 import { ActivityIndicator, Text, View } from "react-native";
-import { useAppStore } from "../hooks/useAppStore";
-import { devDelay } from "../lib/devMode";
+import { useAppStartup } from "../hooks/useAppStartup";
+
+const startupMessages = {
+	loading: "Loading app...",
+	validating: "Validating data...",
+	scannerMode: "Checking scanner mode...",
+	normalScanner: "Starting normal ALPLAprod scanner that has no LST rules",
+	checkingUpdates: "Checking for updates...",
+	opening: "Opening LST scan app...",
+	error: "Something went wrong during startup.",
+};
 
 export default function Index() {
-	const router = useRouter();
-	const [message, setMessage] = useState(<Text>Starting app...</Text>);
+	const { ready, startupRoute, status } = useAppStartup();
 
-	const hasHydrated = useAppStore((s) => s.hasHydrated);
-	const serverPort = useAppStore((s) => s.serverPort);
-	const hasValidSetup = useAppStore((s) => s.hasValidSetup);
+	if (ready && startupRoute) {
+		return <Redirect href={startupRoute as any} />;
+	}
 
-	useEffect(() => {
-		if (!hasHydrated) {
-			setMessage(<Text>Loading app...</Text>);
-			return;
-		}
-
-		const startup = async () => {
-			try {
-				await devDelay(1500);
-
-				setMessage(<Text>Validating data...</Text>);
-				await devDelay(1500);
-
-				if (!hasValidSetup()) {
-					router.replace("/setup");
-					return;
-				}
-
-				setMessage(<Text>Checking scanner mode...</Text>);
-				await devDelay(1500);
-
-				if (parseInt(serverPort || "0", 10) >= 50000) {
-					setMessage(
-						<Text>
-							Starting normal alplaprod scanner that has no LST rules
-						</Text>,
-					);
-					await devDelay(1500);
-					router.replace("/scanner");
-					return;
-				}
-
-				setMessage(<Text>Opening LST scan app</Text>);
-				await devDelay(3250);
-				router.replace("/scanner");
-			} catch (error) {
-				console.log("Startup error", error);
-				setMessage(<Text>Something went wrong during startup.</Text>);
-			}
-		};
-
-		startup();
-	}, [hasHydrated, hasValidSetup, serverPort, router]);
+	if (ready) {
+		return <Redirect href="/login" />;
+	}
 
 	return (
-		<View
-			style={{
-				flex: 1,
-				justifyContent: "center",
-				alignItems: "center",
-				marginTop: 12,
-			}}
-		>
-			{message}
+		<View style={{ flex: 1, justifyContent: "center", alignItems: "center" }}>
+			<Text>{startupMessages[status]}</Text>
 			<ActivityIndicator size="large" />
 		</View>
 	);