indas-ui 0.0.1 → 0.1.0

package/dist/lib/api/enquiry/rate-enquiry.d.ts

@@ -0,0 +1,97 @@
+import type { APIResponse } from '../core/types.js';
+export interface RateQueryItem {
+    RequestId: number;
+    RequestNumber: string;
+    UserID: number;
+    RequestorName?: string;
+    RequestorEmail?: string;
+    Department?: string;
+    RequestMessage: string;
+    RequestData?: string;
+    AssignedToUserId?: number;
+    AssignedToEmail?: string;
+    AssignedToName?: string;
+    EscalationData?: string;
+    ResponseData?: string;
+    Status: string;
+    CreatedAt?: string;
+    UpdatedAt?: string;
+    RefEnquiryID?: number;
+    RefEnquiryNo?: string;
+}
+export interface ParsedEscalation {
+    level: number;
+    responsibleId: number;
+    responsibleName: string;
+    responsibleEmail: string;
+    escalatedAt?: string;
+    slaHours: number;
+}
+export interface ParsedResponse {
+    rate: string;
+    providedBy: number;
+    providedByName: string;
+    respondedAt: string;
+    remarks: string;
+}
+export declare class RateEnquiryAPI {
+    static createRateRequest(data: {
+        UserID: number;
+        Department?: string;
+        RequestMessage: string;
+        RequestData?: string;
+        AssignedToUserId?: number;
+        AssignedToEmail?: string;
+        SLAHours?: number;
+        RefEnquiryID?: number;
+    }, session: any): Promise<APIResponse>;
+    static provideRate(requestId: number, userId: number, rate: string, remarks?: string, session?: any): Promise<APIResponse>;
+    static deleteRateRequest(requestId: number, session?: any): Promise<APIResponse>;
+    static getAllRateRequests(session: any, filters?: {
+        status?: string;
+    }): Promise<APIResponse<RateQueryItem[]>>;
+    static getRateRequestById(id: number, session: any): Promise<APIResponse<RateQueryItem>>;
+    static getUserRateRequests(userId: number, session: any, status?: string): Promise<APIResponse<RateQueryItem[]>>;
+    static getEscalateTarget(requestId: number, session: any): Promise<APIResponse<{
+        targetName: string;
+        canEscalate: boolean;
+    }>>;
+    static escalateRequest(requestId: number, session: any): Promise<APIResponse>;
+    static sendEmail(data: {
+        ToEmail: string;
+        ToName?: string;
+        Subject: string;
+        Body: string;
+        CcEmails?: string[];
+    }, session: any): Promise<APIResponse>;
+    static sendRateRequestEmail(data: {
+        ToEmail: string;
+        ToName?: string;
+        RequestNumber?: string;
+        RefEnquiryNo?: string;
+        RequestMessage?: string;
+        Remark?: string;
+        ItemName?: string;
+        ItemLines?: {
+            group: string;
+            productionUnit: string;
+            specs: string;
+        }[];
+        ActionLink?: string;
+    }, session: any): Promise<APIResponse>;
+    static sendRateProvidedEmail(data: {
+        ToEmail: string;
+        ToName?: string;
+        RequestNumber?: string;
+        Rate?: string;
+        RateProviderName?: string;
+        RateRows?: {
+            item: string;
+            l1: string;
+            l2: string;
+        }[];
+        Remark?: string;
+    }, session: any): Promise<APIResponse>;
+}
+export declare function parseEscalationData(json?: string): ParsedEscalation | null;
+export declare function parseResponseData(json?: string): ParsedResponse | null;

package/dist/lib/api/enquiry/rate-enquiry.js

