@po-ui/ng-sync 5.22.0 → 6.0.0

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

@@ -0,0 +1,58 @@
+import { Injectable } from '@angular/core';
+import { fromEvent, merge, Observable, Subject } from 'rxjs';
+import { mapTo } from 'rxjs/operators';
+import { PoNetworkStatus } from './../../models';
+import * as i0 from "@angular/core";
+import * as i1 from "@ionic-native/network/ngx";
+/**
+ * @description
+ *
+ * O `PoNetworkService` é utilizado para verificar o status e o tipo da conexão de rede do dispositivo.
+ */
+export class PoNetworkService {
+    constructor(network) {
+        this.initNetwork(network);
+    }
+    /**
+     * Retorna as propriedades tipo e status da conexão do dispositivo no momento da chamada.
+     *
+     * @returns {PoNetworkStatus} Instância de [PoNetworkStatus](/documentation/po-network-status) com as
+     * propriedades da conexão.
+     */
+    getConnectionStatus() {
+        this.poNetworkStatus = new PoNetworkStatus(this.networkType);
+        return this.poNetworkStatus;
+    }
+    /**
+     * Notifica as mudanças no tipo de conexão de rede do dispositivo.
+     *
+     * @returns {Observable<{ status: boolean, type: string }>} Observable com as propriedades da conexão.
+     */
+    onChange() {
+        return this.networkTypeNow.asObservable();
+    }
+    getNavigatorStatus() {
+        return merge(fromEvent(window, 'offline').pipe(mapTo(false)), fromEvent(window, 'online').pipe(mapTo(true)), Observable.create(sub => {
+            sub.next(navigator.onLine);
+            sub.complete();
+        }));
+    }
+    initNetwork(network) {
+        this.networkTypeNow = new Subject();
+        this.initSubscriber(network);
+    }
+    initSubscriber(network) {
+        if (network) {
+            this.getNavigatorStatus().subscribe(status => {
+                this.networkType = network.type;
+                this.networkTypeNow.next({ status: status, type: this.networkType });
+            });
+        }
+    }
+}
+PoNetworkService.ɵfac = function PoNetworkService_Factory(t) { return new (t || PoNetworkService)(i0.ɵɵinject(i1.Network)); };
+PoNetworkService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: PoNetworkService, factory: PoNetworkService.ɵfac });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PoNetworkService, [{
+        type: Injectable
+    }], function () { return [{ type: i1.Network }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/services/po-schema/po-schema-definition/po-schema-definition.service.mjs

@@ -0,0 +1,77 @@
+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-ui/ng-storage";
+/**
+ * @docsPrivate
+ *
+ * @description
+ *
+ * Serviço que disponibiliza métodos que permite operar sobre as definições dos *schemas*.
+ */
+export class PoSchemaDefinitionService {
+    constructor(poStorage) {
+        this.poStorage = poStorage;
+    }
+    /**
+     * Destrói a chave do *storage* que contém as definições dos *schemas*.
+     *
+     * > 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.
+     *
+     * @returns {Promise<void>} Promessa que é resolvida quando a chave referente as definições dos *schemas* for destruída.
+     */
+    destroy() {
+        return this.poStorage.remove(PoSchemaUtil.syncSchemasName);
+    }
+    /**
+     * Busca um *schema* a partir do nome informado.
+     *
+     * @param {string} schemaName Nome do *schema*.
+     * @returns {Promise<PoSyncSchema>} Promessa que é resolvida quando o *schema* for retornado.
+     */
+    get(schemaName) {
+        return this.poStorage.getItemByField(PoSchemaUtil.syncSchemasName, 'name', schemaName);
+    }
+    /**
+     * Retorna uma promessa com a lista dos *schemas* definidos.
+     *
+     * @returns {Promise<Array<PoSyncSchema>>} Promessa que é resolvida quando a lista dos *schemas* definidos for retornada.
+     */
+    getAll() {
+        return this.poStorage.get(PoSchemaUtil.syncSchemasName);
+    }
+    /**
+     * Salva uma lista de *schemas*.
+     *
+     * @param {Array<PoSyncSchema>} schemas Lista de schemas que serão salvos.
+     * @returns {Promise<Array<PoSyncSchema>>} Promessa que é resolvida quando a lista de *schemas* for salva.
+     */
+    saveAll(schemas) {
+        return this.poStorage.set(PoSchemaUtil.syncSchemasName, schemas);
+    }
+    /**
+     * Atualiza um *schema* a partir do *schema name*.
+     *
+     * @param {PoSyncSchema} updatedSchema **Schema* que será atualizado.
+     */
+    async update(updatedSchema) {
+        let schemas = await this.getAll();
+        const replaceUpdatedSchema = schema => {
+            if (schema.name === updatedSchema.name) {
+                return updatedSchema;
+            }
+            else {
+                return schema;
+            }
+        };
+        schemas = schemas.map(replaceUpdatedSchema);
+        return this.saveAll(schemas);
+    }
+}
+PoSchemaDefinitionService.ɵfac = function PoSchemaDefinitionService_Factory(t) { return new (t || PoSchemaDefinitionService)(i0.ɵɵinject(i1.PoStorageService)); };
+PoSchemaDefinitionService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: PoSchemaDefinitionService, factory: PoSchemaDefinitionService.ɵfac });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PoSchemaDefinitionService, [{
+        type: Injectable
+    }], function () { return [{ type: i1.PoStorageService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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

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

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