cowch/lst
1
0
Fork 0
Code Issues 6 Pull Requests Actions Packages Projects Releases Wiki Activity

feat(settings): added in settings

Browse Source
This commit is contained in:
cowchmonkey@gmail.com
2025-10-16 14:36:12 -05:00
parent f264c98fbf
commit a09ad8773c
14 changed files with 684 additions and 393 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
.vscode/settings.json vendored
View File

@@ -1,9 +1,11 @@
{ {
"editor.defaultFormatter": "biomejs.biome", "editor.defaultFormatter": "biomejs.biome",
"workbench.colorTheme": "Default Dark+", "workbench.colorTheme": "Default Dark+",
"terminal.integrated.env.windows": {}, "terminal.integrated.env.windows": {},
"editor.formatOnSave": true, "editor.formatOnSave": true,
"editor.codeActionsOnSave": {"source.fixAll.biome": "explicit", "editor.codeActionsOnSave": {
"source.organizeImports.biome": "explicit" }, "source.fixAll.biome": "explicit",
"cSpell.words": ["alpla", "alplamart", "alplaprod", "ppoo"] "source.organizeImports.biome": "explicit"
},
"cSpell.words": ["alpla", "alplamart", "alplaprod", "intiallally", "ppoo"]
} }

315
app/main.ts
View File