@@ -0,0 +1,69 @@
+'use client';
+// Rate Enquiry API — matches new single-table RateEnquiry schema
+import APIClient from '../core/client.js';
+// ============================================================
+//  API Class
+// ============================================================
+export class RateEnquiryAPI {
+    // ── Rate Requests ─────────────────────────────────────────
+    static async createRateRequest(data, session) {
+        return APIClient.post('api/RateEnquiry/rate-request/create', data, session);
+    }
+    static async provideRate(requestId, userId, rate, remarks, session) {
+        return APIClient.post('api/RateEnquiry/rate-request/provide-rate', { RequestId: requestId, UserId: userId, Rate: rate, Remarks: remarks }, session);
+    }
+    static async deleteRateRequest(requestId, session) {
+        return APIClient.post(`api/RateEnquiry/rate-request/delete/${requestId}`, {}, session);
+    }
+    static async getAllRateRequests(session, filters) {
+        const params = new URLSearchParams();
+        if (filters?.status)
+            params.set('status', filters.status);
+        const qs = params.toString();
+        return APIClient.get(`api/RateEnquiry/rate-request/all${qs ? `?${qs}` : ''}`, session);
+    }
+    static async getRateRequestById(id, session) {
+        return APIClient.get(`api/RateEnquiry/rate-request/${id}`, session);
+    }
+    static async getUserRateRequests(userId, session, status) {
+        const qs = status ? `?status=${encodeURIComponent(status)}` : '';
+        return APIClient.get(`api/RateEnquiry/rate-request/user/${userId}${qs}`, session);
+    }
+    static async getEscalateTarget(requestId, session) {
+        return APIClient.get(`api/RateEnquiry/rate-request/escalate-target/${requestId}`, session);
+    }
+    static async escalateRequest(requestId, session) {
+        return APIClient.post('api/RateEnquiry/rate-request/escalate', { RequestId: requestId }, session);
+    }
+    // ── Email ─────────────────────────────────────────────────
+    static async sendEmail(data, session) {
+        return APIClient.post('api/RateEnquiry/mail/send', data, session);
+    }
+    static async sendRateRequestEmail(data, session) {
+        return APIClient.post('api/RateEnquiry/mail/send-rate-request', data, session);
+    }
+    static async sendRateProvidedEmail(data, session) {
+        return APIClient.post('api/RateEnquiry/mail/send-rate-provided', data, session);
+    }
+}
+// JSON parsing helpers
+export function parseEscalationData(json) {
+    if (!json)
+        return null;
+    try {
+        return JSON.parse(json);
+    }
+    catch {
+        return null;
+    }
+}
+export function parseResponseData(json) {
+    if (!json)
+        return null;
+    try {
+        return JSON.parse(json);
+    }
+    catch {
+        return null;
+    }
+}

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

@@ -0,0 +1,28 @@
+import type { APIResponse, Category, Client, SalesPerson } from '../core/types.js';
+/**
+ * Get all categories
+ * @param sessionData - Session data containing user and company info
+ * @returns Promise with categories array
+ */
+export declare function getCategoriesAPI(sessionData?: any): Promise<APIResponse<Category[]>>;
+/**
+ * Get all clients
+ * @param sessionData - Session data containing user and company info
+ * @returns Promise with clients array
+ */
+export declare function getClientsAPI(sessionData?: any): Promise<APIResponse<Client[]>>;
+/**
+ * Get all sales persons
+ * @param sessionData - Session data containing user and company info
+ * @returns Promise with sales persons array
+ */
+export declare function getSalesPersonsAPI(sessionData?: any): Promise<APIResponse<SalesPerson[]>>;
+/**
+ * Get the salesperson assigned to a specific client (LedgerMaster.RefSalesRepresentativeID).
+ * Returns { EmployeeID, EmployeeName } when the client has an assignment,
+ * or null when there is no assignment (caller should keep the existing list).
+ */
+export declare function getSalesPersonForClientAPI(ledgerId: number, sessionData?: any): Promise<APIResponse<{
+    EmployeeID: number;
+    EmployeeName: string;
+} | null>>;

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

