@unvired/react-native-wrapper-sdk 0.0.23 → 0.0.25

package/src/lib/file/FileService.ts

@@ -0,0 +1,313 @@
+import { PlatformManager } from '@unvired/unvired-ts-core-sdk';
+
+export interface IDirectoryReader {
+    readEntries(successCallback: (entries: IFileEntry[]) => void, errorCallback: (error: any) => void): void;
+}
+
+export interface IFileEntry {
+    fullPath: string;
+    nativeURL: string;
+    isDirectory?: boolean;
+    remove(callback: () => void, errorCallback: (error: any) => void): void;
+    removeRecursively(callback: () => void, errorCallback: (error: any) => void): void;
+    createReader(): IDirectoryReader;
+    getDirectory?(path: string, options: { create: boolean }, callback: (entry: IFileEntry) => void, errorCallback: (error: any) => void): void;
+    getFile?(path: string, options: { create: boolean }, callback: (entry: IFileEntry) => void, errorCallback: (error: any) => void): void;
+    file?(callback: (file: File) => void, errorCallback: (error: any) => void): void;
+    createWriter?(callback: (writer: any) => void, errorCallback: (error: any) => void): void;
+}
+
+export class FileService {
+
+    getDocumentDirectory(): string {
+        // @ts-ignore
+        return PlatformManager.getInstance().getPlatformAdapter().getDocumentDirectory();
+    }
+
+    resolveLocalFileSystemURL(url: string): Promise<IFileEntry> {
+        // @ts-ignore
+        return PlatformManager.getInstance().getPlatformAdapter().resolveLocalFileSystemURL(url);
+    }
+
+    async getFolderBasedOnUserId(userId: string): Promise<string> {
+        // @ts-ignore
+        return await PlatformManager.getInstance().getPlatformAdapter().getFolderBasedOnUserId(userId);
+    }
+
+    async deleteUserFolder(userId: string): Promise<void> {
+        // @ts-ignore
+        await PlatformManager.getInstance().getPlatformAdapter().deleteUserFolder(userId);
+    }
+
+    /**
+     * Reads an external file as ArrayBuffer using IFileEntry API
+     * @param filePath Absolute path to the file
+     */
+    async readExternalFile(filePath: string): Promise<ArrayBuffer> {
+        // Get the file entry
+        const fileEntry = await this.resolveLocalFileSystemURL(filePath);
+
+        return new Promise((resolve, reject) => {
+            // Use the file() method to read the file
+            if (!fileEntry.file) {
+                reject(new Error('file() method not available on entry'));
+                return;
+            }
+
+            fileEntry.file(
+                async (fileMetadata: any) => {
+                    try {
+                        // Read the file using react-native-fs
+                        const RNFS = await import('react-native-fs');
+                        const content = await RNFS.readFile(fileMetadata.path, 'utf8');
+
+                        // Convert string to ArrayBuffer
+                        const encoder = new TextEncoder();
+                        resolve(encoder.encode(content).buffer);
+                    } catch (error) {
+                        reject(error);
+                    }
+                },
+                (error: any) => {
+                    reject(error);
+                }
+            );
+        });
+    }
+
+    /**
+     * Writes data to an external file using IFileEntry API
+     * @param filePath Parent directory path
+     * @param fileName File name
+     * @param data Data to write (ArrayBuffer or string)
+     */
+    async writeExternalFile(filePath: string, fileName: string, data: ArrayBuffer | string): Promise<void> {
+        // Convert data to string if it's ArrayBuffer
+        let content: string;
+        if (data instanceof ArrayBuffer) {
+            const decoder = new TextDecoder();
+            content = decoder.decode(data);
+        } else {
+            content = data;
+        }
+
+        // Get the directory entry
+        const dirEntry = await this.resolveLocalFileSystemURL(filePath);
+
+        return new Promise((resolve, reject) => {
+            // Get or create the file
+            if (!dirEntry.getFile) {
+                reject(new Error('getFile() method not available on directory entry'));
+                return;
+            }
+
+            dirEntry.getFile(
+                fileName,
+                { create: true },
+                (fileEntry: IFileEntry) => {
+                    // Create a writer
+                    if (!fileEntry.createWriter) {
+                        reject(new Error('createWriter() method not available on file entry'));
+                        return;
+                    }
+
+                    fileEntry.createWriter(
+                        (writer: any) => {
+                            writer.onwriteend = () => {
+                                resolve();
+                            };
+                            writer.onerror = (error: any) => {
+                                reject(error);
+                            };
+
+                            // Write the content
+                            writer.write(content);
+                        },
+                        (error: any) => {
+                            reject(error);
+                        }
+                    );
+                },
+                (error: any) => {
+                    reject(error);
+                }
+            );
+        });
+    }
+
+    /**
+     * Deletes an external file using IFileEntry API
+     * @param filePath Absolute path to the file
+     */
+    async deleteExternalFile(filePath: string): Promise<void> {
+        const fileEntry = await this.resolveLocalFileSystemURL(filePath);
+
+        return new Promise((resolve, reject) => {
+            fileEntry.remove(
+                () => resolve(),
+                (error: any) => reject(error)
+            );
+        });
+    }
+
+    /**
+     * Checks if a file exists using IFileEntry API
+     * @param filePath Absolute path to the file
+     */
+    async fileExists(filePath: string): Promise<boolean> {
+        try {
+            await this.resolveLocalFileSystemURL(filePath);
+            return true;
+        } catch (error) {
+            return false;
+        }
+    }
+
+    /**
+     * Creates a directory
+     * @param dirPath Parent directory path
+     * @param dirName Directory name to create
+     */
+    async createDirectory(dirPath: string, dirName: string): Promise<IFileEntry> {
+        const parentEntry = await this.resolveLocalFileSystemURL(dirPath);
+
+        return new Promise((resolve, reject) => {
+            if (!parentEntry.getDirectory) {
+                reject(new Error('getDirectory() method not available on entry'));
+                return;
+            }
+
+            parentEntry.getDirectory(
+                dirName,
+                { create: true },
+                (dirEntry: IFileEntry) => resolve(dirEntry),
+                (error: any) => reject(error)
+            );
+        });
+    }
+
+    /**
+     * Lists files and directories in a directory
+     * @param dirPath Directory path to list
+     */
+    async listDirectory(dirPath: string): Promise<IFileEntry[]> {
+        const dirEntry = await this.resolveLocalFileSystemURL(dirPath);
+
+        return new Promise((resolve, reject) => {
+            const reader = dirEntry.createReader();
+            reader.readEntries(
+                (entries: IFileEntry[]) => resolve(entries),
+                (error: any) => reject(error)
+            );
+        });
+    }
+
+    /**
+     * Deletes a directory and all its contents
+     * @param dirPath Directory path to delete
+     */
+    async deleteDirectory(dirPath: string): Promise<void> {
+        const dirEntry = await this.resolveLocalFileSystemURL(dirPath);
+
+        return new Promise((resolve, reject) => {
+            dirEntry.removeRecursively(
+                () => resolve(),
+                (error: any) => reject(error)
+            );
+        });
+    }
+
+    /**
+     * Copies a file
+     * @param sourcePath Source file path
+     * @param destDir Destination directory path
+     * @param newName New file name (optional, keeps original name if not provided)
+     */
+    async copyFile(sourcePath: string, destDir: string, newName?: string): Promise<void> {
+        // Read source file
+        const content = await this.readExternalFile(sourcePath);
+
+        // Get source file name if newName not provided
+        const fileName = newName || sourcePath.split('/').pop() || 'file';
+
+        // Write to destination
+        await this.writeExternalFile(destDir, fileName, content);
+    }
+
+    /**
+     * Moves/renames a file
+     * @param sourcePath Source file path
+     * @param destDir Destination directory path
+     * @param newName New file name (optional, keeps original name if not provided)
+     */
+    async moveFile(sourcePath: string, destDir: string, newName?: string): Promise<void> {
+        // Copy file to destination
+        await this.copyFile(sourcePath, destDir, newName);
+
+        // Delete source file
+        await this.deleteExternalFile(sourcePath);
+    }
+
+    /**
+     * Gets file information (size, modification date, etc.)
+     * @param filePath File path
+     */
+    async getFileInfo(filePath: string): Promise<any> {
+        const fileEntry = await this.resolveLocalFileSystemURL(filePath);
+
+        return new Promise((resolve, reject) => {
+            if (!fileEntry.file) {
+                reject(new Error('file() method not available on entry'));
+                return;
+            }
+
+            fileEntry.file(
+                (fileMetadata: any) => resolve(fileMetadata),
+                (error: any) => reject(error)
+            );
+        });
+    }
+
+    /**
+     * Appends data to an existing file
+     * @param filePath File path
+     * @param data Data to append
+     */
+    async appendToFile(filePath: string, data: ArrayBuffer | string): Promise<void> {
+        // Convert data to string if it's ArrayBuffer
+        let content: string;
+        if (data instanceof ArrayBuffer) {
+            const decoder = new TextDecoder();
+            content = decoder.decode(data);
+        } else {
+            content = data;
+        }
+
+        const fileEntry = await this.resolveLocalFileSystemURL(filePath);
+
+        return new Promise((resolve, reject) => {
+            if (!fileEntry.createWriter) {
+                reject(new Error('createWriter() method not available on file entry'));
+                return;
+            }
+
+            fileEntry.createWriter(
+                (writer: any) => {
+                    writer.onwriteend = () => {
+                        resolve();
+                    };
+                    writer.onerror = (error: any) => {
+                        reject(error);
+                    };
+
+                    // Append the content
+                    writer.append(content);
+                },
+                (error: any) => {
+                    reject(error);
+                }
+            );
+        });
+    }
+
+}