@@ -1,200 +1,201 @@
process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0"; process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
import { toNodeHandler } from "better-auth/node";
import cors from "cors";
import express from "express"; import express from "express";
import morgan from "morgan";
import { createServer } from "http"; import { createServer } from "http";
import { setupRoutes } from "./src/internal/routerHandler/routeHandler.js"; import morgan from "morgan";
import { printers } from "./src/internal/ocp/printers/printers.js"; import os from "os";
import { dirname, join } from "path"; import { dirname, join } from "path";
import { fileURLToPath } from "url"; import { fileURLToPath } from "url";
import { schedulerManager } from "./src/internal/logistics/controller/schedulerManager.js";
import { printers } from "./src/internal/ocp/printers/printers.js";
import { setupRoutes } from "./src/internal/routerHandler/routeHandler.js";
import { baseSettings } from "./src/internal/system/controller/settings/baseSettings.js";
import { auth } from "./src/pkg/auth/auth.js";
import { db } from "./src/pkg/db/db.js"; import { db } from "./src/pkg/db/db.js";
import { settings } from "./src/pkg/db/schema/settings.js"; import { settings } from "./src/pkg/db/schema/settings.js";
import { validateEnv } from "./src/pkg/utils/envValidator.js";
import { createLogger } from "./src/pkg/logger/logger.js"; import { createLogger } from "./src/pkg/logger/logger.js";
import { returnFunc } from "./src/pkg/utils/return.js"; import { v1Listener } from "./src/pkg/logger/v1Listener.js";
import { initializeProdPool } from "./src/pkg/prodSql/prodSqlConnect.js";
import { tryCatch } from "./src/pkg/utils/tryCatch.js";
import os from "os";
import cors from "cors";
import { sendNotify } from "./src/pkg/utils/notify.js";
import { toNodeHandler } from "better-auth/node";
import { auth } from "./src/pkg/auth/auth.js";
import { apiHitMiddleware } from "./src/pkg/middleware/apiHits.js"; import { apiHitMiddleware } from "./src/pkg/middleware/apiHits.js";
import { initializeProdPool } from "./src/pkg/prodSql/prodSqlConnect.js";
import { validateEnv } from "./src/pkg/utils/envValidator.js";
import { sendNotify } from "./src/pkg/utils/notify.js";
import { returnFunc } from "./src/pkg/utils/return.js";
import { tryCatch } from "./src/pkg/utils/tryCatch.js";
import { setupIoServer } from "./src/ws/server.js"; import { setupIoServer } from "./src/ws/server.js";
import { schedulerManager } from "./src/internal/logistics/controller/schedulerManager.js";
const main = async () => { const main = async () => {
const env = validateEnv(process.env); const env = validateEnv(process.env);
const PORT = Number(env.VITE_PORT) || 4200; const PORT = Number(env.VITE_PORT) || 4200;
//create the logger //create the logger
const log = createLogger({ module: "system", subModule: "main start" }); const log = createLogger({ module: "system", subModule: "main start" });
// base path // base path
let basePath: string = ""; let basePath: string = "";
const __filename = fileURLToPath(import.meta.url); const __filename = fileURLToPath(import.meta.url);
const __dirname = dirname(__filename); const __dirname = dirname(__filename);
// Db connection stuff // Db connection stuff
const res = await tryCatch(db.select().from(settings)); const res = await tryCatch(db.select().from(settings));
if (res.error) { if (res.error) {
return returnFunc({ return returnFunc({
success: false, success: false,
module: "system", module: "system",
level: "fatal", level: "fatal",
message: `Database lookup failed`, message: `Database lookup failed`,
notify: false, notify: false,
data: [], data: [],
}); });
} }
if (res.data.length === 0) { if (res.data.length === 0) {
//return //return
// returnFunc({ // returnFunc({
// success: false, // success: false,
// module: "system", // module: "system",
// level: "fatal", // level: "fatal",
// message: `This seems to be the first time you have started the app please validate the settings have been intiated`, // message: `This seems to be the first time you have started the app please validate the settings have been intiated`,
// notify: false, // notify: false,
// data: [], // data: [],
// }); // });
} }
// connect to the prod sql // connect to the prod sql
await initializeProdPool(); await initializeProdPool();
// express app // express app
const app = express(); const app = express();
// global env that run only in dev // global env that run only in dev
if (process.env.NODE_ENV?.trim() !== "production") { if (process.env.NODE_ENV?.trim() !== "production") {
app.use(morgan("tiny")); app.use(morgan("tiny"));
basePath = "/lst"; basePath = "/lst";
app.use( app.use(
basePath + "/test", basePath + "/test",
express.static(join(__dirname, "../controller")) express.static(join(__dirname, "../controller")),
); );
} }
// global middleware // global middleware
app.set("trust proxy", true); app.set("trust proxy", true);
app.use(apiHitMiddleware); app.use(apiHitMiddleware);
app.all(basePath + "/api/auth/*splat", toNodeHandler(auth)); // sign-in sign-out app.all(basePath + "/api/auth/*splat", toNodeHandler(auth)); // sign-in sign-out
app.use(express.json()); app.use(express.json());
const allowedOrigins = [ const allowedOrigins = [
/^https?:\/\/localhost:(5173|5500|4200|3000|4000)$/, // all the allowed backend ports /^https?:\/\/localhost:(5173|5500|4200|3000|4000)$/, // all the allowed backend ports
/^https?:\/\/.*\.alpla\.net$/, /^https?:\/\/.*\.alpla\.net$/,
env.BETTER_AUTH_URL, // prod env.BETTER_AUTH_URL, // prod
]; ];
app.use( app.use(
cors({ cors({
origin: (origin, callback) => { origin: (origin, callback) => {
//console.log("CORS request from origin:", origin); //console.log("CORS request from origin:", origin);
if (!origin) return callback(null, true); // allow same-site or direct calls if (!origin) return callback(null, true); // allow same-site or direct calls
try { try {
const hostname = new URL(origin).hostname; // strips protocol/port const hostname = new URL(origin).hostname; // strips protocol/port
//console.log("Parsed hostname:", hostname); //console.log("Parsed hostname:", hostname);
if (allowedOrigins.includes(origin)) { if (allowedOrigins.includes(origin)) {
return callback(null, true); return callback(null, true);
} }
// Now this works for *.alpla.net // Now this works for *.alpla.net
if ( if (hostname.endsWith(".alpla.net") || hostname === "alpla.net") {
hostname.endsWith(".alpla.net") || return callback(null, true);
hostname === "alpla.net" }
) { } catch (err) {
return callback(null, true); //console.error("Invalid Origin header:", origin);
} }
} catch (err) {
//console.error("Invalid Origin header:", origin);
}
return callback(new Error("Not allowed by CORS: " + origin)); return callback(new Error("Not allowed by CORS: " + origin));
}, },
methods: ["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS"], methods: ["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS"],
credentials: true, credentials: true,
}) }),
); );
// docs and api stuff // docs and api stuff
app.use( app.use(basePath + "/d", express.static(join(__dirname, "../lstDocs/build")));
basePath + "/d", app.use(
express.static(join(__dirname, "../lstDocs/build")) basePath + "/app",
); express.static(join(__dirname, "../frontend/dist")),
app.use( );
basePath + "/app",
express.static(join(__dirname, "../frontend/dist"))
);
// server setup // server setup
const server = createServer(app); const server = createServer(app);
// register app // register app
setupRoutes(app, basePath); setupRoutes(app, basePath);
// ws stuff // ws stuff
setupIoServer(server, basePath); setupIoServer(server, basePath);
// sub systems // start all systems after we are intiallally up and running
printers(); setTimeout(() => {
schedulerManager(); baseSettings();
printers();
schedulerManager();
// start the server up // start up the v1listener
server.listen(PORT, "0.0.0.0", () => v1Listener();
log.info( }, 5 * 1000);
{ stack: { name: "test" } },
`Server running in ${
process.env.NODE_ENV ? process.env.NODE_ENV : "dev"
}, on http://0.0.0.0:${PORT}${basePath}`
)
);
process.on("uncaughtException", async (err) => { // start the server up
//console.log("Uncaught Exception:", err); server.listen(PORT, "0.0.0.0", () =>
// await closePool(); log.info(
// const emailData = { { stack: { name: "test" } },
// email: "blake.matthes@alpla.com", // should be moved to the db so it can be reused. `Server running in ${
// subject: `${os.hostname()} has just encountered a crash.`, process.env.NODE_ENV ? process.env.NODE_ENV : "dev"
// template: "serverCrash", }, on http://0.0.0.0:${PORT}${basePath}`,
// context: { ),
// error: err, );
// plant: `${os.hostname()}`,
// },
// };
if (!process.env.WEBHOOK_URL) { process.on("uncaughtException", async (err) => {
// await sendEmail(emailData); //console.log("Uncaught Exception:", err);
} else { // await closePool();
log.fatal({ stack: err.stack }, err.message); // const emailData = {
await sendNotify({ // email: "blake.matthes@alpla.com", // should be moved to the db so it can be reused.
module: "system", // subject: `${os.hostname()} has just encountered a crash.`,
subModule: "fatalCrash", // template: "serverCrash",
hostname: os.hostname(), // context: {
message: err.message, // error: err,
stack: err?.stack, // plant: `${os.hostname()}`,
}); // },
} // };
//process.exit(1); if (!process.env.WEBHOOK_URL) {
}); // await sendEmail(emailData);
} else {
log.fatal({ stack: err.stack }, err.message);
await sendNotify({
module: "system",
subModule: "fatalCrash",
hostname: os.hostname(),
message: err.message,
stack: err?.stack,
});
}
// setInterval(() => { //process.exit(1);
// const used = process.memoryUsage(); });
// console.log(
// `Heap: ${(used.heapUsed / 1024 / 1024).toFixed(2)} MB / RSS: ${( // setInterval(() => {
// used.rss / // const used = process.memoryUsage();
// 1024 / // console.log(
// 1024 // `Heap: ${(used.heapUsed / 1024 / 1024).toFixed(2)} MB / RSS: ${(
// ).toFixed(2)} MB` // used.rss / 1024 / 1024
// ); // ).toFixed(2)} MB`,
// }, 10000); // );
// }, 10000);
}; };
main(); main();

22
app/src/internal/admin/controller/servers/matchServers.ts Normal file
View File

@@ -0,0 +1,22 @@
/**
* This is intended for when running as dev so we can always keep the servers in sync with the main server.
* in the event the server has a change on it we want to make sure we stay in sync
*/
import { createLogger } from "../../../../pkg/logger/logger.js";
export const mainServerSync = async () => {
const log = createLogger({ module: "admin", subModule: "main server sync" });
if (
process.env.NODE_ENV?.trim() !== "production" &&
process.env.MAIN_SERVER
) {
log.info(
{},
"Running in dev and have a main server set we will now pull the servers and look for any changes",
);
} else {
log.info({}, "This server is running in production no sync will happen");
return;
}
};

7
app/src/internal/admin/routes.ts
View File

@@ -1,6 +1,6 @@
import type { Express, Request, Response } from "express"; import type { Express, Request, Response } from "express";
import { requireAuth } from "../../pkg/middleware/authMiddleware.js"; import { requireAuth } from "../../pkg/middleware/authMiddleware.js";
import { mainServerSync } from "./controller/servers/matchServers.js";
//admin routes //admin routes
import users from "./routes/getUserRoles.js"; import users from "./routes/getUserRoles.js";
import grantRoles from "./routes/grantRole.js"; import grantRoles from "./routes/grantRole.js";
@@ -30,4 +30,9 @@ export const setupAdminRoutes = (app: Express, basePath: string) => {
requireAuth("user", ["systemAdmin", "admin"]), // will pass bc system admin but this is just telling us we need this requireAuth("user", ["systemAdmin", "admin"]), // will pass bc system admin but this is just telling us we need this
revokeRoles, revokeRoles,
); );
// run the sync only on startup
setTimeout(() => {
mainServerSync();
}, 5 * 1000);
}; };

