indas-ui 0.0.1 → 0.1.0

package/dist/lib/api/auth/two-factor-auth.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Trusted IP API for 2FA
+ * Simple CRUD: getlist, save, delete + checkip helper
+ */
+export interface TrustedIP {
+    TrustedIPID: number;
+    CompanyID: number;
+    IPAddress: string;
+    Description: string | null;
+    IsActive: boolean;
+    CreatedBy: number;
+    CreatedDate: string;
+}
+/**
+ * Get all trusted IPs for company
+ * GET api/security/trustedip/getlist
+ */
+export declare function getTrustedIPs(session?: any): Promise<TrustedIP[]>;
+/**
+ * Save trusted IP (insert or update)
+ * POST api/security/trustedip/save
+ */
+export declare function saveTrustedIP(data: {
+    TrustedIPID?: number;
+    CompanyID: number;
+    IPAddress: string;
+    Description: string;
+    CreatedBy: number;
+}, session?: any): Promise<{
+    success: boolean;
+    message: string;
+    TrustedIPID?: number;
+}>;
+/**
+ * Delete trusted IP
+ * POST api/security/trustedip/delete?id=1
+ */
+export declare function deleteTrustedIP(id: number, session?: any): Promise<{
+    success: boolean;
+    message: string;
+}>;
+/**
+ * Check if current IP is trusted
+ * GET api/security/trustedip/checkip
+ */
+export declare function checkTrustedIP(session?: any): Promise<{
+    IsTrusted: boolean;
+    IPAddress: string;
+    Message: string;
+}>;
+/**
+ * Get current IP address
+ * GET api/security/trustedip/myip
+ */
+export declare function getMyIP(session?: any): Promise<string>;

package/dist/lib/api/auth/two-factor-auth.js

@@ -0,0 +1,84 @@
+'use client';
+/**
+ * Trusted IP API for 2FA
+ * Simple CRUD: getlist, save, delete + checkip helper
+ */
+import APIClient from '../core/client.js';
+/**
+ * Get all trusted IPs for company
+ * GET api/security/trustedip/getlist
+ */
+export async function getTrustedIPs(session) {
+    try {
+        const response = await APIClient.get('api/security/trustedip/getlist', session);
+        return response.data || [];
+    }
+    catch (error) {
+        return [];
+    }
+}
+/**
+ * Save trusted IP (insert or update)
+ * POST api/security/trustedip/save
+ */
+export async function saveTrustedIP(data, session) {
+    try {
+        const response = await APIClient.post('api/security/trustedip/save', {
+            TrustedIPID: data.TrustedIPID || 0,
+            CompanyID: data.CompanyID,
+            IPAddress: data.IPAddress,
+            Description: data.Description,
+            CreatedBy: data.CreatedBy
+        }, session);
+        return {
+            success: response.success,
+            message: response.data?.Message || response.message || '',
+            TrustedIPID: response.data?.TrustedIPID
+        };
+    }
+    catch (error) {
+        return { success: false, message: 'Failed to save trusted IP' };
+    }
+}
+/**
+ * Delete trusted IP
+ * POST api/security/trustedip/delete?id=1
+ */
+export async function deleteTrustedIP(id, session) {
+    try {
+        const response = await APIClient.post(`api/security/trustedip/delete?id=${id}`, {}, session);
+        return {
+            success: response.success,
+            message: response.data?.Message || response.message || ''
+        };
+    }
+    catch (error) {
+        return { success: false, message: 'Failed to delete trusted IP' };
+    }
+}
+/**
+ * Check if current IP is trusted
+ * GET api/security/trustedip/checkip
+ */
+export async function checkTrustedIP(session) {
+    try {
+        const response = await APIClient.get('api/security/trustedip/checkip', session);
+        return response.data || { IsTrusted: false, IPAddress: 'Unknown', Message: 'Failed to check' };
+    }
+    catch (error) {
+        return { IsTrusted: false, IPAddress: 'Unknown', Message: 'Failed to check' };
+    }
+}
+/**
+ * Get current IP address
+ * GET api/security/trustedip/myip
+ */
+export async function getMyIP(session) {
+    try {
+        const response = await APIClient.get('api/security/trustedip/myip', session);
+        return response.data?.IPAddress || 'Unknown';
+    }
+    catch (error) {
+        return 'Unknown';
+    }
+}

