indas-ui 0.0.1 → 0.1.0

package/dist/cjs/lib/api/ai/chat.js

@@ -0,0 +1,227 @@
+'use client';
+"use strict";
+/**
+ * AI Chat API Functions
+ * Connects to main backend for Parksons AI chat (ParksonsBotController)
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendChatMessageAPI = sendChatMessageAPI;
+exports.getConversationsAPI = getConversationsAPI;
+exports.getMessagesAPI = getMessagesAPI;
+exports.deleteMessagesAfterAPI = deleteMessagesAfterAPI;
+exports.renameConversationAPI = renameConversationAPI;
+exports.toggleStarConversationAPI = toggleStarConversationAPI;
+exports.getHelpCombinationsAPI = getHelpCombinationsAPI;
+exports.submitMessageFeedbackAPI = submitMessageFeedbackAPI;
+exports.deleteConversationAPI = deleteConversationAPI;
+exports.duplicateConversationAPI = duplicateConversationAPI;
+const client_1 = __importDefault(require("../core/client.js"));
+/**
+ * Send a chat message to the AI
+ * Returns standard APIResponse plus optional userMessageId from X-User-MessageID header
+ */
+async function sendChatMessageAPI(params, sessionData, signal) {
+    try {
+        // Costingbot turns can take 30-90s when the model chains multiple tools
+        // (validation → costing → freight). The default 60s timeout aborts legit
+        // turns mid-flight, leaving the server with a half-finished AiMessages row
+        // and no assistant reply. 3 minutes is a sane upper bound — the user's
+        // Stop button (signal) is the meaningful cancel for normal use.
+        const response = await client_1.default.post('/api/synthia/costingbot', {
+            message: params.message,
+            conversationId: params.conversationId,
+            newChat: params.newChat,
+            title: params.title,
+            phone: params.phone || sessionData?.user?.UserID?.toString() || '9999999999'
+        }, sessionData, undefined, signal, 180000);
+        // Try to extract tokens + ui_data if backend returns JSON with { message, tokens, ui_data }
+        let tokens;
+        let ui_data;
+        let messageContent = response.data;
+        if (typeof response.data === 'string') {
+            try {
+                const parsed = JSON.parse(response.data);
+                if (parsed.message && parsed.tokens) {
+                    messageContent = parsed.message;
+                    tokens = parsed.tokens;
+                    if (Array.isArray(parsed.ui_data)) {
+                        ui_data = parsed.ui_data.filter((e) => e.version === 1);
+                    }
+                }
+            }
+            catch {
+                // Not JSON — plain string response, that's fine
+            }
+        }
+        else if (response.data && typeof response.data === 'object') {
+            const obj = response.data;
+            if (obj.message && obj.tokens) {
+                messageContent = obj.message;
+                tokens = obj.tokens;
+                if (Array.isArray(obj.ui_data)) {
+                    ui_data = obj.ui_data.filter(e => e.version === 1);
+                }
+            }
+        }
+        const convIdRaw = response.responseHeaders?.['X-Conversation-ID'];
+        const conversationId = convIdRaw ? Number(convIdRaw) : undefined;
+        return {
+            ...response,
+            data: messageContent,
+            userMessageId: response.responseHeaders?.['X-User-MessageID'],
+            conversationId: Number.isFinite(conversationId) ? conversationId : undefined,
+            tokens,
+            ui_data
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to send message'
+        };
+    }
+}
+/**
+ * Get all conversations for current user
+ */
+async function getConversationsAPI(sessionData) {
+    try {
+        const response = await client_1.default.get('/api/synthia/conversations', sessionData);
+        return response;
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to load conversations'
+        };
+    }
+}
+/**
+ * Get messages for a specific conversation
+ */
+async function getMessagesAPI(conversationId, sessionData) {
+    try {
+        const response = await client_1.default.get(`/api/synthia/messages/${conversationId}`, sessionData);
+        return response;
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to load messages'
+        };
+    }
+}
+/**
+ * Delete all messages after a specific message in a conversation (cascade delete on edit/resend)
+ * Backend uses [HttpGet] route
+ */
+async function deleteMessagesAfterAPI(conversationId, messageId, sessionData) {
+    try {
+        const response = await client_1.default.get(`/api/synthia/delete-messages-after/${conversationId}/${messageId}`, sessionData);
+        return response;
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to delete messages'
+        };
+    }
+}
+/**
+ * Rename a conversation
+ */
+async function renameConversationAPI(conversationId, title, sessionData) {
+    try {
+        const response = await client_1.default.post(`/api/synthia/rename-conversation/${conversationId}`, { title }, sessionData);
+        return response;
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to rename conversation'
+        };
+    }
+}
+/**
+ * Toggle star (favorite) on a conversation — server flips the state and returns the new value
+ */
+async function toggleStarConversationAPI(conversationId, sessionData) {
+    try {
+        const response = await client_1.default.post(`/api/synthia/toggle-star/${conversationId}`, undefined, sessionData);
+        return response;
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to toggle star'
+        };
+    }
+}
+async function getHelpCombinationsAPI(sessionData, opts) {
+    try {
+        const params = [];
+        if (opts?.contentType)
+            params.push(`contentType=${encodeURIComponent(opts.contentType)}`);
+        if (opts?.contentId != null)
+            params.push(`contentId=${opts.contentId}`);
+        const qs = params.length > 0 ? `?${params.join('&')}` : '';
+        const response = await client_1.default.get(`/api/synthia/help/combinations${qs}`, sessionData);
+        if (response.success && response.data && typeof response.data === 'object') {
+            const obj = response.data;
+            return { ...response, data: Array.isArray(obj.categories) ? obj.categories : [] };
+        }
+        return { ...response, data: [] };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to load categories'
+        };
+    }
+}
+/**
+ * Submit thumbs up/down feedback on an AI message. Pass null to clear.
+ */
+async function submitMessageFeedbackAPI(messageId, rating, sessionData) {
+    try {
+        const response = await client_1.default.post(`/api/synthia/messages/${messageId}/feedback`, { rating }, sessionData);
+        return response;
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to submit feedback'
+        };
+    }
+}
+/**
+ * Delete a conversation
+ * Backend uses [HttpGet] route
+ */
+async function deleteConversationAPI(conversationId, sessionData) {
+    try {
+        const response = await client_1.default.get(`/api/synthia/delete-conversation/${conversationId}`, sessionData);
+        return response;
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to delete conversation'
+        };
+    }
+}
+async function duplicateConversationAPI(conversationId, sessionData) {
+    try {
+        const response = await client_1.default.post(`/api/synthia/duplicate-conversation/${conversationId}`, {}, sessionData);
+        return response;
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to duplicate conversation'
+        };
+    }
+}