170
app/src/internal/admin/routes/servers/addServer.ts
View File

@@ -1,100 +1,106 @@
import { Router } from "express";
import type { Request, Response } from "express";
import {
insertServerDataSchema,
serverData,
} from "../../../../pkg/db/schema/servers.js";
import { db } from "../../../../pkg/db/db.js";
import { tryCatch } from "../../../../pkg/utils/tryCatch.js";
import type { DrizzleError } from "drizzle-orm";
import axios from "axios"; import axios from "axios";
import { createLogger } from "../../../../pkg/logger/logger.js"; import { type DrizzleError, sql } from "drizzle-orm";
import type { Request, Response } from "express";
import { Router } from "express";
import https from "https"; import https from "https";
import { db } from "../../../../pkg/db/db.js";
import {
insertServerDataSchema,
serverData,
} from "../../../../pkg/db/schema/servers.js";
import { createLogger } from "../../../../pkg/logger/logger.js";
import { tryCatch } from "../../../../pkg/utils/tryCatch.js";
const router = Router(); const router = Router();
router.post("/", async (req: Request, res: Response) => { router.post("/", async (req: Request, res: Response) => {
// when a new server is posted from localhost or 127.0.0.1 we also want to post it to the test server so we can see it from there // when a new server is posted from localhost or 127.0.0.1 we also want to post it to the test server so we can see it from there
//res.status(200).json({ message: "Server added", ip: req.hostname }); //res.status(200).json({ message: "Server added", ip: req.hostname });
const log = createLogger({ module: "admin", subModule: "add server" }); const log = createLogger({ module: "admin", subModule: "add server" });
const parsed = insertServerDataSchema.safeParse(req.body); const parsed = insertServerDataSchema.safeParse(req.body);
if (!parsed.success) { if (!parsed.success) {
return res.status(400).json({ errors: parsed.error.flatten() }); return res.status(400).json({ errors: parsed.error.flatten() });
} }
const { data, error } = await tryCatch( const { data, error } = await tryCatch(
db db
.insert(serverData) .insert(serverData)
.values(parsed.data) .values({
//.onConflictDoNothing() ...parsed.data,
.returning({ add_user: req.user?.username,
name: serverData.name, add_date: sql`NOW()`,
plantToken: serverData.plantToken, upd_user: req.user?.username,
}) upd_date: sql`NOW()`,
); })
//.onConflictDoNothing()
.returning({
name: serverData.name,
plantToken: serverData.plantToken,
}),
);
if (error) { if (error) {
const err: DrizzleError = error; const err: DrizzleError = error;
return res.status(400).json({ return res.status(400).json({
message: `Error adding the server`, message: `Error adding the server`,
error: err.cause, error: err.cause,
}); });
} }
if (req.hostname === "localhost" && process.env.MAIN_SERVER) { if (req.hostname === "localhost" && process.env.MAIN_SERVER) {
log.info({}, "Running in dev server about to add in a new server"); log.info({}, "Running in dev server about to add in a new server");
const axiosInstance = axios.create({ const axiosInstance = axios.create({
httpsAgent: new https.Agent({ rejectUnauthorized: false }), httpsAgent: new https.Agent({ rejectUnauthorized: false }),
baseURL: process.env.MAIN_SERVER, // e.g. "https://example.com" baseURL: process.env.MAIN_SERVER, // e.g. "https://example.com"
withCredentials: true, withCredentials: true,
}); });
const loginRes = (await axiosInstance.post( const loginRes = (await axiosInstance.post(
`${process.env.MAIN_SERVER}/lst/api/auth/sign-in/username`, `${process.env.MAIN_SERVER}/lst/api/auth/sign-in/username`,
{ {
username: process.env.MAIN_SERVER_USERNAME, username: process.env.MAIN_SERVER_USERNAME,
password: process.env.MAIN_SERVER_PASSWORD, password: process.env.MAIN_SERVER_PASSWORD,
}, },
{ {
headers: { "Content-Type": "application/json" }, headers: { "Content-Type": "application/json" },
} },
)) as any; )) as any;
const setCookie = loginRes.headers["set-cookie"][0]; const setCookie = loginRes.headers["set-cookie"][0];
if (!setCookie) { if (!setCookie) {
throw new Error("Did not receive a Set-Cookie header from login"); throw new Error("Did not receive a Set-Cookie header from login");
} }
const { data, error } = await tryCatch( const { data, error } = await tryCatch(
axios.post( axios.post(
`${process.env.MAIN_SERVER}/lst/api/admin/server`, `${process.env.MAIN_SERVER}/lst/api/admin/server`,
parsed.data, parsed.data,
{ {
headers: { headers: {
"Content-Type": "application/json", "Content-Type": "application/json",
Cookie: setCookie.split(";")[0], Cookie: setCookie.split(";")[0],
}, },
withCredentials: true, withCredentials: true,
} },
) ),
); );
if (error) { if (error) {
log.error( log.error(
{ stack: error }, { stack: error },
"There was an error adding the server to Main Server" "There was an error adding the server to Main Server",
); );
} }
log.info( log.info(
{ stack: data?.data }, { stack: data?.data },
"A new Server was just added to the server." "A new Server was just added to the server.",
); );
} }
return res return res
.status(201) .status(201)
.json({ message: `Server ${data[0]?.name} added`, data: data }); .json({ message: `Server ${data[0]?.name} added`, data: data });
}); });
export default router; export default router;