package/dist/lib/api/auth/two-factor.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Two-Factor Authentication API
+ * Handles OTP send and verify operations for 2FA
+ * Uses server-side proxy to keep company credentials secure
+ */
+import type { APIResponse } from '../core/types.js';
+export declare function getDeviceId(): string;
+export declare function getDeviceName(): string;
+interface SendOTPResponse {
+    success: boolean;
+    message: string;
+    otpExpiry?: number;
+}
+interface VerifyOTPResponse {
+    success: boolean;
+    userId?: number;
+    companyId?: number;
+    userName?: string;
+    email?: string;
+    companyName?: string;
+    message: string;
+}
+interface TwoFactorSessionData {
+    userId: number;
+    companyId: number;
+    productionUnitId?: number;
+    fYear?: string;
+}
+/**
+ * Send OTP to user's registered email
+ * Uses server-side proxy at /api/auth/2fa
+ * Company credentials read from HttpOnly cookie on server
+ */
+export declare function sendOTP(deviceId: string, sessionData: TwoFactorSessionData): Promise<APIResponse<SendOTPResponse>>;
+/**
+ * Verify OTP and register device as trusted
+ * Uses server-side proxy at /api/auth/2fa
+ * Company credentials read from HttpOnly cookie on server
+ */
+export declare function verifyOTP(otp: string, deviceId: string, deviceName: string, sessionData: TwoFactorSessionData): Promise<APIResponse<VerifyOTPResponse>>;
+export {};

package/dist/lib/api/auth/two-factor.js

@@ -0,0 +1,180 @@
+'use client';
+/**
+ * Two-Factor Authentication API
+ * Handles OTP send and verify operations for 2FA
+ * Uses server-side proxy to keep company credentials secure
+ */
+// Get device fingerprint from browser - enhanced version
+export function getDeviceId() {
+    if (typeof window === 'undefined')
+        return 'server';
+    // Collect multiple browser/device properties for a more unique fingerprint
+    const components = [];
+    // Basic browser info
+    components.push(navigator.userAgent);
+    components.push(navigator.language);
+    components.push(navigator.languages?.join(',') || '');
+    components.push(String(navigator.hardwareConcurrency || ''));
+    components.push(String(navigator.maxTouchPoints || 0));
+    // Screen properties
+    components.push(`${window.screen.width}x${window.screen.height}`);
+    components.push(`${window.screen.availWidth}x${window.screen.availHeight}`);
+    components.push(String(window.screen.colorDepth));
+    components.push(String(window.screen.pixelDepth));
+    components.push(String(window.devicePixelRatio || 1));
+    // Timezone
+    components.push(Intl.DateTimeFormat().resolvedOptions().timeZone);
+    components.push(String(new Date().getTimezoneOffset()));
+    // Platform
+    components.push(navigator.platform || '');
+    // Canvas fingerprint (renders text and gets unique signature)
+    try {
+        const canvas = document.createElement('canvas');
+        const ctx = canvas.getContext('2d');
+        if (ctx) {
+            canvas.width = 200;
+            canvas.height = 50;
+            ctx.textBaseline = 'top';
+            ctx.font = '14px Arial';
+            ctx.fillStyle = '#f60';
+            ctx.fillRect(0, 0, 100, 50);
+            ctx.fillStyle = '#069';
+            ctx.fillText('INDAS-FP', 2, 15);
+            ctx.fillStyle = 'rgba(102, 204, 0, 0.7)';
+            ctx.fillText('INDAS-FP', 4, 17);
+            components.push(canvas.toDataURL().slice(-50));
+        }
+    }
+    catch (e) {
+        components.push('canvas-error');
+    }
+    // WebGL fingerprint
+    try {
+        const canvas = document.createElement('canvas');
+        const gl = canvas.getContext('webgl') || canvas.getContext('experimental-webgl');
+        if (gl && gl instanceof WebGLRenderingContext) {
+            const debugInfo = gl.getExtension('WEBGL_debug_renderer_info');
+            if (debugInfo) {
+                components.push(gl.getParameter(debugInfo.UNMASKED_VENDOR_WEBGL) || '');
+                components.push(gl.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL) || '');
+            }
+        }
+    }
+    catch (e) {
+        components.push('webgl-error');
+    }
+    // Combine all components and create hash
+    const fingerprint = components.join('|');
+    // Create a more robust hash (FNV-1a algorithm)
+    let hash = 2166136261;
+    for (let i = 0; i < fingerprint.length; i++) {
+        hash ^= fingerprint.charCodeAt(i);
+        hash = (hash * 16777619) >>> 0;
+    }
+    return hash.toString(36);
+}
+// Get device name (browser + OS)
+export function getDeviceName() {
+    if (typeof window === 'undefined')
+        return 'Unknown Device';
+    const userAgent = navigator.userAgent;
+    // Detect browser
+    let browser = 'Unknown Browser';
+    if (userAgent.includes('Chrome') && !userAgent.includes('Edg'))
+        browser = 'Chrome';
+    else if (userAgent.includes('Safari') && !userAgent.includes('Chrome'))
+        browser = 'Safari';
+    else if (userAgent.includes('Firefox'))
+        browser = 'Firefox';
+    else if (userAgent.includes('Edg'))
+        browser = 'Edge';
+    // Detect OS
+    let os = 'Unknown OS';
+    if (userAgent.includes('Windows'))
+        os = 'Windows';
+    else if (userAgent.includes('Mac'))
+        os = 'macOS';
+    else if (userAgent.includes('Linux'))
+        os = 'Linux';
+    else if (userAgent.includes('Android'))
+        os = 'Android';
+    else if (userAgent.includes('iOS'))
+        os = 'iOS';
+    return `${browser} on ${os}`;
+}
+/**
+ * Send OTP to user's registered email
+ * Uses server-side proxy at /api/auth/2fa
+ * Company credentials read from HttpOnly cookie on server
+ */
+export async function sendOTP(deviceId, sessionData) {
+    try {
+        const response = await fetch('/api/auth/2fa', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                action: 'send-otp',
+                deviceId,
+                userId: sessionData.userId,
+                companyId: sessionData.companyId,
+                productionUnitId: sessionData.productionUnitId || 1,
+                fYear: sessionData.fYear || '2025-2026'
+            })
+        });
+        const result = await response.json();
+        return {
+            success: result.success,
+            data: result.data || result,
+            error: result.success ? undefined : (result.message || 'Failed to send OTP')
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: 'Failed to send OTP',
+            data: {
+                success: false,
+                message: 'Failed to send OTP'
+            }
+        };
+    }
+}
+/**
+ * Verify OTP and register device as trusted
+ * Uses server-side proxy at /api/auth/2fa
+ * Company credentials read from HttpOnly cookie on server
+ */
+export async function verifyOTP(otp, deviceId, deviceName, sessionData) {
+    try {
+        const response = await fetch('/api/auth/2fa', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                action: 'verify-otp',
+                otp,
+                deviceId,
+                deviceName,
+                userId: sessionData.userId,
+                companyId: sessionData.companyId,
+                productionUnitId: sessionData.productionUnitId || 1,
+                fYear: sessionData.fYear || '2025-2026'
+            })
+        });
+        const result = await response.json();
+        return {
+            success: result.success,
+            data: result.data || result,
+            error: result.success ? undefined : (result.message || 'Failed to verify OTP')
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: 'Failed to verify OTP',
+            data: {
+                success: false,
+                message: 'Failed to verify OTP'
+            }
+        };
+    }
+}

