cordova-plugin-unvired-universal-sdk 1.0.1

package/www/attachment/attachmentHelper.ts

@@ -0,0 +1,326 @@
+import { UnviredAccountManager } from "../helper/unviredAccountManager";
+import { Logger } from "../helper/logger";
+import FrameworkHelper from "../helper/frameworkHelper";
+import DatabaseManager, { DatabaseType } from "../database/databaseManager";
+
+const fileName = "AttachmentHelper";
+
+export default class AttachmentHelper {
+  private static readonly ATTACHMENT_DIR = 'Attachment/'; 
+
+  // Helper method to create directories recursively
+  private static async createDirectoriesRecursively(dirPath: string): Promise<string> {
+      return new Promise((resolve, reject) => {
+          // Split the path into parts
+          const pathParts = dirPath.split(/[\\\/]/).filter(part => part.length > 0);
+          let currentPath = '';
+          
+          // Handle Windows drive letter
+          if (pathParts.length > 0 && pathParts[0].includes(':')) {
+              currentPath = pathParts[0] + '/';
+              pathParts.shift();
+          }
+          
+          const createNextDirectory = (index: number) => {
+              if (index >= pathParts.length) {
+                  // All directories created, resolve with the final path
+                  resolve(dirPath);
+                  return;
+              }
+              
+              currentPath += pathParts[index] + '/';
+              
+              window.resolveLocalFileSystemURL(currentPath, 
+                  (dirEntry) => {
+                      // Directory exists, continue to next
+                      Logger.logInfo(fileName, "createDirectoriesRecursively", "Directory exists: " + currentPath);
+                      createNextDirectory(index + 1);
+                  },
+                  (error) => {
+                      // Directory doesn't exist, create it
+                      Logger.logInfo(fileName, "createDirectoriesRecursively", "Creating directory: " + currentPath);
+                      
+                      // Get parent directory
+                      const trimmedPath = currentPath.replace(/\/$/, ''); // Remove trailing slash if present
+                      const parentPath = trimmedPath.substring(0, trimmedPath.lastIndexOf('/'));
+                      window.resolveLocalFileSystemURL(parentPath, 
+                          (parentDir) => {
+                              parentDir.getDirectory(pathParts[index], { create: true }, 
+                                  (newDir) => {
+                                      Logger.logInfo(fileName, "createDirectoriesRecursively", "Directory created: " + newDir.fullPath);
+                                      createNextDirectory(index + 1);
+                                  },
+                                  (createError) => {
+                                      Logger.logError(fileName, "createDirectoriesRecursively", "Failed to create directory: " + currentPath + " Error: " + createError);
+                                      reject(createError);
+                                  }
+                              );
+                          },
+                          (parentError) => {
+                              Logger.logError(fileName, "createDirectoriesRecursively", "Failed to get parent directory: " + parentPath + " Error: " + parentError);
+                              reject(parentError);
+                          }
+                      );
+                  }
+              );
+          };
+          
+          createNextDirectory(0);
+      });
+  }
+
+  static getAttachmentDirectory(): Promise<string> {
+    return new Promise(async (resolve, reject) => {
+      if (FrameworkHelper.getPlatform() === "electron") {
+        const mobileUserSettings: any[] = await DatabaseManager.getInstance().select(DatabaseType.FrameworkDb, "MobileUserSettings", "keyName = 'ATTACHMENT_STORAGE_PATH'" );
+        if (mobileUserSettings.length > 0) {
+          const attachmentStoragePath = mobileUserSettings[0].description;
+
+          // Check if the path exists, if not create directories recursively
+          try {
+              const pathExists = await this.fileExists(attachmentStoragePath);
+              if (pathExists) {
+                  Logger.logInfo(fileName, "getAttachmentDirectory", "Path exists: " + attachmentStoragePath);
+                  resolve(attachmentStoragePath);
+              } else {
+                  Logger.logInfo(fileName, "getAttachmentDirectory", "Path does not exist, creating directories: " + attachmentStoragePath);
+                  const createdPath = await this.createDirectoriesRecursively(attachmentStoragePath);
+                  resolve(createdPath);
+              }
+          } catch (error) {
+              Logger.logError(fileName, "getAttachmentDirectory", "Error checking/creating path: " + error);
+              resolve("");
+          }
+          return;
+        }
+      }
+      
+      const account = UnviredAccountManager.getInstance().getLastLoggedInAccount()
+      const userDirectory = await FrameworkHelper.getFolderBasedOnUserId(account.getAccountId());
+      const inboxDir = `${userDirectory}${AttachmentHelper.ATTACHMENT_DIR}`;
+      window.resolveLocalFileSystemURL(inboxDir, (dir) => {
+          Logger.logInfo(fileName, "getAttachmentDirectory", "Directory exists: " + dir.fullPath);
+          resolve(dir.nativeURL);
+      }, (error) => {
+          Logger.logInfo(fileName, "getAttachmentDirectory", "Directory did not exist. Error: " + error);
+          // Directory did not exist, so creating it.
+          Logger.logInfo(fileName, "getAttachmentDirectory", "Directory did not exist, so creating it: " + inboxDir);
+          window.resolveLocalFileSystemURL(userDirectory, (parentDir) => {
+              parentDir.getDirectory(AttachmentHelper.ATTACHMENT_DIR, {create: true}, (newDir) => {
+                  Logger.logInfo(fileName, "getAttachmentDirectory", "Directory created: " + newDir.nativeURL);
+                  resolve(newDir.nativeURL);
+              }, (error) => {
+                  Logger.logError(fileName, "getAttachmentDirectory", "Unable to create Attachment directory. Error: " + error);
+                  resolve("");
+              })
+          }, (error) => {
+              Logger.logError(fileName, "getAttachmentDirectory", "Unable to get Attachment directory. Error: " + error);
+              resolve("");
+          })
+      })
+    })
+  }
+
+  static addAttachment(attachmentName: string, attachmentData: ArrayBuffer): Promise<string> {
+    return new Promise(async (resolve, reject) => {
+        const attachmentDir = await this.getAttachmentDirectory();
+        window.resolveLocalFileSystemURL(attachmentDir, (dirEntry) => {
+            dirEntry.getFile(`${attachmentName}`, { create: true }, (fileEntry) => {
+              fileEntry.createWriter((fileWriter) => {
+                      fileWriter.onwriteend = () => {
+                          Logger.logInfo("AttachmentHelper", "addAttachment", "Write completed");
+                          resolve(fileEntry.nativeURL);
+                      };
+                      fileWriter.onerror = (e) => {
+                          Logger.logError("AttachmentHelper", "addAttachment", "Write error: " + e);
+                          reject(e);
+                      };
+                      const blob = new Blob([attachmentData]);
+                      fileWriter.write(blob);
+                  },
+                  (error) => {
+                      Logger.logError("AttachmentHelper", "addAttachment", "Create writer error: " + error);
+                      reject(error);
+                  }
+              );
+            },
+            (error) => {
+                Logger.logError("AttachmentHelper", "addAttachment", "Get file error: " + error);
+                reject(error);
+            });
+        },
+        (error) => {
+            Logger.logError("AttachmentHelper", "addAttachment", "Resolve file system URL error: " + error);
+            reject(error);
+        });
+    });
+  }
+
+  static getAttachment(attachmentName: string): Promise<ArrayBuffer> {
+    return new Promise(async (resolve, reject) => {
+      const attachmentDir = await this.getAttachmentDirectory();
+      window.resolveLocalFileSystemURL(attachmentDir, (dirEntry) => {
+        dirEntry.getFile(`${attachmentName}`, { create: false }, (fileEntry) => {
+          fileEntry.file((file) => {
+            const reader = new FileReader();
+            reader.onloadend = () => {
+              Logger.logInfo("AttachmentHelper", "getAttachment", "Read completed");
+              resolve(reader.result as ArrayBuffer);
+            };
+            reader.onerror = (e) => {
+              Logger.logError("AttachmentHelper", "getAttachment", "Read error: " + e);
+              reject(e);
+            };
+            reader.readAsArrayBuffer(file);
+          }, 
+          (error) => {
+            Logger.logError("AttachmentHelper", "getAttachment", "Get file error: " + error);
+            reject(error);
+          });
+        },
+        (error) => {
+          Logger.logError("AttachmentHelper", "getAttachment", "Get file error: " + error);
+          reject(error);
+        });
+      }, 
+      error => {
+        Logger.logError("AttachmentHelper", "getAttachment", "Resolve file system URL error: " + error);
+        reject(error);
+      });
+    });
+  }
+
+  static deleteAttachment(attachmentName: string): Promise<void> {
+    return new Promise(async (resolve, reject) => {
+      const attachmentDir = await this.getAttachmentDirectory();
+      window.resolveLocalFileSystemURL(attachmentDir, (dirEntry) => {
+        dirEntry.getFile(`${attachmentName}`, { create: false }, (fileEntry) => {
+          fileEntry.remove(() => {
+              Logger.logInfo("AttachmentHelper", "deleteAttachment", "File removed");
+              resolve();
+            },
+            (error) => {
+              Logger.logError("AttachmentHelper", "deleteAttachment", "Remove file error: " + error);
+              reject(error);
+            }
+          );
+        },
+        (error) => {
+          Logger.logError("AttachmentHelper", "deleteAttachment", "Get file error: " + error);
+          reject(error);
+        });
+      },
+      (error) => {
+        Logger.logError("AttachmentHelper", "deleteAttachment", "Resolve file system URL error: " + error);
+        reject(error);
+      });
+    });
+  }
+
+  static readFileAsArrayBuffer(filePath: string): Promise<ArrayBuffer> {
+    return new Promise((resolve, reject) => {
+      window.resolveLocalFileSystemURL(filePath, (fileEntry) => {
+        fileEntry.file((file) => {
+          const reader = new FileReader();
+          reader.onloadend = function() {
+            Logger.logInfo("AttachmentHelper", "readFileAsArrayBuffer", "Read completed");
+            resolve(this.result as ArrayBuffer);
+          };
+          reader.onerror = function(err) {
+            Logger.logError("AttachmentHelper", "readFileAsArrayBuffer", "Read error: " + err);
+            reject(err);
+          };
+          reader.readAsArrayBuffer(file);
+        },
+        (error) => {
+          Logger.logError("AttachmentHelper", "readFileAsArrayBuffer", "Get file error: " + error);
+          reject(error);
+        });
+      }, 
+      (error) => {
+        Logger.logError("AttachmentHelper", "readFileAsArrayBuffer", "Resolve file system URL error: " + error);
+        reject(error);
+      });
+    });
+  }
+
+  static async fileExists(filePath: string): Promise<boolean> {
+      return new Promise((resolve) => {
+          window.resolveLocalFileSystemURL(filePath, 
+              () => resolve(true), // File exists
+              () => resolve(false) // File doesn't exist
+          );
+      });
+  }
+
+  // Mainly used for electron/windows platform.
+  static async readExternalFile(filePath: string): Promise<ArrayBuffer> {
+    return new Promise((resolve, reject) => {
+        window.resolveLocalFileSystemURL(filePath, (fileEntry) => {
+            fileEntry.file((file) => {
+                const reader = new FileReader();
+                reader.onloadend = function() {
+                    Logger.logInfo(fileName, "readExternalFile", "Read completed");
+                    resolve(this.result as ArrayBuffer);
+                };
+                reader.onerror = function(err) {
+                    Logger.logError(fileName, "readExternalFile", "Read error: " + err);
+                    reject(err);
+                };
+                reader.readAsArrayBuffer(file);
+            }, 
+            (error) => {
+                Logger.logError(fileName, "readExternalFile", "Get file error: " + error);
+                reject(error);
+            });
+        }, 
+        (error) => {
+            Logger.logError(fileName, "readExternalFile", "Resolve file system URL error: " + error);
+            reject(error);
+        });
+    });
+  }
+
+  // Mainly used for electron/windows platform.
+  static async writeExternalFile(filePath: string, fileName: string, data: ArrayBuffer): Promise<void> {
+    return new Promise((resolve, reject) => {
+      window.resolveLocalFileSystemURL(filePath, (dirEntry) => {
+        dirEntry.getFile(`${fileName}`, { create: true }, (fileEntry) => {
+          fileEntry.createWriter((fileWriter) => {
+                  fileWriter.onwriteend = () => {
+                      Logger.logInfo("AttachmentHelper", "writeExternalFile", "Write completed");
+                      resolve();
+                  };
+                  fileWriter.onerror = (e) => {
+                      Logger.logError("AttachmentHelper", "writeExternalFile", "Write error: " + e);
+                      reject(e);
+                  };
+                  const blob = new Blob([data]);
+                  fileWriter.write(blob);
+              },
+              (error) => {
+                  Logger.logError("AttachmentHelper", "writeExternalFile", "Create writer error: " + error);
+                  reject(error);
+              }
+          );
+        },
+        (error) => {
+            Logger.logError("AttachmentHelper", "writeExternalFile", "Get file error: " + error);
+            reject(error);
+        });
+    },
+    (error) => {
+        Logger.logError("AttachmentHelper", "writeExternalFile", "Resolve file system URL error: " + error);
+        reject(error);
+    });
+    })
+  }
+
+  static async getAttachmentPath(attachmentName: string): Promise<string> {
+    return new Promise(async (resolve, reject) => {
+      const attachmentDir = await this.getAttachmentDirectory();
+      resolve(`${attachmentDir}${attachmentName}`);
+    });
+  }
+}
+  