package/dist/cjs/lib/api/ai/types.js

@@ -0,0 +1,6 @@
+'use client';
+"use strict";
+/**
+ * AI Chat API Types
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/lib/api/approval/approvals.js

@@ -0,0 +1,210 @@
+'use client';
+"use strict";
+/**
+ * Approval Workflow API Client
+ *
+ * Handles multi-level approval workflows for quotations, master data changes, etc.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const client_1 = __importDefault(require("../core/client.js"));
+/**
+ * Approval API
+ */
+class ApprovalAPI {
+    /**
+     * Request approval for an entity
+     */
+    static async requestApproval(entityType, entityId, comments, metadata, session) {
+        try {
+            const requestBody = {
+                UserID: session?.user?.UserID?.toString() || '',
+                CompanyID: session?.user?.CompanyID?.toString() || '',
+                EntityType: entityType,
+                EntityID: entityId,
+                Comments: comments,
+                Metadata: metadata
+            };
+            const response = await client_1.default.post('/api/approval/request', requestBody, session);
+            if (response.success && response.data?.data) {
+                return {
+                    success: true,
+                    data: response.data.data
+                };
+            }
+            return {
+                success: false,
+                error: response.error || 'Failed to request approval'
+            };
+        }
+        catch (error) {
+            console.error('❌ [Approval API] Error requesting approval:', error);
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error'
+            };
+        }
+    }
+    /**
+     * Approve a request
+     */
+    static async approve(approvalId, comments, session) {
+        try {
+            const requestBody = {
+                UserID: session?.user?.UserID?.toString() || '',
+                ApprovalID: approvalId,
+                Action: 'APPROVE',
+                Comments: comments
+            };
+            const response = await client_1.default.post('/api/approval/process', requestBody, session);
+            if (response.success && response.data?.data) {
+                return {
+                    success: true,
+                    data: response.data.data
+                };
+            }
+            return {
+                success: false,
+                error: response.error || 'Failed to approve request'
+            };
+        }
+        catch (error) {
+            console.error('❌ [Approval API] Error approving request:', error);
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error'
+            };
+        }
+    }
+    /**
+     * Reject a request
+     */
+    static async reject(approvalId, comments, session) {
+        try {
+            const requestBody = {
+                UserID: session?.user?.UserID?.toString() || '',
+                ApprovalID: approvalId,
+                Action: 'REJECT',
+                Comments: comments
+            };
+            const response = await client_1.default.post('/api/approval/process', requestBody, session);
+            if (response.success && response.data?.data) {
+                return {
+                    success: true,
+                    data: response.data.data
+                };
+            }
+            return {
+                success: false,
+                error: response.error || 'Failed to reject request'
+            };
+        }
+        catch (error) {
+            console.error('❌ [Approval API] Error rejecting request:', error);
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error'
+            };
+        }
+    }
+    /**
+     * Escalate approval to another user
+     */
+    static async escalate(approvalId, toUserId, reason, session) {
+        try {
+            const requestBody = {
+                UserID: session?.user?.UserID?.toString() || '',
+                ApprovalID: approvalId,
+                ToUserID: toUserId,
+                Reason: reason || ''
+            };
+            const response = await client_1.default.post('/api/approval/escalate', requestBody, session);
+            if (response.success && response.data?.data) {
+                return {
+                    success: true,
+                    data: response.data.data
+                };
+            }
+            return {
+                success: false,
+                error: response.error || 'Failed to escalate approval'
+            };
+        }
+        catch (error) {
+            console.error('❌ [Approval API] Error escalating approval:', error);
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error'
+            };
+        }
+    }
+    /**
+     * Get pending approvals for current user.
+     *
+     * Backend endpoint /api/approval/pending does not exist yet. Returning an
+     * empty list short-circuits the 60s fetch timeout that was firing on every
+     * estimation page load. Un-stub once the backend controller ships.
+     */
+    static async getPendingApprovals(_session) {
+        return { success: true, data: [] };
+    }
+    /**
+     * Get approval chain for an entity (full history)
+     */
+    static async getApprovalChain(entityType, entityId, session) {
+        try {
+            const companyId = session?.user?.CompanyID?.toString() || '';
+            const response = await client_1.default.get(`/api/approval/chain/${entityType}/${entityId}?companyId=${companyId}`, session);
+            if (response.success && response.data?.data) {
+                return {
+                    success: true,
+                    data: response.data.data
+                };
+            }
+            return {
+                success: false,
+                error: response.error || 'Failed to get approval chain'
+            };
+        }
+        catch (error) {
+            console.error('❌ [Approval API] Error getting approval chain:', error);
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error'
+            };
+        }
+    }
+    /**
+     * Withdraw an approval request
+     */
+    static async withdraw(approvalId, reason, session) {
+        try {
+            const requestBody = {
+                UserID: session?.user?.UserID?.toString() || '',
+                ApprovalID: approvalId,
+                Reason: reason
+            };
+            const response = await client_1.default.post('/api/approval/withdraw', requestBody, session);
+            if (response.success) {
+                return {
+                    success: true,
+                    data: { message: response.data?.message || 'Approval withdrawn successfully' }
+                };
+            }
+            return {
+                success: false,
+                error: response.error || 'Failed to withdraw approval'
+            };
+        }
+        catch (error) {
+            console.error('❌ [Approval API] Error withdrawing approval:', error);
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error'
+            };
+        }
+    }
+}
+exports.default = ApprovalAPI;

