@unvired/react-native-wrapper-sdk 0.0.22 → 0.0.24

package/src/UnviredWrapper.ts

@@ -1,5 +1,11 @@
-import AuthBuilder from './lib/AuthBuilder';
-import { AuthenticationService, PlatformManager } from '@unvired/unvired-ts-core-sdk';
+import { AuthenticationService } from '@unvired/unvired-ts-core-sdk';
+import { AuthService } from './lib/auth/AuthService';
+import { DatabaseService } from './lib/database/DatabaseService';
+import { FileService } from './lib/file/FileService';
+import { NotificationService } from './lib/notification/NotificationService';
+import { SyncService } from './lib/sync/SyncService';
+import { SettingsService } from './lib/settings/SettingsService';
+import { LoggerService } from './lib/logger/LoggerService';
 
 /**
  * React Native Wrapper for Unvired Core SDK
@@ -11,78 +17,54 @@ export class UnviredWrapper {
   }
 
   /**
-   * Returns a builder for login method
-   * Can be awaited directly: await sdk.login().setAppName("my-app")
+   * Access Authentication operations
    */
-  login(): AuthBuilder {
-    return new AuthBuilder('login');
+  auth(): AuthService {
+    return new AuthService();
   }
 
   /**
-   * Returns a builder for authenticateAndActivate method
-   * Can be awaited directly: await sdk.authenticateAndActivate().setUsername("demo")
+   * Access Database operations
    */
-  authenticateAndActivate(): AuthBuilder {
-    return new AuthBuilder('authenticateAndActivate');
+  database(): DatabaseService {
+    return new DatabaseService();
   }
 
   /**
-   * Returns a builder for authenticateLocal method
-   * Can be awaited directly: await sdk.authenticateLocal().setUsername("demo")
+   * Access File/Attachment operations
    */
-  authenticateLocal(): AuthBuilder {
-    return new AuthBuilder('authenticateLocal');
+  file(): FileService {
+    return new FileService();
   }
 
   /**
-   * Logout method - Logs out the current user
+   * Access Notification operations
    */
-  async logout(): Promise<any> {
-    const authService = (AuthenticationService as any).instance;
-    return authService.logout();
+  notification(): NotificationService {
+    return new NotificationService();
   }
 
   /**
-   * Clear all data
+   * Access Synchronization operations
    */
-  async clearData(): Promise<any> {
-    const authService = (AuthenticationService as any).instance;
-    return authService.clearData();
+  sync(): SyncService {
+    return new SyncService();
   }
 
-  // Logging methods - delegating to PlatformManager's adapter
-  static logInfo(className: string, methodName: string, message: string) {
-    return PlatformManager.getInstance().getPlatformAdapter().getLoggerAdapter().logInfo(className, methodName, message);
-  }
-
-  static logError(className: string, methodName: string, message: string) {
-    return PlatformManager.getInstance().getPlatformAdapter().getLoggerAdapter().logError(className, methodName, message);
-  }
-
-  static logDebug(className: string, methodName: string, message: string) {
-    return PlatformManager.getInstance().getPlatformAdapter().getLoggerAdapter().logDebug(className, methodName, message);
-  }
-
-
-  static setLogLevel(level: string) {
-    return PlatformManager.getInstance().getPlatformAdapter().getLoggerAdapter().setLogLevel(level);
-  }
-
-  static async getLogFileURL(): Promise<string> {
-    return PlatformManager.getInstance().getPlatformAdapter().getLoggerAdapter().getLogFileURL();
-  }
-
-  static async getLogFileContent(): Promise<string> {
-    return PlatformManager.getInstance().getPlatformAdapter().getLoggerAdapter().getLogFileContent();
+  /**
+   * Access Settings and Utility operations
+   */
+  settings(): SettingsService {
+    return new SettingsService();
   }
 
-  static async getBackupLogFileContent(): Promise<string> {
-    return PlatformManager.getInstance().getPlatformAdapter().getLoggerAdapter().getBackupLogFileContent();
+  /**
+   * Access Logger operations
+   */
+  logger(): LoggerService {
+    return new LoggerService();
   }
 
-  static async clearLogFile(): Promise<void> {
-    return PlatformManager.getInstance().getPlatformAdapter().getLoggerAdapter().clearLogFile();
-  }
 }
 
-export default UnviredWrapper;
+export default UnviredWrapper;

package/src/lib/auth/AuthService.ts

@@ -0,0 +1,45 @@
+import AuthBuilder from './AuthBuilder';
+import { AuthenticationService } from '@unvired/unvired-ts-core-sdk';
+
+/**
+ * Service for handling Authentication operations
+ */
+export class AuthService {
+
+    /**
+     * Returns a builder for login method
+     */
+    login(): AuthBuilder {
+        return new AuthBuilder('login');
+    }
+
+    /**
+     * Returns a builder for authenticateAndActivate method
+     */
+    authenticateAndActivate(): AuthBuilder {
+        return new AuthBuilder('authenticateAndActivate');
+    }
+
+    /**
+     * Returns a builder for authenticateLocal method
+     */
+    authenticateLocal(): AuthBuilder {
+        return new AuthBuilder('authenticateLocal');
+    }
+
+    /**
+     * Logout method - Logs out the current user
+     */
+    async logout(): Promise<any> {
+        const authService = (AuthenticationService as any).instance;
+        return authService.logout();
+    }
+
+    /**
+     * Clear all data
+     */
+    async clearData(): Promise<any> {
+        const authService = (AuthenticationService as any).instance;
+        return authService.clearData();
+    }
+}

package/src/lib/database/DatabaseService.ts

@@ -0,0 +1,53 @@
+import { PlatformManager } from '@unvired/unvired-ts-core-sdk';
+
+
+export interface IDatabaseAdapter {
+    create(options: { userId: string }, successCallback: (result: any) => void, errorCallback: (error: any) => void): void;
+    execute(options: any, successCallback: (result: any) => void, errorCallback: (error: any) => void): void;
+    executeStatementOnPath(dbPath: string, sqlQuery: string, callback: (result: any) => void): void;
+    selectFromPath(dbPath: string, sqlQuery: string, callback: (result: any) => void): void;
+    createDatabase(dbPath: string, callback: () => void): void;
+    getDBFilePath(options: { dbType: string }, callback: (path: string) => void): void;
+    saveWebDB(options: { userId: string }, callback: (result: any) => void, errorCallback: (error: any) => void): void;
+    exportWebDB(options: { userId: string }, callback: (result: any) => void, errorCallback: (error: any) => void): void;
+    deleteUserData(options: { userId: string }, callback: () => void, errorCallback: (error: any) => void): void;
+}
+
+export class DatabaseService {
+
+    create(options: { userId: string }, successCallback: (result: any) => void, errorCallback: (error: any) => void): void {
+        PlatformManager.getInstance().getPlatformAdapter().getDatabaseAdapter().create(options, successCallback, errorCallback);
+    }
+
+    execute(options: any, successCallback: (result: any) => void, errorCallback: (error: any) => void): void {
+        PlatformManager.getInstance().getPlatformAdapter().getDatabaseAdapter().execute(options, successCallback, errorCallback);
+    }
+
+    executeStatementOnPath(dbPath: string, sqlQuery: string, callback: (result: any) => void): void {
+        PlatformManager.getInstance().getPlatformAdapter().getDatabaseAdapter().executeStatementOnPath(dbPath, sqlQuery, callback);
+    }
+
+    selectFromPath(dbPath: string, sqlQuery: string, callback: (result: any) => void): void {
+        PlatformManager.getInstance().getPlatformAdapter().getDatabaseAdapter().selectFromPath(dbPath, sqlQuery, callback);
+    }
+
+    createDatabase(dbPath: string, callback: () => void): void {
+        PlatformManager.getInstance().getPlatformAdapter().getDatabaseAdapter().createDatabase(dbPath, callback);
+    }
+
+    getDBFilePath(options: { dbType: string }, callback: (path: string) => void): void {
+        PlatformManager.getInstance().getPlatformAdapter().getDatabaseAdapter().getDBFilePath(options, callback);
+    }
+
+    saveWebDB(options: { userId: string }, callback: (result: any) => void, errorCallback: (error: any) => void): void {
+        PlatformManager.getInstance().getPlatformAdapter().getDatabaseAdapter().saveWebDB(options, callback, errorCallback);
+    }
+
+    exportWebDB(options: { userId: string }, callback: (result: any) => void, errorCallback: (error: any) => void): void {
+        PlatformManager.getInstance().getPlatformAdapter().getDatabaseAdapter().exportWebDB(options, callback, errorCallback);
+    }
+
+    deleteUserData(options: { userId: string }, callback: () => void, errorCallback: (error: any) => void): void {
+        PlatformManager.getInstance().getPlatformAdapter().getDatabaseAdapter().deleteUserData(options, callback, errorCallback);
+    }
+}

package/src/lib/file/FileService.ts

@@ -0,0 +1,166 @@
+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;
+        }
+    }
+
+}

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();
+    }
+}