@po-ui/ng-sync 5.22.3 → 6.2.0

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

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

package/{esm2015/lib/utils/utils.js → esm2020/lib/utils/utils.mjs}

@@ -1,63 +1,63 @@
-/**
- * Retorna um *array* contendo os pares `[chave, valor]` do objeto.
- *
- * Semelhante ao método `Object.entries()` nativo do javascript.
- *
- * > Veja mais em: https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Object/entries
- *
- * @param object Objeto que será extraído os pares [chave, valor].
- */
-export const getObjectEntries = (object) => {
-    const objectName = Object.keys(object)[0];
-    const objectValue = object[objectName];
-    return [objectName, objectValue];
-};
-/**
- * Recebe um objeto e valida se o seu valor é diferente de *undefined* ou *null*.
- *
- * @param {object} parameter Objeto contento o nome do parâmetro que está sendo validado
- * e o seu valor.
- */
-export const validateParameter = (parameter) => {
-    const [paramName, paramValue] = getObjectEntries(parameter);
-    if (paramValue === undefined || paramValue === null) {
-        throw new Error(`The ${paramName} parameter cannot be undefined or null`);
-    }
-};
-/**
- * Recebe um objeto e valida se o seu valor é uma instância de *Array* e se não
- * está vazio.
- *
- * @param value Objeto contento o nome da propriedade que está sendo validada e o seu valor.
- */
-export const validateArray = (value) => {
-    validateParameter(value);
-    const [paramName, paramValue] = getObjectEntries(value);
-    if (!(paramValue instanceof Array)) {
-        throw new Error(`${paramName} is not an Array instance`);
-    }
-    if (!paramValue.length) {
-        throw new Error(`${paramName} cannot be empty array`);
-    }
-};
-/**
- * Recebe um arquivo e converte para uma string base64
- *
- * @param Objeto do tipo file.
- */
-export const toBase64 = (file) => new Promise((resolve, reject) => {
-    const reader = new FileReader();
-    reader.readAsDataURL(file);
-    reader.onload = () => resolve(reader.result);
-    /* istanbul ignore next */
-    reader.onerror = error => reject(error);
-});
-/**
- * Recebe uma string base64 e converte para um arquivo
- *
- * @param string base64.
- */
-export const toFile = (url, fileName, mimeType) => fetch(url)
-    .then(result => result.arrayBuffer())
-    .then(buffer => new File([buffer], fileName, { type: mimeType }));
-//# sourceMappingURL=data:application/json;base64,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
+/**
+ * Retorna um *array* contendo os pares `[chave, valor]` do objeto.
+ *
+ * Semelhante ao método `Object.entries()` nativo do javascript.
+ *
+ * > Veja mais em: https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Object/entries
+ *
+ * @param object Objeto que será extraído os pares [chave, valor].
+ */
+export const getObjectEntries = (object) => {
+    const objectName = Object.keys(object)[0];
+    const objectValue = object[objectName];
+    return [objectName, objectValue];
+};
+/**
+ * Recebe um objeto e valida se o seu valor é diferente de *undefined* ou *null*.
+ *
+ * @param {object} parameter Objeto contento o nome do parâmetro que está sendo validado
+ * e o seu valor.
+ */
+export const validateParameter = (parameter) => {
+    const [paramName, paramValue] = getObjectEntries(parameter);
+    if (paramValue === undefined || paramValue === null) {
+        throw new Error(`The ${paramName} parameter cannot be undefined or null`);
+    }
+};
+/**
+ * Recebe um objeto e valida se o seu valor é uma instância de *Array* e se não
+ * está vazio.
+ *
+ * @param value Objeto contento o nome da propriedade que está sendo validada e o seu valor.
+ */
+export const validateArray = (value) => {
+    validateParameter(value);
+    const [paramName, paramValue] = getObjectEntries(value);
+    if (!(paramValue instanceof Array)) {
+        throw new Error(`${paramName} is not an Array instance`);
+    }
+    if (!paramValue.length) {
+        throw new Error(`${paramName} cannot be empty array`);
+    }
+};
+/**
+ * Recebe um arquivo e converte para uma string base64
+ *
+ * @param Objeto do tipo file.
+ */
+export const toBase64 = (file) => new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.readAsDataURL(file);
+    reader.onload = () => resolve(reader.result);
+    /* istanbul ignore next */
+    reader.onerror = error => reject(error);
+});
+/**
+ * Recebe uma string base64 e converte para um arquivo
+ *
+ * @param string base64.
+ */
+export const toFile = (url, fileName, mimeType) => fetch(url)
+    .then(result => result.arrayBuffer())
+    .then(buffer => new File([buffer], fileName, { type: mimeType }));
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/po-ui-ng-sync.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG8tdWktbmctc3luYy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL3N5bmMvc3JjL3BvLXVpLW5nLXN5bmMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==

package/{esm2015/public-api.js → esm2020/public-api.mjs}

@@ -1,2 +1,2 @@
-export * from './lib/index';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL3N5bmMvc3JjL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxhQUFhLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2xpYi9pbmRleCc7XHJcbiJdfQ==
+export * from './lib/index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL3N5bmMvc3JjL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxhQUFhLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2xpYi9pbmRleCc7XG4iXX0=