220
app/src/internal/admin/routes/servers/updateServer.ts
View File

@@ -1,139 +1,141 @@
import { Router } from "express"; import axios from "axios";
import { eq, sql } from "drizzle-orm";
import type { Request, Response } from "express"; import type { Request, Response } from "express";
import { Router } from "express";
import https from "https";
import { db } from "../../../../pkg/db/db.js"; import { db } from "../../../../pkg/db/db.js";
import { serverData } from "../../../../pkg/db/schema/servers.js"; import { serverData } from "../../../../pkg/db/schema/servers.js";
import { eq } from "drizzle-orm";
import { tryCatch } from "../../../../pkg/utils/tryCatch.js";
import axios from "axios";
import { createLogger } from "../../../../pkg/logger/logger.js"; import { createLogger } from "../../../../pkg/logger/logger.js";
import https from "https"; import { tryCatch } from "../../../../pkg/utils/tryCatch.js";
const router = Router(); const router = Router();
router.patch("/:token", async (req: Request, res: Response) => { router.patch("/:token", async (req: Request, res: Response) => {
const log = createLogger({ module: "admin", subModule: "update server" }); const log = createLogger({ module: "admin", subModule: "update server" });
// when a server is updated and is posted from localhost or 127.0.0.1 we also want to post it to the test server so we can see it from there, we want to insert with update on conflict. // when a server is updated and is posted from localhost or 127.0.0.1 we also want to post it to the test server so we can see it from there, we want to insert with update on conflict.
const token = req.params.token; const token = req.params.token;
const updates: Record<string, any> = {}; const updates: Record<string, any> = {};
if (req.body?.name !== undefined) { if (req.body?.name !== undefined) {
updates.name = req.body.name; updates.name = req.body.name;
} }
if (req.body?.serverDNS !== undefined) { if (req.body?.serverDNS !== undefined) {
updates.serverDNS = req.body.serverDNS; updates.serverDNS = req.body.serverDNS;
} }
if (req.body?.ipAddress !== undefined) { if (req.body?.ipAddress !== undefined) {
updates.ipAddress = req.body.ipAddress; updates.ipAddress = req.body.ipAddress;
} }
if (req.body?.greatPlainsPlantCode !== undefined) { if (req.body?.greatPlainsPlantCode !== undefined) {
updates.greatPlainsPlantCode = req.body.greatPlainsPlantCode; updates.greatPlainsPlantCode = req.body.greatPlainsPlantCode;
} }
if (req.body?.lstServerPort !== undefined) { if (req.body?.lstServerPort !== undefined) {
updates.lstServerPort = req.body.lstServerPort; updates.lstServerPort = req.body.lstServerPort;
} }
if (req.body?.serverLoc !== undefined) { if (req.body?.serverLoc !== undefined) {
updates.serverLoc = req.body.serverLoc; updates.serverLoc = req.body.serverLoc;
} }
if (req.body?.streetAddress !== undefined) { if (req.body?.streetAddress !== undefined) {
updates.streetAddress = req.body.streetAddress; updates.streetAddress = req.body.streetAddress;
} }
if (req.body?.cityState !== undefined) { if (req.body?.cityState !== undefined) {
updates.cityState = req.body.cityState; updates.cityState = req.body.cityState;
} }
if (req.body?.zipcode !== undefined) { if (req.body?.zipcode !== undefined) {
updates.zipcode = req.body.zipcode; updates.zipcode = req.body.zipcode;
} }
if (req.body?.contactEmail !== undefined) { if (req.body?.contactEmail !== undefined) {
updates.contactEmail = req.body.contactEmail; updates.contactEmail = req.body.contactEmail;
} }
if (req.body?.contactPhone !== undefined) { if (req.body?.contactPhone !== undefined) {
updates.contactPhone = req.body.contactPhone; updates.contactPhone = req.body.contactPhone;
} }
if (req.body?.customerTiAcc !== undefined) { if (req.body?.customerTiAcc !== undefined) {
updates.customerTiAcc = req.body.customerTiAcc; updates.customerTiAcc = req.body.customerTiAcc;
} }
if (req.body?.active !== undefined) { if (req.body?.active !== undefined) {
updates.active = req.body.active; updates.active = req.body.active;
} }
try {
if (Object.keys(updates).length > 0) {
await db
.update(serverData)
.set(updates)
.where(eq(serverData.plantToken, token));
}
if (req.hostname === "localhost" && process.env.MAIN_SERVER) { updates.upd_user = req.user!.username || "lst_user";
log.info({}, "Running in dev server about to add in a new server"); updates.upd_date = sql`NOW()`;
const axiosInstance = axios.create({
httpsAgent: new https.Agent({ rejectUnauthorized: false }),
baseURL: process.env.MAIN_SERVER,
withCredentials: true,
});
const loginRes = (await axiosInstance.post( try {
`${process.env.MAIN_SERVER}/lst/api/auth/sign-in/username`, if (Object.keys(updates).length > 0) {
{ await db
username: process.env.MAIN_SERVER_USERNAME, .update(serverData)
password: process.env.MAIN_SERVER_PASSWORD, .set(updates)
}, .where(eq(serverData.plantToken, token));
{ }
headers: { "Content-Type": "application/json" },
}
)) as any;
const setCookie = loginRes?.headers["set-cookie"][0]; if (req.hostname === "localhost" && process.env.MAIN_SERVER) {
log.info({}, "Running in dev server about to add in a new server");
const axiosInstance = axios.create({
httpsAgent: new https.Agent({ rejectUnauthorized: false }),
baseURL: process.env.MAIN_SERVER,
withCredentials: true,
});
//console.log(setCookie.split(";")[0].replace("__Secure-", "")); const loginRes = (await axiosInstance.post(
`${process.env.MAIN_SERVER}/lst/api/auth/sign-in/username`,
{
username: process.env.MAIN_SERVER_USERNAME,
password: process.env.MAIN_SERVER_PASSWORD,
},
{
headers: { "Content-Type": "application/json" },
},
)) as any;
if (!setCookie) { const setCookie = loginRes?.headers["set-cookie"][0];
throw new Error(
"Did not receive a Set-Cookie header from login"
);
}
const { data, error } = await tryCatch( //console.log(setCookie.split(";")[0].replace("__Secure-", ""));
axios.patch(
`${process.env.MAIN_SERVER}/lst/api/admin/server/${token}`,
updates,
{
headers: {
"Content-Type": "application/json",
Cookie: setCookie.split(";")[0],
},
withCredentials: true,
}
)
);
if (error) { if (!setCookie) {
console.log(error); throw new Error("Did not receive a Set-Cookie header from login");
log.error( }
{ stack: error },
"There was an error adding the server to Main Server" const { data, error } = await tryCatch(
); axios.patch(
} `${process.env.MAIN_SERVER}/lst/api/admin/server/${token}`,
log.info( updates,
{ stack: data?.data }, {
"A new Server was just added to the server." headers: {
); "Content-Type": "application/json",
} Cookie: setCookie.split(";")[0],
res.status(200).json({ message: `${token} Server was just updated` }); },
} catch (error) { withCredentials: true,
console.log(error); },
res.status(400).json({ message: "Error Server updated", error }); ),
} );
if (error) {
console.log(error);
log.error(
{ stack: error },
"There was an error adding the server to Main Server",
);
}
log.info(
{ stack: data?.data },
"A new Server was just added to the server.",
);
}
res.status(200).json({ message: `${token} Server was just updated` });
} catch (error) {
console.log(error);
res.status(400).json({ message: "Error Server updated", error });
}
}); });
export default router; export default router;

