indas-ui 0.0.1 → 0.1.0

package/dist/lib/api/estimation/grid-costing.js

@@ -0,0 +1,126 @@
+'use client';
+// Grid Costing API
+// Uses direct fetch for file upload (multipart/form-data)
+// Uses APIClient for JSON endpoints (save/load)
+import APIClient, { handleSessionExpired } from '../core/client.js';
+import { buildAPIURL } from '../core/config.js';
+// ─── Import: file upload via direct fetch ─────────────────────────────
+export async function importGridCostingExcel(file, session) {
+    try {
+        const formData = new FormData();
+        formData.append('file', file);
+        const url = buildAPIURL('/api/grid-costing/import');
+        if (!url) {
+            return { success: false, error: 'API configuration not set. Please configure the API connection.' };
+        }
+        // Build auth headers (same as APIClient)
+        const headers = {};
+        const companyUsername = session?.user?.companyUsername;
+        const companyPassword = session?.user?.companyPassword;
+        if (companyUsername && companyPassword) {
+            headers['Authorization'] = `Basic ${btoa(`${companyUsername}:${companyPassword}`)}`;
+        }
+        const companyId = session?.user?.CompanyID || session?.user?.companyID;
+        if (companyId)
+            headers['CompanyID'] = companyId.toString();
+        const userId = session?.user?.UserID || session?.user?.userID;
+        if (userId)
+            headers['UserID'] = userId.toString();
+        const productionUnitId = session?.productionUnitId ||
+            session?.user?.ProductionUnitID || session?.user?.productionUnitID;
+        if (productionUnitId)
+            headers['ProductionUnitID'] = productionUnitId.toString();
+        const fYear = session?.fYear || session?.user?.FYear || session?.user?.fYear;
+        if (fYear)
+            headers['FYear'] = fYear;
+        // No Content-Type — browser sets multipart/form-data with boundary
+        // 120s timeout for large Excel files
+        const response = await fetch(url, {
+            method: 'POST',
+            headers,
+            body: formData,
+            signal: AbortSignal.timeout(120000),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            if (response.status === 401 || errorText?.toLowerCase().includes('session not found')) {
+                handleSessionExpired();
+                return { success: false, error: 'Session expired. Redirecting to login...', status: response.status };
+            }
+            return { success: false, error: errorText || `Import failed: ${response.status}`, status: response.status };
+        }
+        const data = await response.json();
+        // Backend may return { error: "..." } on validation failure
+        if (data.error) {
+            return { success: false, error: data.error };
+        }
+        return { success: true, data };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to import Excel file',
+        };
+    }
+}
+// ─── Save: JSON via APIClient ─────────────────────────────────────────
+export async function saveGridCosting(payload, session) {
+    return APIClient.post('/api/grid-costing/save', payload, session);
+}
+// ─── Load list: JSON via APIClient ────────────────────────────────────
+export async function getGridCostingList(session) {
+    return APIClient.get('/api/grid-costing', session);
+}
+// ─── Load by ID: JSON via APIClient ───────────────────────────────────
+export async function getGridCostingById(id, session) {
+    return APIClient.get(`/api/grid-costing/${id}`, session);
+}
+/** Calculate costing for a single row — payload must match Shirin_Job input shape */
+export async function calculateGridCosting(payload, session) {
+    return APIClient.post('/api/grid-costing/calculate', { payload }, session);
+}
+/** Calculate costing for multiple rows in parallel (backend batches up to 10 concurrent) */
+export async function calculateGridCostingBatch(rows, session) {
+    return APIClient.post('/api/grid-costing/calculate-batch', { rows }, session);
+}
+/** Calculate costing for multiple jobs via BulkShirinJob (planwindow) */
+export async function bulkShirinJob(jobs, session) {
+    return APIClient.post('api/planwindow/BulkShirinJob', jobs, session);
+}
+export async function startBulkCosting(jobs, session) {
+    return APIClient.post('api/BulkCosting/start', jobs, session);
+}
+export async function getBulkCostingStatus(jobId, session) {
+    return APIClient.get(`api/BulkCosting/${jobId}/status`, session);
+}
+export async function getBulkCostingPreview(jobId, session, page = 1, pageSize = 20) {
+    return APIClient.get(`api/BulkCosting/${jobId}/preview?page=${page}&pageSize=${pageSize}`, session);
+}
+export async function getBulkCostingCategoryCombination(categoryId, contentId, session, rateTier = 'L1') {
+    const tierQuery = rateTier === 'L2' ? '?rateTier=L2' : '';
+    return APIClient.get(`api/BulkCosting/category/${categoryId}/content/${contentId}/combination${tierQuery}`, session);
+}
+/**
+ * Enqueue an async save batch for a completed bulk-costing job. Returns
+ * immediately with a saveBatchId. Use getBulkCostingSaveStatus to poll.
+ * Empty body = save all; { jobIndexes: [...] } = save selected jobs only.
+ */
+export async function saveBulkCosting(jobId, session, jobIndexes) {
+    const body = jobIndexes && jobIndexes.length > 0 ? { jobIndexes } : {};
+    return APIClient.post(`api/BulkCosting/${jobId}/save`, body, session);
+}
+export async function getBulkCostingSaveStatus(saveBatchId, session) {
+    return APIClient.get(`api/BulkCosting/save/${saveBatchId}/status`, session);
+}
+/**
+ * Validate + resolve import rows in a single round-trip.
+ * The backend loads master tables once (filtered by CompanyID) and resolves
+ * name → ID in-memory. Returns per-row validity + resolved IDs + error list.
+ */
+export async function validateBatchAPI(rows, session) {
+    return APIClient.post('/api/grid-costing/validate-batch', { rows }, session);
+}
+/** Delete a saved grid costing session */
+export async function deleteGridCosting(id, session) {
+    return APIClient.post('/api/grid-costing/delete', { sessionID: id }, session);
+}

