cordova-plugin-unvired-universal-sdk 1.0.6 → 1.0.9

package/www/attachment/attachmentHelper.ts

@@ -1,326 +0,0 @@
-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

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