37
app/src/internal/system/controller/settings/baseSettings.ts Normal file
View File

@@ -0,0 +1,37 @@
/**
* will be all the base settings so we dont have to remember to add ever new setting in these will be the defaults
*/
import { readFileSync } from "fs";
import path from "path";
import { fileURLToPath } from "url";
import { db } from "../../../../pkg/db/db.js";
import { settings } from "../../../../pkg/db/schema/settings.js";
import { createLogger } from "../../../../pkg/logger/logger.js";
import { tryCatch } from "../../../../pkg/utils/tryCatch.js";
const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);
export const baseSettings = async () => {
const log = createLogger({ module: "system", subModule: "base settings" });
const settingsPath = path.resolve(__dirname, "./settings.json");
const newSettings = JSON.parse(readFileSync(settingsPath, "utf-8"));
const { data, error } = await tryCatch(
db
.insert(settings)
.values(newSettings)
.onConflictDoNothing()
.returning({ name: settings.name }),
);
if (error) {
log.error({ error }, "There was an error adding new settings");
}
if (data) {
log.info({ newSettingsAdded: data }, "New settings added");
}
};

16
app/src/internal/system/controller/settings/settings.json Normal file
View File

@@ -0,0 +1,16 @@
[
{
"name": "plantToken",
"value": "test3",
"description": "The plant token for the plant IE: test3 or usday1",
"moduleName": "system",
"roles": ["systemAdmin"]
},
{
"name": "dbServer",
"value": "usmcd1vms036",
"description": "What is the db server",
"moduleName": "system",
"roles": ["systemAdmin"]
}
]