package/src/lib/logger/LoggerService.ts

@@ -0,0 +1,70 @@
+import { PlatformManager } from '@unvired/unvired-ts-core-sdk';
+
+export class LoggerService {
+
+    /**
+     * Log Information
+     * @param className Class Name
+     * @param methodName Method Name
+     * @param message Message
+     */
+    info(className: string, methodName: string, message: string): void {
+        PlatformManager.getInstance().getPlatformAdapter().getLoggerAdapter().logInfo(className, methodName, message);
+    }
+
+    /**
+     * Log Error
+     * @param className Class Name
+     * @param methodName Method Name
+     * @param message Message
+     */
+    error(className: string, methodName: string, message: string): void {
+        PlatformManager.getInstance().getPlatformAdapter().getLoggerAdapter().logError(className, methodName, message);
+    }
+
+    /**
+     * Log Debug
+     * @param className Class Name
+     * @param methodName Method Name
+     * @param message Message
+     */
+    debug(className: string, methodName: string, message: string): void {
+        PlatformManager.getInstance().getPlatformAdapter().getLoggerAdapter().logDebug(className, methodName, message);
+    }
+
+    /**
+     * Set Log Level
+     * @param level Log Level
+     */
+    setLogLevel(level: string): void {
+        PlatformManager.getInstance().getPlatformAdapter().getLoggerAdapter().setLogLevel(level);
+    }
+
+    /**
+     * Get Log File URL
+     */
+    async getLogFileURL(): Promise<string> {
+        return PlatformManager.getInstance().getPlatformAdapter().getLoggerAdapter().getLogFileURL();
+    }
+
+    /**
+     * Get Log File Content
+     */
+    async getLogFileContent(): Promise<string> {
+        return PlatformManager.getInstance().getPlatformAdapter().getLoggerAdapter().getLogFileContent();
+    }
+
+    /**
+     * Get Backup Log File Content
+     */
+    async getBackupLogFileContent(): Promise<string> {
+        return PlatformManager.getInstance().getPlatformAdapter().getLoggerAdapter().getBackupLogFileContent();
+    }
+
+    /**
+     * Clear Log File
+     */
+    async clearLogFile(): Promise<void> {
+        return PlatformManager.getInstance().getPlatformAdapter().getLoggerAdapter().clearLogFile();
+    }
+}

