indas-ui 0.0.1 → 0.1.0

package/dist/lib/api/estimation/shipper-planning.js

@@ -0,0 +1,208 @@
+'use client';
+/**
+ * Shipper Planning API Client
+ * Aligned with ShipperPlanningController.cs (updated 26/02/2026)
+ */
+import APIClient from '../core/client.js';
+const BASE_URL = process.env.NEXT_PUBLIC_API_BASE_URL || undefined;
+/**
+ * Map SP_ShipperSuggestion (flat) → ShipperPlan.
+ * Backend returns flat JSON array from Ok(suggestions).
+ */
+function mapShipperSuggestion(s) {
+    return {
+        ShipperID: s.ShipperID ?? 0,
+        ShipperName: s.ShipperName ?? '',
+        ItemID: s.ItemID ?? null,
+        SizeL: s.SizeL ?? 0,
+        SizeW: s.SizeW ?? 0,
+        SizeH: s.SizeH ?? 0,
+        PackX: s.PackX ?? 0,
+        PackY: s.PackY ?? 0,
+        PackZ: s.PackZ ?? 0,
+        QtyPerShipper: s.QtyPerShipper ?? 0,
+        EmptyCartonWt: s.EmptyCartonWt ?? 0,
+        PerBoxWt: s.PerBoxWt ?? 0,
+        ShipperWeightPerPack: s.ShipperWeightPerPack ?? 0,
+        TotalWtOfAllShippers: s.TotalWtOfAllShippers ?? 0,
+        CBM: s.CBM ?? 0,
+        CBF: s.CBF ?? 0,
+        TotalShipperQtyReq: s.TotalShippersRequired ?? 0,
+        BoxUtilizationPct: s.BoxUtilizationPct ?? 0,
+        ShippingRate: s.ShippingRatePerCBM ?? 0,
+        ShippingCost: s.ShippingCost ?? 0,
+        ShipperRate: s.ShipperRate ?? 0,
+        ShipperCost: s.ShipperCost ?? 0,
+        Capacity: s.QtyPerShipper ?? 0,
+        // Pallet fields (null when no PalletID)
+        PalletType: s.PalletType ?? null,
+        PalletLength: s.PalletLength ?? null,
+        PalletWidth: s.PalletWidth ?? null,
+        PalletTi: s.PalletTi ?? null,
+        PalletHi: s.PalletHi ?? null,
+        PalletTotalBoxesPerPallet: s.PalletTotalBoxesPerPallet ?? null,
+        PalletLoadedLength: s.PalletLoadedLength ?? null,
+        PalletLoadedWidth: s.PalletLoadedWidth ?? null,
+        PalletLoadedHeight: s.PalletLoadedHeight ?? null,
+        PalletTotalWeight: s.PalletTotalWeight ?? null,
+        PalletAreaEfficiency: s.PalletAreaEfficiency ?? null,
+    };
+}
+/**
+ * Calculate shipper plans — POST /api/ShipperPlanning/shipper/calculate
+ * Response is a flat JSON array of SP_ShipperSuggestion.
+ */
+export async function calculateShipperPlan(request, session) {
+    try {
+        const response = await APIClient.post('/api/ShipperPlanning/shipper/calculate', request, session, BASE_URL);
+        if (response.success) {
+            // Controller returns Ok(suggestions) — flat array
+            // Also handle legacy wrapper { Suggestions: [...] } for safety
+            const raw = Array.isArray(response.data)
+                ? response.data
+                : Array.isArray(response.data?.Suggestions)
+                    ? response.data.Suggestions
+                    : [];
+            return { success: true, data: raw.map(mapShipperSuggestion) };
+        }
+        return response;
+    }
+    catch (error) {
+        return {
+            success: false,
+            data: [],
+            error: error instanceof Error ? error.message : 'Unknown error',
+        };
+    }
+}
+/**
+ * Calculate container plans — POST /api/ShipperPlanning/container/calculate
+ * Response is a flat JSON array of SP_ContainerOption.
+ */
+export async function calculateContainerPlanning(request, session) {
+    try {
+        const response = await APIClient.post('/api/ShipperPlanning/container/calculate', request, session, BASE_URL);
+        if (response.success) {
+            const raw = Array.isArray(response.data)
+                ? response.data
+                : Array.isArray(response.data?.Containers)
+                    ? response.data.Containers
+                    : [];
+            return { success: true, data: raw };
+        }
+        return response;
+    }
+    catch (error) {
+        return {
+            success: false,
+            data: [],
+            error: error instanceof Error ? error.message : 'Unknown error',
+        };
+    }
+}
+/**
+ * Load container master data — GET /api/ShipperPlanning/masters/containers
+ */
+export async function loadContainerMasters(session) {
+    try {
+        const response = await APIClient.get('/api/ShipperPlanning/masters/containers', session, BASE_URL);
+        if (response.success && Array.isArray(response.data)) {
+            return { success: true, data: response.data };
+        }
+        return response;
+    }
+    catch (error) {
+        return {
+            success: false,
+            data: [],
+            error: error instanceof Error ? error.message : 'Unknown error',
+        };
+    }
+}
+/**
+ * Load pallet master data — GET /api/ShipperPlanning/masters/pallets
+ */
+export async function loadPalletMasters(session) {
+    try {
+        const response = await APIClient.get('/api/ShipperPlanning/masters/pallets', session, BASE_URL);
+        if (response.success && Array.isArray(response.data)) {
+            return { success: true, data: response.data };
+        }
+        return response;
+    }
+    catch (error) {
+        return {
+            success: false,
+            data: [],
+            error: error instanceof Error ? error.message : 'Unknown error',
+        };
+    }
+}
+/**
+ * Load port master data — GET /api/ShipperPlanning/masters/ports
+ */
+export async function loadPortMasters(session) {
+    try {
+        const response = await APIClient.get('/api/ShipperPlanning/masters/ports', session, BASE_URL);
+        if (response.success && Array.isArray(response.data)) {
+            return { success: true, data: response.data };
+        }
+        return response;
+    }
+    catch (error) {
+        return {
+            success: false,
+            data: [],
+            error: error instanceof Error ? error.message : 'Unknown error',
+        };
+    }
+}
+/**
+ * Load standard shipper sizes from Item Master — GET /api/ShipperPlanning/masters/shippers
+ * Returns boxes where ItemGroupID = 7.
+ */
+export async function loadShipperMasters(session) {
+    try {
+        const response = await APIClient.get('/api/ShipperPlanning/masters/shippers', session, BASE_URL);
+        if (response.success && Array.isArray(response.data)) {
+            return { success: true, data: response.data };
+        }
+        return response;
+    }
+    catch (error) {
+        return {
+            success: false,
+            data: [],
+            error: error instanceof Error ? error.message : 'Unknown error',
+        };
+    }
+}
+/**
+ * Lookup board caliper for a paper spec.
+ *
+ * Returns { success: true, data: null } when no master row matches — the
+ * caller should fall back to the GSM heuristic. HTTP status is always 200;
+ * branch on `success === false` for bad requests and `data === null` for
+ * "no match".
+ */
+export async function getPaperCaliper(filters, session) {
+    try {
+        const params = new URLSearchParams({
+            quality: filters.quality,
+            gsm: String(filters.gsm),
+            mill: filters.mill,
+            finish: filters.finish,
+            bf: filters.bf ?? '',
+            boardBrand: filters.boardBrand ?? '',
+        });
+        const response = await APIClient.get(`/api/ShipperPlanning/paper/caliper?${params.toString()}`, session, BASE_URL);
+        return response;
+    }
+    catch (error) {
+        return {
+            success: false,
+            data: null,
+            error: error instanceof Error ? error.message : 'Unknown error',
+        };
+    }
+}

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

