@po-ui/ng-sync 15.15.0 → 16.0.0-next.2

package/esm2022/lib/services/po-schema/po-schema.service.mjs

@@ -0,0 +1,176 @@
+import { Injectable } from '@angular/core';
+import { PoSchemaUtil } from './po-schema-util/po-schema-util.model';
+import * as i0 from "@angular/core";
+import * as i1 from "./po-schema-definition/po-schema-definition.service";
+import * as i2 from "@po-ui/ng-storage";
+/**
+ * @docsPrivate
+ *
+ * @description
+ *
+ * Serviço que realiza as operações nos `schemas`.
+ */
+export class PoSchemaService {
+    poSchemaDefinitionService;
+    poStorage;
+    constructor(poSchemaDefinitionService, poStorage) {
+        this.poSchemaDefinitionService = poSchemaDefinitionService;
+        this.poStorage = poStorage;
+    }
+    /**
+     * Retorna o id a partir de uma chave de um *schema*.
+     *
+     * @param {string} schemaKey Chave do *schema* em que será realizada a busca do id.
+     */
+    static getIdByRecordKey(schemaKey) {
+        return schemaKey.split(':')[1];
+    }
+    /**
+     * Retorna a chave do *schema* informado.
+     *
+     * @param {string} schemaName Nome do *schema*.
+     * @param {any} recordId Id do registro.
+     * @param {boolean} isLocalKey Indica se é uma chave local.
+     */
+    static getRecordKey(schemaName, recordId, isLocalKey = false) {
+        return isLocalKey ? `${schemaName}_local:${recordId}` : `${schemaName}:${recordId}`;
+    }
+    /**
+     * Verifica se o dado informado é uma chave de um *schema*.
+     *
+     * @param {string} data Dado que será verificado se é uma chave de um *schema*.
+     * @param {string} schemaName Nome do *schema*.
+     */
+    static isSchemaKey(data, schemaName) {
+        return data ? data.startsWith(`${schemaName}:`) : false;
+    }
+    /**
+     * Cria um novo registro para o *schema* informado.
+     *
+     * @param {PoSyncSchema} schema **Schema* em que será criado o registro.
+     * @param {object} newRecord Registro que será criado.
+     */
+    async create(schema, newRecord) {
+        const id = PoSchemaUtil.getRecordId(newRecord, schema);
+        return this.save(schema, newRecord, id);
+    }
+    /**
+     * Destrói as chaves do *storage* que contém os registros dos *schemas*.
+     *
+     * @returns {Promise<void>} Promessa que é resolvida quando as chaves referentes aos *schemas* forem destruídas.
+     */
+    async destroySchemasRecords() {
+        const schemas = await this.poSchemaDefinitionService.getAll();
+        const storageKeys = await this.poStorage.keys();
+        for (const key of storageKeys) {
+            const schemaKey = schemas.find(schema => PoSchemaService.isSchemaKey(key, schema.name));
+            if (schemaKey) {
+                const id = PoSchemaService.getIdByRecordKey(key);
+                await this.remove(schemaKey.name, id);
+            }
+        }
+    }
+    /**
+     * Retorna o registro referente ao *schema* informado.
+     *
+     * @param {string} schemaName Nome do *schema*.
+     * @param {any} recordId Id do registro.
+     */
+    async get(schemaName, recordId) {
+        const isLocalRecord = true;
+        const localRecord = await this.getRecord(schemaName, recordId, isLocalRecord);
+        const record = await this.getRecord(schemaName, recordId);
+        return Object.assign(record, localRecord);
+    }
+    /**
+     * Retorna todos os registros referente ao *schema* informado.
+     *
+     * @param {string} schemaName Nome do *schema*.
+     */
+    async getAll(schemaName) {
+        const storageKeys = await this.poStorage.keys();
+        const schemaRecords = [];
+        for (const key of storageKeys) {
+            if (PoSchemaService.isSchemaKey(key, schemaName)) {
+                const id = PoSchemaService.getIdByRecordKey(key);
+                schemaRecords.push(await this.get(schemaName, id));
+            }
+        }
+        return schemaRecords;
+    }
+    /**
+     * Aguarda a liberação do recurso limitado, posteriormente o envolve em um comportamento
+     * de bloqueio e desbloqueio.
+     *
+     * @param {Function} limitedResource Função que será envolvida no comportamento de bloqueio e desbloqueio.
+     */
+    limitedCallWrap(limitedResource) {
+        return this.poStorage.limitedCallWrap(limitedResource);
+    }
+    /**
+     * Remove um registro de um *schema* informado.
+     *
+     * @param {string} schemaName Nome do *schema*.
+     * @param {any} recordId Id do registro.
+     */
+    async remove(schemaName, recordId) {
+        const recordKey = PoSchemaService.getRecordKey(schemaName, recordId);
+        const localRecordKey = PoSchemaService.getRecordKey(schemaName, recordId, true);
+        await this.poStorage.remove(recordKey);
+        await this.poStorage.remove(localRecordKey);
+    }
+    /**
+     * Atualiza um registro de um *schema* informado.
+     *
+     * @param {PoSyncSchema} schema **Schema* referente ao registro que será alterado.
+     * @param {object} record Registro que será atualizado.
+     * @param {any} recordId Id do registro que deseja ser alterado. Deve ser utilizado em casos em que o id foi alterado.
+     */
+    async update(schema, record, recordId) {
+        const id = PoSchemaUtil.getRecordId(record, schema);
+        if (recordId) {
+            record = await this.updateRecordId(schema.name, record, recordId);
+        }
+        return this.save(schema, record, id);
+    }
+    /**
+     * Atualiza todos os registros de um *schema*.
+     *
+     * @param {PoSyncSchema} schema **Schema* referente aos registros que serão alterados.
+     * @param {Array<object>} records Lista de registros que serão alterados.
+     */
+    async updateAll(schema, records) {
+        for (const record of records) {
+            await this.update(schema, record);
+        }
+    }
+    async getRecord(schemaName, recordId, isLocalRecord = false) {
+        return (await this.poStorage.get(PoSchemaService.getRecordKey(schemaName, recordId, isLocalRecord))) || {};
+    }
+    async save(schema, record, recordId) {
+        const { serverRecord, localRecord } = PoSchemaUtil.separateSchemaFields(schema, record);
+        const recordKey = PoSchemaService.getRecordKey(schema.name, recordId);
+        await this.poStorage.set(recordKey, serverRecord);
+        await this.saveLocalFields(schema.name, localRecord, recordId);
+        return record;
+    }
+    async saveLocalFields(schemaName, localFields, recordId) {
+        const containsLocalFields = Object.keys(localFields).length;
+        if (containsLocalFields) {
+            const localRecordKey = PoSchemaService.getRecordKey(schemaName, recordId, true);
+            await this.poStorage.set(localRecordKey, localFields);
+        }
+    }
+    async updateRecordId(schemaName, record, recordId) {
+        const isLocalRecord = true;
+        const localRecord = await this.getRecord(schemaName, recordId, isLocalRecord);
+        await this.remove(schemaName, recordId);
+        return Object.assign(record, localRecord);
+    }
+    static ɵfac = function PoSchemaService_Factory(t) { return new (t || PoSchemaService)(i0.ɵɵinject(i1.PoSchemaDefinitionService), i0.ɵɵinject(i2.PoStorageService)); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: PoSchemaService, factory: PoSchemaService.ɵfac });
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PoSchemaService, [{
+        type: Injectable
+    }], function () { return [{ type: i1.PoSchemaDefinitionService }, { type: i2.PoStorageService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"po-schema.service.js","sourceRoot":"","sources":["../../../../../../projects/sync/src/lib/services/po-schema/po-schema.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\n\r\nimport { PoStorageService } from '@po-ui/ng-storage';\r\n\r\nimport { PoSchemaDefinitionService } from './po-schema-definition/po-schema-definition.service';\r\nimport { PoSchemaUtil } from './po-schema-util/po-schema-util.model';\r\nimport { PoSyncSchema } from '../po-sync/interfaces/po-sync-schema.interface';\r\n\r\n/**\r\n * @docsPrivate\r\n *\r\n * @description\r\n *\r\n * Serviço que realiza as operações nos `schemas`.\r\n */\r\n@Injectable()\r\nexport class PoSchemaService {\r\n  constructor(private poSchemaDefinitionService: PoSchemaDefinitionService, private poStorage: PoStorageService) {}\r\n\r\n  /**\r\n   * Retorna o id a partir de uma chave de um *schema*.\r\n   *\r\n   * @param {string} schemaKey Chave do *schema* em que será realizada a busca do id.\r\n   */\r\n  private static getIdByRecordKey(schemaKey: string): string {\r\n    return schemaKey.split(':')[1];\r\n  }\r\n\r\n  /**\r\n   * Retorna a chave do *schema* informado.\r\n   *\r\n   * @param {string} schemaName Nome do *schema*.\r\n   * @param {any} recordId Id do registro.\r\n   * @param {boolean} isLocalKey Indica se é uma chave local.\r\n   */\r\n  private static getRecordKey(schemaName: string, recordId: any, isLocalKey: boolean = false): string {\r\n    return isLocalKey ? `${schemaName}_local:${recordId}` : `${schemaName}:${recordId}`;\r\n  }\r\n\r\n  /**\r\n   * Verifica se o dado informado é uma chave de um *schema*.\r\n   *\r\n   * @param {string} data Dado que será verificado se é uma chave de um *schema*.\r\n   * @param {string} schemaName Nome do *schema*.\r\n   */\r\n  private static isSchemaKey(data: string, schemaName: string): boolean {\r\n    return data ? data.startsWith(`${schemaName}:`) : false;\r\n  }\r\n\r\n  /**\r\n   * Cria um novo registro para o *schema* informado.\r\n   *\r\n   * @param {PoSyncSchema} schema **Schema* em que será criado o registro.\r\n   * @param {object} newRecord Registro que será criado.\r\n   */\r\n  async create(schema: PoSyncSchema, newRecord: object): Promise<object> {\r\n    const id = PoSchemaUtil.getRecordId(newRecord, schema);\r\n    return this.save(schema, newRecord, id);\r\n  }\r\n\r\n  /**\r\n   * Destrói as chaves do *storage* que contém os registros dos *schemas*.\r\n   *\r\n   * @returns {Promise<void>} Promessa que é resolvida quando as chaves referentes aos *schemas* forem destruídas.\r\n   */\r\n  async destroySchemasRecords(): Promise<void> {\r\n    const schemas = await this.poSchemaDefinitionService.getAll();\r\n    const storageKeys = await this.poStorage.keys();\r\n\r\n    for (const key of storageKeys) {\r\n      const schemaKey = schemas.find(schema => PoSchemaService.isSchemaKey(key, schema.name));\r\n\r\n      if (schemaKey) {\r\n        const id = PoSchemaService.getIdByRecordKey(key);\r\n        await this.remove(schemaKey.name, id);\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Retorna o registro referente ao *schema* informado.\r\n   *\r\n   * @param {string} schemaName Nome do *schema*.\r\n   * @param {any} recordId Id do registro.\r\n   */\r\n  async get(schemaName: string, recordId: any): Promise<object> {\r\n    const isLocalRecord = true;\r\n    const localRecord = await this.getRecord(schemaName, recordId, isLocalRecord);\r\n    const record = await this.getRecord(schemaName, recordId);\r\n\r\n    return Object.assign(record, localRecord);\r\n  }\r\n\r\n  /**\r\n   * Retorna todos os registros referente ao *schema* informado.\r\n   *\r\n   * @param {string} schemaName Nome do *schema*.\r\n   */\r\n  async getAll(schemaName: string): Promise<Array<object>> {\r\n    const storageKeys = await this.poStorage.keys();\r\n    const schemaRecords = [];\r\n\r\n    for (const key of storageKeys) {\r\n      if (PoSchemaService.isSchemaKey(key, schemaName)) {\r\n        const id = PoSchemaService.getIdByRecordKey(key);\r\n        schemaRecords.push(await this.get(schemaName, id));\r\n      }\r\n    }\r\n\r\n    return schemaRecords;\r\n  }\r\n\r\n  /**\r\n   * Aguarda a liberação do recurso limitado, posteriormente o envolve em um comportamento\r\n   * de bloqueio e desbloqueio.\r\n   *\r\n   * @param {Function} limitedResource Função que será envolvida no comportamento de bloqueio e desbloqueio.\r\n   */\r\n  limitedCallWrap(limitedResource: Function): Promise<any> {\r\n    return this.poStorage.limitedCallWrap(limitedResource);\r\n  }\r\n\r\n  /**\r\n   * Remove um registro de um *schema* informado.\r\n   *\r\n   * @param {string} schemaName Nome do *schema*.\r\n   * @param {any} recordId Id do registro.\r\n   */\r\n  async remove(schemaName: string, recordId: any): Promise<any> {\r\n    const recordKey = PoSchemaService.getRecordKey(schemaName, recordId);\r\n    const localRecordKey = PoSchemaService.getRecordKey(schemaName, recordId, true);\r\n\r\n    await this.poStorage.remove(recordKey);\r\n    await this.poStorage.remove(localRecordKey);\r\n  }\r\n\r\n  /**\r\n   * Atualiza um registro de um *schema* informado.\r\n   *\r\n   * @param {PoSyncSchema} schema **Schema* referente ao registro que será alterado.\r\n   * @param {object} record Registro que será atualizado.\r\n   * @param {any} recordId Id do registro que deseja ser alterado. Deve ser utilizado em casos em que o id foi alterado.\r\n   */\r\n  async update(schema: PoSyncSchema, record: object, recordId?: any): Promise<object> {\r\n    const id = PoSchemaUtil.getRecordId(record, schema);\r\n\r\n    if (recordId) {\r\n      record = await this.updateRecordId(schema.name, record, recordId);\r\n    }\r\n\r\n    return this.save(schema, record, id);\r\n  }\r\n\r\n  /**\r\n   * Atualiza todos os registros de um *schema*.\r\n   *\r\n   * @param {PoSyncSchema} schema **Schema* referente aos registros que serão alterados.\r\n   * @param {Array<object>} records Lista de registros que serão alterados.\r\n   */\r\n  async updateAll(schema: PoSyncSchema, records: Array<object>): Promise<void> {\r\n    for (const record of records) {\r\n      await this.update(schema, record);\r\n    }\r\n  }\r\n\r\n  private async getRecord(schemaName, recordId, isLocalRecord = false): Promise<object> {\r\n    return (await this.poStorage.get(PoSchemaService.getRecordKey(schemaName, recordId, isLocalRecord))) || {};\r\n  }\r\n\r\n  private async save(schema: PoSyncSchema, record: object, recordId: any) {\r\n    const { serverRecord, localRecord } = PoSchemaUtil.separateSchemaFields(schema, record);\r\n    const recordKey = PoSchemaService.getRecordKey(schema.name, recordId);\r\n\r\n    await this.poStorage.set(recordKey, serverRecord);\r\n    await this.saveLocalFields(schema.name, localRecord, recordId);\r\n\r\n    return record;\r\n  }\r\n\r\n  private async saveLocalFields(schemaName: string, localFields: object, recordId): Promise<void> {\r\n    const containsLocalFields = Object.keys(localFields).length;\r\n\r\n    if (containsLocalFields) {\r\n      const localRecordKey = PoSchemaService.getRecordKey(schemaName, recordId, true);\r\n      await this.poStorage.set(localRecordKey, localFields);\r\n    }\r\n  }\r\n\r\n  private async updateRecordId(schemaName, record, recordId) {\r\n    const isLocalRecord = true;\r\n\r\n    const localRecord = await this.getRecord(schemaName, recordId, isLocalRecord);\r\n    await this.remove(schemaName, recordId);\r\n\r\n    return Object.assign(record, localRecord);\r\n  }\r\n}\r\n"]}

package/{esm2020 → esm2022}/lib/services/po-sync/interfaces/po-sync-config.interface.mjs

@@ -1,2 +1,2 @@
-export {};
+export {};
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG8tc3luYy1jb25maWcuaW50ZXJmYWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvc3luYy9zcmMvbGliL3NlcnZpY2VzL3BvLXN5bmMvaW50ZXJmYWNlcy9wby1zeW5jLWNvbmZpZy5pbnRlcmZhY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFBvRGF0YVRyYW5zZm9ybSB9IGZyb20gJy4vLi4vLi4vLi4vbW9kZWxzL3BvLWRhdGEtdHJhbnNmb3JtLm1vZGVsJztcclxuaW1wb3J0IHsgUG9OZXR3b3JrVHlwZSB9IGZyb20gJy4vLi4vLi4vLi4vbW9kZWxzL3BvLW5ldHdvcmstdHlwZS5lbnVtJztcclxuXHJcbi8qKlxyXG4gKiBAdXNlZEJ5IFBvU3luY1NlcnZpY2VcclxuICpcclxuICogQGRlc2NyaXB0aW9uXHJcbiAqXHJcbiAqIEludGVyZmFjZSBwYXJhIGEgZGVmaW5pw6fDo28gZGFzIGNvbmZpZ3VyYcOnw7VlcyBkbyBzaW5jcm9uaXNtby5cclxuICovXHJcblxyXG5leHBvcnQgaW50ZXJmYWNlIFBvU3luY0NvbmZpZyB7XHJcbiAgLyoqXHJcbiAgICogQ2xhc3NlIHVzYWRhIHBhcmEgYSB0cmFzZm9ybWHDp8OjbyBkb3MgZGFkb3MgbmFzIHJlcXVpc2nDp8O1ZXMuXHJcbiAgICpcclxuICAgKiA+IFZlamEgbWFpcyBkZXRhbGhlcyBlbSBbRnVuZGFtZW50b3MgZG8gUE8gU3luYyAtIEFkYXB0YW5kbyBhIHJlc3Bvc3RhIGRhIEFQSSBwYXJhIG8gcGFkcsOjbyBkbyBQTyBVSV0oL2d1aWRlcy9zeW5jLWZ1bmRhbWVudGFscykuXHJcbiAgICovXHJcbiAgZGF0YVRyYW5zZm9ybT86IFBvRGF0YVRyYW5zZm9ybTtcclxuXHJcbiAgLyoqXHJcbiAgICogVGVtcG8gZW0gc2VndW5kb3MgZG8gc2ljcm9uaXNtbyBwZXJpw7NkaWNvLlxyXG4gICAqIENhc28gbsOjbyBzZWphIGRlZmluaWRvLCBvIHNpbmNyb25pc21vIHBlcmnDs2RpY28gZXN0YXLDoSBkZXNhYmlsaXRhZG8uXHJcbiAgICovXHJcbiAgcGVyaW9kPzogbnVtYmVyO1xyXG5cclxuICAvKiogVGlwb3MgZGUgY29uZXjDtWVzIHBlcm1pdGlkYXMgcGFyYSBvIHNpbmNyb25pc21vLiAqL1xyXG4gIHR5cGU6IFBvTmV0d29ya1R5cGUgfCBBcnJheTxQb05ldHdvcmtUeXBlPjtcclxufVxyXG4iXX0=

package/{esm2020 → esm2022}/lib/services/po-sync/interfaces/po-sync-field-options.interface.mjs

@@ -1,2 +1,2 @@
-export {};
+export {};
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG8tc3luYy1maWVsZC1vcHRpb25zLmludGVyZmFjZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3N5bmMvc3JjL2xpYi9zZXJ2aWNlcy9wby1zeW5jL2ludGVyZmFjZXMvcG8tc3luYy1maWVsZC1vcHRpb25zLmludGVyZmFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXHJcbiAqIEB1c2VkQnkgUG9TeW5jU2VydmljZVxyXG4gKlxyXG4gKiBAZGVzY3JpcHRpb25cclxuICpcclxuICogSW50ZXJmYWNlIHF1ZSBpcsOhIG1hcGVhciBhcyBjb25maWd1cmHDp8O1ZXMgZG9zIGNhbXBvcyBkbyBgUG9TeW5jU2NoZW1hYC5cclxuICovXHJcbmV4cG9ydCBpbnRlcmZhY2UgUG9TeW5jRmllbGRPcHRpb25zIHtcclxuICAvKiogUHJvcHJpZWRhZGUgcXVlIGluZm9ybWEgbyBub21lIGRvIGNhbXBvLiAqL1xyXG4gIHJlYWRvbmx5IG5hbWU6IHN0cmluZztcclxuXHJcbiAgLyoqIFByb3ByaWVkYWRlIHF1ZSBpbmZvcm1hIHNlIG8gY2FtcG8gc2Vyw6EgYXBlbmFzIHBhcmEgYXJtYXplbmFtZW50byBsb2NhbFxyXG4gICAqIG91IHNlIGRldmUgc2VyIGVudmlhZG8gcGFyYSBvIHNlcnZpZG9yLlxyXG4gICAqL1xyXG4gIHJlYWRvbmx5IGxvY2FsPzogYm9vbGVhbjtcclxufVxyXG4iXX0=

package/{esm2020 → esm2022}/lib/services/po-sync/interfaces/po-sync-response.interface.mjs

@@ -1,2 +1,2 @@
-export {};
+export {};
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG8tc3luYy1yZXNwb25zZS5pbnRlcmZhY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9zeW5jL3NyYy9saWIvc2VydmljZXMvcG8tc3luYy9pbnRlcmZhY2VzL3BvLXN5bmMtcmVzcG9uc2UuaW50ZXJmYWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBIdHRwRXJyb3JSZXNwb25zZSwgSHR0cFJlc3BvbnNlIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uL2h0dHAnO1xyXG5cclxuaW1wb3J0IHsgUG9FdmVudFNvdXJjaW5nRXJyb3JSZXNwb25zZSB9IGZyb20gJy4uLy4uLy4uL21vZGVscy9wby1ldmVudC1zb3VyY2luZy1lcnJvci1yZXNwb25zZS5tb2RlbCc7XHJcbmltcG9ydCB7IFBvSHR0cFJlcXVlc3REYXRhIH0gZnJvbSAnLi4vLi4vcG8taHR0cC1jbGllbnQvaW50ZXJmYWNlcy9wby1odHRwLXJlcXVlc3QtZGF0YS5pbnRlcmZhY2UnO1xyXG5cclxuLyoqXHJcbiAqIEB1c2VkQnkgUG9TeW5jU2VydmljZVxyXG4gKlxyXG4gKiBAZGVzY3JpcHRpb25cclxuICpcclxuICogRGVmaW5lIGEgcmVzcG9zdGEgZG9zIGV2ZW50b3MgZW52aWFkb3MgYW8gc2Vydmlkb3IuXHJcbiAqL1xyXG5leHBvcnQgaW50ZXJmYWNlIFBvU3luY1Jlc3BvbnNlIHtcclxuICAvKiogSWRlbnRpZmljYWRvciBkbyBldmVudG8gbmEgZmlsYS4gKi9cclxuICBpZDogbnVtYmVyO1xyXG5cclxuICAvKiogSWRlbnRpZmljYWRvciBjdXN0b21pemFkbyBkbyByZWdpc3Ryby4gKi9cclxuICBjdXN0b21SZXF1ZXN0SWQ/OiBzdHJpbmc7XHJcblxyXG4gIC8qKiBEYWRvcyBkYSByZXF1aXNpw6fDo28uICovXHJcbiAgcmVxdWVzdDogUG9IdHRwUmVxdWVzdERhdGE7XHJcblxyXG4gIC8qKiBSZXNwb3N0YSByZXRvcm5hZGEgYXDDs3MgYSB0ZW50YXRpdmEgZGUgZW52aW8gcGFyYSBvIHNlcnZpZG9yLiAqL1xyXG4gIHJlc3BvbnNlOiBIdHRwUmVzcG9uc2U8T2JqZWN0PiB8IEh0dHBFcnJvclJlc3BvbnNlIHwgUG9FdmVudFNvdXJjaW5nRXJyb3JSZXNwb25zZTtcclxufVxyXG4iXX0=

package/{esm2020 → esm2022}/lib/services/po-sync/interfaces/po-sync-schema.interface.mjs

@@ -1,2 +1,2 @@
-export {};
+export {};
 //# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/po-sync/po-sync.service.mjs

@@ -0,0 +1,336 @@
+import { Injectable } from '@angular/core';
+import { forkJoin, Observable, of, Subject, timer } from 'rxjs';
+import { expand, map, mergeMap, reduce } from 'rxjs/operators';
+import { validateParameter, validateArray } from '../../utils/utils';
+import { PoDataMessage, PoEntity } from '../../models';
+import { PoRequestType } from '../../models/po-request-type.enum';
+import { PoSchemaUtil } from './../po-schema/po-schema-util/po-schema-util.model';
+import * as i0 from "@angular/core";
+import * as i1 from "../po-event-sourcing/po-event-sourcing.service";
+import * as i2 from "../po-http-client/po-http-client.service";
+import * as i3 from "../po-network/po-network.service";
+import * as i4 from "./../po-schema/po-schema-definition/po-schema-definition.service";
+import * as i5 from "./../po-schema/po-schema.service";
+/**
+ * @description
+ *
+ * O `PoSyncService` é utilizado para configurar toda a base de dados que receberá as informações que serão
+ * armazenadas *offline* vindas do servidor. Nele ocorre toda a preparação dos modelos de dados retornados por
+ * cada consulta.
+ */
+export class PoSyncService {
+    poEventSourcingService;
+    poHttpClient;
+    poNetworkService;
+    poSchemaDefinitionService;
+    poSchemaService;
+    models = [];
+    config;
+    emitter;
+    eventSub;
+    finishSyncSubject = new Subject();
+    isSyncEnabled = true;
+    schemas;
+    subscription;
+    syncing = false;
+    timer;
+    constructor(poEventSourcingService, poHttpClient, poNetworkService, poSchemaDefinitionService, poSchemaService) {
+        this.poEventSourcingService = poEventSourcingService;
+        this.poHttpClient = poHttpClient;
+        this.poNetworkService = poNetworkService;
+        this.poSchemaDefinitionService = poSchemaDefinitionService;
+        this.poSchemaService = poSchemaService;
+    }
+    /**
+     * Destrói todas as chaves do *storage* referentes ao `po-sync`, ou seja,
+     * as definições dos *schemas*, os registros de cada *schema* e a fila
+     * de eventos que estão para ser enviados ao servidor *(EventSourcing)*.
+     *
+     * > Para que não venham ocorrer erros em ações que dependam das definições dos *schemas*,
+     * recomenda-se utilizar o método `prepare()` em seguida.
+     *
+     * > Veja mais detalhes em [Fundamentos do PO Sync - Alterando as definições dos schemas](/guides/sync-fundamentals).
+     *
+     * @returns {Promise<any>} Promessa que é resolvida quando as chaves referentes ao `po-sync` forem destruídas.
+     */
+    async destroy() {
+        const destroyFunction = async () => {
+            await this.poSchemaService.destroySchemasRecords();
+            await this.poSchemaDefinitionService.destroy();
+            await this.poEventSourcingService.destroyEventSourcingQueue();
+        };
+        return this.poSchemaService.limitedCallWrap(destroyFunction);
+    }
+    /**
+     * Desabilita todos os tipos de sincronização de dados (periódica, reativa e manual).
+     *
+     * > Para habilitar novamente a sincronização utilize o método [`PoSyncService.enableSync()`](documentation/po-sync#enable-sync).
+     */
+    disableSync() {
+        this.isSyncEnabled = false;
+        if (this.timer && this.subscription) {
+            this.subscription.unsubscribe();
+        }
+    }
+    /**
+     * <a id="enable-sync"></a>
+     * Habilita todos os tipos de sincronização de dados (periódica, reativa e manual).
+     *
+     * Por padrão, sempre que se inicializa uma aplicação com PO Sync as sincronizações já estão habilitadas.
+     */
+    enableSync() {
+        this.isSyncEnabled = true;
+        this.createSubscribe();
+    }
+    /**
+     * Método que disponibiliza a partir de sua inscrição o evento de retorno das operações da fila de eventos que
+     * foram enviadas ao servidor. A cada operação enviada para o servidor, será disparado um evento para a inscrição
+     * deste método.
+     *
+     * > Veja mais detalhes em [Fundamentos do PO Sync - Capturando respostas da sincronização](/guides/sync-fundamentals).
+     *
+     * @returns {Observable<PoSyncResponse>} Observable com um objeto do tipo `PoSyncResponse`.
+     */
+    getResponses() {
+        return this.poEventSourcingService.responsesSubject();
+    }
+    /**
+     * Retorna uma instância de `PoEntity` para um determinado *schema*.
+     *
+     * > Veja mais detalhes em [Fundamentos do PO Sync - Manipulando os registros de um schema](/guides/sync-fundamentals).
+     *
+     * @param {string} schemaName Nome do *schema*.
+     * @returns {PoEntity} Objeto para efetuar consultas e alterações nos dados.
+     */
+    getModel(schemaName) {
+        const model = this.models[schemaName];
+        if (!model) {
+            throw new Error('Model not found: ' + schemaName);
+        }
+        return model;
+    }
+    /**
+     * Insere uma requisição HTTP na fila de eventos do `po-sync`.
+     *
+     * > Veja mais detalhes em [Fundamentos do PO Sync - Inserindo requisições HTTP na fila de eventos](/guides/sync-fundamentals).
+     *
+     * @param {PoHttpRequestData} poHttpRequestData Dados da requisição HTTP.
+     * @param {string} customRequestId Identificador customizado da requisição HTTP.
+     * @returns {Promise<number>} Promessa com o identificador da requisição HTTP criada.
+     */
+    insertHttpCommand(requestData, customRequestId) {
+        validateParameter({ requestData });
+        return this.poEventSourcingService.httpCommand(requestData, customRequestId);
+    }
+    /**
+     * Efetua uma chamada na API do servidor para realizar a carga inicial dos dados. Deve ser chamado apenas uma vez
+     * na aplicação, após a preparação dos *schemas* realizada através do método `PoSyncService.prepare()`.
+     *
+     * > Veja mais detalhes em [Fundamentos do PO Sync - Carga inicial dos dados](/guides/sync-fundamentals).
+     *
+     * @returns {Observable<Array<{ entity: string, data: Array<any> }>>} Observable que notificará quando a
+     * carga inicial for concluída.
+     */
+    loadData() {
+        const loads = [];
+        this.schemas.forEach(el => loads.push(this.loadEntityData(el)));
+        return forkJoin(loads);
+    }
+    /**
+     * Responsável por notificar sempre que houver sincronismo.
+     *
+     * > Veja mais detalhes em [Fundamentos do PO Sync - Notificação pós-sincronização](/guides/sync-fundamentals).
+     *
+     * @returns {Observable<any>} Observable que é disparado a cada sincronismo realizado.
+     */
+    onSync() {
+        if (!this.eventSub) {
+            this.eventSub = Observable.create(e => {
+                this.emitter = e;
+            });
+        }
+        return this.eventSub;
+    }
+    /**
+     * Prepara a aplicação criando os schemas e aplica as configurações.
+     *
+     * > Veja mais detalhes em [Fundamentos do PO Sync - Preparando a aplicação](/guides/sync-fundamentals).
+     *
+     * @param {Array<PoSyncSchema>} schemas Lista de *schemas* a serem preparados.
+     * @param {PoSyncConfig} config Configurações adicionais.
+     * @returns {Promise<any>} Promessa que é resolvida quando a aplicação estiver preparada para a utilização do `po-sync`.
+     */
+    prepare(schemas, config) {
+        validateArray({ schemas });
+        const defaultSyncConfig = {
+            type: this.poNetworkService.getConnectionStatus().type,
+            period: 60,
+            dataTransform: new PoDataMessage()
+        };
+        this.schemas = schemas;
+        this.config = config || defaultSyncConfig;
+        this.config.dataTransform = this.config.dataTransform || new PoDataMessage();
+        this.poEventSourcingService.config = this.config;
+        this.startTimer(this.config.period);
+        this.reactiveSync();
+        this.poEventSourcingService.onSaveData().subscribe(() => this.sync());
+        return this.saveSchemas().then(() => {
+            this.schemas.forEach(schema => {
+                this.models[schema.name] = new PoEntity(this.poEventSourcingService, schema, this.poSchemaService);
+            });
+            return Promise.resolve();
+        });
+    }
+    /**
+     * Remove um item da fila de eventos que espera a sincronização.
+     *
+     * > Veja mais detalhes em [Fundamentos do PO Sync - Capturando respostas da sincronização](/guides/sync-fundamentals).
+     *
+     * @param {any} idEventSourcing Identificador do item da fila de eventos.
+     * @returns {Promise<any>} Promessa que é resolvida quando o item da fila de eventos é removido.
+     */
+    removeItemOfSync(idEventSourcing) {
+        return this.poEventSourcingService.removeEventSourcingItem(idEventSourcing);
+    }
+    /**
+     * Reenvia os comandos pendentes na fila (inclusão, alteração e exclusão) e busca novos dados do servidor.
+     *
+     * > Veja mais detalhes em [Fundamentos do PO Sync - Capturando respostas da sincronização](/guides/sync-fundamentals).
+     *
+     * @returns {Promise<any>} Promessa que resolve o sincronismo disparado.
+     */
+    resumeSync() {
+        if (!this.canSync()) {
+            const finishSyncSubscription = this.finishSyncSubject.asObservable().subscribe(() => {
+                finishSyncSubscription.unsubscribe();
+                return this.sync();
+            });
+            return Promise.resolve();
+        }
+        return this.sync();
+    }
+    /**
+     * Dispara o sincronismo enviando os eventos pendentes (inclusão, alteração e exclusão) e buscando novos dados do servidor.
+     *
+     * O sincronismo somente será executado depois que o acesso a base de dados local do dispositivo for liberada.
+     *
+     * > Veja mais detalhes em [Fundamentos do PO Sync - Sincronização manual](/guides/sync-fundamentals).
+     *
+     * @returns {Promise<any>} Promessa que é resolvida quando o sincronismo for finalizado.
+     */
+    async sync() {
+        if (this.canSync()) {
+            this.startSync();
+            try {
+                await this.poEventSourcingService.syncSend();
+                await this.poEventSourcingService.syncGet();
+                if (this.emitter) {
+                    this.emitter.next();
+                }
+                this.finishSync();
+            }
+            catch (error) {
+                this.syncError();
+            }
+        }
+    }
+    canSync() {
+        if (this.syncing || !this.isSyncEnabled) {
+            return false;
+        }
+        else {
+            const currentConnection = this.poNetworkService.getConnectionStatus();
+            const isConfiguredConnection = this.config && currentConnection.type === this.config.type;
+            const isConfigIncludesType = this.config && this.config.type instanceof Array && this.config.type.includes(currentConnection.type);
+            return currentConnection.status && (!this.config || isConfiguredConnection || isConfigIncludesType);
+        }
+    }
+    createSubscribe() {
+        if (this.timer) {
+            this.subscription = this.timer.subscribe(() => {
+                this.sync().then(() => {
+                    this.subscription.unsubscribe();
+                    this.subscription = null;
+                    this.timer = null;
+                    this.startTimer(this.config.period);
+                });
+            });
+        }
+    }
+    finishSync() {
+        this.syncing = false;
+        this.finishSyncSubject.next(null);
+    }
+    getOnePage(schema, page = 1) {
+        const params = [];
+        params.push(`${this.config.dataTransform.getPageSizeParamName()}=${schema.pageSize}`);
+        params.push(`${this.config.dataTransform.getPageParamName()}=${page}`);
+        const url = `${PoSchemaUtil.getUrl(schema, PoRequestType.GET)}?${params.join('&')}`;
+        return this.poHttpClient.get(url).pipe(map(response => response.body), mergeMap(responseBody => {
+            const now = new Date().getTime();
+            responseBody[this.config.dataTransform.getItemsFieldName()].map(item => {
+                item.SyncInsertedDateTime = now;
+                item.SyncUpdatedDateTime = null;
+                item.SyncExclusionDateTime = null;
+                item.SyncDeleted = false;
+                item.SyncStatus = 2;
+            });
+            return this.poSchemaService
+                .updateAll(schema, responseBody[this.config.dataTransform.getItemsFieldName()])
+                .then(() => responseBody);
+        }));
+    }
+    loadEntityData(schema) {
+        let page = 1;
+        return this.getOnePage(schema, page).pipe(expand(data => {
+            this.config.dataTransform.transform(data);
+            const hasNext = this.config.dataTransform.hasNext();
+            if (hasNext) {
+                return this.getOnePage(schema, ++page);
+            }
+            else {
+                return of();
+            }
+        }), reduce((acc, obj) => {
+            acc.data = acc.data.concat(obj[this.config.dataTransform.getItemsFieldName()]);
+            return acc;
+        }, {
+            entity: schema.name,
+            data: []
+        }));
+    }
+    reactiveSync() {
+        this.poNetworkService.onChange().subscribe(networkStatus => {
+            if (networkStatus.status) {
+                this.startTimer(this.config.period);
+                return this.sync();
+            }
+            if (this.subscription) {
+                this.subscription.unsubscribe();
+            }
+        });
+    }
+    async saveSchemas() {
+        const storageSchemas = await this.poSchemaDefinitionService.getAll();
+        this.schemas.forEach(schema => (schema.lastSync = PoSchemaUtil.getLastSync(storageSchemas, schema.name)));
+        return this.poSchemaDefinitionService.saveAll(this.schemas);
+    }
+    startSync() {
+        this.syncing = true;
+    }
+    startTimer(period) {
+        if (period && this.isSyncEnabled) {
+            this.timer = timer(period * 1000);
+            this.createSubscribe();
+        }
+    }
+    syncError() {
+        this.finishSync();
+    }
+    static ɵfac = function PoSyncService_Factory(t) { return new (t || PoSyncService)(i0.ɵɵinject(i1.PoEventSourcingService), i0.ɵɵinject(i2.PoHttpClientService), i0.ɵɵinject(i3.PoNetworkService), i0.ɵɵinject(i4.PoSchemaDefinitionService), i0.ɵɵinject(i5.PoSchemaService)); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: PoSyncService, factory: PoSyncService.ɵfac });
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PoSyncService, [{
+        type: Injectable
+    }], function () { return [{ type: i1.PoEventSourcingService }, { type: i2.PoHttpClientService }, { type: i3.PoNetworkService }, { type: i4.PoSchemaDefinitionService }, { type: i5.PoSchemaService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"po-sync.service.js","sourceRoot":"","sources":["../../../../../../projects/sync/src/lib/services/po-sync/po-sync.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\n\r\nimport { forkJoin, Observable, of, Subject, Subscription, timer } from 'rxjs';\r\nimport { expand, map, mergeMap, reduce } from 'rxjs/operators';\r\nimport { validateParameter, validateArray } from '../../utils/utils';\r\n\r\nimport { PoDataMessage, PoEntity } from '../../models';\r\nimport { PoEventSourcingService } from '../po-event-sourcing/po-event-sourcing.service';\r\nimport { PoHttpClientService } from '../po-http-client/po-http-client.service';\r\nimport { PoHttpRequestData } from '../po-http-client/interfaces/po-http-request-data.interface';\r\nimport { PoNetworkService } from '../po-network/po-network.service';\r\nimport { PoRequestType } from '../../models/po-request-type.enum';\r\nimport { PoSchemaDefinitionService } from './../po-schema/po-schema-definition/po-schema-definition.service';\r\nimport { PoSchemaService } from './../po-schema/po-schema.service';\r\nimport { PoSchemaUtil } from './../po-schema/po-schema-util/po-schema-util.model';\r\nimport { PoSyncConfig } from './interfaces/po-sync-config.interface';\r\nimport { PoSyncResponse } from '../po-sync/interfaces/po-sync-response.interface';\r\nimport { PoSyncSchema } from './interfaces/po-sync-schema.interface';\r\n\r\n/**\r\n * @description\r\n *\r\n * O `PoSyncService` é utilizado para configurar toda a base de dados que receberá as informações que serão\r\n * armazenadas *offline* vindas do servidor. Nele ocorre toda a preparação dos modelos de dados retornados por\r\n * cada consulta.\r\n */\r\n@Injectable()\r\nexport class PoSyncService {\r\n  models: Array<PoEntity> = [];\r\n\r\n  private config: PoSyncConfig;\r\n  private emitter: any;\r\n  private eventSub: Observable<any>;\r\n  private finishSyncSubject: Subject<null> = new Subject<null>();\r\n  private isSyncEnabled: boolean = true;\r\n  private schemas: Array<PoSyncSchema>;\r\n  private subscription: Subscription;\r\n  private syncing: boolean = false;\r\n  private timer: Observable<number>;\r\n\r\n  constructor(\r\n    private poEventSourcingService: PoEventSourcingService,\r\n    private poHttpClient: PoHttpClientService,\r\n    private poNetworkService: PoNetworkService,\r\n    private poSchemaDefinitionService: PoSchemaDefinitionService,\r\n    private poSchemaService: PoSchemaService\r\n  ) {}\r\n\r\n  /**\r\n   * Destrói todas as chaves do *storage* referentes ao `po-sync`, ou seja,\r\n   * as definições dos *schemas*, os registros de cada *schema* e a fila\r\n   * de eventos que estão para ser enviados ao servidor *(EventSourcing)*.\r\n   *\r\n   * > Para que não venham ocorrer erros em ações que dependam das definições dos *schemas*,\r\n   * recomenda-se utilizar o método `prepare()` em seguida.\r\n   *\r\n   * > Veja mais detalhes em [Fundamentos do PO Sync - Alterando as definições dos schemas](/guides/sync-fundamentals).\r\n   *\r\n   * @returns {Promise<any>} Promessa que é resolvida quando as chaves referentes ao `po-sync` forem destruídas.\r\n   */\r\n  async destroy(): Promise<any> {\r\n    const destroyFunction = async () => {\r\n      await this.poSchemaService.destroySchemasRecords();\r\n      await this.poSchemaDefinitionService.destroy();\r\n      await this.poEventSourcingService.destroyEventSourcingQueue();\r\n    };\r\n\r\n    return this.poSchemaService.limitedCallWrap(destroyFunction);\r\n  }\r\n\r\n  /**\r\n   * Desabilita todos os tipos de sincronização de dados (periódica, reativa e manual).\r\n   *\r\n   * > Para habilitar novamente a sincronização utilize o método [`PoSyncService.enableSync()`](documentation/po-sync#enable-sync).\r\n   */\r\n  disableSync() {\r\n    this.isSyncEnabled = false;\r\n\r\n    if (this.timer && this.subscription) {\r\n      this.subscription.unsubscribe();\r\n    }\r\n  }\r\n\r\n  /**\r\n   * <a id=\"enable-sync\"></a>\r\n   * Habilita todos os tipos de sincronização de dados (periódica, reativa e manual).\r\n   *\r\n   * Por padrão, sempre que se inicializa uma aplicação com PO Sync as sincronizações já estão habilitadas.\r\n   */\r\n  enableSync() {\r\n    this.isSyncEnabled = true;\r\n    this.createSubscribe();\r\n  }\r\n\r\n  /**\r\n   * Método que disponibiliza a partir de sua inscrição o evento de retorno das operações da fila de eventos que\r\n   * foram enviadas ao servidor. A cada operação enviada para o servidor, será disparado um evento para a inscrição\r\n   * deste método.\r\n   *\r\n   * > Veja mais detalhes em [Fundamentos do PO Sync - Capturando respostas da sincronização](/guides/sync-fundamentals).\r\n   *\r\n   * @returns {Observable<PoSyncResponse>} Observable com um objeto do tipo `PoSyncResponse`.\r\n   */\r\n  getResponses(): Observable<PoSyncResponse> {\r\n    return this.poEventSourcingService.responsesSubject();\r\n  }\r\n\r\n  /**\r\n   * Retorna uma instância de `PoEntity` para um determinado *schema*.\r\n   *\r\n   * > Veja mais detalhes em [Fundamentos do PO Sync - Manipulando os registros de um schema](/guides/sync-fundamentals).\r\n   *\r\n   * @param {string} schemaName Nome do *schema*.\r\n   * @returns {PoEntity} Objeto para efetuar consultas e alterações nos dados.\r\n   */\r\n  getModel(schemaName: string): PoEntity {\r\n    const model = this.models[schemaName];\r\n    if (!model) {\r\n      throw new Error('Model not found: ' + schemaName);\r\n    }\r\n    return model;\r\n  }\r\n\r\n  /**\r\n   * Insere uma requisição HTTP na fila de eventos do `po-sync`.\r\n   *\r\n   * > Veja mais detalhes em [Fundamentos do PO Sync - Inserindo requisições HTTP na fila de eventos](/guides/sync-fundamentals).\r\n   *\r\n   * @param {PoHttpRequestData} poHttpRequestData Dados da requisição HTTP.\r\n   * @param {string} customRequestId Identificador customizado da requisição HTTP.\r\n   * @returns {Promise<number>} Promessa com o identificador da requisição HTTP criada.\r\n   */\r\n  insertHttpCommand(requestData: PoHttpRequestData, customRequestId?: string): Promise<number> {\r\n    validateParameter({ requestData });\r\n\r\n    return this.poEventSourcingService.httpCommand(requestData, customRequestId);\r\n  }\r\n\r\n  /**\r\n   * Efetua uma chamada na API do servidor para realizar a carga inicial dos dados. Deve ser chamado apenas uma vez\r\n   * na aplicação, após a preparação dos *schemas* realizada através do método `PoSyncService.prepare()`.\r\n   *\r\n   * > Veja mais detalhes em [Fundamentos do PO Sync - Carga inicial dos dados](/guides/sync-fundamentals).\r\n   *\r\n   * @returns {Observable<Array<{ entity: string, data: Array<any> }>>} Observable que notificará quando a\r\n   * carga inicial for concluída.\r\n   */\r\n  loadData(): Observable<Array<{ entity: string; data: Array<any> }>> {\r\n    const loads: Array<Observable<{ entity: string; data: Array<any> }>> = [];\r\n    this.schemas.forEach(el => loads.push(this.loadEntityData(el)));\r\n    return forkJoin(loads);\r\n  }\r\n\r\n  /**\r\n   * Responsável por notificar sempre que houver sincronismo.\r\n   *\r\n   * > Veja mais detalhes em [Fundamentos do PO Sync - Notificação pós-sincronização](/guides/sync-fundamentals).\r\n   *\r\n   * @returns {Observable<any>} Observable que é disparado a cada sincronismo realizado.\r\n   */\r\n  onSync(): Observable<any> {\r\n    if (!this.eventSub) {\r\n      this.eventSub = Observable.create(e => {\r\n        this.emitter = e;\r\n      });\r\n    }\r\n    return this.eventSub;\r\n  }\r\n\r\n  /**\r\n   * Prepara a aplicação criando os schemas e aplica as configurações.\r\n   *\r\n   * > Veja mais detalhes em [Fundamentos do PO Sync - Preparando a aplicação](/guides/sync-fundamentals).\r\n   *\r\n   * @param {Array<PoSyncSchema>} schemas Lista de *schemas* a serem preparados.\r\n   * @param {PoSyncConfig} config Configurações adicionais.\r\n   * @returns {Promise<any>} Promessa que é resolvida quando a aplicação estiver preparada para a utilização do `po-sync`.\r\n   */\r\n  prepare(schemas: Array<PoSyncSchema>, config?: PoSyncConfig): Promise<any> {\r\n    validateArray({ schemas });\r\n\r\n    const defaultSyncConfig: PoSyncConfig = {\r\n      type: this.poNetworkService.getConnectionStatus().type,\r\n      period: 60,\r\n      dataTransform: new PoDataMessage()\r\n    };\r\n\r\n    this.schemas = schemas;\r\n    this.config = config || defaultSyncConfig;\r\n    this.config.dataTransform = this.config.dataTransform || new PoDataMessage();\r\n    this.poEventSourcingService.config = this.config;\r\n    this.startTimer(this.config.period);\r\n    this.reactiveSync();\r\n    this.poEventSourcingService.onSaveData().subscribe(() => this.sync());\r\n\r\n    return this.saveSchemas().then(() => {\r\n      this.schemas.forEach(schema => {\r\n        this.models[schema.name] = new PoEntity(this.poEventSourcingService, schema, this.poSchemaService);\r\n      });\r\n      return Promise.resolve();\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Remove um item da fila de eventos que espera a sincronização.\r\n   *\r\n   * > Veja mais detalhes em [Fundamentos do PO Sync - Capturando respostas da sincronização](/guides/sync-fundamentals).\r\n   *\r\n   * @param {any} idEventSourcing Identificador do item da fila de eventos.\r\n   * @returns {Promise<any>} Promessa que é resolvida quando o item da fila de eventos é removido.\r\n   */\r\n  removeItemOfSync(idEventSourcing: any): Promise<any> {\r\n    return this.poEventSourcingService.removeEventSourcingItem(idEventSourcing);\r\n  }\r\n\r\n  /**\r\n   * Reenvia os comandos pendentes na fila (inclusão, alteração e exclusão) e busca novos dados do servidor.\r\n   *\r\n   * > Veja mais detalhes em [Fundamentos do PO Sync - Capturando respostas da sincronização](/guides/sync-fundamentals).\r\n   *\r\n   * @returns {Promise<any>} Promessa que resolve o sincronismo disparado.\r\n   */\r\n  resumeSync(): Promise<any> {\r\n    if (!this.canSync()) {\r\n      const finishSyncSubscription = this.finishSyncSubject.asObservable().subscribe(() => {\r\n        finishSyncSubscription.unsubscribe();\r\n        return this.sync();\r\n      });\r\n      return Promise.resolve();\r\n    }\r\n\r\n    return this.sync();\r\n  }\r\n\r\n  /**\r\n   * Dispara o sincronismo enviando os eventos pendentes (inclusão, alteração e exclusão) e buscando novos dados do servidor.\r\n   *\r\n   * O sincronismo somente será executado depois que o acesso a base de dados local do dispositivo for liberada.\r\n   *\r\n   * > Veja mais detalhes em [Fundamentos do PO Sync - Sincronização manual](/guides/sync-fundamentals).\r\n   *\r\n   * @returns {Promise<any>} Promessa que é resolvida quando o sincronismo for finalizado.\r\n   */\r\n  async sync(): Promise<any> {\r\n    if (this.canSync()) {\r\n      this.startSync();\r\n\r\n      try {\r\n        await this.poEventSourcingService.syncSend();\r\n        await this.poEventSourcingService.syncGet();\r\n\r\n        if (this.emitter) {\r\n          this.emitter.next();\r\n        }\r\n\r\n        this.finishSync();\r\n      } catch (error) {\r\n        this.syncError();\r\n      }\r\n    }\r\n  }\r\n\r\n  private canSync(): boolean {\r\n    if (this.syncing || !this.isSyncEnabled) {\r\n      return false;\r\n    } else {\r\n      const currentConnection = this.poNetworkService.getConnectionStatus();\r\n      const isConfiguredConnection = this.config && currentConnection.type === this.config.type;\r\n      const isConfigIncludesType =\r\n        this.config && this.config.type instanceof Array && this.config.type.includes(currentConnection.type);\r\n\r\n      return currentConnection.status && (!this.config || isConfiguredConnection || isConfigIncludesType);\r\n    }\r\n  }\r\n\r\n  private createSubscribe(): void {\r\n    if (this.timer) {\r\n      this.subscription = this.timer.subscribe(() => {\r\n        this.sync().then(() => {\r\n          this.subscription.unsubscribe();\r\n          this.subscription = null;\r\n          this.timer = null;\r\n          this.startTimer(this.config.period);\r\n        });\r\n      });\r\n    }\r\n  }\r\n\r\n  private finishSync(): void {\r\n    this.syncing = false;\r\n    this.finishSyncSubject.next(null);\r\n  }\r\n\r\n  private getOnePage(schema: PoSyncSchema, page: number = 1): Observable<any> {\r\n    const params = [];\r\n    params.push(`${this.config.dataTransform.getPageSizeParamName()}=${schema.pageSize}`);\r\n    params.push(`${this.config.dataTransform.getPageParamName()}=${page}`);\r\n\r\n    const url = `${PoSchemaUtil.getUrl(schema, PoRequestType.GET)}?${params.join('&')}`;\r\n\r\n    return this.poHttpClient.get(url).pipe(\r\n      map(response => response.body),\r\n      mergeMap(responseBody => {\r\n        const now = new Date().getTime();\r\n        responseBody[this.config.dataTransform.getItemsFieldName()].map(item => {\r\n          item.SyncInsertedDateTime = now;\r\n          item.SyncUpdatedDateTime = null;\r\n          item.SyncExclusionDateTime = null;\r\n          item.SyncDeleted = false;\r\n          item.SyncStatus = 2;\r\n        });\r\n        return this.poSchemaService\r\n          .updateAll(schema, responseBody[this.config.dataTransform.getItemsFieldName()])\r\n          .then(() => responseBody);\r\n      })\r\n    );\r\n  }\r\n\r\n  private loadEntityData(schema: PoSyncSchema): Observable<{ entity: string; data: Array<any> }> {\r\n    let page = 1;\r\n    return this.getOnePage(schema, page).pipe(\r\n      expand(data => {\r\n        this.config.dataTransform.transform(data);\r\n        const hasNext = this.config.dataTransform.hasNext();\r\n        if (hasNext) {\r\n          return this.getOnePage(schema, ++page);\r\n        } else {\r\n          return of();\r\n        }\r\n      }),\r\n      reduce(\r\n        (acc, obj) => {\r\n          acc.data = acc.data.concat(obj[this.config.dataTransform.getItemsFieldName()]);\r\n          return acc;\r\n        },\r\n        {\r\n          entity: schema.name,\r\n          data: []\r\n        }\r\n      )\r\n    );\r\n  }\r\n\r\n  private reactiveSync(): void {\r\n    this.poNetworkService.onChange().subscribe(networkStatus => {\r\n      if (networkStatus.status) {\r\n        this.startTimer(this.config.period);\r\n        return this.sync();\r\n      }\r\n\r\n      if (this.subscription) {\r\n        this.subscription.unsubscribe();\r\n      }\r\n    });\r\n  }\r\n\r\n  private async saveSchemas(): Promise<any> {\r\n    const storageSchemas: Array<PoSyncSchema> = await this.poSchemaDefinitionService.getAll();\r\n    this.schemas.forEach(schema => (schema.lastSync = PoSchemaUtil.getLastSync(storageSchemas, schema.name)));\r\n    return this.poSchemaDefinitionService.saveAll(this.schemas);\r\n  }\r\n\r\n  private startSync(): void {\r\n    this.syncing = true;\r\n  }\r\n\r\n  private startTimer(period): void {\r\n    if (period && this.isSyncEnabled) {\r\n      this.timer = timer(period * 1000);\r\n      this.createSubscribe();\r\n    }\r\n  }\r\n\r\n  private syncError(): void {\r\n    this.finishSync();\r\n  }\r\n}\r\n"]}