indas-ui 0.0.1 → 0.1.0

package/dist/lib/api/approval/approvals.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Approval Workflow API Client
+ *
+ * Handles multi-level approval workflows for quotations, master data changes, etc.
+ */
+import type { APIResponse } from '../core/types.js';
+import type { ApprovalWorkflow, ApprovalChain } from '../../../types/approval.js';
+/**
+ * Approval API
+ */
+declare class ApprovalAPI {
+    /**
+     * Request approval for an entity
+     */
+    static requestApproval(entityType: string, entityId: number, comments: string | undefined, metadata: Record<string, any> | undefined, session: any): Promise<APIResponse<{
+        approvalId: number;
+        approvalLevel: number;
+        approverId?: number;
+        requestedAt: string;
+    }>>;
+    /**
+     * Approve a request
+     */
+    static approve(approvalId: number, comments: string | undefined, session: any): Promise<APIResponse<{
+        approvalId: number;
+        status: string;
+        nextLevel?: number;
+        nextApproverId?: number;
+        isComplete: boolean;
+    }>>;
+    /**
+     * Reject a request
+     */
+    static reject(approvalId: number, comments: string | undefined, session: any): Promise<APIResponse<{
+        approvalId: number;
+        status: string;
+        isComplete: boolean;
+    }>>;
+    /**
+     * Escalate approval to another user
+     */
+    static escalate(approvalId: number, toUserId: number, reason: string | undefined, session: any): Promise<APIResponse<{
+        approvalId: number;
+        newApproverId: number;
+        escalatedAt: string;
+    }>>;
+    /**
+     * 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 getPendingApprovals(_session: any): Promise<APIResponse<ApprovalWorkflow[]>>;
+    /**
+     * Get approval chain for an entity (full history)
+     */
+    static getApprovalChain(entityType: string, entityId: number, session: any): Promise<APIResponse<ApprovalChain>>;
+    /**
+     * Withdraw an approval request
+     */
+    static withdraw(approvalId: number, reason: string | undefined, session: any): Promise<APIResponse<{
+        message: string;
+    }>>;
+}
+export default ApprovalAPI;

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

@@ -0,0 +1,205 @@
+'use client';
+/**
+ * Approval Workflow API Client
+ *
+ * Handles multi-level approval workflows for quotations, master data changes, etc.
+ */
+import APIClient from '../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 APIClient.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 APIClient.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 APIClient.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 APIClient.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 APIClient.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 APIClient.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'
+            };
+        }
+    }
+}
+export default ApprovalAPI;

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

@@ -0,0 +1,5 @@
+/**
+ * Approval API Module
+ * Exports approval workflow functionality
+ */
+export { default as ApprovalAPI } from './approvals.js';

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

@@ -0,0 +1,6 @@
+'use client';
+/**
+ * Approval API Module
+ * Exports approval workflow functionality
+ */
+export { default as ApprovalAPI } from './approvals.js';

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

@@ -0,0 +1,12 @@
+import type { LoginRequest, LoginResponse, UserData } from '../core/types.js';
+export interface AuthAPIConfig {
+    baseURL: string;
+    authEndpoint?: string;
+    username?: string;
+    password?: string;
+}
+export declare function setAuthAPIConfig(config: AuthAPIConfig): void;
+export declare function getAuthAPIConfig(): AuthAPIConfig | null;
+export declare function clearAuthAPIConfig(): void;
+export declare function authenticateUser(credentials: LoginRequest): Promise<LoginResponse>;
+export type { LoginRequest, LoginResponse, UserData };

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

