lst/lstV2/server/services/eom/controller/getHistoricalInvByDate.ts

import { format } from "date-fns";
import { eq, sql } from "drizzle-orm";
import { success } from "zod/v4";
import { db } from "../../../../database/dbclient.js";
import { invHistoricalData } from "../../../../database/schema/historicalINV.js";
import { settings } from "../../../../database/schema/settings.js";
import { tryCatch } from "../../../globalUtils/tryCatch.js";
import { createLog } from "../../logger/logger.js";
import { serverSettings } from "../../server/controller/settings/getSettings.js";
import { query } from "../../sqlServer/prodSqlServer.js";
import { activeArticle } from "../../sqlServer/querys/dataMart/article.js";
import { missingHistInv } from "../../sqlServer/querys/eom/missingHistInv.js";

const missingHistoricalData = async (date: string) => {
	const plantToken = serverSettings.filter((n) => n.name === "plantToken");
	const { data: inv, error: invError } = (await tryCatch(
		query(
			missingHistInv.replace("[eomHistDate]", date),
			"eom missing historical data",
		),
	)) as any;

	if (invError) {
		createLog("error", "eom", "eom", `There was an error getting the sql data`);
		return;
	}

	const { data: articles, error: avError } = (await tryCatch(
		query(activeArticle, "Get active articles"),
	)) as any;

	const av = articles.data.length > 0 ? articles.data : ([] as any);

	const importInv = inv.data ? inv.data : [];

	const remap = importInv.map((i: any) => {
		return {
			//histDate: sql`(NOW() - INTERVAL '1 day')::date`,
			histDate: date,
			plantToken: plantToken[0].value,
			article: i.article,
			articleDescription: i.articleDescription,
			materialType:
				av.filter((a: any) => a.IdArtikelvarianten === i.article).length > 0
					? av.filter((a: any) => a.IdArtikelvarianten === i.article)[0]
							?.TypeOfMaterial
					: "Item not defined",
			total_QTY: i.total_QTY,
			avaliable_QTY: 0,
			coa_QTY: 0,
			held_QTY: 0,
			consignment: 0,
			lot_Number: 0,
		};
	});

	const { data: dataImport, error: errorImport } = await tryCatch(
		db.insert(invHistoricalData).values(remap),
	);

	if (errorImport) {
		console.log(errorImport);
		createLog(
			"error",
			"eom",
			"eom",
			`There was an error importing all the inventory data.`,
		);
		return [];
	}

	if (dataImport) {
		createLog("info", "eom", "eom", `All data was imported successfully.`);

		return remap;
	}
};

function parseFlexibleDate(date: string): Date {
	const parts = date.replace(/[-.]/g, "/").split("/");
	if (parts.length !== 3) throw new Error("Invalid date format");

	let year: number, month: number, day: number;

	// find which index looks like a year
	if (parts[0].length === 4) {
		// yyyy/mm/dd
		year = +parts[0];
		month = +parts[1];
		day = +parts[2];
	} else if (parts[2].length === 4) {
		// mm/dd/yyyy
		year = +parts[2];
		month = +parts[0];
		day = +parts[1];
	} else {
		throw new Error("Cannot determine year position");
	}

	return new Date(year, month - 1, day);
}

export const historicalInvByDate = async (
	date: string,
	includePlantToken: boolean = false,
) => {
	console.log(date);
	// date format should always be yyyy-MM-dd or yyyy-MM-dd
	// let splitDate: string[];
	// if (date.includes("/")) {
	// 	splitDate = date.split("/");
	// } else if (date.includes("-")) {
	// 	splitDate = date.split("-");
	// } else {
	// 	return {
	// 		success: false,
	// 		message: "An invalid date was passed over",
	// 		data: [],
	// 	};
	// }

	// const year = parseInt(splitDate[0], 10);
	// const month = parseInt(splitDate[1], 10) - 1; // zero-based months
	// const day = parseInt(splitDate[2], 10);
	//const histDate = new Date(year, month, day);
	console.log(parseFlexibleDate(date));
	console.log(format(parseFlexibleDate(date), "yyyy-MM-dd"));
	const { data, error } = (await tryCatch(
		db
			.select()
			.from(invHistoricalData)
			.where(
				eq(
					invHistoricalData.histDate,
					format(parseFlexibleDate(date), "yyyy-MM-dd"),
				),
			),
	)) as any;

	if (error) {
		return {
			success: false,
			message: "There was an error with getting the inventory",
			data: error,
		};
	}

	if (includePlantToken) {
		const { data: s, error: se } = (await tryCatch(
			db.select().from(settings).where(eq(settings.name, "plantToken")),
		)) as any;

		if (se) {
			console.log("Error getting articles");
			return data;
		}

		if (data.length === 0) {
			// pass over the old lame

			return {
				success: true,
				message: `Historical inventory is missing for ${date}`,
				data: await missingHistoricalData(date),
			};
		}
		return {
			success: true,
			message: `Historical inventory for ${date}`,
			data: data.map((n: any) => {
				return { plantToken: s[0].value, ...n };
			}),
		};
	} else {
		if (data.length === 0) {
			// pass over the old lame
			//const oldData = missingHistoricalData(date)
			return {
				success: true,
				message: `Historical inventory is missing for ${date}`,
				data: await missingHistoricalData(date),
			};
		}
		return {
			success: true,
			message: `Historical inventory for ${date}`,
			data: data,
		};
	}
};