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

package/www/inbox/inboxService.ts

@@ -1,223 +0,0 @@
-import DatabaseManager, { DatabaseType } from "../database/databaseManager";
-import FrameworkHelper from "../helper/frameworkHelper";
-import { Logger } from "../helper/logger";
-import ServerResponseHandler from "../helper/serverResponseHandler";
-import { ObjectStatus, SyncStatus } from "../helper/utils";
-import DownloadMessageService from "./downloadMessageService";
-import * as ServiceConstants from "../helper/serviceConstants";
-import * as FieldConstants from "../applicationMeta/fieldConstants";
-import InboxHelper from "./inboxHelper";
-import AttachmentService from "../attachment/attachmentService";
-import { NotificationListenerHelper, NotificationListnerType } from "../helper/notificationListnerHelper";
-
-const fileName = "InboxService"
-export default class InboxService {
-    
-    private static instance: InboxService;
-    private isProcessing: boolean = false;
-    private shouldStop: boolean = false;
-
-    private constructor() {}
-
-    public static getInstance(): InboxService {
-        if (!InboxService.instance) {
-            InboxService.instance = new InboxService();
-        }
-        return InboxService.instance;
-    }
-
-    public start(): void {
-        if (!this.isProcessing) {
-            this.isProcessing = true;
-            this.shouldStop = false;
-            this.startInboxProcessing();
-        } else {
-            Logger.logInfo(fileName, "start", "Inbox processing is already running.");
-        }
-    }
-
-    public stop(): void {
-        if (this.isProcessing) {
-            this.shouldStop = true;
-            Logger.logInfo(fileName, "stop", "Stopping inbox processing...");
-        } else {
-            Logger.logInfo(fileName, "stop", "Inbox processing is not running.");
-        }
-    }
-
-    async startInboxProcessing(): Promise<void> {
-        Logger.logInfo(fileName, "startInboxProcessing", "Starting inbox processing...");
-        let isInboxEmpty = false;
-        const databaseManager = DatabaseManager.getInstance();
-        const inboxCount = await databaseManager.count(DatabaseType.FrameworkDb, "InObject");
-        var currentIndex = 0;
-        try {
-            do {
-                if (this.shouldStop) {
-                    Logger.logInfo(fileName, "startInboxProcessing", "Stopping inbox processing...");
-                    break;
-                }
-                const inObject = await databaseManager.getFirstEntity(DatabaseType.FrameworkDb, "InObject");
-                isInboxEmpty = inObject === null;
-                if (!isInboxEmpty) {
-                    currentIndex++;
-                    const currentProcessingNumber = inboxCount - currentIndex;
-                    if (currentProcessingNumber > 0) {
-                        NotificationListenerHelper.postSynchronizationStateNotification(`processing (${currentProcessingNumber})`);
-                    }
-                    Logger.logInfo(fileName, "startInboxProcessing", `Processing LID : ${inObject.lid}. Conversation ID : ${inObject.conversationId}.`);
-                    try {
-                        if (inObject.type !== -1 && inObject.subtype !== -1) {
-                            Logger.logInfo(fileName, "startInboxProcessing", `Admin service messages. Starting in-object processing.`);
-                            await DownloadMessageService.handleMessageTypes(inObject);
-                            await databaseManager.delete(DatabaseType.FrameworkDb, "InObject", `conversationId = '${inObject.conversationId}'`);
-                            Logger.logInfo(fileName, "startInboxProcessing", `Admin service messages. Deleting from in-object.`);
-                            await InboxHelper.deleteInBoxData(inObject.conversationId);
-                        } else {
-                            let jsonData: any = {};
-                            try {
-                                const inboxData = await InboxHelper.getInBoxData(inObject.conversationId);
-                                jsonData = JSON.parse(inboxData);
-                            } catch (e) {
-                                Logger.logError(fileName, "startInboxProcessing", `Application messages. Error while getting inbox data: ${JSON.stringify(e)}.`);
-                                await databaseManager.delete(DatabaseType.FrameworkDb, "InObject", `lid = '${inObject.lid}'`);
-                                continue;
-                            }
-                            
-                            try {
-                                Logger.logInfo(fileName, "startInboxProcessing", `Application messages. Starting in-object processing.`);
-                                // map["currentConvId"] = inObject.conversationId;
-                                await ServerResponseHandler.handleResponseData(jsonData, true, false, inObject.beLid, inObject.jsonData, inObject.requestType);
-                                Logger.logInfo(fileName, "startInboxProcessing", `Application messages. In-object successfully processed.`);
-                            } catch (e) {
-                                Logger.logError(fileName, "startInboxProcessing", `Application messages. Error while processing in-object: ${JSON.stringify(e)}.`);
-                                const infoMessage = {
-                                    lid: FrameworkHelper.getUUID(),
-                                    timestamp: Date.now(),
-                                    objectStatus: ObjectStatus.global,
-                                    syncStatus: SyncStatus.none,
-                                    type: inObject.type.toString(),
-                                    subtype: inObject.subtype.toString(),
-                                    category: FieldConstants.InfoMessageFailure,
-                                    message: `Deleted the InObject from the inobject Queue. Could not handle the In Object because the XML data had a parsing Issue: ${JSON.stringify(e)}. Conversation ID: ${inObject.conversationId}. `,
-                                    bename: inObject.jsonData,
-                                    belid: inObject.beLid,
-                                    messagedetails: new Uint8Array(0)
-                                };
-                                await databaseManager.insert(DatabaseType.FrameworkDb, "InfoMessage", infoMessage, true);
-                                await this.updateSyncStatusToEntityObjects(inObject, SyncStatus.error);
-                            }
-                            Logger.logInfo(fileName, "startInboxProcessing", `Application messages. Deleting from in-object.`);
-                            const result: number = await databaseManager.delete(DatabaseType.FrameworkDb, "InObject", `conversationId = '${inObject.conversationId}'`);
-                            Logger.logInfo(fileName, "startInboxProcessing", `Application messages. in-object deleted. Result: ${result}`);
-                            await InboxHelper.deleteInBoxData(inObject.conversationId);
-                        }
-                    } catch (e) {
-                        Logger.logError(fileName, "startInboxProcessing", `Application messages. Error while processing in-object: ${JSON.stringify(e)}.`);
-                    }
-                } else {
-                    Logger.logInfo(fileName, "startInboxProcessing", `Inbox is empty. Stopping inbox processing.`);
-                }
-            } while (!isInboxEmpty);
-            await this.checkAndUpdateHeaderSyncStatus();
-            Logger.logInfo(fileName, "startInboxProcessing", `Inbox processing completed.`);
-            NotificationListenerHelper.postSynchronizationStateNotification(`idle`);
-            if (inboxCount > 0) {
-                NotificationListenerHelper.postDataSenderNotification(null, NotificationListnerType.incomingDataProcessingFinished);
-            }
-            AttachmentService.getInstance().start();
-        }
-        catch (e) {
-            Logger.logError(fileName, "startInboxProcessing", `Error while starting inbox processing. Error: ${e}`);
-        }
-        finally {
-            this.isProcessing = false;
-            this.shouldStop = false;
-        }
-    }
-    
-    private async checkAndUpdateHeaderSyncStatus(): Promise<void> {
-        try {
-            const databaseManager = DatabaseManager.getInstance();
-            const headerStructMetas: any[] = await databaseManager.select(DatabaseType.FrameworkDb, "StructureMeta", `isHeader = '1'`);
-            const allBusinessEntityMetas: any[] = await databaseManager.select(DatabaseType.FrameworkDb, "BusinessEntityMeta");
-            const allSentItems = await databaseManager.select(DatabaseType.FrameworkDb, "SentItems");
-            const allBeLids: string[] = allSentItems.map(e => e.beHeaderLid);
-            let beLidsSting = "";
-            if (allBeLids.length > 0) {
-                beLidsSting = "'" + allBeLids.join("','") + "'";
-            }
-            for (const headerStructure of headerStructMetas) {
-                try {
-                    const currentBeMeta = allBusinessEntityMetas.find(element => element.beName === headerStructure.beName);
-                    if (currentBeMeta?.save === "false") {
-                        continue;
-                    }
-                    Logger.logInfo(fileName, "checkAndUpdateHeaderSyncStatus", `headerStructure: ${JSON.stringify(headerStructure)}.`);
-                    const allData: any[] = await databaseManager.select(DatabaseType.AppDb, headerStructure.structureName, `${FieldConstants.FieldSyncStatus}=${SyncStatus.sent} AND ${FieldConstants.FieldObjectStatus}=${ObjectStatus.modify}` +
-                        (beLidsSting.length > 0 ? ` AND ${FieldConstants.FieldLid} NOT IN (${beLidsSting})` : ""))
-                    for (const headerData of allData) {
-                        try {
-                            await databaseManager.update(DatabaseType.AppDb, headerStructure.structureName, {
-                                [FieldConstants.FieldSyncStatus]: SyncStatus.error,
-                                [FieldConstants.FieldInfoMsgCat]: FieldConstants.InfoMessageFailure
-                            }, `${FieldConstants.FieldLid} = '${headerData[FieldConstants.FieldLid]}'`, true); // isFromApp is true because it just need to update the data and should not set the missing fields to null.
-                            const infoMessage = {
-                                lid: FrameworkHelper.getUUID(),
-                                timestamp: Date.now(),
-                                objectStatus: ObjectStatus.global,
-                                syncStatus: SyncStatus.none,
-                                type: "",
-                                subtype: "",
-                                category: FieldConstants.InfoMessageFailure,
-                                message: "The connection was interrupted. Please try again.",
-                                bename: headerStructure.structureName,
-                                belid: headerData[FieldConstants.FieldLid],
-                                messagedetails: new Uint8Array(0)
-                            };
-                            await databaseManager.insert(DatabaseType.FrameworkDb, "InfoMessage", infoMessage, true);
-                        } catch (e) {
-                            Logger.logError(fileName, "checkAndUpdateHeaderSyncStatus", `Error while updating header (${headerStructure.structureName}) Sync Status to ERROR into database. Error: ${JSON.stringify(e)}`);
-                        }
-                    }
-                } catch (e) {
-                    Logger.logError(fileName, "checkAndUpdateHeaderSyncStatus", `Error while getting BE Meta for header (${headerStructure.structureName}). Error: ${JSON.stringify(e)}`);
-                }
-            }
-        } catch (e) {
-            Logger.logError(fileName, "checkAndUpdateHeaderSyncStatus", `Error while updating header Sync Status to ERROR. Error: ${JSON.stringify(e)}`);
-        }
-    }
-    
-    async updateSyncStatusToEntityObjects(inObject: any, syncStatus: SyncStatus): Promise<void> {
-        const requestType = inObject.requestType;
-        const entityName = inObject.jsonData; // BE Name is set in the jsonData field
-        const beLid = inObject.beLid;
-        
-        if (requestType === ServiceConstants.RequestType.RQST.toString()) {
-            const databaseManager = DatabaseManager.getInstance();
-            const structureMetaData = await databaseManager.select(DatabaseType.FrameworkDb, "StructureMeta", `structureName = '${entityName}'`)
-            if (structureMetaData.length === 0) {
-                Logger.logError(fileName, "updateSyncStatusToEntityObjects", `No structure meta found for BE-NAME: ${entityName}, BE-LID: ${beLid}`);
-                return;
-            }
-            const structName = structureMetaData[0].structureName;
-            const structureFieldData = await databaseManager.select(DatabaseType.AppDb, structName, `${FieldConstants.FieldLid} = '${beLid}'`);
-            if (structureFieldData.length === 0) {
-                Logger.logError(fileName, "updateSyncStatusToEntityObjects", `No Business Entity got from database, BE-NAME: ${entityName}, BE-LID: ${beLid}`);
-                return;
-            }
-            const data = structureFieldData[0];
-            
-            data[FieldConstants.FieldSyncStatus] = syncStatus;
-            await databaseManager.update(DatabaseType.AppDb, structName, data, `${FieldConstants.FieldLid} = '${beLid}'`);
-                
-            const childStructureMetas = await databaseManager.select(DatabaseType.FrameworkDb, "StructureMeta", `beName = '${entityName}' AND isHeader != '1'`);
-            for (const childStructureMetaData of childStructureMetas) {
-                await databaseManager.update(DatabaseType.AppDb, childStructureMetaData.structureName, {
-                    [FieldConstants.FieldSyncStatus]: syncStatus
-                }, `${FieldConstants.FieldLid}='${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.    
-            }
-        }
-    }
-}

package/www/outbox/outboxAttachmentManager.ts

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

@@ -1,67 +0,0 @@
-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.
-            }
-        }
-    }
-}