package/dist/lib/api/estimation/index.d.ts

@@ -0,0 +1,10 @@
+export { getCategoriesAPI, getClientsAPI, getSalesPersonsAPI, getSalesPersonForClientAPI } from './categories.js';
+export { getQualitiesAPI, getGSMAPI, getMillAPI, getFinishAPI, getCoatingAPI, getBFAPI, getBoardBrandAPI, getPaperCombinationsAPI, getCertificationTypesAPI, getQuoteDefaultsAPI, getMaterialRateAPI, type BFData, type PaperCombinationRow, type CertificationType, type QuoteDefaults } from './qualities.js';
+export { getMachineGridAPI } from './machines.js';
+export { ContentAPI, type ContentItem, type ParsedContentSizes, type DisplayContent } from './content.js';
+export { LoadOperationsAPI, PlanWindowAPI, getMachineAllocatedItemList, getProcessAllocatedItemList, calculateFlapDimensions, type MachineAllocatedItem, type ShirinJobMasterRequest, type ShirinJobMasterResponse, type JobSizeObject, type TblPlanningItem, type TblOperationsItem, type TblBookFormsItem, type CalculateFlapDimensionsRequest, type CalculateFlapDimensionsResponse } from './planning.js';
+export { handleAPIResponse } from '../core/utils.js';
+export { QuotationAPI } from './quotepanel.js';
+export { saveQuotationAPI, uploadQuotationFilesAPI, QuotationSaveAPI, type TblBookingData, type SaveQuotationPayload } from './quotation-save.js';
+export { calculateShipperPlan, calculateContainerPlanning, loadContainerMasters, loadPalletMasters, loadShipperMasters, } from './shipper-planning.js';
+export { getFreightLocations, type FreightLocation } from './freight.js';

package/dist/lib/api/estimation/index.js

@@ -0,0 +1,22 @@
+'use client';
+// Estimation API exports
+// Central export point for all estimation-related APIs
+// Export category APIs
+export { getCategoriesAPI, getClientsAPI, getSalesPersonsAPI, getSalesPersonForClientAPI } from './categories.js';
+// Export quality APIs
+export { getQualitiesAPI, getGSMAPI, getMillAPI, getFinishAPI, getCoatingAPI, getBFAPI, getBoardBrandAPI, getPaperCombinationsAPI, getCertificationTypesAPI, getQuoteDefaultsAPI, getMaterialRateAPI } from './qualities.js';
+// Export machine APIs
+export { getMachineGridAPI } from './machines.js';
+// Export content API
+export { ContentAPI } from './content.js';
+// Export planning APIs (includes Shirin Job Master)
+export { LoadOperationsAPI, PlanWindowAPI, getMachineAllocatedItemList, getProcessAllocatedItemList, calculateFlapDimensions } from './planning.js';
+export { handleAPIResponse } from '../core/utils.js';
+// Export quote panel APIs
+export { QuotationAPI } from './quotepanel.js';
+// Export quotation save APIs
+export { saveQuotationAPI, uploadQuotationFilesAPI, QuotationSaveAPI } from './quotation-save.js';
+// Export shipper planning APIs
+export { calculateShipperPlan, calculateContainerPlanning, loadContainerMasters, loadPalletMasters, loadShipperMasters, } from './shipper-planning.js';
+// Export freight APIs
+export { getFreightLocations } from './freight.js';