8
app/src/internal/system/routes.ts
View File

@@ -1,6 +1,12 @@
import type { Express, Request, Response } from "express"; import type { Express, Request, Response } from "express";
import settings from "./routes/settings/settingRoutes.js";
import stats from "./routes/stats.js"; import stats from "./routes/stats.js";
export const setupSystemRoutes = (app: Express, basePath: string) => { export const setupSystemRoutes = (app: Express, basePath: string) => {
app.use(basePath + "/api/system/stats", stats); app.use(basePath + "/api/system/stats", stats);
app.use(
basePath + "/api/system/settings", // will pass bc system admin but this is just telling us we need this
settings,
);
}; };

35
app/src/internal/system/routes/settings/getSettings.ts Normal file
View File

@@ -0,0 +1,35 @@
import { Router } from "express";
import type { Request, Response } from "express";
import { tryCatch } from "../../../../pkg/utils/tryCatch.js";
import { db } from "../../../../pkg/db/db.js";
import { serverData } from "../../../../pkg/db/schema/servers.js";
import { and, asc, eq } from "drizzle-orm";
const router = Router();
router.get("/", async (req: Request, res: Response) => {
const token = req.query.token;
const conditions = [];
if (token !== undefined) {
conditions.push(eq(serverData.plantToken, `${token}`));
}
conditions.push(eq(serverData.active, true));
const { data, error } = await tryCatch(
db
.select()
.from(serverData)
.where(and(...conditions))
.orderBy(asc(serverData.name))
);
if (error) {
return res.status(400).json({ error: error });
}
res.status(200).json({ message: "Current Active server", data: data });
});
export default router;