@@ -0,0 +1,104 @@
+'use client';
+// Estimation Categories API
+// Handles categories, clients, and sales persons for estimation
+import APIClient from '../core/client.js';
+/**
+ * Get all categories
+ * @param sessionData - Session data containing user and company info
+ * @returns Promise with categories array
+ */
+export async function getCategoriesAPI(sessionData) {
+    try {
+        const endpoint = 'api/planwindow/GetSbCategory';
+        const response = await APIClient.get(endpoint, sessionData);
+        return response;
+    }
+    catch (error) {
+        console.error('❌ [getCategoriesAPI] Caught error:', error);
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to fetch categories'
+        };
+    }
+}
+/**
+ * Get all clients
+ * @param sessionData - Session data containing user and company info
+ * @returns Promise with clients array
+ */
+export async function getClientsAPI(sessionData) {
+    try {
+        const endpoint = 'api/planwindow/GetSbClient';
+        const response = await APIClient.get(endpoint, sessionData);
+        return response;
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to fetch clients'
+        };
+    }
+}
+/**
+ * Get all sales persons
+ * @param sessionData - Session data containing user and company info
+ * @returns Promise with sales persons array
+ */
+export async function getSalesPersonsAPI(sessionData) {
+    try {
+        const endpoint = 'api/planwindow/getsbsalesperson';
+        const response = await APIClient.get(endpoint, sessionData);
+        return response;
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to fetch sales persons'
+        };
+    }
+}
+/**
+ * Get the salesperson assigned to a specific client (LedgerMaster.RefSalesRepresentativeID).
+ * Returns { EmployeeID, EmployeeName } when the client has an assignment,
+ * or null when there is no assignment (caller should keep the existing list).
+ */
+export async function getSalesPersonForClientAPI(ledgerId, sessionData) {
+    try {
+        const endpoint = `api/planwindow/getsbsalespersondata/${ledgerId}`;
+        const response = await APIClient.get(endpoint, sessionData);
+        if (!response.success) {
+            return { success: false, error: response.error || 'Failed to fetch salesperson for client' };
+        }
+        // Backend body is a (possibly double-encoded) JSON string, or the literal "500" on error.
+        let rows = [];
+        const raw = response.data;
+        if (typeof raw === 'string') {
+            if (raw.trim() === '500' || raw.trim() === '"500"')
+                return { success: true, data: null };
+            try {
+                const once = JSON.parse(raw);
+                rows = typeof once === 'string' ? JSON.parse(once) : once;
+            }
+            catch {
+                rows = [];
+            }
+        }
+        else if (Array.isArray(raw)) {
+            rows = raw;
+        }
+        if (!Array.isArray(rows) || rows.length === 0)
+            return { success: true, data: null };
+        // Auto-pick discriminator: a single row with LedgerID > 0 means the client has an assigned salesperson.
+        // Anything else is the fallback list — treat as "no assignment".
+        if (rows.length === 1 && Number(rows[0].LedgerID) > 0) {
+            return { success: true, data: { EmployeeID: Number(rows[0].EmployeeID), EmployeeName: String(rows[0].EmployeeName || '') } };
+        }
+        return { success: true, data: null };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to fetch salesperson for client'
+        };
+    }
+}

package/dist/lib/api/estimation/category-defaults.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Category Default Configuration API
+ *
+ * API to fetch default values for margins, trimmings, and other parameters
+ * based on selected category
+ */
+import { Session } from 'next-auth';
+/**
+ * Category Default Configuration Response
+ */
+export interface CategoryDefaultConfig {
+    CategoryID: number;
+    MinimumAroundGap: number;
+    MaximumAroundGap: number;
+    DefaultAroundGap: number;
+    MinimumAcrossGap: number;
+    MaximumAcrossGap: number;
+    DefaultAcrossGap: number;
+    MinimumPlateBearer: number;
+    MaximumPlateBearer: number;
+    DefaultPlateBearer: number;
+    MinimumSideStrip: number;
+    MaximumSideStrip: number;
+    DefaultSideStrip: number;
+    DefaultPrintingMarginLeft: number;
+    DefaultPrintingMarginLeft1: number;
+    DefaultPrintingMarginRight: number;
+    DefaultPrintingMarginTop: number;
+    DefaultPrintingMarginBottom: number;
+    DefaultStrippingMarginLeft: number;
+    DefaultStrippingMarginRight: number;
+    DefaultStrippingMarginTop: number;
+    DefaultStrippingMarginBottom: number;
+    DefaultJobTrimmingTop: number;
+    DefaultJobTrimmingBottom: number;
+    DefaultJobTrimmingLeft: number;
+    DefaultJobTrimmingRight: number;
+    DefaultFactor: number;
+    DefaultPackingCostPercentage: number;
+    Layer: string;
+}
+/**
+ * Get category-wise default configuration
+ *
+ * Fetches default values for margins, trimmings, gaps, and other parameters
+ * based on the selected category
+ *
+ * @param categoryId - Category ID to fetch defaults for
+ * @param session - User session
+ * @returns Promise with category default configuration
+ */
+export declare function getCategoryDefaultsAPI(categoryId: number, session: Session): Promise<{
+    success: boolean;
+    data?: CategoryDefaultConfig;
+    error?: string;
+}>;