@@ -0,0 +1,40 @@
+/**
+ * Wastage API Module
+ *
+ * Handles wastage type retrieval and slab calculations for estimation
+ */
+export interface WastageType {
+    WastageType: string;
+}
+export interface WastageTypeSlab {
+    ID: number;
+    WastageCode: string;
+    WastageType: string;
+    WastagePer: number;
+    WastagePerFluted: number;
+    IsCorrugated: number;
+}
+/**
+ * Get all available wastage types
+ *
+ * @param session - Session data containing auth credentials and company context
+ * @returns Array of wastage types
+ *
+ * @example
+ * const wastageTypes = await getAllWastageTypes(session)
+ * // Returns: [{ WastageType: "PLDP" }, { WastageType: "PUVDP" }, ...]
+ */
+export declare function getAllWastageTypes(session: any): Promise<import("../index.js").APIResponse<WastageType[]>>;
+/**
+ * Get wastage type slab data for specific actual sheet count and wastage type
+ *
+ * @param actualSheet - The actual sheet count
+ * @param wastageType - The wastage type (e.g., "PVDP", "PUVDP", "PLDP")
+ * @param session - Session data containing auth credentials and company context
+ * @returns Array of wastage slab data
+ *
+ * @example
+ * const slabs = await getWastageTypeSlab(1000, "PUVDP", session)
+ * // Returns: [{ ID: 8, WastageCode: "PUVDP1", WastageType: "PUVDP", WastagePer: 44 }]
+ */
+export declare function getWastageTypeSlab(actualSheet: number, wastageType: string, session: any): Promise<import("../index.js").APIResponse<WastageTypeSlab[]>>;

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