package/dist/lib/api/core/auth-helpers.d.ts

@@ -0,0 +1,13 @@
+import type { APIResponse } from './types.js';
+/**
+ * Login API - Authenticate user credentials
+ * @param username - User's username
+ * @param password - User's password
+ * @returns Promise with login response containing user data
+ */
+export declare function loginAPI(username: string, password: string): Promise<APIResponse<any>>;
+/**
+ * Ping API - Check API connectivity
+ * @returns Promise with ping response
+ */
+export declare function pingAPI(): Promise<APIResponse<string>>;

package/dist/lib/api/core/auth-helpers.js

@@ -0,0 +1,137 @@
+'use client';
+// Authentication helper functions
+// Login and ping APIs
+import { getGlobalAPIConfig, getBasicAuthHeader, buildAPIURL } from './config.js';
+/**
+ * Login API - Authenticate user credentials
+ * @param username - User's username
+ * @param password - User's password
+ * @returns Promise with login response containing user data
+ */
+export async function loginAPI(username, password) {
+    try {
+        // Get configuration (should be set by NextAuth with company credentials)
+        let config = getGlobalAPIConfig();
+        if (!config) {
+            console.error('❌ [LOGIN API] API configuration not available');
+            console.error('❌ [LOGIN API] Company credentials must be set via setAuthAPIConfig before calling loginAPI');
+            throw new Error('API configuration not available - company credentials not set');
+        }
+        // Validate that credentials are actually set (not empty)
+        if (!config.username || (!config.authToken && !config.password)) {
+            console.error('❌ [LOGIN API] Company credentials are missing or empty');
+            throw new Error('Company credentials not configured - login requires valid company authentication');
+        }
+        // Build URL with username and password as path parameters
+        const url = buildAPIURL(`api/auth/GetLoginDetails/${encodeURIComponent(username)}/${encodeURIComponent(password)}`);
+        if (!url) {
+            console.error('❌ [LOGIN API] Failed to build API URL');
+            throw new Error('Failed to build API URL');
+        }
+        // Use pre-computed auth token, fall back to password for legacy
+        const authHeader = config.authToken
+            ? `Basic ${config.authToken}`
+            : `Basic ${btoa(`${config.username}:${config.password}`)}`;
+        // Make request - API uses GET with URL parameters
+        const response = await fetch(url, {
+            method: 'GET',
+            headers: {
+                'Accept': 'application/json',
+                'Authorization': authHeader
+            },
+            signal: AbortSignal.timeout(config.timeout)
+        });
+        if (!response.ok) {
+            console.error('❌ [LOGIN API] Request failed with status:', response.status);
+            return {
+                success: false,
+                error: `Login failed: ${response.status} ${response.statusText}`,
+                status: response.status
+            };
+        }
+        // Parse response
+        const responseText = await response.text();
+        if (!responseText || responseText.trim() === '') {
+            console.error('❌ [LOGIN API] Empty response received');
+            return {
+                success: false,
+                error: 'Invalid username or password'
+            };
+        }
+        let data = JSON.parse(responseText);
+        // Handle double/triple-encoded JSON
+        if (typeof data === 'string') {
+            try {
+                data = JSON.parse(data);
+                if (typeof data === 'string') {
+                    data = JSON.parse(data);
+                }
+            }
+            catch {
+                // Keep as is
+            }
+        }
+        return {
+            success: true,
+            data,
+            status: response.status
+        };
+    }
+    catch (error) {
+        console.error('❌ [LOGIN API] Exception:', error instanceof Error ? error.message : 'Unknown error');
+        if (error instanceof Error) {
+            console.error('❌ [LOGIN API] Stack:', error.stack);
+        }
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Login request failed'
+        };
+    }
+}
+/**
+ * Ping API - Check API connectivity
+ * @returns Promise with ping response
+ */
+export async function pingAPI() {
+    try {
+        const config = getGlobalAPIConfig();
+        if (!config) {
+            throw new Error('API configuration not available');
+        }
+        const url = buildAPIURL('api/ping');
+        if (!url) {
+            throw new Error('Failed to build API URL');
+        }
+        const authHeader = getBasicAuthHeader();
+        if (!authHeader) {
+            throw new Error('Failed to generate authorization header');
+        }
+        const response = await fetch(url, {
+            method: 'GET',
+            headers: {
+                'Accept': 'application/json',
+                'Authorization': authHeader
+            },
+            signal: AbortSignal.timeout(config.timeout)
+        });
+        if (!response.ok) {
+            return {
+                success: false,
+                error: `Ping failed: ${response.status} ${response.statusText}`,
+                status: response.status
+            };
+        }
+        const data = await response.text();
+        return {
+            success: true,
+            data,
+            status: response.status
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Ping request failed'
+        };
+    }
+}