package/dist/lib/api/estimation/legacy-costing.d.ts

@@ -0,0 +1,42 @@
+export declare const LEGACY_COSTING_CODE = "LegacyCosting";
+/**
+ * Row shape returned by the external legacy software — passed through as-is.
+ * All numerics arrive as strings; `rate` is absent on some rows; `job_date`
+ * can be "NaN/NaN/NaN".
+ */
+export interface LegacyCostingJob {
+    job_no: string;
+    job_date: string | null;
+    job_design: string | null;
+    customer_name: string | null;
+    product_name: string | null;
+    product_code: string | null;
+    VARNISH: string | null;
+    leaf: string | null;
+    emboss: string | null;
+    braille: string | null;
+    lamination: string | null;
+    qty: string | null;
+    rate?: string | null;
+    actul_h: string | null;
+    actul_w: string | null;
+    actul_l: string | null;
+    UPS: string | null;
+    GSM: string | null;
+    dieno: string | null;
+    dsignstyl: string | null;
+    cutsz_l: string | null;
+    cutsz_w: string | null;
+    board: string | null;
+}
+export interface LegacyCostingResult {
+    success: boolean;
+    rows: LegacyCostingJob[];
+    /** True when the API responded but had no matching record (not a failure). */
+    notFound?: boolean;
+    /** The API's own message (e.g. "Job not found") when notFound. */
+    message?: string;
+    error?: string;
+}
+export declare function getLegacyCostingByJobCardAPI(jobCard: string, session: any): Promise<LegacyCostingResult>;
+export declare function getLegacyCostingBySizeAPI(l: number, w: number, h: number, session: any): Promise<LegacyCostingResult>;

package/dist/lib/api/estimation/legacy-costing.js

@@ -0,0 +1,46 @@
+'use client';
+// Legacy Costing Integration (Estimation module)
+// First consumer of the generic module integration proxy — see
+// src/lib/api/integration/proxy.ts. All API-specific details (URL template,
+// credentials) live in IntegrationConfig rows under IntegrationCode='LegacyCosting',
+// owned by the Estimation module (ModuleName='/costing/estimation').
+import { callIntegrationProxyAPI } from '../integration/proxy.js';
+export const LEGACY_COSTING_CODE = 'LegacyCosting';
+/**
+ * Unwrap the legacy costing response. The upstream API can return:
+ *   • an array of jobs                              → rows
+ *   • { data: [...] }                               → rows
+ *   • { success:false, message:"Job not found" }    → NOT-FOUND (empty, friendly)
+ *   • a proxy-level 404 / "not found" error string  → NOT-FOUND
+ * "Not found" is a valid empty result, NOT a failure — surface it as notFound
+ * with the API's own message so the UI shows a friendly note, not a raw error.
+ */
+function toResult(result) {
+    if (!result.success) {
+        const err = String(result.error || '');
+        if (/\b404\b|not\s*found/i.test(err)) {
+            return { success: true, rows: [], notFound: true, message: 'Job not found' };
+        }
+        return { success: false, rows: [], error: err || 'Request failed' };
+    }
+    const payload = result.payload;
+    // Array of jobs.
+    if (Array.isArray(payload))
+        return { success: true, rows: payload, notFound: payload.length === 0 };
+    if (payload && typeof payload === 'object') {
+        // The API's own { success:false, message } not-found body.
+        if (payload.success === false) {
+            return { success: true, rows: [], notFound: true, message: String(payload.message || 'Job not found') };
+        }
+        if (Array.isArray(payload.data)) {
+            return { success: true, rows: payload.data, notFound: payload.data.length === 0 };
+        }
+    }
+    return { success: false, rows: [], error: 'Unexpected response from legacy costing API' };
+}
+export async function getLegacyCostingByJobCardAPI(jobCard, session) {
+    return toResult(await callIntegrationProxyAPI(LEGACY_COSTING_CODE, { jobCard }, session));
+}
+export async function getLegacyCostingBySizeAPI(l, w, h, session) {
+    return toResult(await callIntegrationProxyAPI(LEGACY_COSTING_CODE, { l, w, h }, session));
+}