package/dist/lib/api/estimation/category-defaults.js

@@ -0,0 +1,41 @@
+'use client';
+/**
+ * Category Default Configuration API
+ *
+ * API to fetch default values for margins, trimmings, and other parameters
+ * based on selected category
+ */
+import APIClient from '../core/client.js';
+/**
+ * Get category-wise default configuration
+ *
+ * Fetches default values for margins, trimmings, gaps, and other parameters
+ * based on the selected category
+ *
+ * @param categoryId - Category ID to fetch defaults for
+ * @param session - User session
+ * @returns Promise with category default configuration
+ */
+export async function getCategoryDefaultsAPI(categoryId, session) {
+    try {
+        const response = await APIClient.get(`/api/planwindow/GetCategoryWiseDefaultConfiguration/${categoryId}`, session);
+        if (response.success && response.data && Array.isArray(response.data) && response.data.length > 0) {
+            const config = response.data[0];
+            return {
+                success: true,
+                data: config
+            };
+        }
+        return {
+            success: false,
+            error: 'No default configuration found for this category'
+        };
+    }
+    catch (error) {
+        console.error('❌ [CATEGORY_DEFAULTS] Error fetching defaults:', error);
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to fetch category defaults'
+        };
+    }
+}

package/dist/lib/api/estimation/company-config.d.ts

@@ -0,0 +1,59 @@
+import type { APIResponse } from '../core/types.js';
+/**
+ * Company Configuration interface
+ */
+export interface CompanyConfiguration {
+    ShowPlanUptoWastagePerc: number;
+    JobReleasedChecklistFeature: boolean;
+    IsGstApplicable: boolean;
+    IsVatApplicable: boolean;
+    IsEinvoiceApplicable: boolean;
+    CurrencyHeadName: string;
+    CurrencyChildName: string;
+    CurrencyCode: string;
+    CurrencySymboliconRef: string;
+    TaxApplicableBranchWise: boolean;
+    CostEstimationMethodType: string;
+    EstimationRoundOffDecimalPlace: number;
+    PurchaseRoundOffDecimalPlace: number;
+    InvoiceRoundOffDecimalPlace: number;
+    DefaultTaxLedgerTypeName: string;
+    IsInternalApprovalRequired: boolean;
+    CannotViewCostingDetail: boolean;
+    CanCopyQuotation: boolean;
+    CanDeleteQuotation: boolean;
+    CanRejectQuotation: boolean;
+    CanPrintQuotation: boolean;
+    CanReviewQuotation: boolean;
+    CanReviseQuotation: boolean;
+    CanUserViewOtherQuotation: boolean;
+    CanSendQuotationForSO: boolean;
+    CanCheckEstimatedJobDetails: boolean;
+    CanCheckEstimatedDetailCosting: boolean;
+    CanAssignEnquiry: boolean;
+    CanEditApprovedCostInPriceApproval: boolean;
+    CanEditPOQuantityAndRate: boolean;
+    CanEditMaterialCostParameter: boolean;
+    WtCalculateOnEstimation: string;
+    EstimationPerUnitCostDecimalPlace: number;
+    AcceptSOLessThanEstimatedQty: boolean;
+    TypeOfCost: string;
+    ProcessWiseWastageTypeSetting: number;
+    IsMarginBasedApproval: boolean;
+    IsHeadCustomerApproval: boolean;
+    IsExcludeFromProfit: boolean;
+    StatusLabels: string;
+    GridCostingColumnConfig: string;
+}
+/**
+ * Company Configuration API class
+ * Manages company configurations for estimation
+ */
+export declare class CompanyConfigAPI {
+    /**
+     * Get company configurations
+     * Called when estimation page opens
+     * @param sessionData - Session data (REQUIRED)
+     */
+    static getCompanyConfigurations(sessionData?: any): Promise<APIResponse<CompanyConfiguration[]>>;
+}

