indas-ui 0.0.1 → 0.1.0

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

@@ -0,0 +1,385 @@
+'use client';
+// Planning APIs
+// Handles plan window and load operations for estimation
+import APIClient from '../core/client.js';
+/**
+ * Load Operations API class
+ */
+export class LoadOperationsAPI {
+    /**
+     * Load operations list for a given DomainType
+     * @param domainType - Domain type (e.g., 'Offset', 'Digital', 'Flexo')
+     * @param sessionData - Session data
+     */
+    static async loadOperations(domainType, sessionData) {
+        const endpoint = `api/planwindow/LoadOperations/${domainType}`;
+        try {
+            const response = await APIClient.get(endpoint, sessionData);
+            return response;
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: `LoadOperations API failed: ${error instanceof Error ? error.message : 'Unknown error'}`
+            };
+        }
+    }
+}
+/**
+ * Plan Window API
+ * API calls for calculating operations based on machine planning data
+ */
+export class PlanWindowAPI {
+    /**
+     * Calculate operation costs for selected processes
+     * @param requestBody - Request body containing planning data and process IDs
+     * @param isDefault - Whether to fetch default processes (true) or calculate for selected processes (false)
+     * @param category - Content domain type/category
+     * @param content - Content name
+     */
+    static async calculateOperation(requestBody, options, sessionData) {
+        // Build query parameters
+        const queryParams = [];
+        if (options?.isDefault !== undefined) {
+            queryParams.push(`Isdefault=${options.isDefault}`);
+        }
+        if (options?.category) {
+            queryParams.push(`category=${encodeURIComponent(options.category)}`);
+        }
+        if (options?.content) {
+            queryParams.push(`content=${encodeURIComponent(options.content)}`);
+        }
+        const queryString = queryParams.length > 0 ? `?${queryParams.join('&')}` : '';
+        const endpoint = `api/planwindow/CalculateOperation${queryString}`;
+        const response = await APIClient.post(endpoint, requestBody, sessionData);
+        return response;
+    }
+    /**
+     * Get all machines
+     */
+    static async getAllMachines(sessionData) {
+        return APIClient.get('api/planwindow/getallmachines', sessionData);
+    }
+    /**
+     * Get material group cost formula settings for a specific sub-item group and plant
+     * @param itemSubGroupID - The sub-item group ID
+     * @param plantID - The plant ID
+     */
+    static async getMaterialGroupCostFormulaSetting(itemSubGroupID, plantID, sessionData) {
+        const endpoint = `api/planwindow/GetMaterialGroupCostFormulaSetting/${itemSubGroupID}/${plantID}`;
+        return APIClient.get(endpoint, sessionData);
+    }
+    /**
+     * Get keyline coordinates for die-cut patterns
+     * @param contentType - The orientation/product type (e.g., "StandardStraightTuckIn", "ReverseTuckAndTongue")
+     * @param grain - Grain direction (e.g., "With Grain", "Across Grain")
+     */
+    static async getKeylineCoordinates(contentType, grain, sessionData) {
+        // URL encode parameters to handle spaces and special characters
+        const encodedContentType = encodeURIComponent(contentType);
+        const encodedGrain = encodeURIComponent(grain);
+        return APIClient.get(`api/planwindow/keylinecoordinates/${encodedContentType}/${encodedGrain}`, sessionData);
+    }
+    /**
+     * Get auto-generated quote number
+     * @param sessionData - Session data for authentication
+     * @returns Promise with quote number string (e.g., "10711")
+     */
+    static async getQuoteNo(sessionData) {
+        const endpoint = 'api/planwindow/getquoteno';
+        try {
+            const response = await APIClient.get(endpoint, sessionData);
+            return response;
+        }
+        catch (error) {
+            console.error('❌ [QUOTE_NO] Error:', error);
+            return {
+                success: false,
+                error: `Get Quote No API failed: ${error instanceof Error ? error.message : 'Unknown error'}`
+            };
+        }
+    }
+    /**
+     * Get type of charges calculation formulas and operation slabs
+     * Called after LoadOperations to get formula definitions and rate slabs
+     * @param sessionData - Session data for authentication
+     * @returns Promise with TypeOfCharges array and LoadOperationSlabsDetails array
+     */
+    static async getTypeOfCharges(sessionData) {
+        const endpoint = 'api/planwindow/GetTypeOfCharges';
+        try {
+            const response = await APIClient.get(endpoint, sessionData);
+            return response;
+        }
+        catch (error) {
+            console.error('❌ [GET_TYPE_OF_CHARGES] Error:', error);
+            return {
+                success: false,
+                error: `GetTypeOfCharges API failed: ${error instanceof Error ? error.message : 'Unknown error'}`
+            };
+        }
+    }
+    /**
+     * Get client list with credit days
+     * @param sessionData - Session data for authentication
+     * @returns Promise with array of clients including LedgerName, LedgerId, and CreditDays
+     */
+    static async getSbClient(sessionData) {
+        const endpoint = 'api/planwindow/GetSbClient';
+        try {
+            const response = await APIClient.get(endpoint, sessionData);
+            return response;
+        }
+        catch (error) {
+            console.error('❌ [API ERROR] GetSbClient Error:', error);
+            return {
+                success: false,
+                error: `GetSbClient API failed: ${error instanceof Error ? error.message : 'Unknown error'}`
+            };
+        }
+    }
+    /**
+     * Shirin Job Master - Main planning calculation endpoint
+     * Generates machine plans with comprehensive planning data
+     *
+     * Legacy reference: plan.txt line 236-237
+     * Endpoint: POST /api/planwindow/ShirinJobMaster
+     *
+     * @param request - Job size, operations, and rates (PlateRate, PaperRate, MakeReadyRate, CoatingRate)
+     * @param sessionData - Session data for authentication
+     * @returns Promise with planning results (TblPlanning, TblOperations, TblBookForms)
+     */
+    static async shirinJobMaster(request, sessionData) {
+        const endpoint = 'api/planwindow/ShirinJobMaster';
+        try {
+            const response = await APIClient.post(endpoint, request, sessionData);
+            return response;
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: `ShirinJobMaster API failed: ${error instanceof Error ? error.message : 'Unknown error'}`
+            };
+        }
+    }
+}
+/**
+ * Get machine allocated item list
+ * @param machineId - Machine ID
+ * @param sessionData - Session data
+ * @param filters - Optional filters: categoryID, processID, contentType, rateTier
+ */
+export async function getMachineAllocatedItemList(machineId, sessionData, filters) {
+    try {
+        const params = new URLSearchParams();
+        if (filters?.categoryID)
+            params.append('categoryID', String(filters.categoryID));
+        if (filters?.processID)
+            params.append('processID', String(filters.processID));
+        if (filters?.contentType)
+            params.append('contentType', filters.contentType);
+        if (filters?.rateTier === 'L2')
+            params.append('rateTier', 'L2');
+        const qs = params.toString();
+        const endpoint = `api/planwindow/GetMachineAllocatedItemList/${machineId}${qs ? `?${qs}` : ''}`;
+        const response = await APIClient.get(endpoint, sessionData);
+        return response;
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to fetch machine allocated items: ${error instanceof Error ? error.message : 'Unknown error'}`
+        };
+    }
+}
+/**
+ * Get process-allocated items (no machine involvement). Used by EnquiryMaterialModal
+ * where the user picks materials per (category, content, process) without ever
+ * selecting a machine. Backend joins across all machines allocated to the process
+ * and dedupes by ItemID; IsDefault is collapsed (true if any machine flags it).
+ */
+export async function getProcessAllocatedItemList(filters, sessionData) {
+    try {
+        const params = new URLSearchParams();
+        params.append('CategoryID', String(filters.categoryID));
+        params.append('ContentID', String(filters.contentID));
+        params.append('ProcessID', String(filters.processID));
+        const endpoint = `api/planwindow/GetProcessAllocatedItemList?${params.toString()}`;
+        return await APIClient.get(endpoint, sessionData);
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to fetch process allocated items: ${error instanceof Error ? error.message : 'Unknown error'}`
+        };
+    }
+}
+/**
+ * Get ALL materials/items allocated to one or more processes (by ProcessID only,
+ * no category/content/machine needed). Returns the actual allocated items — not
+ * just material sub-group names. `processIds` are joined comma-separated for the
+ * IN(...) clause, so one call covers every chosen process.
+ */
+export async function getProcessWiseMaterials(processIds, sessionData) {
+    try {
+        const ids = processIds.filter(n => Number(n) > 0).join(',');
+        if (!ids)
+            return { success: true, data: [] };
+        const endpoint = `api/planwindow/processmaterials/${encodeURIComponent(ids)}`;
+        return await APIClient.get(endpoint, sessionData);
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to fetch process-wise materials: ${error instanceof Error ? error.message : 'Unknown error'}`
+        };
+    }
+}
+/**
+ * Get Winding Directions by domain type
+ * @param contentDomainType - The content domain type (FLEXO, ROTOGRAVURE, etc.)
+ * @param sessionData - Session data for authentication
+ * @returns Promise with winding direction options
+ */
+export async function getWindingDirections(contentDomainType, sessionData) {
+    try {
+        const endpoint = `api/planwindow/windingdirection/${contentDomainType}`;
+        const response = await APIClient.get(endpoint, sessionData);
+        if (response.success && response.data) {
+            if (!Array.isArray(response.data)) {
+                const errorMessage = typeof response.data === 'string'
+                    ? response.data
+                    : 'API returned invalid data format';
+                return {
+                    success: false,
+                    error: errorMessage,
+                    data: []
+                };
+            }
+        }
+        return response;
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to fetch winding directions: ${error instanceof Error ? error.message : 'Unknown error'}`,
+            data: []
+        };
+    }
+}
+/**
+ * Get Thickness options
+ * @param contentType - Content type (e.g., "FLEXO")
+ * @param quality - Item quality (e.g., "Shrink Sleeve")
+ * @param gsm - GSM value (e.g., "54")
+ * @param sessionData - Session data for authentication
+ * @returns Promise with thickness options
+ */
+export async function getThicknessOptions(contentType, quality, gsm, sessionData) {
+    try {
+        const endpoint = `api/planwindow/thickness?contenttype=${encodeURIComponent(contentType)}&quality=${encodeURIComponent(quality)}&gsm=${encodeURIComponent(gsm)}`;
+        const response = await APIClient.get(endpoint, sessionData);
+        if (response.success && response.data) {
+            if (!Array.isArray(response.data)) {
+                const errorMessage = typeof response.data === 'string'
+                    ? response.data
+                    : 'API returned invalid data format';
+                return {
+                    success: false,
+                    error: errorMessage,
+                    data: []
+                };
+            }
+        }
+        return response;
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to fetch thickness options: ${error instanceof Error ? error.message : 'Unknown error'}`,
+            data: []
+        };
+    }
+}
+/**
+ * Get Label Type options (Static data for FLEXO)
+ * @returns Label type options
+ */
+export function getLabelTypes() {
+    return [
+        { LabelType: "Front" },
+        { LabelType: "Back" },
+        { LabelType: "Top" },
+        { LabelType: "Bottom" },
+        { LabelType: "Neck" },
+        { LabelType: "Flat Label" },
+        { LabelType: "Single" },
+        { LabelType: "Set" }
+    ];
+}
+/**
+ * Get Pouch Style options (Static data for ROTOGRAVURE)
+ * @returns Pouch style options
+ */
+export function getPouchStyles() {
+    return [
+        { LabelType: "Stand-Up Pouch", WtPerPieceGram: 0 },
+        { LabelType: "K-Seal Pouch", WtPerPieceGram: 0 },
+        { LabelType: "Three-Side Seal Pouch", WtPerPieceGram: 0 },
+        { LabelType: "Four-Side Seal Pouch", WtPerPieceGram: 0 },
+        { LabelType: "Single-Use Sachet", WtPerPieceGram: 0 },
+        { LabelType: "Side Gusset Pouch", WtPerPieceGram: 0 },
+        { LabelType: "Bottom Gusset Pouch", WtPerPieceGram: 0 },
+        { LabelType: "Spouted Pouch", WtPerPieceGram: 10 },
+        { LabelType: "Retort Pouch", WtPerPieceGram: 0 },
+        { LabelType: "Zipper Pouch", WtPerPieceGram: 5 },
+        { LabelType: "Pillow Pouch", WtPerPieceGram: 0 },
+        { LabelType: "Quad-Seal Pouch", WtPerPieceGram: 0 },
+        { LabelType: "Shaped Pouch", WtPerPieceGram: 0 },
+        { LabelType: "Flat-Bottom Pouch", WtPerPieceGram: 0 },
+        { LabelType: "Vacuum Pouch", WtPerPieceGram: 0 },
+        { LabelType: "Slider Pouch", WtPerPieceGram: 0 }
+    ];
+}
+/**
+ * Get Punching Type options (Static data)
+ * @returns Punching type options
+ */
+export function getPunchingTypes() {
+    return [
+        { PunchingType: "None" },
+        { PunchingType: "Threding" },
+        { PunchingType: "Hole Punching" }
+    ];
+}
+/**
+ * Get Finished Format options (Static data for FLEXO)
+ * @returns Finished format options
+ */
+export function getFinishedFormats() {
+    return [
+        "Sheet Form",
+        "Roll Form",
+        "Fan Fold",
+        "Cut Label",
+        "Pcs Or Unit"
+    ];
+}
+/**
+ * Calculate flap dimensions for 3D content types
+ * @param request - Dimensions and content info
+ * @param sessionData - Session data
+ */
+export async function calculateFlapDimensions(request, sessionData) {
+    try {
+        const endpoint = 'api/planwindow/calculate-flap-dimensions';
+        const response = await APIClient.post(endpoint, request, sessionData);
+        return response;
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to calculate flap dimensions: ${error instanceof Error ? error.message : 'Unknown error'}`
+        };
+    }
+}

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