11
app/src/internal/system/routes/settings/settingRoutes.ts Normal file
View File

@@ -0,0 +1,11 @@
import { Router } from "express";
import { requireAuth } from "../../../../pkg/middleware/authMiddleware.js";
import getSettings from "./getSettings.js";
import updateSetting from "./updateSetting.js";
const router = Router();
router.use("/", getSettings);
router.use("/", requireAuth("system", ["systemAdmin", "admin"]), updateSetting);
export default router;

141
app/src/internal/system/routes/settings/updateSetting.ts Normal file
View File

@@ -0,0 +1,141 @@
import axios from "axios";
import { eq, sql } from "drizzle-orm";
import type { Request, Response } from "express";
import { Router } from "express";
import https from "https";
import { db } from "../../../../pkg/db/db.js";
import { serverData } from "../../../../pkg/db/schema/servers.js";
import { createLogger } from "../../../../pkg/logger/logger.js";
import { tryCatch } from "../../../../pkg/utils/tryCatch.js";
const router = Router();
router.patch("/:token", async (req: Request, res: Response) => {
const log = createLogger({ module: "admin", subModule: "update server" });
// when a server is updated and is posted from localhost or 127.0.0.1 we also want to post it to the test server so we can see it from there, we want to insert with update on conflict.
const token = req.params.token;
const updates: Record<string, any> = {};
if (req.body?.name !== undefined) {
updates.name = req.body.name;
}
if (req.body?.serverDNS !== undefined) {
updates.serverDNS = req.body.serverDNS;
}
if (req.body?.ipAddress !== undefined) {
updates.ipAddress = req.body.ipAddress;
}
if (req.body?.greatPlainsPlantCode !== undefined) {
updates.greatPlainsPlantCode = req.body.greatPlainsPlantCode;
}
if (req.body?.lstServerPort !== undefined) {
updates.lstServerPort = req.body.lstServerPort;
}
if (req.body?.serverLoc !== undefined) {
updates.serverLoc = req.body.serverLoc;
}
if (req.body?.streetAddress !== undefined) {
updates.streetAddress = req.body.streetAddress;
}
if (req.body?.cityState !== undefined) {
updates.cityState = req.body.cityState;
}
if (req.body?.zipcode !== undefined) {
updates.zipcode = req.body.zipcode;
}
if (req.body?.contactEmail !== undefined) {
updates.contactEmail = req.body.contactEmail;
}
if (req.body?.contactPhone !== undefined) {
updates.contactPhone = req.body.contactPhone;
}
if (req.body?.customerTiAcc !== undefined) {
updates.customerTiAcc = req.body.customerTiAcc;
}
if (req.body?.active !== undefined) {
updates.active = req.body.active;
}
updates.upd_user = req.user!.username || "lst_user";
updates.upd_date = sql`NOW()`;
try {
if (Object.keys(updates).length > 0) {
await db
.update(serverData)
.set(updates)
.where(eq(serverData.plantToken, token));
}
if (req.hostname === "localhost" && process.env.MAIN_SERVER) {
log.info({}, "Running in dev server about to add in a new server");
const axiosInstance = axios.create({
httpsAgent: new https.Agent({ rejectUnauthorized: false }),
baseURL: process.env.MAIN_SERVER,
withCredentials: true,
});
const loginRes = (await axiosInstance.post(
`${process.env.MAIN_SERVER}/lst/api/auth/sign-in/username`,
{
username: process.env.MAIN_SERVER_USERNAME,
password: process.env.MAIN_SERVER_PASSWORD,
},
{
headers: { "Content-Type": "application/json" },
},
)) as any;
const setCookie = loginRes?.headers["set-cookie"][0];
//console.log(setCookie.split(";")[0].replace("__Secure-", ""));
if (!setCookie) {
throw new Error("Did not receive a Set-Cookie header from login");
}
const { data, error } = await tryCatch(
axios.patch(
`${process.env.MAIN_SERVER}/lst/api/admin/server/${token}`,
updates,
{
headers: {
"Content-Type": "application/json",
Cookie: setCookie.split(";")[0],
},
withCredentials: true,
},
),
);
if (error) {
console.log(error);
log.error(
{ stack: error },
"There was an error adding the server to Main Server",
);
}
log.info(
{ stack: data?.data },
"A new Server was just added to the server.",
);
}
res.status(200).json({ message: `${token} Server was just updated` });
} catch (error) {
console.log(error);
res.status(400).json({ message: "Error Server updated", error });
}
});
export default router;