package/dist/cjs/lib/api/approval/index.js

@@ -0,0 +1,13 @@
+'use client';
+"use strict";
+/**
+ * Approval API Module
+ * Exports approval workflow functionality
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApprovalAPI = void 0;
+var approvals_1 = require("./approvals.js");
+Object.defineProperty(exports, "ApprovalAPI", { enumerable: true, get: function () { return __importDefault(approvals_1).default; } });

package/dist/cjs/lib/api/auth/auth.js

@@ -0,0 +1,154 @@
+'use client';
+"use strict";
+// Authentication API
+// Handles user authentication
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setAuthAPIConfig = setAuthAPIConfig;
+exports.getAuthAPIConfig = getAuthAPIConfig;
+exports.clearAuthAPIConfig = clearAuthAPIConfig;
+exports.authenticateUser = authenticateUser;
+const auth_helpers_1 = require("../core/auth-helpers.js");
+const config_1 = require("../core/config.js");
+let apiConfig = null;
+function setAuthAPIConfig(config) {
+    if (!config.baseURL) {
+        throw new Error('Invalid API configuration: baseURL is required');
+    }
+    // Validate URL format
+    try {
+        new URL(config.baseURL);
+    }
+    catch {
+        throw new Error('Invalid baseURL format');
+    }
+    // Ensure authEndpoint starts with / (if provided)
+    if (config.authEndpoint && !config.authEndpoint.startsWith('/')) {
+        config.authEndpoint = '/' + config.authEndpoint;
+    }
+    apiConfig = config;
+    // IMPORTANT: Also update global API config for loginAPI to use
+    // This ensures company credentials are available for authentication
+    if (config.username && config.password) {
+        (0, config_1.setGlobalAPIConfig)({
+            baseURL: config.baseURL,
+            username: config.username,
+            password: config.password,
+            timeout: 60000
+        });
+    }
+    // Persist configuration for session
+    if (typeof window !== 'undefined') {
+        sessionStorage.setItem('auth-api-config', JSON.stringify(config));
+    }
+}
+function getAuthAPIConfig() {
+    if (apiConfig) {
+        return apiConfig;
+    }
+    // Try to restore from session storage
+    if (typeof window !== 'undefined') {
+        const stored = sessionStorage.getItem('auth-api-config');
+        if (stored) {
+            try {
+                apiConfig = JSON.parse(stored);
+                return apiConfig;
+            }
+            catch {
+                sessionStorage.removeItem('auth-api-config');
+            }
+        }
+    }
+    return null;
+}
+function clearAuthAPIConfig() {
+    apiConfig = null;
+    if (typeof window !== 'undefined') {
+        sessionStorage.removeItem('auth-api-config');
+    }
+}
+async function authenticateUser(credentials) {
+    // Use the new global API configuration
+    try {
+        const response = await (0, auth_helpers_1.loginAPI)(credentials.username, credentials.password);
+        if (response.success && response.data) {
+            // Handle array response format
+            let data = response.data;
+            // Check if data is a JSON string that needs parsing
+            if (typeof data === 'string') {
+                try {
+                    data = JSON.parse(data);
+                }
+                catch (parseError) {
+                    // Keep as is
+                }
+            }
+            if (Array.isArray(data) && data.length > 0) {
+                const userData = data[0]; // Take first user data object
+                // Map the response data to our UserData interface
+                const mappedUserData = {
+                    UserID: userData.UserID?.toString() || '',
+                    UserName: userData.UserName || '',
+                    FYear: userData.FYear || new Date().getFullYear().toString(),
+                    CompanyID: userData.CompanyID?.toString() || '',
+                    BranchID: userData.BranchID?.toString() || '',
+                    CompanyName: userData.CompanyName || '',
+                    ProductionUnitID: userData.ProductionUnitID?.toString() || '',
+                    IsAdmin: userData.UserType === 'Admin' || userData.IsAdmin === true,
+                    APIIntegrationRequired: userData.APIIntegrationRequired,
+                    APIBaseURL: userData.APIBaseURL,
+                    APIAuthenticationURL: userData.APIAuthenticationURL,
+                    HomePage: userData.HomePage,
+                    IsGstApplicable: userData.IsGstApplicable,
+                    IsVatApplicable: userData.IsVatApplicable,
+                    DefaultTaxLedgerTypeName: userData.DefaultTaxLedgerTypeName,
+                    IsEinvoiceApplicable: userData.IsEinvoiceApplicable,
+                    CurrencyHeadName: userData.CurrencyHeadName,
+                    CurrencyChildName: userData.CurrencyChildName,
+                    CurrencyCode: userData.CurrencyCode,
+                    CurrencySymboliconRef: userData.CurrencySymboliconRef,
+                    TaxApplicableBranchWise: userData.TaxApplicableBranchWise,
+                    EstimationRoundOffDecimalPlace: userData.EstimationRoundOffDecimalPlace,
+                    PurchaseRoundOffDecimalPlace: userData.PurchaseRoundOffDecimalPlace,
+                    InvoiceRoundOffDecimalPlace: userData.InvoiceRoundOffDecimalPlace,
+                    CostEstimationMethodType: userData.CostEstimationMethodType,
+                    OTPVerificationFeatureEnabled: userData.OTPVerificationFeatureEnabled,
+                    EmailID: userData.EmailID,
+                    // Role
+                    RoleID: userData.RoleID || userData.roleID || 0,
+                    RoleName: userData.RoleName || userData.roleName || '',
+                    DepartmentID: Number(userData.DepartmentID ?? userData.departmentID ?? 0),
+                    // SMTP Settings (handle various casing from API)
+                    smtpUserName: userData.smtpUserName || userData.SmtpUserName || userData.SMTPUserName,
+                    smtpUserPassword: userData.smtpUserPassword || userData.SmtpUserPassword || userData.SMTPUserPassword,
+                    smtpServer: userData.smtpServer || userData.SmtpServer || userData.SMTPServer,
+                    smtpServerPort: userData.smtpServerPort || userData.SmtpServerPort || userData.SMTPServerPort,
+                    smtpAuthenticate: userData.smtpAuthenticate || userData.SmtpAuthenticate || userData.SMTPAuthenticate,
+                    smtpUseSSL: userData.smtpUseSSL || userData.SmtpUseSSL || userData.SMTPUseSSL
+                };
+                return {
+                    success: true,
+                    user: mappedUserData,
+                    token: userData.token || userData.SessionToken || userData.authToken
+                };
+            }
+            else {
+                return {
+                    success: false,
+                    message: 'Invalid username or password'
+                };
+            }
+        }
+        else {
+            return {
+                success: false,
+                message: response.error || 'Authentication failed'
+            };
+        }
+    }
+    catch (error) {
+        return {
+            success: false,
+            message: error instanceof Error ? error.message : 'Authentication service error'
+        };
+    }
+}

package/dist/cjs/lib/api/auth/index.js

@@ -0,0 +1,11 @@
+'use client';
+"use strict";
+// Authentication API exports
+// Central export point for all authentication APIs
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearAuthAPIConfig = exports.getAuthAPIConfig = exports.setAuthAPIConfig = exports.authenticateUser = void 0;
+var auth_1 = require("./auth.js");
+Object.defineProperty(exports, "authenticateUser", { enumerable: true, get: function () { return auth_1.authenticateUser; } });
+Object.defineProperty(exports, "setAuthAPIConfig", { enumerable: true, get: function () { return auth_1.setAuthAPIConfig; } });
+Object.defineProperty(exports, "getAuthAPIConfig", { enumerable: true, get: function () { return auth_1.getAuthAPIConfig; } });
+Object.defineProperty(exports, "clearAuthAPIConfig", { enumerable: true, get: function () { return auth_1.clearAuthAPIConfig; } });