cordova-plugin-unvired-universal-sdk 1.0.1

package/www/outbox/outboxAttachmentManager.ts

@@ -0,0 +1,152 @@
+import DatabaseManager, { DatabaseType } from "../database/databaseManager";
+import { Logger } from "../helper/logger";
+import * as FieldConstants from '../applicationMeta/fieldConstants';
+import * as ServiceConstants from '../helper/serviceConstants';
+import { UnviredAccountManager } from "../helper/unviredAccountManager";
+import { HttpConnection, bearerAuth } from "../helper/httpConnection";
+import { UserSettingsFields, UserSettingsManager } from "../helper/userSettingsManager";
+import { isServerReachable, LoginType, ObjectStatus, SyncStatus } from "../helper/utils";
+import FrameworkHelper from "../helper/frameworkHelper";
+import { Status } from "../helper/status";
+import { AuthenticationService } from "../authenticationService";
+
+export default class OutboxAttachmentManager {
+    async checkAndUploadAttachmentsInOutBox(entityName:string, inputData: any): Promise<boolean> {
+        const databaseManager = DatabaseManager.getInstance();
+        const structureMetas = await databaseManager.select(DatabaseType.FrameworkDb, "StructureMeta");
+        const structureMeta = structureMetas.find(element => element.structureName === entityName);
+        // Invalid condition. Should never occur.
+        if (!structureMeta) {
+            Logger.logError("OutboxAttachmentManager", "checkAndUploadAttachmentsInOutBox", `Invalid BE. Cannot Upload Attachments. Table Name: ${entityName}`);
+            return false;
+        }
+        // If attachments are not supported do not do anything
+        const isAttachmentSupported: boolean = await this.isAttachmentSupportedForBEName(structureMeta.beName);
+        if (!isAttachmentSupported) {
+            Logger.logInfo("OutboxAttachmentManager", "checkAndUploadAttachmentsInOutBox", `This BE: ${structureMeta.beName} does not support attachments.`);
+            return true; // Return true since no attachments to upload
+        }
+
+        Logger.logDebug("OutboxAttachmentManager", "checkAndUploadAttachmentsInOutBox", `This BE: ${structureMeta.beName} supports attachments.`);
+
+        try {
+            const attachmentEntityNames: string[] = structureMetas
+                .filter(element => element.beName === structureMeta.beName && element.structureName.endsWith(ServiceConstants.AttachmentBE))
+                .map(e => e.structureName);
+
+            for (const attachmentEntityName of attachmentEntityNames) {
+                let attachmentItems: any[] = [];
+                try {
+                    attachmentItems = await this.getAttachmentsMarkedForUploadOutbox(attachmentEntityName, inputData);
+                } catch (e) {
+                    Logger.logError("OutboxAttachmentManager", "checkAndUploadAttachmentsInOutBox", `Error when trying to get attachments marked for upload ${JSON.stringify(e)}`);
+                    return false;
+                }
+
+                for (const attachmentItem of attachmentItems) {
+                    try {
+                        if (!navigator.onLine) {
+                            Logger.logError("OutboxAttachmentManager", "checkAndUploadAttachmentsInOutBox", "No Internet connection.");
+                            return false;
+                        }
+                        const lastLoggedInAccount = UnviredAccountManager.getInstance().getLastLoggedInAccount();
+                        if (!(await isServerReachable(lastLoggedInAccount.getServerURL()))) {
+                            return false;
+                        }
+                        const response = await new HttpConnection().uploadAttachment(attachmentItem);
+                        if (response.status === Status.ok || response.status === Status.created) {
+                            const isSuccess: boolean = await this.updateAttachmentStatusOutBox(attachmentEntityName, attachmentItem, ServiceConstants.AttachmentStatusUploaded);
+                            if (!isSuccess) {
+                                Logger.logError("OutboxAttachmentManager", "checkAndUploadAttachmentsInOutBox", `Failed to update status in ${attachmentEntityName} LID : ${attachmentItem[FieldConstants.FieldLid]}`);
+                            }
+                            return true;
+                        } else {
+                            Logger.logError("OutboxAttachmentManager", "checkAndUploadAttachmentsInOutBox", "Error while uploading attachment.");  
+                            const infoMessage = {
+                                lid: FrameworkHelper.getUUID(),
+                                timestamp: Date.now(),
+                                objectStatus: ObjectStatus.global,
+                                syncStatus: SyncStatus.none,
+                                type: "",
+                                subtype: "",
+                                category: 'InfoMessageFailure',
+                                message: "Error while uploading attachment.",
+                                bename: entityName,
+                                belid: attachmentItem[FieldConstants.FieldLid],
+                                messagedetails: new Uint8Array(0)
+                            };
+                            await databaseManager.insert(DatabaseType.FrameworkDb, "InfoMessage", infoMessage, true);
+                            const isSuccess: boolean = await this.updateAttachmentStatusOutBox(attachmentEntityName, attachmentItem, ServiceConstants.AttachmentStatusErrorInUpload);
+                            if (!isSuccess) {
+                                Logger.logError("OutboxAttachmentManager", "checkAndUploadAttachmentsInOutBox", `Failed to update status in ${attachmentEntityName} LID : ${attachmentItem[FieldConstants.FieldLid]}`);
+                            }
+                            return false;
+                        }
+                    } catch (e) {
+                        const isSuccess: boolean = await this.updateAttachmentStatusOutBox(attachmentEntityName, attachmentItem, ServiceConstants.AttachmentStatusErrorInUpload);
+                        if (!isSuccess) {
+                            Logger.logError("OutboxAttachmentManager", "checkAndUploadAttachmentsInOutBox", `Failed to update status in ${attachmentEntityName} LID : ${attachmentItem[FieldConstants.FieldLid]}`);
+                        }
+                        return false;
+                    }
+                }
+            }
+            return true;
+        } catch (e) {
+            Logger.logError("OutboxAttachmentManager", "checkAndUploadAttachmentsInOutBox", `Error when trying to check and upload attachments in outbox ${JSON.stringify(e)}`);
+            return false;
+        }
+    }
+
+    async updateAttachmentStatusOutBox(attachmentItemName: string, attachmentItem: any, attachmentStatus: string): Promise<boolean> {
+        attachmentItem[ServiceConstants.AttachmentItemFieldAttachmentStatus] = attachmentStatus;
+        const databaseManager = DatabaseManager.getInstance();
+        return await databaseManager.update(DatabaseType.AppDb, attachmentItemName, attachmentItem, `${FieldConstants.FieldLid} = '${attachmentItem[FieldConstants.FieldLid]}'`);
+    }
+
+    async isAttachmentSupportedForBEName(beName: string): Promise<boolean> {
+        if (!beName) {
+            return false;
+        }
+        try {
+            const databaseManager = DatabaseManager.getInstance();
+            const beMeta = await databaseManager.select(DatabaseType.FrameworkDb, "BusinessEntityMeta", `beName = '${beName}'`)
+            if (beMeta.length === 0) {
+                return false;
+            }
+            return beMeta[0].attachments === "1";
+        } catch (e) {
+            Logger.logError("OutboxAttachmentManager", "isAttachmentSupportedForBEName", `Error when trying to get BusinessEntityMeta. Error: ${JSON.stringify(e)}`);
+        }
+        return false;
+    }
+
+    async getAttachmentsMarkedForUploadOutbox(attachmentEntityName: string, inputData: any): Promise<any[]> {
+        const parsedData: any = JSON.parse(inputData[ServiceConstants.QueryParamInputMessage]);
+        const inputDataKeys: Iterable<string> = Object.keys(parsedData);
+        const beData: any = parsedData[inputDataKeys[0]];
+
+        let headerData: any ;
+        for (const key in beData[0]) {
+            if (key.endsWith("_HEADER")) {
+                headerData = beData[0][key];
+                break;
+            }
+        }
+        if (!headerData) {
+            Logger.logError("OutboxAttachmentManager", "getAttachmentsMarkedForUploadOutbox", "Header data not available.");
+            return [];
+        }
+        // Check if the header supports attachments, if yes, check if it has any, if yes send to server.
+        const whereClause: string = `${FieldConstants.FieldFid} = '${headerData[FieldConstants.FieldLid]}' AND ${ServiceConstants.AttachmentItemFieldAttachmentStatus} = '${ServiceConstants.AttachmentStatusSavedForUpload}'`;
+        let attachmentItems: any[] = [];
+        try {
+            const databaseManager = DatabaseManager.getInstance();
+            attachmentItems = await databaseManager.select(DatabaseType.AppDb, attachmentEntityName, whereClause);
+        } catch (e) {
+            Logger.logError("OutboxAttachmentManager", "getAttachmentsMarkedForUploadOutbox", `Error when trying to get attachments marked for upload ${JSON.stringify(e)}`);
+        }
+
+        return attachmentItems;
+    }
+}