package/src/lib/notification/NotificationService.ts

@@ -0,0 +1,45 @@
+import { PlatformManager } from '@unvired/unvired-ts-core-sdk';
+
+export class NotificationService {
+
+    private get adapter() {
+        return PlatformManager.getInstance().getPlatformAdapter().getPushNotificationAdapter();
+    }
+
+    /**
+     * Requests permission and gets token
+     */
+    async requestPermission(options?: { forceShow: boolean }): Promise<void> {
+        return this.adapter?.requestPermission(options);
+    }
+
+    /**
+     * Gets the push token
+     */
+    async getToken(): Promise<string | undefined> {
+        return this.adapter?.getToken();
+    }
+
+    /**
+     * Sets callback for token refresh
+     */
+    onTokenRefresh(callback: (token: string) => void): void {
+        this.adapter?.onTokenRefresh(callback);
+    }
+
+    /**
+     * Sets listener for incoming notifications (foreground)
+     * @param onMessage Callback when a notification is received
+     */
+    onNotificationReceived(onMessage: (data: any) => void): void {
+        this.adapter?.onMessage(onMessage);
+    }
+
+    /**
+     * Sets listener for incoming notifications (background)
+     * @param onMessage Callback when a notification is received
+     */
+    onBackgroundNotificationReceived(onMessage: (data: any) => void): void {
+        this.adapter?.onBackgroundMessage(onMessage);
+    }
+}