@@ -0,0 +1,40 @@
+'use client';
+/**
+ * Wastage API Module
+ *
+ * Handles wastage type retrieval and slab calculations for estimation
+ */
+import APIClient from '../core/client.js';
+// ============================================================================
+// API Functions
+// ============================================================================
+/**
+ * Get all available wastage types
+ *
+ * @param session - Session data containing auth credentials and company context
+ * @returns Array of wastage types
+ *
+ * @example
+ * const wastageTypes = await getAllWastageTypes(session)
+ * // Returns: [{ WastageType: "PLDP" }, { WastageType: "PUVDP" }, ...]
+ */
+export async function getAllWastageTypes(session) {
+    const response = await APIClient.get('/api/planwindow/getallwastagetypes', session);
+    return response;
+}
+/**
+ * Get wastage type slab data for specific actual sheet count and wastage type
+ *
+ * @param actualSheet - The actual sheet count
+ * @param wastageType - The wastage type (e.g., "PVDP", "PUVDP", "PLDP")
+ * @param session - Session data containing auth credentials and company context
+ * @returns Array of wastage slab data
+ *
+ * @example
+ * const slabs = await getWastageTypeSlab(1000, "PUVDP", session)
+ * // Returns: [{ ID: 8, WastageCode: "PUVDP1", WastageType: "PUVDP", WastagePer: 44 }]
+ */
+export async function getWastageTypeSlab(actualSheet, wastageType, session) {
+    const response = await APIClient.get(`/api/planwindow/getwastagetypeslab/${actualSheet}/${wastageType}`, session);
+    return response;
+}

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

@@ -0,0 +1,7 @@
+export * from './core/index.js';
+export * from './estimation/index.js';
+export * from './master/index.js';
+export * from './utility/index.js';
+export * from './auth/index.js';
+export * from './enquiry/index.js';
+export * from './activity/index.js';

package/dist/lib/api/index.js

@@ -0,0 +1,17 @@
+'use client';
+// Main API barrel export
+// Provides convenient access to all API modules
+// Re-export core utilities
+export * from './core/index.js';
+// Re-export estimation APIs
+export * from './estimation/index.js';
+// Re-export master APIs
+export * from './master/index.js';
+// Re-export utility APIs
+export * from './utility/index.js';
+// Re-export authentication APIs
+export * from './auth/index.js';
+// Re-export enquiry APIs
+export * from './enquiry/index.js';
+// Re-export activity APIs (audit, email)
+export * from './activity/index.js';

package/dist/lib/api/integration/proxy.d.ts

@@ -0,0 +1,7 @@
+export interface IntegrationProxyResult<T = any> {
+    success: boolean;
+    /** Parsed upstream payload (the external API's body, verbatim from the proxy) */
+    payload: T | null;
+    error?: string;
+}
+export declare function callIntegrationProxyAPI<T = any>(integrationCode: string, params: Record<string, string | number | null | undefined>, session: any): Promise<IntegrationProxyResult<T>>;

package/dist/lib/api/integration/proxy.js