package/www/outbox/outboxHelper.ts

@@ -0,0 +1,67 @@
+import DatabaseManager, { DatabaseType } from "../database/databaseManager";
+import * as FieldConstants from "../applicationMeta/fieldConstants";
+import { ObjectStatus, SyncStatus } from "../helper/utils";
+import { RequestType } from "../helper/serviceConstants";
+import { Logger } from "../helper/logger";
+
+const fileName = "OutBoxHelper";
+export default class OutBoxHelper {
+    static async checkIsInOutBox(beLid: string): Promise<any> {
+        if (beLid === "") {
+            return null;
+        }
+        const databaseManager = await DatabaseManager.getInstance();
+        const outObjectData = await databaseManager.select(DatabaseType.FrameworkDb, "OutObject", `beHeaderLid = '${beLid}'`);
+        return outObjectData.length > 0 ? outObjectData[0] : null;
+    }
+
+    static async checkIsInSentItems(beLid: string): Promise<any> {
+        if (beLid === "") {
+            return null;
+        }
+        const databaseManager = await DatabaseManager.getInstance();
+        const sentItem = await databaseManager.select(DatabaseType.FrameworkDb, "SentItems", `beHeaderLid = '${beLid}'`);
+        return sentItem.length > 0 ? sentItem[0] : null;
+    }
+
+    static async updateSyncStatusToEntityObjects(outObject: any, syncStatus: SyncStatus): Promise<void> {
+        const requestType = outObject.requestType;
+        const entityName = outObject.beName;
+        const beLid = outObject.beHeaderLid;
+
+        if (requestType === RequestType.RQST.toString()) {
+            const databaseManager = await DatabaseManager.getInstance();
+            const structureMetaData = await databaseManager.select(DatabaseType.FrameworkDb, "StructureMeta", `structureName = '${entityName}'`);
+            if (structureMetaData.length === 0) {
+                await Logger.logDebug(
+                    "OutboxHelper",
+                    "updateSyncStatusToEntityObjects",
+                    "No Business Entity got from database, BE-NAME: " +
+                        outObject.beName +
+                        ", BE-LID: " +
+                        beLid);
+                return;
+            }
+            const structureFieldData = await databaseManager.select(DatabaseType.AppDb, structureMetaData[0].structureName, `${FieldConstants.FieldLid} = '${beLid}'`);
+            if (structureFieldData.length === 0) {
+                await Logger.logDebug(
+                    "OutboxHelper",
+                    "updateSyncStatusToEntityObjects",
+                    `No Business Entity got from database, BE-NAME: ${outObject.beName}, BE-LID: ${beLid}`
+                );
+                return;
+            }
+            const data = structureFieldData[0];
+
+            data[FieldConstants.FieldSyncStatus] = syncStatus;
+            await databaseManager.update(DatabaseType.AppDb, entityName, data, `${FieldConstants.FieldLid} = '${beLid}'`);
+
+            const childStructureMetas = await databaseManager.select(DatabaseType.FrameworkDb, "StructureMeta", `beName = '${structureMetaData[0].beName}' AND isHeader != 1`);
+            for (const childStructureMetaData of childStructureMetas) {
+                await databaseManager.update(DatabaseType.AppDb, childStructureMetaData.structureName, {
+                    [FieldConstants.FieldSyncStatus]: syncStatus
+                }, `${FieldConstants.FieldFid}='${beLid}' AND ${FieldConstants.FieldObjectStatus} <> ${ObjectStatus.global}`, true); // isFromApp is true because it just need to update the data and should not set the missing fields to null.
+            }
+        }
+    }
+}