package/dist/lib/api/core/client.d.ts

@@ -0,0 +1,37 @@
+import type { APIResponse } from './types.js';
+export declare function setSessionExpiredHandler(handler: () => void): void;
+export declare function handleSessionExpired(): void;
+/**
+ * APIClient class for making HTTP requests to the backend API
+ */
+declare class APIClient {
+    /**
+     * Make a generic API request
+     * @param endpoint - API endpoint (relative to base URL)
+     * @param options - Fetch options
+     * @param sessionData - Optional session data for CompanyID and UserID headers
+     * @returns Promise<APIResponse>
+     */
+    static request<T = any>(endpoint: string, options?: RequestInit, sessionData?: any, baseURLOverride?: string, externalSignal?: AbortSignal, timeoutMs?: number): Promise<APIResponse<T>>;
+    /**
+     * Make a GET request
+     */
+    static get<T = any>(endpoint: string, sessionData?: any, baseURLOverride?: string): Promise<APIResponse<T>>;
+    /**
+     * Make a POST request
+     */
+    static post<T = any>(endpoint: string, data?: any, sessionData?: any, baseURLOverride?: string, signal?: AbortSignal, timeoutMs?: number): Promise<APIResponse<T>>;
+    /**
+     * Make a PUT request
+     */
+    static put<T = any>(endpoint: string, data?: any, sessionData?: any, baseURLOverride?: string): Promise<APIResponse<T>>;
+    /**
+     * Make a DELETE request
+     */
+    static delete<T = any>(endpoint: string, sessionData?: any, baseURLOverride?: string): Promise<APIResponse<T>>;
+    /**
+     * Make a PATCH request
+     */
+    static patch<T = any>(endpoint: string, data?: any, sessionData?: any): Promise<APIResponse<T>>;
+}
+export default APIClient;