package/dist/lib/api/estimation/company-config.js

@@ -0,0 +1,19 @@
+'use client';
+// Company Configuration API
+// Handles company configurations for estimation module
+// Called when estimation page opens
+import APIClient from '../core/client.js';
+/**
+ * Company Configuration API class
+ * Manages company configurations for estimation
+ */
+export class CompanyConfigAPI {
+    /**
+     * Get company configurations
+     * Called when estimation page opens
+     * @param sessionData - Session data (REQUIRED)
+     */
+    static async getCompanyConfigurations(sessionData) {
+        return APIClient.post('api/othermaster/getcompanyconfigrations', {}, sessionData);
+    }
+}

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

@@ -0,0 +1,103 @@
+import type { APIResponse } from '../core/types.js';
+/**
+ * Content data interface based on the provided JSON structure
+ */
+export interface ContentItem {
+    ContentID: number;
+    ContentName: string;
+    ContentCaption: string;
+    ContentOpenHref: string;
+    ContentClosedHref: string;
+    ContentSizes: string;
+    ContentDomainType: string;
+    ContentSizeInputUnit: string;
+    ContentSizeInputDecimalValue: number;
+    ContentOrientation?: string;
+    ZipperWeightPerMeter?: number;
+    SizeZipperLength?: number;
+    IsDefaultContent?: boolean | string | number;
+}
+/**
+ * Parsed content sizes for easier handling
+ */
+export interface ParsedContentSizes {
+    SizeHeight?: boolean;
+    SizeWidth?: boolean;
+    SizeLength?: boolean;
+    JobPrePlan?: boolean;
+    JobAcrossUps?: boolean;
+    JobAroundUps?: boolean;
+    JobUps?: boolean;
+}
+/**
+ * Content display interface with normalized image paths
+ */
+export interface DisplayContent extends ContentItem {
+    imagePath: string;
+    imagePathClosed?: string;
+    availableSizes: ParsedContentSizes;
+    displayColor: string;
+}
+/**
+ * Content API class for handling content-related operations
+ */
+export declare 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 getCategoryAllocatedContents(categoryID: string | number, sessionData?: any): Promise<APIResponse<ContentItem[]>>;
+    /**
+     * Parse content sizes string into a more usable object
+     * @param contentSizes - Comma-separated string like "SizeHeight,SizeWidth"
+     * @returns Parsed sizes object
+     */
+    static parseContentSizes(contentSizes: string): ParsedContentSizes;
+    /**
+     * 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: string): string;
+    /**
+     * Get display color based on content domain type
+     * @param domainType - The domain type like "Flexo", "Offset", etc.
+     * @returns CSS color class
+     */
+    static getDisplayColor(domainType: string): string;
+    /**
+     * Transform API content items to display-ready format
+     * @param contentItems - Raw content items from API
+     * @returns Display-ready content items
+     */
+    static transformForDisplay(contentItems: ContentItem[]): DisplayContent[];
+    /**
+     * 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 getDisplayContents(categoryID: string | number, sessionData?: any): Promise<APIResponse<DisplayContent[]>>;
+    /**
+     * 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: DisplayContent[], searchTerm: string): DisplayContent[];
+    /**
+     * 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: DisplayContent[], domainType: string): DisplayContent[];
+    /**
+     * Get unique domain types from content items
+     * @param contentItems - Array of content items
+     * @returns Array of unique domain types
+     */
+    static getUniqueDomainTypes(contentItems: DisplayContent[]): string[];
+}