@@ -0,0 +1,148 @@
+'use client';
+// Authentication API
+// Handles user authentication
+import { loginAPI } from '../core/auth-helpers.js';
+import { setGlobalAPIConfig } from '../core/config.js';
+let apiConfig = null;
+export 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) {
+        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));
+    }
+}
+export 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;
+}
+export function clearAuthAPIConfig() {
+    apiConfig = null;
+    if (typeof window !== 'undefined') {
+        sessionStorage.removeItem('auth-api-config');
+    }
+}
+export async function authenticateUser(credentials) {
+    // Use the new global API configuration
+    try {
+        const response = await 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/lib/api/auth/index.d.ts

@@ -0,0 +1 @@
+export { authenticateUser, setAuthAPIConfig, getAuthAPIConfig, clearAuthAPIConfig, type AuthAPIConfig, type LoginRequest, type LoginResponse, type UserData } from './auth.js';

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

@@ -0,0 +1,4 @@
+'use client';
+// Authentication API exports
+// Central export point for all authentication APIs
+export { authenticateUser, setAuthAPIConfig, getAuthAPIConfig, clearAuthAPIConfig } from './auth.js';

package/dist/lib/api/auth/password-reset-otp.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Password Reset OTP API
+ * Integrates with C# backend for OTP generation and validation
+ *
+ * NOTE: These APIs do NOT require session/authentication since they're used BEFORE login
+ * We use direct fetch calls instead of APIClient to avoid session requirements
+ */
+/**
+ * Generate OTP for password reset
+ * Calls backend: POST /api/CommanApis/generate-otp
+ * Requires Basic Auth with company credentials from company code validation
+ */
+export declare function generateOTPAPI(email: string, companyUsername: string, companyPassword: string): Promise<{
+    success: boolean;
+    data: any;
+    message: any;
+}>;
+/**
+ * Validate OTP for password reset
+ * Calls backend: POST /api/CommanApis/validate-otp
+ * Requires Basic Auth with company credentials from company code validation
+ */
+export declare function validateOTPAPI(email: string, otpCode: string, companyUsername: string, companyPassword: string): Promise<{
+    success: boolean;
+    data: any;
+    message: any;
+}>;
+/**
+ * Reset password with OTP
+ * Calls backend: POST /api/CommanApis/reset-password
+ * Requires Basic Auth with company credentials from company code validation
+ */
+export declare function resetPasswordAPI(email: string, otpCode: string, newPassword: string, companyUsername: string, companyPassword: string): Promise<{
+    success: boolean;
+    data: any;
+    message: any;
+}>;
+/**
+ * Get OTP statistics (Admin only)
+ * Calls backend: GET api/auth/password-reset/stats
+ * NOTE: These admin functions are kept for future use but currently not implemented
+ */
+export declare function getOTPStatsAPI(): Promise<void>;
+/**
+ * Cleanup expired OTPs (Admin only)
+ * Calls backend: POST api/auth/password-reset/cleanup
+ * NOTE: These admin functions are kept for future use but currently not implemented
+ */
+export declare function cleanupExpiredOTPsAPI(): Promise<void>;

package/dist/lib/api/auth/password-reset-otp.js

@@ -0,0 +1,185 @@
+'use client';
+/**
+ * Password Reset OTP API
+ * Integrates with C# backend for OTP generation and validation
+ *
+ * NOTE: These APIs do NOT require session/authentication since they're used BEFORE login
+ * We use direct fetch calls instead of APIClient to avoid session requirements
+ */
+/**
+ * Get API base URL
+ */
+function getAPIBaseURL() {
+    return process.env.NEXT_PUBLIC_API_BASE_URL || '';
+}
+/**
+ * Get Basic Auth header from company credentials
+ * Uses the credentials obtained from company code validation
+ */
+function getPasswordResetAuthHeader(companyUsername, companyPassword) {
+    if (!companyUsername || !companyPassword) {
+        console.error('❌ [Password Reset] Company credentials are required');
+        return null;
+    }
+    try {
+        const credentials = btoa(`${companyUsername}:${companyPassword}`);
+        return `Basic ${credentials}`;
+    }
+    catch (error) {
+        console.error('❌ [Password Reset] Failed to encode credentials:', error);
+        return null;
+    }
+}
+/**
+ * Get client IP address (best effort)
+ * Note: Due to CSP restrictions and browser security, we cannot fetch external IP
+ * The backend should extract IP from request headers instead
+ */
+async function getClientIPAddress() {
+    // Return "Unknown" - backend will extract actual IP from request headers
+    // This avoids CSP violations from calling external IP services
+    return 'Unknown';
+}
+/**
+ * Get user agent from browser
+ */
+function getUserAgent() {
+    return typeof navigator !== 'undefined' ? navigator.userAgent : 'Unknown';
+}
+/**
+ * Generate OTP for password reset
+ * Calls backend: POST /api/CommanApis/generate-otp
+ * Requires Basic Auth with company credentials from company code validation
+ */
+export async function generateOTPAPI(email, companyUsername, companyPassword) {
+    try {
+        // Get client information from browser
+        const ipAddress = await getClientIPAddress();
+        const userAgent = getUserAgent();
+        const baseURL = getAPIBaseURL();
+        const authHeader = getPasswordResetAuthHeader(companyUsername, companyPassword);
+        const response = await fetch(`${baseURL}/api/CommanApis/generate-otp`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Accept': 'application/json',
+                ...(authHeader ? { 'Authorization': authHeader } : {}),
+            },
+            body: JSON.stringify({
+                Email: email,
+                IPAddress: ipAddress,
+                UserAgent: userAgent
+            })
+        });
+        const text = await response.text();
+        let data;
+        try {
+            data = JSON.parse(text);
+        }
+        catch (e) {
+            console.error('❌ [Generate OTP] Failed to parse JSON:', text);
+            return {
+                success: false,
+                data: null,
+                message: 'Invalid response from server'
+            };
+        }
+        // Handle double-nested response: data.data instead of just data
+        const actualData = data.data || data;
+        const isSuccess = response.ok && (data.success === true || actualData.success === true);
+        return {
+            success: isSuccess,
+            data: actualData,
+            message: actualData.message || data.message || data.Message || (response.ok ? 'OTP generated successfully' : 'Failed to generate OTP')
+        };
+    }
+    catch (error) {
+        console.error('❌ [Generate OTP] Error:', error);
+        return {
+            success: false,
+            data: null,
+            message: error instanceof Error ? error.message : 'Failed to generate OTP'
+        };
+    }
+}
+/**
+ * Validate OTP for password reset
+ * Calls backend: POST /api/CommanApis/validate-otp
+ * Requires Basic Auth with company credentials from company code validation
+ */
+export async function validateOTPAPI(email, otpCode, companyUsername, companyPassword) {
+    const baseURL = getAPIBaseURL();
+    const authHeader = getPasswordResetAuthHeader(companyUsername, companyPassword);
+    const response = await fetch(`${baseURL}/api/CommanApis/validate-otp`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'Accept': 'application/json',
+            ...(authHeader ? { 'Authorization': authHeader } : {}),
+        },
+        body: JSON.stringify({
+            Email: email,
+            OTPCode: otpCode
+        })
+    });
+    const data = await response.json();
+    // Handle double-nested response: data.data instead of just data
+    const actualData = data.data || data;
+    const isSuccess = response.ok && (data.success === true || actualData.success === true);
+    return {
+        success: isSuccess,
+        data: actualData,
+        message: actualData.message || data.message || (response.ok ? 'OTP validated successfully' : 'Invalid OTP')
+    };
+}
+/**
+ * Reset password with OTP
+ * Calls backend: POST /api/CommanApis/reset-password
+ * Requires Basic Auth with company credentials from company code validation
+ */
+export async function resetPasswordAPI(email, otpCode, newPassword, companyUsername, companyPassword) {
+    const baseURL = getAPIBaseURL();
+    const authHeader = getPasswordResetAuthHeader(companyUsername, companyPassword);
+    const response = await fetch(`${baseURL}/api/CommanApis/reset-password`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'Accept': 'application/json',
+            ...(authHeader ? { 'Authorization': authHeader } : {}),
+        },
+        body: JSON.stringify({
+            Email: email,
+            OTPCode: otpCode,
+            NewPassword: newPassword
+        })
+    });
+    const data = await response.json();
+    // Handle double-nested response: data.data instead of just data
+    const actualData = data.data || data;
+    const isSuccess = response.ok && (data.success === true || actualData.success === true);
+    return {
+        success: isSuccess,
+        data: actualData,
+        message: actualData.message || data.message || (response.ok ? 'Password reset successfully' : 'Failed to reset password')
+    };
+}
+/**
+ * Get OTP statistics (Admin only)
+ * Calls backend: GET api/auth/password-reset/stats
+ * NOTE: These admin functions are kept for future use but currently not implemented
+ */
+export async function getOTPStatsAPI() {
+    // TODO: Implement when admin panel is ready
+    // These will need session/authentication, so they should use APIClient when implemented
+    throw new Error('OTP statistics endpoint not yet implemented');
+}
+/**
+ * Cleanup expired OTPs (Admin only)
+ * Calls backend: POST api/auth/password-reset/cleanup
+ * NOTE: These admin functions are kept for future use but currently not implemented
+ */
+export async function cleanupExpiredOTPsAPI() {
+    // TODO: Implement when admin panel is ready
+    // These will need session/authentication, so they should use APIClient when implemented
+    throw new Error('OTP cleanup endpoint not yet implemented');
+}