package/www/attachment/attachmentQHelper.ts

@@ -0,0 +1,158 @@
+import FrameworkHelper from "../helper/frameworkHelper";
+import { Logger } from "../helper/logger";
+import * as ServiceConstants from "../helper/serviceConstants";
+import { DatabaseManager, DatabaseType } from "../database/databaseManager";
+import { UnviredAccountManager } from "../helper/unviredAccountManager";
+import { AuthenticationService } from "../authenticationService";
+import { FrameworkSettingsFields, FrameworkSettingsManager } from "../helper/frameworkSettingsManager";
+import { ObjectStatus, SyncStatus } from "../helper/utils";
+import { HttpConnection } from "../helper/httpConnection";
+import { Status } from "../helper/status";
+import AttachmentHelper from "./attachmentHelper";
+import { kAttachmentItem, kError, NotificationListenerHelper, NotificationListnerType } from "../helper/notificationListnerHelper";
+
+const fileName = "AttachmentQHelper";
+export default class AttachmentQHelper {
+    static async checkAttachmentAndQueueForAutoDownload(
+        attachmentItemName: string, attachmentItem: any): Promise<void> {
+        if (FrameworkHelper.getPlatform() === "browser") {
+            await Logger.logError(fileName, "checkAttachmentAndQueueForAutoDownload", "Attachment download is not supported in Web.");
+            return;
+        }
+
+        attachmentItem[ServiceConstants.AttachmentItemFieldAttachmentStatus] = ServiceConstants.AttachmentStatusDefault;
+        try {
+            await DatabaseManager.getInstance().update(DatabaseType.AppDb, attachmentItemName, attachmentItem, `${ServiceConstants.AttachmentItemFieldUid} = '${attachmentItem[ServiceConstants.AttachmentItemFieldUid]}'`);
+        } catch (e) {
+            await Logger.logError(
+                "AttachmentHelper",
+                "checkAttachmentAndQueueForAutodownload",
+                `Error while updating the status of the attachment item. Error: ${e}`);
+        }
+
+        // Check if it is marked for auto download and queue request if required
+        const autoDownload = attachmentItem[ServiceConstants.AttachmentItemFieldAutoDownload];
+        if (autoDownload != null && autoDownload === "true") {
+            const isDatabaseOperationSuccessful = await AttachmentQHelper.queueForDownload(
+                attachmentItemName, attachmentItem, ServiceConstants.FwAttachmentAutoDownloadPriority);
+            if (!isDatabaseOperationSuccessful) {
+                await Logger.logError(
+                    "AttachmentHelper",
+                    "checkAttachmentAndQueueForAutodownload",
+                    "Failed to Queue Attachment Item for Download");
+            }
+        }
+    }
+
+    static async queueForDownload(attachmentItemName: string, attachmentItem: any, priority: number): Promise<boolean> {
+        //  In Demo Mode, Attachments cannot be queued for Download.
+        //  Therefore we log an Error Message saying that this feature is not supported in demo Mode.
+
+        const demoMode = await FrameworkSettingsManager.getInstance().getFieldValue(FrameworkSettingsFields.isDemo);
+        if (demoMode) {
+            // Create an Error Object.
+            attachmentItem[ServiceConstants.AttachmentItemFieldMessage] =
+                "Downloading of attachments is not supported in demo mode.";
+            attachmentItem[ServiceConstants.AttachmentItemFieldAttachmentStatus] =
+                ServiceConstants.AttachmentStatusErrorInDownload;
+
+            // Update the Attachment in the Database as well.
+            try {
+                await DatabaseManager.getInstance().update(DatabaseType.AppDb, attachmentItemName, attachmentItem, `${ServiceConstants.AttachmentItemFieldUid} = '${attachmentItem[ServiceConstants.AttachmentItemFieldUid]}'`);
+            } catch (e) {
+                await Logger.logError("AttachmentHelper", "queueForDownload",
+                    `There was an error while downloading Attachments. Error: ${e}`);
+            }
+            const notifData = {
+                [kAttachmentItem]: attachmentItem,
+                [kError]: "Downloading of attachments is not supported in demo mode."
+            }
+            NotificationListenerHelper.postDataSenderNotification(notifData, NotificationListnerType.attachmentDownloadError);
+            return true;
+        }
+        if (attachmentItem == null || Object.keys(attachmentItem).length === 0) {
+            throw new Error("Attachment Item is null.");
+        }
+        await AttachmentQHelper.addAttachmentQForDownload(attachmentItemName, attachmentItem, priority);
+        return true;
+    }
+
+    private static async addAttachmentQForDownload(attachmentItemName: string, attachmentItem: any, priority: number): Promise<void> {
+        const structMetas = await DatabaseManager.getInstance().select(DatabaseType.FrameworkDb, "StructureMeta");
+        //get AttachmentStructure
+        const attachmentStructMeta = structMetas.find(
+            (element) => element.structureName === attachmentItemName);
+        if (!attachmentStructMeta) {
+            await Logger.logError("AttachmentDownloader", "queueForDownload",
+                `Structure Meta for Attachment Item (${attachmentItemName}) is not found.`);
+            return;
+        }
+        //get BEHeader
+        const headerStructMeta = structMetas.find(
+            (element) =>
+                element.beName === attachmentStructMeta.beName &&
+                element.isHeader === "1");
+        if (!headerStructMeta) {
+            await Logger.logError("AttachmentDownloader", "queueForDownload",
+                `Header Structure Meta for Attachment Item (${attachmentItemName}) is not found.`);
+            return;
+        }
+        const timestamp = Date.now();
+        const uid = attachmentItem[ServiceConstants.AttachmentItemFieldUid] ?? "";
+
+        //create attachmentQObject and save it
+        const attachmentQObjectData = {
+            lid: FrameworkHelper.getUUID(),
+            timestamp: timestamp,
+            objectStatus: ObjectStatus.add,
+            syncStatus: SyncStatus.none,
+            uid: uid,
+            beName: attachmentStructMeta.beName,
+            beHeaderName: headerStructMeta.structureName,
+            beAttachmentStructName: attachmentStructMeta.structureName,
+            priority: priority,
+            timeStamp: timestamp
+        };
+        await Logger.logDebug("AttachmentDownloader", "queueForDownload",
+            `ATTACHMENT QUEUED LID ${attachmentQObjectData.lid} HEADER NAME : ${headerStructMeta.structureName} STRUCT NAME : ${attachmentStructMeta.structureName}`);
+
+        try {
+            // Add the Attachment Q Object to the Attachment Q
+            await DatabaseManager.getInstance().insert(DatabaseType.FrameworkDb, "AttachmentQObject", attachmentQObjectData, true);
+        } catch (e) {
+            await Logger.logDebug("AttachmentDownloader", "queueForDownload",
+                `ATTACHMENT QUEUE FAILED...... LID ${attachmentQObjectData.lid} HEADER NAME : ${headerStructMeta.structureName} STRUCT NAME : ${attachmentStructMeta.structureName}`);
+            await Logger.logError("AttachmentDownloader", "queueForDownload",
+                `Error while adding attachment Q object to the Attachment Q. Error: ${e}`);
+            return;
+        }
+        //change status to queued for download
+        attachmentItem[ServiceConstants.AttachmentItemFieldAttachmentStatus] =
+            ServiceConstants.AttachmentStatusQueuedForDownload;
+
+        // Update the Attachment Status
+        try {
+            await DatabaseManager.getInstance().update(DatabaseType.AppDb, attachmentItemName, attachmentItem, `${ServiceConstants.AttachmentItemFieldUid} = '${attachmentItem[ServiceConstants.AttachmentItemFieldUid]}'`);
+        } catch (e) {
+            await Logger.logError("AttachmentDownloader", "queueForDownload",
+                `DB Error while trying to mark Attachment as Queued for download. Error: ${e}`);
+        }
+        // call start AttachmentDownloadThread
+        //start();
+    }
+
+    static async downloadAttachmentAndGetPath(uid: string, fileName: string): Promise<any> {
+        const result = await new HttpConnection().downloadAttachment(uid);
+        if (result.status === Status.ok) {
+            const arrayBuffer = await result.arrayBuffer();
+            const attachmentPath = await AttachmentHelper.addAttachment(fileName, arrayBuffer);
+            return attachmentPath;
+        } else {
+            await Logger.logDebug("AttachmentHelper", "downloadAttachmentAndGetPath",
+                `Failed to download attachment. Result: ${result.toString()}`);
+            await Logger.logError("AttachmentHelper", "downloadAttachmentAndGetPath",
+                'Failed to download attachment.');
+            throw result;
+        }
+    }
+}