package/dist/lib/api/estimation/machines.d.ts

@@ -0,0 +1,32 @@
+import type { APIResponse, MachineData, CompatMachineData } from '../core/types.js';
+/**
+ * Get machine grid data filtered by Production Unit.
+ *
+ * The frontend always selects a Production Unit before opening any machine flow,
+ * so this argument is required. The backend scopes machines to MM.ProductionUnitID.
+ *
+ * @param sessionData - Session data containing user and company info
+ * @param productionUnitId - The selected Production Unit (number or numeric string)
+ */
+export declare function getMachineGridAPI(sessionData: any, productionUnitId: number | string): Promise<APIResponse<MachineData[]>>;
+/**
+ * Job spec for a compatibility query — the FIXED inputs that don't change across units.
+ */
+export interface CompatMachineArgs {
+    productionUnitId: number | string;
+    domainType: string;
+    jobSheetL: number;
+    jobSheetW: number;
+    jobWebWidth?: number;
+    requiredColors: number;
+    paperGroup?: string;
+}
+/**
+ * Get machines on a target production unit with a server-computed compatibility verdict for
+ * a given job spec. Backend mirrors the planner's fit/colors/group rules. Used to decide
+ * whether a planned content can be re-costed on another unit. (Production Unit Re-Costing.)
+ *
+ * @param sessionData - pass a plant-overridden session (targetSession) to scope correctly
+ * @param args - the frozen job spec (sheet/web dims, required colors, paper group, domain)
+ */
+export declare function getCompatibleMachinesAPI(sessionData: any, args: CompatMachineArgs): Promise<APIResponse<CompatMachineData[]>>;

package/dist/lib/api/estimation/machines.js

@@ -0,0 +1,67 @@
+'use client';
+// Estimation Machines API
+// Handles machine grid data for estimation
+import APIClient from '../core/client.js';
+/**
+ * Get machine grid data filtered by Production Unit.
+ *
+ * The frontend always selects a Production Unit before opening any machine flow,
+ * so this argument is required. The backend scopes machines to MM.ProductionUnitID.
+ *
+ * @param sessionData - Session data containing user and company info
+ * @param productionUnitId - The selected Production Unit (number or numeric string)
+ */
+export async function getMachineGridAPI(sessionData, productionUnitId) {
+    try {
+        const idNum = Number(productionUnitId);
+        if (!Number.isFinite(idNum) || idNum <= 0) {
+            return {
+                success: false,
+                error: 'getMachineGridAPI: productionUnitId is required and must be > 0'
+            };
+        }
+        const endpoint = `api/planwindow/machigrid?ProductionUnitID=${idNum}`;
+        const response = await APIClient.get(endpoint, sessionData);
+        return response;
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to fetch machine grid: ${error instanceof Error ? error.message : 'Unknown error'}`
+        };
+    }
+}
+/**
+ * Get machines on a target production unit with a server-computed compatibility verdict for
+ * a given job spec. Backend mirrors the planner's fit/colors/group rules. Used to decide
+ * whether a planned content can be re-costed on another unit. (Production Unit Re-Costing.)
+ *
+ * @param sessionData - pass a plant-overridden session (targetSession) to scope correctly
+ * @param args - the frozen job spec (sheet/web dims, required colors, paper group, domain)
+ */
+export async function getCompatibleMachinesAPI(sessionData, args) {
+    try {
+        const idNum = Number(args.productionUnitId);
+        if (!Number.isFinite(idNum) || idNum <= 0) {
+            return { success: false, error: 'getCompatibleMachinesAPI: productionUnitId is required and must be > 0' };
+        }
+        const params = new URLSearchParams({
+            ProductionUnitID: String(idNum),
+            domainType: args.domainType || 'OFFSET',
+            jobSheetL: String(args.jobSheetL || 0),
+            jobSheetW: String(args.jobSheetW || 0),
+            jobWebWidth: String(args.jobWebWidth || 0),
+            requiredColors: String(args.requiredColors || 0),
+            paperGroup: args.paperGroup || '',
+        });
+        const endpoint = `api/planwindow/compatiblemachines?${params.toString()}`;
+        const response = await APIClient.get(endpoint, sessionData);
+        return response;
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to fetch compatible machines: ${error instanceof Error ? error.message : 'Unknown error'}`
+        };
+    }
+}