@@ -0,0 +1,128 @@
+import type { APIResponse, Quality, GSMData, MillData, FinishData, CoatingData, BoardBrandData } from '../core/types.js';
+/**
+ * Get qualities by content type
+ * @param contentType - The content type to filter by
+ * @param sessionData - Session data containing user and company info
+ * @returns Promise with qualities array
+ */
+/**
+ * Get matched raw-material rate (L1 + L2) for the Raw Material card.
+ * Backend resolves the item group dynamically from contentType (Paper/Reel/Board/etc),
+ * so this works for any group. Returns matched item rows.
+ */
+export declare function getMaterialRateAPI(filters: {
+    contentType: string;
+    quality: string;
+    gsm: string;
+    mill?: string;
+    bf?: string;
+    boardBrand?: string;
+    finish?: string;
+    plant?: string;
+}, sessionData?: any): Promise<APIResponse>;
+export declare function getQualitiesAPI(contentType: string, sessionData?: any): Promise<APIResponse<Quality[]>>;
+/**
+ * Get GSM (Grams per Square Meter) options
+ * @param contentType - The content type
+ * @param quality - The quality name
+ * @param thickness - Optional thickness value (defaults to '0')
+ * @param sessionData - Session data containing user and company info
+ * @returns Promise with GSM data array
+ */
+export declare function getGSMAPI(contentType: string, quality: string, thickness?: string, sessionData?: any): Promise<APIResponse<GSMData[]>>;
+/**
+ * Get Mill options
+ * @param contentType - The content type
+ * @param quality - The quality name
+ * @param gsm - The GSM value
+ * @param thickness - Optional thickness value (defaults to '0')
+ * @param sessionData - Session data containing user and company info
+ * @returns Promise with mill data array
+ */
+export declare function getMillAPI(contentType: string, quality: string, gsm: string, thickness?: string, sessionData?: any): Promise<APIResponse<MillData[]>>;
+/**
+ * Get Finish options
+ * @param quality - The quality name
+ * @param gsm - The GSM value
+ * @param mill - The mill name
+ * @param sessionData - Session data containing user and company info
+ * @returns Promise with finish data array
+ */
+export declare function getFinishAPI(quality: string, gsm: string, mill: string, sessionData?: any): Promise<APIResponse<FinishData[]>>;
+/**
+ * One distinct paper combination — drives the import-template paper cascade.
+ */
+export interface PaperCombinationRow {
+    Quality: string;
+    GSM: string;
+    Mill: string;
+    Finish: string;
+    Brand: string;
+}
+/**
+ * Get the FULL flat paper combination table in one call (Quality / GSM / Mill /
+ * Finish / Brand). Used to build the Grid Costing import template's dependent
+ * paper dropdowns without thousands of per-combination requests.
+ */
+export declare function getPaperCombinationsAPI(sessionData?: any): Promise<APIResponse<PaperCombinationRow[]>>;
+/**
+ * Get Coating options
+ * @param sessionData - Session data containing user and company info
+ * @returns Promise with coating data array
+ */
+export declare function getCoatingAPI(sessionData?: any): Promise<APIResponse<CoatingData[]>>;
+/**
+ * BF (Burst Factor) data interface
+ */
+export interface BFData {
+    BF: number;
+}
+/**
+ * Get BF (Burst Factor) options
+ * @param quality - The quality name
+ * @param gsm - The GSM value
+ * @param mill - Optional mill name
+ * @param sessionData - Session data containing user and company info
+ * @returns Promise with BF data array
+ */
+export declare function getBFAPI(quality: string, gsm: string, mill?: string, sessionData?: any): Promise<APIResponse<BFData[]>>;
+/**
+ * Certification type data interface
+ */
+export interface CertificationType {
+    ParameterType: string;
+    ParameterName: string;
+    ParameterValue: string;
+}
+/**
+ * Get Certification Types (FSC, PEFC, NONE, etc.)
+ * @param sessionData - Session data containing user and company info
+ * @returns Promise with certification types array
+ */
+export declare function getCertificationTypesAPI(sessionData?: any): Promise<APIResponse<CertificationType[]>>;
+/**
+ * Quote default values keyed by ParameterName (backend ParameterType = 'Quote Defaults')
+ */
+export interface QuoteDefaults {
+    'Overhead Percentage'?: number | null;
+    'Profit Percentage'?: number | null;
+    'Packing Percentage'?: number | null;
+    'Misc Percentage'?: number | null;
+    'Factor Percentage'?: number | null;
+    'Tax Percentage'?: number | null;
+    'Discount Percentage'?: number | null;
+    'Freight Rate'?: number | null;
+    'Credit Interest Percentage'?: number | null;
+    'Insurance Percentage'?: number | null;
+}
+/**
+ * Get default values for cost-table fields (Overhead/Profit/Packing/etc.)
+ * Endpoint returns an object keyed by ParameterName with parsed decimal values (or null).
+ */
+export declare function getQuoteDefaultsAPI(sessionData?: any): Promise<APIResponse<QuoteDefaults>>;
+/**
+ * Get Board Brand options filtered by content type, quality, GSM, mill, and finish
+ * Pass "all" for any param to skip that filter
+ * Route: boardbrand/{contenttype}/{quality}/{gsm}/{mill}/{finish}
+ */
+export declare function getBoardBrandAPI(contentType: string, quality: string, gsm: string, mill: string, finish: string, sessionData?: any): Promise<APIResponse<BoardBrandData[]>>;