package/src/lib/settings/SettingsService.ts

@@ -0,0 +1,150 @@
+import {
+  SettingsHelper,
+  FrameworkSettingsManager,
+  FrameworkSettingsFields,
+  UserSettingsManager,
+  UserSettingsFields,
+  UnviredAccountManager,
+  HttpConnection,
+  AuthenticationService,
+  PlatformManager,
+} from '@unvired/unvired-ts-core-sdk';
+
+export class SettingsService {
+  /**
+   * Get current log level
+   */
+  async getLogLevel(): Promise<string> {
+    return FrameworkSettingsManager.getInstance().getFieldValue(FrameworkSettingsFields.logLevel);
+  }
+
+  getDeviceInfo(): string {
+    // @ts-ignore
+    return PlatformManager.getInstance().getPlatformAdapter().getDeviceInfo();
+  }
+
+  getPlatform(): string {
+    // @ts-ignore
+    return PlatformManager.getInstance().getPlatformAdapter().getPlatform();
+  }
+
+  getFrontendType(): string {
+    // @ts-ignore
+    return PlatformManager.getInstance().getPlatformAdapter().getFrontendType();
+  }
+  /**
+   * Set log level
+   * @param logLevel Log Level
+   */
+  async setLogLevel(logLevel: string): Promise<void> {
+    return SettingsHelper.setLogLevel(logLevel);
+  }
+
+  /**
+   * Send logs to server
+   */
+  async sendLogToServer(): Promise<void> {
+    return SettingsHelper.sendLogsToServer();
+  }
+
+  /**
+   * Create and get Log Zip path (for email etc)
+   */
+  async getLogZipPath(): Promise<string> {
+    return SettingsHelper.createAndGetLogZipPath();
+  }
+
+  /**
+   * Test Push Notification
+   */
+  async testPushNotification(): Promise<void> {
+    return SettingsHelper.testPushNotification();
+  }
+
+  /**
+   * Get list of Info Messages
+   */
+  async getInfoMessages(headerName: string, lid: string): Promise<any[]> {
+    return SettingsHelper.getInfoMessages(headerName, lid);
+  }
+
+  /**
+   * Get User Settings / Current Account Information
+   */
+  async getUserSettings(): Promise<any> {
+    const unviredAccount = UnviredAccountManager.getInstance().getLastLoggedInAccount();
+    if (!unviredAccount) {
+      throw new Error('No account found');
+    }
+
+    let jwtToken = (AuthenticationService as any).instance.jwtToken;
+    // Fallback or re-fetch token logic
+    if (!jwtToken) {
+      jwtToken = unviredAccount.getJwtToken();
+    }
+
+    const serverType = await FrameworkSettingsManager.getInstance().getFieldValue(
+      FrameworkSettingsFields.serverType
+    );
+    const emailId = await FrameworkSettingsManager.getInstance().getFieldValue(
+      FrameworkSettingsFields.email
+    );
+    const unviredUserId = await UserSettingsManager.getInstance().getFieldValue(
+      UserSettingsFields.unviredUserId
+    );
+    const unviredPassword = await UserSettingsManager.getInstance().getFieldValue(
+      UserSettingsFields.unviredPassword
+    );
+
+    // Accessing loginParameters from AuthenticationService might need cast if it's protected/private or simply public
+    // index.d.ts says: loginParameters: any;
+    const loginParams = (AuthenticationService as any).instance.loginParameters || {};
+
+    return {
+      UNVIRED_ID: unviredUserId,
+      USER_ID: loginParams.username || unviredUserId,
+      FIRST_NAME: unviredAccount.getFirstName(),
+      LAST_NAME: unviredAccount.getLastName(),
+      FULL_NAME: `${unviredAccount.getFirstName()} ${unviredAccount.getLastName()}`,
+      EMAIL: emailId || '',
+      SERVER_URL: unviredAccount.getServerURL(),
+      SERVER_TYPE: serverType || '',
+      LOGIN_TYPE: loginParams.loginType,
+      UNVIRED_PASSWORD: unviredPassword || '',
+      JWT_TOKEN: jwtToken,
+    };
+  }
+
+  /**
+   * Set Auth Token
+   * @param token JWT Token
+   */
+  async setAuthToken(token: string): Promise<void> {
+    (AuthenticationService as any).instance.jwtToken = token;
+    await UserSettingsManager.getInstance().setFieldValue(UserSettingsFields.jwtToken, token);
+  }
+
+  /**
+   * Get Auth Token Validity (remaining seconds)
+   */
+  async getAuthTokenValidity(): Promise<number> {
+    const token = await UserSettingsManager.getInstance().getFieldValue(
+      UserSettingsFields.jwtToken
+    );
+    if (!token) return 0;
+
+    try {
+      const parts = token.split('.');
+      if (parts.length !== 3) return 0;
+
+      const payload = JSON.parse(atob(parts[1]));
+      if (!payload.exp) return 0;
+
+      const now = Math.floor(Date.now() / 1000);
+      const remaining = payload.exp - now;
+      return remaining > 0 ? remaining : 0;
+    } catch (e) {
+      return 0;
+    }
+  }
+}

package/src/lib/storage/StorageService.ts

@@ -0,0 +1,27 @@
+import { PlatformManager } from '@unvired/unvired-ts-core-sdk';
+
+export interface IStorageAdapter {
+    getItem(key: string): void;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+    clear(): void;
+}
+
+export class StorageService {
+
+    getItem(key: string): void {
+        PlatformManager.getInstance().getPlatformAdapter().getStorageAdapter().getItem(key);
+    }
+
+    setItem(key: string, value: string): void {
+        PlatformManager.getInstance().getPlatformAdapter().getStorageAdapter().setItem(key, value);
+    }
+
+    removeItem(key: string): void {
+        PlatformManager.getInstance().getPlatformAdapter().getStorageAdapter().removeItem(key);
+    }
+
+    clear(): void {
+        PlatformManager.getInstance().getPlatformAdapter().getStorageAdapter().clear();
+    }
+}