@@ -0,0 +1,34 @@
+'use client';
+// Generic Module Integration Proxy
+// One client for ALL module-wise external integrations. The backend endpoint
+// api/integration/proxy/{integrationCode} resolves everything API-specific
+// (BaseUrl, UrlTemplate, credentials, owning module) from the IntegrationConfig
+// table per company — adding an integration to another module needs only config
+// rows + a UI, no new backend or client code.
+//
+// Gating: show integration UI only when the owning module has
+// ModuleMaster.IsIntegrationRequired = 1 (useModuleIntegrationRequired).
+import APIClient from '../core/client.js';
+export async function callIntegrationProxyAPI(integrationCode, params, session) {
+    const qs = Object.entries(params)
+        .filter(([, v]) => v !== undefined && v !== null && v !== '')
+        .map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`)
+        .join('&');
+    const response = await APIClient.get(`api/integration/proxy/${encodeURIComponent(integrationCode)}${qs ? `?${qs}` : ''}`, session);
+    if (!response.success) {
+        return { success: false, payload: null, error: response.error || 'Integration request failed' };
+    }
+    let payload = response.data;
+    if (typeof payload === 'string') {
+        try {
+            payload = JSON.parse(payload);
+        }
+        catch {
+            return { success: false, payload: null, error: payload };
+        }
+    }
+    if (payload && typeof payload === 'object' && 'error' in payload && payload.error) {
+        return { success: false, payload: null, error: String(payload.error) };
+    }
+    return { success: true, payload };
+}

package/dist/lib/api/master/category.d.ts

@@ -0,0 +1,126 @@
+import type { APIResponse } from '../core/types.js';
+/**
+ * Category data interface based on API response
+ */
+export interface CategoryItem {
+    SegmentID: number;
+    SegmentName: string;
+    CategoryID: number;
+    CategoryName: string;
+    Orientation: '2D' | '3D' | 'BOOK';
+    ProcessIDString: string | null;
+    ContentsIDString: string | null;
+    MinimumAroundGap: number;
+    MaximumAroundGap: number;
+    DefaultAroundGap: number;
+    MinimumAcrossGap: number;
+    MaximumAcrossGap: number;
+    DefaultAcrossGap: number;
+    MinimumPlateBearer: number;
+    MaximumPlateBearer: number;
+    DefaultPlateBearer: number;
+    MinimumSideStrip: number;
+    MaximumSideStrip: number;
+    DefaultSideStrip: number;
+    DefaultPrintingMarginTop: number;
+    DefaultPrintingMarginBottom: number;
+    DefaultPrintingMarginLeft: number;
+    DefaultPrintingMarginRight: number;
+    DefaultStrippingMarginTop: number;
+    DefaultStrippingMarginBottom: number;
+    DefaultStrippingMarginLeft: number;
+    DefaultStrippingMarginRight: number;
+    DefaultJobTrimmingTop: number;
+    DefaultJobTrimmingBottom: number;
+    DefaultJobTrimmingLeft: number;
+    DefaultJobTrimmingRight: number;
+    Layer: number | null;
+    IsForBot?: boolean | number;
+    Remark: string | null;
+}
+/**
+ * Segment (Division) data interface based on API response
+ */
+export interface SegmentItem {
+    SegmentID: number;
+    SegmentCode: string;
+    SegmentName: string;
+    RefSegmentCode: string;
+    CompanyID: number;
+    UserID: number;
+    CreatedBy: number;
+    CreatedDate: string;
+    ModifiedBy: number;
+    ModifiedDate: string | null;
+    IsDeletedTransaction: boolean;
+    DeletedDate: string | null;
+    DeletedBy: number;
+    MaxSegmentCode: number;
+    SegmentPrefix: string;
+    ProductionUnitID: number | null;
+    DefaultFactor: number;
+    FactorValueType: string;
+    DefaultProfit: number;
+    DefaultPackingCostPercentage: number | null;
+}
+/**
+ * Category API class
+ */
+export declare class CategoryAPI {
+    /**
+     * Get all categories
+     * @param sessionData - Session data for authentication
+     * @returns Promise with category items array
+     */
+    static getCategories(sessionData?: any): Promise<APIResponse<CategoryItem[]>>;
+    /**
+     * Get all segments (divisions)
+     * @param sessionData - Session data for authentication
+     * @returns Promise with segment items array
+     */
+    static getSegments(sessionData?: any): Promise<APIResponse<SegmentItem[]>>;
+    /**
+     * Get all allocated contents for a category
+     * @param categoryID - Category ID to fetch contents for
+     * @param sessionData - Session data for authentication
+     * @returns Promise with allocated contents array
+     */
+    static getAllContents(categoryID: number, sessionData?: any): Promise<APIResponse<any>>;
+    /**
+     * Update an existing category
+     * @param categoryData - Category data to update
+     * @param sessionData - Session data for authentication
+     * @returns Promise with API response
+     */
+    static updateCategory(categoryData: any, sessionData?: any): Promise<APIResponse<any>>;
+    /**
+     * Save a new category
+     * @param categoryData - Category data to save
+     * @param sessionData - Session data for authentication
+     * @returns Promise with API response
+     */
+    static saveCategory(categoryData: any, sessionData?: any): Promise<APIResponse<any>>;
+    /**
+     * Delete a category
+     * @param categoryId - Category ID to delete
+     * @param sessionData - Session data for authentication
+     * @returns Promise with API response
+     */
+    static deleteCategory(categoryId: number, sessionData?: any): Promise<APIResponse<any>>;
+    /**
+     * Get the processes allocated to a category (its default processes).
+     * Returns the distinct ProcessName list from CategoryWiseProcessAllocation.
+     * Used to auto-fill the grid-costing template's process columns when
+     * downloading from an enquiry (no manual process picker).
+     */
+    static getCategoryProcesses(categoryID: number, sessionData?: any): Promise<APIResponse<string[]>>;
+    static getMachineAllocatedItemSubList(machineId: number, sessionData?: any): Promise<APIResponse<MachineAllocatedItemSubGroup[]>>;
+}
+export interface MachineAllocatedItemSubGroup {
+    MachineID: number;
+    MachineName: string;
+    ItemSubGroupID: number;
+    ItemSubGroupName: string;
+    ItemID: number;
+    ItemName: string;
+}