76
app/src/pkg/db/schema/servers.ts
View File

@@ -1,49 +1,53 @@
import { import {
boolean, boolean,
integer, integer,
pgTable, pgTable,
text, text,
timestamp, timestamp,
uniqueIndex, uniqueIndex,
uuid, uuid,
} from "drizzle-orm/pg-core"; } from "drizzle-orm/pg-core";
import { createInsertSchema, createSelectSchema } from "drizzle-zod"; import { createInsertSchema, createSelectSchema } from "drizzle-zod";
import z from "zod"; import z from "zod";
export const serverData = pgTable( export const serverData = pgTable(
"serverData", "serverData",
{ {
server_id: uuid("server_id").defaultRandom().primaryKey(), server_id: uuid("server_id").defaultRandom().primaryKey(),
name: text("name").notNull(), name: text("name").notNull(),
serverDNS: text("serverDNS").notNull(), serverDNS: text("serverDNS").notNull(),
plantToken: text("plantToken").notNull(), plantToken: text("plantToken").notNull(),
ipAddress: text("ipAddress").notNull(), ipAddress: text("ipAddress").notNull(),
greatPlainsPlantCode: integer("greatPlainsPlantCode").notNull(), greatPlainsPlantCode: integer("greatPlainsPlantCode").notNull(),
streetAddress: text("streetAddress"), streetAddress: text("streetAddress"),
cityState: text("cityState"), cityState: text("cityState"),
zipcode: integer("zipcode"), zipcode: integer("zipcode"),
contactEmail: text("contactEmail"), contactEmail: text("contactEmail"),
contactPhone: text("contactPhone"), contactPhone: text("contactPhone"),
customerTiAcc: text("customerTiAcc"), customerTiAcc: text("customerTiAcc"),
lstServerPort: integer("lstServerPort").notNull(), lstServerPort: integer("lstServerPort").notNull(),
active: boolean("active").default(true), active: boolean("active").default(true),
serverLoc: text("serverLoc").notNull(), serverLoc: text("serverLoc").notNull(),
lastUpdated: timestamp("lastUpdated").defaultNow(), lastUpdated: timestamp("lastUpdated").defaultNow(),
isUpgrading: boolean("isUpgrading").default(false), isUpgrading: boolean("isUpgrading").default(false),
}, add_user: text("add_user").default("lst_user"),
add_date: timestamp("add_date").defaultNow(),
upd_user: text("upd_user").default("lst_user"),
upd_date: timestamp("upd_date").defaultNow(),
},
(table) => [ (table) => [
// uniqueIndex('emailUniqueIndex').on(sql`lower(${table.email})`), // uniqueIndex('emailUniqueIndex').on(sql`lower(${table.email})`),
uniqueIndex("plantToken").on(table.plantToken), uniqueIndex("plantToken").on(table.plantToken),
] ],
); );
export const selectServerDataSchema = createSelectSchema(serverData); export const selectServerDataSchema = createSelectSchema(serverData);
export const insertServerDataSchema = createInsertSchema(serverData).extend({ export const insertServerDataSchema = createInsertSchema(serverData).extend({
contactEmail: z.email().optional(), contactEmail: z.email().optional(),
// zipcode: z // zipcode: z
// .string() // .string()
// .regex(/^\d{5}$/) // .regex(/^\d{5}$/)
// .optional(), // .optional(),
}); });

3
app/src/pkg/utils/delay.ts Normal file
View File

@@ -0,0 +1,3 @@
export const delay = (ms: number) => {
return new Promise((resolve) => setTimeout(resolve, ms));
};