indas-ui 0.0.1 → 0.1.1

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

@@ -0,0 +1,203 @@
+'use client';
+// Content API
+// Handles content-related API calls for estimation screen
+import APIClient from '../core/client.js';
+/**
+ * Content API class for handling content-related operations
+ */
+export class ContentAPI {
+    /**
+     * Get category allocated contents from the API
+     * @param categoryID - The category ID to fetch contents for
+     * @param sessionData - Optional session data for authentication
+     * @returns Promise with content items array
+     */
+    static async getCategoryAllocatedContents(categoryID, sessionData) {
+        try {
+            const endpoint = `api/planwindow/GetCategoryAllocatedContents/${categoryID}`;
+            const response = await APIClient.get(endpoint, sessionData);
+            // Validate that data is actually an array
+            // Sometimes the API returns error strings with 200 OK status
+            if (response.success && response.data) {
+                if (!Array.isArray(response.data)) {
+                    // API returned an error message as a string instead of an array
+                    const errorMessage = typeof response.data === 'string'
+                        ? response.data
+                        : 'API returned invalid data format (expected array, got string)';
+                    console.error('❌ Content API returned error string:', errorMessage);
+                    return {
+                        success: false,
+                        error: errorMessage,
+                        data: []
+                    };
+                }
+            }
+            return response;
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: `Failed to fetch category contents: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                data: []
+            };
+        }
+    }
+    /**
+     * Parse content sizes string into a more usable object
+     * @param contentSizes - Comma-separated string like "SizeHeight,SizeWidth"
+     * @returns Parsed sizes object
+     */
+    static parseContentSizes(contentSizes) {
+        const sizes = {};
+        if (!contentSizes)
+            return sizes;
+        const sizeArray = contentSizes.split(',').map(s => s.trim());
+        sizeArray.forEach(size => {
+            switch (size) {
+                case 'SizeHeight':
+                    sizes.SizeHeight = true;
+                    break;
+                case 'SizeWidth':
+                    sizes.SizeWidth = true;
+                    break;
+                case 'SizeLength':
+                    sizes.SizeLength = true;
+                    break;
+                case 'JobPrePlan':
+                    sizes.JobPrePlan = true;
+                    break;
+                case 'JobAcrossUps':
+                    sizes.JobAcrossUps = true;
+                    break;
+                case 'JobAroundUps':
+                    sizes.JobAroundUps = true;
+                    break;
+                case 'JobUps':
+                    sizes.JobUps = true;
+                    break;
+                default:
+                    // Handle any other size types that might be added
+                    sizes[size] = true;
+            }
+        });
+        return sizes;
+    }
+    /**
+     * Normalize image path to work with the application structure
+     * @param href - Original href from API like "images/Contents/Label.jpg"
+     * @returns Normalized path for the application
+     */
+    static normalizeImagePath(href) {
+        if (!href)
+            return '/Contents/Rectangular.jpg';
+        let normalizedPath = '';
+        // Convert API path format to application path format
+        // API: "images/Contents/Label.jpg"
+        // App: "/Contents/Label.jpg" (images/ removed since Contents is now in public root)
+        if (href.startsWith('images/Contents/')) {
+            normalizedPath = '/' + href.replace('images/', '');
+        }
+        else if (href.startsWith('/')) {
+            // If already starts with /, return as is
+            normalizedPath = href;
+        }
+        else {
+            // Default fallback
+            normalizedPath = '/Contents/' + href;
+        }
+        return normalizedPath;
+    }
+    /**
+     * Get display color based on content domain type
+     * @param domainType - The domain type like "Flexo", "Offset", etc.
+     * @returns CSS color class
+     */
+    static getDisplayColor(domainType) {
+        // Spelled out per case — a template literal inside a class name would not
+        // survive the Tailwind build.
+        switch (domainType?.toLowerCase()) {
+            case 'flexo':
+                return 'bg-[rgb(var(--color-info))]';
+            case 'offset':
+                return 'bg-[rgb(var(--color-success))]';
+            case 'digital':
+                return 'bg-[rgb(var(--color-purple))]';
+            case 'finishing':
+                return 'bg-[rgb(var(--color-orange))]';
+            default:
+                return 'bg-[rgb(var(--color-neutral))]';
+        }
+    }
+    /**
+     * Transform API content items to display-ready format
+     * @param contentItems - Raw content items from API
+     * @returns Display-ready content items
+     */
+    static transformForDisplay(contentItems) {
+        // Safety check: ensure contentItems is an array
+        if (!Array.isArray(contentItems)) {
+            console.error('❌ transformForDisplay: contentItems is not an array:', contentItems);
+            return [];
+        }
+        return contentItems.map(item => ({
+            ...item,
+            imagePath: this.normalizeImagePath(item.ContentOpenHref),
+            imagePathClosed: item.ContentClosedHref ? this.normalizeImagePath(item.ContentClosedHref) : undefined,
+            availableSizes: this.parseContentSizes(item.ContentSizes),
+            displayColor: this.getDisplayColor(item.ContentDomainType)
+        }));
+    }
+    /**
+     * Get contents with automatic transformation for display
+     * @param categoryID - The category ID to fetch contents for
+     * @param sessionData - Optional session data for authentication
+     * @returns Promise with display-ready content items
+     */
+    static async getDisplayContents(categoryID, sessionData) {
+        const response = await this.getCategoryAllocatedContents(categoryID, sessionData);
+        if (response.success && response.data) {
+            const displayContents = this.transformForDisplay(response.data);
+            return {
+                ...response,
+                data: displayContents
+            };
+        }
+        return {
+            ...response,
+            data: []
+        };
+    }
+    /**
+     * Search contents by name or caption
+     * @param contentItems - Array of content items to search
+     * @param searchTerm - Search term
+     * @returns Filtered content items
+     */
+    static searchContents(contentItems, searchTerm) {
+        if (!searchTerm.trim())
+            return contentItems;
+        const term = searchTerm.toLowerCase();
+        return contentItems.filter(item => item.ContentName.toLowerCase().includes(term) ||
+            item.ContentCaption.toLowerCase().includes(term));
+    }
+    /**
+     * Filter contents by domain type
+     * @param contentItems - Array of content items to filter
+     * @param domainType - Domain type to filter by
+     * @returns Filtered content items
+     */
+    static filterByDomainType(contentItems, domainType) {
+        if (!domainType)
+            return contentItems;
+        return contentItems.filter(item => item.ContentDomainType.toLowerCase() === domainType.toLowerCase());
+    }
+    /**
+     * Get unique domain types from content items
+     * @param contentItems - Array of content items
+     * @returns Array of unique domain types
+     */
+    static getUniqueDomainTypes(contentItems) {
+        const types = contentItems.map(item => item.ContentDomainType);
+        return [...new Set(types)].sort();
+    }
+}

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

@@ -0,0 +1,34 @@
+import type { APIResponse } from '../core/types.js';
+export interface FreightLocation {
+    ProductionUnitID: number;
+    State: string;
+    Location: string;
+    /** Full-truck rate per kg (sheet: FLAT → Truck Load). */
+    FreightRate: number;
+    /** Part-load rate per kg (sheet: FLAT → Part Load). */
+    PartLoadKgRate?: number;
+    /** Part-load flat amount (sheet: Formed → Part Load). */
+    FreightPerShipper?: number;
+    Truck1Rate?: number;
+    Truck2Rate?: number;
+    Truck3Rate?: number;
+    Truck4Rate?: number;
+    Truck5Rate?: number;
+}
+export interface TruckRateSlot {
+    /** 'Truck1'..'Truck5' — which TruckNRate column on FreightRateMaster */
+    Slot: string;
+    /** ContainerMaster row (Category='Truck') this slot holds rates for */
+    ContainerID: number;
+    ContainerName: string;
+}
+/**
+ * Get all freight locations with rates
+ * @param productionUnitId - Production Unit ID from dropdown (not from session)
+ */
+export declare function getFreightLocations(productionUnitId: number, session: any): Promise<APIResponse<FreightLocation[]>>;
+/**
+ * Per-plant mapping of FreightRateMaster TruckNRate columns to trucks
+ * (ERPParameterSetting, ParameterType='TruckRateColumnMapping')
+ */
+export declare function getTruckRateMapping(productionUnitId: number, session: any): Promise<APIResponse<TruckRateSlot[]>>;

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

@@ -0,0 +1,18 @@
+'use client';
+// Freight API
+// Handles freight-related operations for estimation module
+import APIClient from '../core/client.js';
+/**
+ * Get all freight locations with rates
+ * @param productionUnitId - Production Unit ID from dropdown (not from session)
+ */
+export async function getFreightLocations(productionUnitId, session) {
+    return APIClient.get(`/api/planwindow/freight/locations?productionUnitId=${productionUnitId}`, session);
+}
+/**
+ * Per-plant mapping of FreightRateMaster TruckNRate columns to trucks
+ * (ERPParameterSetting, ParameterType='TruckRateColumnMapping')
+ */
+export async function getTruckRateMapping(productionUnitId, session) {
+    return APIClient.get(`/api/planwindow/freight/truck-mapping?productionUnitId=${productionUnitId}`, session);
+}

package/dist/lib/api/estimation/grid-costing-drafts.d.ts

@@ -0,0 +1,38 @@
+import type { APIResponse } from '../core/types.js';
+/** A draft as returned by the LIST endpoint (no heavy RowsJson). */
+export interface GridCostingDraftSummary {
+    DraftID: number;
+    DraftName: string;
+    RowCount: number | null;
+    CompletedRowCount: number | null;
+    CreatedAt: string;
+    UpdatedAt: string;
+    /** Pre-formatted readable date from the backend SQL (e.g. "13 Jun 2026, 06:42"). */
+    UpdatedAtText?: string;
+}
+/** Full draft incl. the serialized grid state. */
+export interface GridCostingDraftFull extends GridCostingDraftSummary {
+    RowsJson: string;
+}
+export interface SaveDraftRequest {
+    /** 0 / null = create new; >0 = update existing. */
+    DraftID?: number | null;
+    DraftName: string;
+    /** Full grid state (rows + selectedProcesses + materials) serialized. */
+    RowsJson: string;
+    RowCount: number;
+    /** Rows that have at least one material allocated (drives the resume UI). */
+    CompletedRowCount: number;
+}
+/** Create or update a draft. Returns the saved DraftID. */
+export declare function saveGridCostingDraft(req: SaveDraftRequest, session: any): Promise<APIResponse<{
+    DraftID: number;
+}>>;
+/** List the current user's drafts (newest first). */
+export declare function listGridCostingDrafts(session: any): Promise<APIResponse<GridCostingDraftSummary[]>>;
+/** Load a single draft (with RowsJson) by ID. */
+export declare function getGridCostingDraft(draftId: number, session: any): Promise<APIResponse<GridCostingDraftFull>>;
+/** Soft-delete a draft. */
+export declare function deleteGridCostingDraft(draftId: number, session: any): Promise<APIResponse<{
+    Message: string;
+}>>;

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

@@ -0,0 +1,21 @@
+'use client';
+// Grid Costing — Drafts API
+// Save/resume bulk-costing work in progress. Multiple named drafts per user,
+// scoped server-side to the session's CompanyID + UserID.
+import APIClient from '../core/client.js';
+/** Create or update a draft. Returns the saved DraftID. */
+export async function saveGridCostingDraft(req, session) {
+    return APIClient.post('api/gridcostingdraft/save', req, session);
+}
+/** List the current user's drafts (newest first). */
+export async function listGridCostingDrafts(session) {
+    return APIClient.get('api/gridcostingdraft/list', session);
+}
+/** Load a single draft (with RowsJson) by ID. */
+export async function getGridCostingDraft(draftId, session) {
+    return APIClient.get(`api/gridcostingdraft/get/${draftId}`, session);
+}
+/** Soft-delete a draft. */
+export async function deleteGridCostingDraft(draftId, session) {
+    return APIClient.post(`api/gridcostingdraft/delete/${draftId}`, {}, session);
+}

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

@@ -0,0 +1,353 @@
+import type { APIResponse } from '../core/types.js';
+export interface GridCostingImportResult {
+    rows: GridCostingRowDto[];
+    materialColumns: MaterialColumnDto[];
+    remarks: TransformerRemarkDto[];
+    unmappedHeaders: string[];
+    totalRowsParsed: number;
+    headerRowIndex: number;
+    mappedHeaders: Record<string, string>;
+    ignoredHeaders: string[];
+    columnMap: ColumnMappingDto[];
+}
+export interface ColumnMappingDto {
+    colIndex: number;
+    rawHeader: string;
+    /** field | paperQuality | material | ignored | unmapped */
+    classification: string;
+    /** Assigned field name (e.g. "clientName") or null */
+    fieldName: string | null;
+    /** How matched: "alias" | "smart" | "data" | "user" | null */
+    matchMethod: string | null;
+    /** For paperQuality columns only: 0 = Board, 1 = Kraft, 2 = Liner */
+    pqGroupIndex?: number;
+    /** Sample values from first few data rows */
+    sampleValues: string[];
+}
+export interface GridCostingRowDto {
+    srNo: number;
+    status: string;
+    projectNo: string;
+    quoteBookingId: string;
+    productionUnit: string;
+    salesPerson: string;
+    clientName: string;
+    consignee: string;
+    deliveryLocation: string;
+    category: string;
+    contentType: string;
+    jobName: string;
+    quantity: string;
+    annualQuantity: string;
+    length: string;
+    width: string;
+    height: string;
+    sheetSizeL?: string;
+    sheetSizeW?: string;
+    noOfUps: string;
+    opening: string;
+    pasting: string;
+    bottom: string;
+    bottomFlapPer?: string;
+    tongueHeight?: string;
+    flapHeight?: string;
+    corrugation: string;
+    paperQuality: PaperQualityDto[];
+    frontColors: string;
+    backColors: string;
+    specialFrontColor?: string;
+    specialBackColor?: string;
+    machine: string;
+    asPerBid: string;
+    variants: string;
+    variablePrinting: string;
+    wastageType: string;
+    materials: Record<string, string>;
+    revisedMOQ: string;
+    remark: string;
+    /**
+     * Process matrix from the import template: header (process name) → cell value
+     * (Yes/No). A process applies to this job when its value is Yes/1/true.
+     * Resolved to selectedProcesses on map.
+     */
+    processMatrix?: Record<string, string>;
+    /**
+     * Material matrix from the import template: header "Process :: Material" →
+     * cell value (Yes/No). A material is pre-ticked under its process when the
+     * value is Yes/1/true. Resolved to selectedProcesses[].Items on map.
+     */
+    materialMatrix?: Record<string, string>;
+    /**
+     * Corrugation spec from the import template: ply count + ONE shared flute spec
+     * + ONE shared liner spec (top sheet = the main paper). The page expands this
+     * into the full alternating ply array → CorrugationPlyData JSON at cost time.
+     */
+    corrugationSpec?: CorrugationSpecDto;
+    remarks: TransformerRemarkDto[];
+}
+/** Shared corrugation spec: ply count + one flute + one liner spec. */
+export interface CorrugationSpecDto {
+    noOfPly: number;
+    flute: {
+        fluteName: string;
+        quality: string;
+        gsm: number;
+        bf: number;
+    };
+    liner: {
+        quality: string;
+        gsm: number;
+        bf: number;
+    };
+}
+export interface PaperQualityDto {
+    type: string;
+    board: string;
+    gsm: string;
+    mill: string;
+    rate: string;
+    finish?: string;
+    brand?: string;
+    bf?: string;
+}
+export interface MaterialColumnDto {
+    id: string;
+    name: string;
+    rate: string;
+}
+export interface TransformerRemarkDto {
+    field: string;
+    message: string;
+    severity: string;
+}
+export declare function importGridCostingExcel(file: File, session: any): Promise<APIResponse<GridCostingImportResult>>;
+export declare function saveGridCosting(payload: {
+    Rows: any[];
+    MaterialColumns: any[];
+    Name?: string;
+}, session: any): Promise<APIResponse<{
+    Message: string;
+    GridCostingID: number;
+    RowCount: number;
+}>>;
+export declare function getGridCostingList(session: any): Promise<APIResponse<any[]>>;
+export declare function getGridCostingById(id: number, session: any): Promise<APIResponse<any>>;
+export interface GridCostResult {
+    sheetSize: string;
+    noOfUps: number;
+    noOfSheets: number;
+    boardKgs: number;
+    boardRatePerKg: number;
+    boardValue: number;
+    exWorks: number;
+    pkr: number;
+    psr: number;
+    totalRMC: number;
+    rmcPercent: number;
+    conversionCost: number;
+    freight: number;
+    fob: number;
+    kraftLinerValue: number;
+    error?: string;
+}
+export interface BatchResultItem {
+    rowIndex: number;
+    result: GridCostResult | null;
+}
+/** Calculate costing for a single row — payload must match Shirin_Job input shape */
+export declare function calculateGridCosting(payload: Record<string, any>, session: any): Promise<APIResponse<GridCostResult>>;
+/** Calculate costing for multiple rows in parallel (backend batches up to 10 concurrent) */
+export declare function calculateGridCostingBatch(rows: Record<string, any>[], session: any): Promise<APIResponse<BatchResultItem[]>>;
+/** Full result tables from BulkShirinJob — cached per row for later save */
+export interface BulkShirinJobResult {
+    TblBooking: Record<string, any>[];
+    TblPlanning: Record<string, any>[];
+    TblOperations: Record<string, any>[];
+    TblAllocatedMaterials: Record<string, any>[];
+    TblMaterialCostParams: Record<string, any>[];
+    TblContentSpecData: Record<string, any>[];
+    CostingData: Record<string, any>[];
+    TblDeliverySpecData: Record<string, any>[];
+    TblCorrugationPlyDetails: Record<string, any>[];
+}
+/** Response item from BulkShirinJob */
+export interface BulkShirinJobResultItem {
+    JobIndex: number;
+    Status: 'Success' | 'Error';
+    Result?: BulkShirinJobResult;
+    Error?: string;
+}
+/** Process entry for BulkShirinJob (Case 2 — with materials) */
+export interface BulkShirinJobProcess {
+    ProcessID: number;
+    MachineID: number;
+    Items: {
+        ItemSubGroupID: number;
+        ItemID: number;
+        Rate?: number;
+    }[];
+}
+/** Calculate costing for multiple jobs via BulkShirinJob (planwindow) */
+export declare function bulkShirinJob(jobs: Record<string, any>[], session: any): Promise<APIResponse<BulkShirinJobResultItem[]>>;
+export interface BulkCostingStartResponse {
+    jobId: string;
+    status: string;
+    jobCount: number;
+}
+export interface BulkCostingSummaryRow {
+    JobIndex: number;
+    JobName: string;
+    Status: 'Success' | 'Error';
+    Error: string | null;
+    BoardKgs: number;
+    BoardRatePerKg: number;
+    BoardValue: number;
+    KraftLinerValue: number;
+    ExWorks: number;
+    Profit: number;
+    Freight: number;
+    FOB: number;
+    SheetSize: string;
+    NoOfSheets: number;
+    NoOfUps: number;
+    WastagePercent?: number;
+    CutSize?: string;
+    TotalRMC: number;
+    RMCPercent: number;
+    ConversionCost: number;
+    PSR: number;
+    PKRBefore: number;
+    PKRAfter: number;
+    ExistingBefore: number;
+    ExistingAfter: number;
+    PriceIncPercent: number;
+    TotalPriceDcr: number;
+    RevisedRate: number;
+    PercentOfDiff: number;
+    ProcessCosts?: BulkCostingProcessCost[];
+    PlateAmount?: number;
+    PrintingAmount?: number;
+    MakeReadyAmount?: number;
+    CostQuantity?: number;
+    ImpressionsToBeCharged?: number;
+    PrintingRate?: number;
+    /** Rate per plate from the winning plan row. */
+    PlateRate?: number;
+    FirstRate?: number;
+    SecondRate?: number;
+}
+export interface BulkCostingProcessCost {
+    ProcessID: number;
+    ProcessName: string;
+    DepartmentID: number;
+    ProcessCost: number;
+    /** Process rate from TblOperations (first non-zero row). */
+    Rate?: number;
+}
+export interface BulkCostingStatusResponse {
+    status: 'queued' | 'processing' | 'completed' | 'failed' | 'saved';
+    progress: number;
+    jobCount: number;
+    successCount: number;
+    errorCount: number;
+    summary?: BulkCostingSummaryRow[];
+    errorMessage?: string;
+}
+export declare function startBulkCosting(jobs: Record<string, any>[], session: any): Promise<APIResponse<BulkCostingStartResponse>>;
+export declare function getBulkCostingStatus(jobId: string, session: any): Promise<APIResponse<BulkCostingStatusResponse>>;
+export interface BulkCostingPreviewRow {
+    JobIndex: number;
+    Status: 'Success' | 'Error';
+    /** Full Shirin_Job result — TblPlanning, TblOperations, CostingData, etc. */
+    Result?: Record<string, any>;
+    Error?: string;
+}
+export interface BulkCostingPreviewResponse {
+    page: number;
+    pageSize: number;
+    total: number;
+    rows: BulkCostingPreviewRow[];
+}
+export declare function getBulkCostingPreview(jobId: string, session: any, page?: number, pageSize?: number): Promise<APIResponse<BulkCostingPreviewResponse>>;
+export interface BulkCostingCombinationItem {
+    ItemSubGroupID: number;
+    ItemSubGroupName?: string;
+    ItemID: number;
+    ItemName?: string;
+    EstimationRate?: number;
+}
+export interface BulkCostingCombinationProcess {
+    ProcessID: number;
+    ProcessName?: string;
+    MachineID: number;
+    MachineName?: string;
+    Items: BulkCostingCombinationItem[];
+}
+export interface BulkCostingCombinationResponse {
+    CategoryID: number;
+    Processes: BulkCostingCombinationProcess[];
+}
+export declare function getBulkCostingCategoryCombination(categoryId: number, contentId: number, session: any, rateTier?: 'L1' | 'L2'): Promise<APIResponse<BulkCostingCombinationResponse>>;
+export interface BulkCostingSaveSubmitResponse {
+    saveBatchId: string;
+    status: 'queued';
+    totalJobs: number;
+}
+export interface BulkCostingSaveError {
+    jobIndex: number;
+    error: string;
+}
+export interface BulkCostingSaveStatusResponse {
+    status: 'queued' | 'processing' | 'completed' | 'failed';
+    progress: number;
+    totalJobs: number;
+    savedCount: number;
+    skippedCount: number;
+    bookingIds?: (number | string)[];
+    errors?: BulkCostingSaveError[];
+    errorMessage?: string;
+    costingJobId: string;
+}
+/**
+ * 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 declare function saveBulkCosting(jobId: string, session: any, jobIndexes?: number[]): Promise<APIResponse<BulkCostingSaveSubmitResponse>>;
+export declare function getBulkCostingSaveStatus(saveBatchId: string, session: any): Promise<APIResponse<BulkCostingSaveStatusResponse>>;
+export interface ValidateBatchRowInput {
+    rowIndex: number;
+    customer: string;
+    category: string;
+    salesPerson: string;
+    productionUnit: string;
+    machine: string;
+    contentType: string;
+}
+export interface ValidateBatchResolvedIds {
+    customer: string;
+    category: string;
+    salesPerson: string;
+    productionUnit: string;
+    machine: string;
+    contentName: string;
+}
+export interface ValidateBatchRowResult {
+    rowIndex: number;
+    valid: boolean;
+    ids: ValidateBatchResolvedIds;
+    errors: string[];
+}
+export interface ValidateBatchResponse {
+    rows: ValidateBatchRowResult[];
+}
+/**
+ * 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 declare function validateBatchAPI(rows: ValidateBatchRowInput[], session: any): Promise<APIResponse<ValidateBatchResponse>>;
+/** Delete a saved grid costing session */
+export declare function deleteGridCosting(id: number, session: any): Promise<APIResponse<{
+    Message: string;
+}>>;