@sapphire-ion/framework 0.30.0

package/esm2022/lib/services/utils.service.mjs

@@ -0,0 +1,149 @@
+import { ActionSheetController } from '@ionic/angular';
+import { FilePicker } from '@capawesome/capacitor-file-picker';
+import { CameraSource } from '@capacitor/camera';
+import { Injectable } from '@angular/core';
+import moment from 'moment';
+import * as i0 from "@angular/core";
+import * as i1 from "@ionic/angular";
+export class UtilsService {
+    constructor(actionSheetController) {
+        this.actionSheetController = actionSheetController;
+    }
+    /** Retorna um array de arquivos de acordo com o tipo de configutação */
+    async SelectFile(configuration) {
+        let SelectType;
+        (function (SelectType) {
+            SelectType[SelectType["camera"] = 1] = "camera";
+            SelectType[SelectType["galery"] = 2] = "galery";
+            SelectType[SelectType["file"] = 3] = "file";
+            SelectType[SelectType["deny"] = 4] = "deny";
+        })(SelectType || (SelectType = {}));
+        const btnCamera = { text: 'Câmera', icon: 'camera', data: SelectType.camera };
+        const btnGalery = { text: 'Galeria', icon: 'image', data: SelectType.galery };
+        const btnFile = { text: 'Selecionar Arquivo', icon: 'document', data: SelectType.file };
+        const btnDeny = { text: 'Cancelar', icon: 'close-circle', data: SelectType.deny, role: 'cancel', };
+        const isApp = (!document.URL.startsWith('http') || document.URL.startsWith('http://localhost:8080'));
+        var lstBtn = [];
+        if (isApp) {
+            lstBtn.push(btnCamera);
+            lstBtn.push(btnGalery);
+        }
+        lstBtn.push(btnFile);
+        lstBtn.push(btnDeny);
+        var res;
+        if (lstBtn.length > 2) {
+            const actionSheet = await this.actionSheetController.create({ buttons: lstBtn });
+            actionSheet.present();
+            res = await actionSheet.onDidDismiss();
+        }
+        else {
+            res = { role: 'confirm', data: lstBtn[0].data };
+        }
+        if (['backdrop', 'cancel'].includes(res.role)) {
+            return;
+        }
+        if ([SelectType.camera, SelectType.galery].includes(res.data)) {
+            const Source = res.data == SelectType.camera ? CameraSource.Camera : CameraSource.Photos;
+            //const photo = await Camera.getPhoto({ resultType: CameraResultType.Uri, source: Source, quality: 100 });
+            console.error("[ TODO ]");
+            return null;
+        }
+        else {
+            const res = FilePicker.pickFiles({ types: configuration.types, limit: configuration.multiple ? 0 : 1 });
+            const files = (await res).files;
+            return files.map(p => p.blob);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: UtilsService, deps: [{ token: i1.ActionSheetController }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: UtilsService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: UtilsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.ActionSheetController }] });
+export class Utils {
+    /** Converte de unix para Date object */
+    static UNIXToDate(unix_timestamp) {
+        var date = new Date(unix_timestamp * 1000);
+        return date;
+    }
+    /**
+     * @param DateStr - Date on ISO format, e.g:
+     * [ 2010-10-05T14:48:00.000Z ]
+     * @returns Date on format DD/MM/YYYY
+    */
+    static DateISOToDDMMYYYYHHMM(iso, onInvalidDateString = '-') {
+        if (!iso) {
+            return onInvalidDateString;
+        }
+        return moment(iso).format("DD/MM/YYYY HH:mm");
+    }
+    /**
+       * @param iso - Date on ISO format, e.g:
+       * [ 2010-10-05T14:48:00.000Z ]
+       * @returns Date on format DD/MM/YYYY
+      */
+    static DateISOToDDMMYYYY(iso, onInvalidDateString = '-') {
+        if (!iso) {
+            return onInvalidDateString;
+        }
+        return moment(iso).format("DD/MM/YYYY");
+    }
+    static GenerateGUID() {
+        return 'id-xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+            var r = Math.random() * 16 | 0, v = c === 'x' ? r : (r & 0x3 | 0x8);
+            return v.toString(16);
+        });
+    }
+    /**
+     * @param file: base64 | Blob
+     */
+    static async DownloadFile(file, fileName) {
+        var blob = null;
+        if (!(file instanceof Blob)) {
+            blob = await this.Base64ToBlob(file);
+        }
+        else {
+            blob = file;
+        }
+        var fileURL = URL.createObjectURL(blob);
+        const linkElement = document.createElement("a");
+        linkElement.setAttribute("href", fileURL);
+        linkElement.setAttribute("target", "_blank");
+        linkElement.setAttribute("download", fileName);
+        let me = new MouseEvent("click", {
+            view: window,
+            bubbles: true,
+            cancelable: false,
+        });
+        linkElement.dispatchEvent(me);
+    }
+    static async Base64ToBlob(base64) {
+        return (await fetch(base64)).blob();
+    }
+}
+export function Search(items, Search, bindLabel) {
+    return items.filter(p => bindLabel(p)?.toLowerCase().includes(Search.toLowerCase()));
+}
+export function Timeout(timeout) {
+    return new Promise(resolve => setTimeout(resolve, timeout));
+}
+//[ Base 64 ]
+function DecodeBase64(b64) {
+    return JSON.parse(Buffer.from(b64, 'base64').toString('utf-8'));
+}
+function DecodeBase64AsString(b64) {
+    return Buffer.from(b64, 'base64').toString('utf-8');
+}
+function EncodeBase64(obj) {
+    if (typeof obj == "object") {
+        return Buffer.from(JSON.stringify(obj)).toString('base64');
+    }
+    else if (typeof obj == "string") {
+        return Buffer.from(obj).toString('base64');
+    }
+}
+export const INT_MAX = 2_147_483_646;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.service.js","sourceRoot":"","sources":["../../../../../projects/sapphire-ion-framework/src/lib/services/utils.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { ActionSheetButton, ActionSheetController } from '@ionic/angular';\r\nimport { FilePicker, PickFilesResult, PickedFile } from '@capawesome/capacitor-file-picker';\r\nimport { OverlayEventDetail } from '@ionic/core';\r\nimport { CameraSource } from '@capacitor/camera';\r\nimport { Injectable } from '@angular/core';\r\nimport moment from 'moment';\r\n\r\nimport { InputFileConfiguration } from '../components/inputs/input-file/input-file.configuration';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class UtilsService{\r\n\r\n  constructor(private actionSheetController: ActionSheetController) {\r\n  }\r\n\r\n  /** Retorna um array de arquivos de acordo com o tipo de configutação */\r\n  async SelectFile(configuration: InputFileConfiguration): Promise<File[]>{\r\n    enum SelectType {\r\n      camera = 1,\r\n      galery = 2,\r\n      file   = 3,\r\n      deny   = 4,\r\n    }\r\n\r\n    const btnCamera: ActionSheetButton = { text: 'Câmera'            , icon: 'camera'      , data: SelectType.camera }\r\n    const btnGalery: ActionSheetButton = { text: 'Galeria'           , icon: 'image'       , data: SelectType.galery }\r\n    const btnFile  : ActionSheetButton = { text: 'Selecionar Arquivo', icon: 'document'    , data: SelectType.file   }\r\n    const btnDeny  : ActionSheetButton = { text: 'Cancelar'          , icon: 'close-circle', data: SelectType.deny, role: 'cancel', };\r\n\r\n    const isApp = (!document.URL.startsWith('http') || document.URL.startsWith('http://localhost:8080'));\r\n\r\n    var lstBtn: any[] = [];\r\n    if(isApp){ \r\n      lstBtn.push(btnCamera); \r\n      lstBtn.push(btnGalery);\r\n    }\r\n    lstBtn.push(btnFile);\r\n    lstBtn.push(btnDeny);\r\n\r\n    var res: OverlayEventDetail<any>;\r\n    if(lstBtn.length > 2){\r\n      const actionSheet = await this.actionSheetController.create({ buttons: lstBtn });\r\n      actionSheet.present();\r\n      res = await actionSheet.onDidDismiss();\r\n    }else{\r\n      res = { role: 'confirm', data: lstBtn[0].data };\r\n    }\r\n\r\n    \r\n    if(['backdrop', 'cancel'].includes(res.role)){ return; }\r\n\r\n    if([SelectType.camera, SelectType.galery].includes(res.data)){ \r\n      const Source = res.data == SelectType.camera ? CameraSource.Camera : CameraSource.Photos\r\n      //const photo = await Camera.getPhoto({ resultType: CameraResultType.Uri, source: Source, quality: 100 });\r\n      console.error(\"[ TODO ]\")\r\n      return null;\r\n    }else{\r\n      const res: Promise<PickFilesResult> = FilePicker.pickFiles({ types: configuration.types, limit: configuration.multiple ? 0 : 1 });\r\n      const files: PickedFile[] = (await res).files;\r\n      return files.map(p => <File>p.blob);\r\n    }\r\n  } \r\n}\r\n\r\nexport class Utils {\r\n  /** Converte de unix para Date object */\r\n  static UNIXToDate(unix_timestamp: number): Date {\r\n    var date = new Date(unix_timestamp * 1000);\r\n    return date;\r\n  }\r\n  \r\n  /**\r\n   * @param DateStr - Date on ISO format, e.g: \r\n   * [ 2010-10-05T14:48:00.000Z ]\r\n   * @returns Date on format DD/MM/YYYY\r\n  */\r\n  static DateISOToDDMMYYYYHHMM(iso: string, onInvalidDateString: string = '-'): string{\r\n    if(!iso){ return onInvalidDateString; }\r\n    return moment(iso).format(\"DD/MM/YYYY HH:mm\");\r\n  }\r\n\r\n  /**\r\n     * @param iso - Date on ISO format, e.g: \r\n     * [ 2010-10-05T14:48:00.000Z ]\r\n     * @returns Date on format DD/MM/YYYY\r\n    */\r\n  static DateISOToDDMMYYYY(iso: string, onInvalidDateString: string = '-'): string{\r\n    if(!iso){ return onInvalidDateString; }\r\n    return moment(iso).format(\"DD/MM/YYYY\");\r\n  }\r\n\r\n  static GenerateGUID(): string {\r\n    return 'id-xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {\r\n      var r = Math.random() * 16 | 0,\r\n      v = c === 'x' ? r : (r & 0x3 | 0x8);\r\n      return v.toString(16);\r\n    });\r\n  }\r\n\r\n  /** \r\n   * @param file: base64 | Blob\r\n   */\r\n  static async DownloadFile(file: string | Blob, fileName: string){\r\n    var blob: Blob = null;\r\n    if(!(file instanceof Blob)){\r\n      blob = await this.Base64ToBlob(file);\r\n    }\r\n    else{ \r\n      blob = file; \r\n    }\r\n\r\n    var fileURL = URL.createObjectURL(blob);\r\n    const linkElement = document.createElement(\"a\");\r\n    linkElement.setAttribute(\"href\", fileURL);\r\n    linkElement.setAttribute(\"target\", \"_blank\");\r\n    linkElement.setAttribute(\"download\", fileName);\r\n\r\n    let me = new MouseEvent(\"click\", {\r\n      view: window,\r\n      bubbles: true,\r\n      cancelable: false,\r\n    });\r\n\r\n    linkElement.dispatchEvent(me);\r\n  }\r\n\r\n  static async Base64ToBlob(base64: string): Promise<Blob>{\r\n    return (await fetch(base64)).blob();\r\n  }\r\n}\r\n\r\nexport function Search<T = any>(items: T[], Search: string, bindLabel: ((obj: T) => string)): T[] {\r\n  return items.filter(p => bindLabel(p)?.toLowerCase().includes(Search.toLowerCase()));\r\n}\r\n\r\nexport function Timeout(timeout: number): Promise<void>{\r\n  return new Promise(resolve => setTimeout(resolve, timeout));\r\n}\r\n\r\n//[ Base 64 ]\r\nfunction DecodeBase64<T>(b64: string): T{\r\n  return JSON.parse(Buffer.from(b64, 'base64').toString('utf-8'));\r\n}\r\n\r\nfunction DecodeBase64AsString(b64: string) {\r\n  return Buffer.from(b64, 'base64').toString('utf-8');\r\n}\r\n\r\nfunction EncodeBase64(obj: any | string): string{\r\n  if(typeof obj == \"object\"){\r\n    return Buffer.from(JSON.stringify(obj)).toString('base64');\r\n  }\r\n  else\r\n  if(typeof obj == \"string\"){\r\n    return Buffer.from(obj).toString('base64');\r\n  }\r\n}\r\n\r\nexport const INT_MAX = 2_147_483_646;"]}

package/esm2022/lib/services/web/api-url-provider.service.mjs

@@ -0,0 +1,29 @@
+import { Injectable } from '@angular/core';
+import { EnvironmentService } from '../environment.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../environment.service";
+export class ApiUrlProviderService {
+    constructor(coreService) {
+        this.coreService = coreService;
+        //#region [ API URL ]
+        this._apiUrl = '';
+        this._production = coreService.environment.production;
+        this.apiUrl = this.coreService.environment.apiUrl;
+        ;
+        console.log(`%c [ sapphire-ion-framework : ${this.coreService.environment.applicationName} started @ development ] | Conectado em: ${this.apiUrl}`, "background-color: #2fdf75; color: black;");
+    }
+    get apiUrl() { return this._apiUrl; }
+    set apiUrl(value) {
+        this._apiUrl = value;
+    }
+    get production() { return this._production; }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiUrlProviderService, deps: [{ token: i1.EnvironmentService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiUrlProviderService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiUrlProviderService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.EnvironmentService }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/web/http.ativo.service.mjs

@@ -0,0 +1,55 @@
+import { NavController } from '@ionic/angular';
+import { FormBuilder } from '@angular/forms';
+import { HttpClient } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { InputBoolConfiguration, InputBoolType } from '../../components/inputs/input-bool/input-bool.configuration';
+import { HttpService } from './http.service';
+import { ApiUrlProviderService } from './api-url-provider.service';
+import { GenericService } from '../generics.service';
+import { TableField } from '../../classes/inputs/table-field';
+import { InputType } from '../../components/inputs/input-type';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "@angular/forms";
+import * as i3 from "../generics.service";
+import * as i4 from "@ionic/angular";
+import * as i5 from "./api-url-provider.service";
+export class HttpServiceAtivo extends HttpService {
+    constructor(http, fb, genericService, navController, apiUrlProviderService) {
+        super(http, fb, genericService, navController, apiUrlProviderService);
+        this.http = http;
+        this.fb = fb;
+        this.genericService = genericService;
+        this.navController = navController;
+        this.apiUrlProviderService = apiUrlProviderService;
+    }
+    /**
+     * Troca o status de ativo da entidade
+     */
+    Ativar(id) {
+        return this.http.post(this.fullRoute + `/ativar/${id}`, {});
+    }
+    /**
+     * Lista todos os dados ativos
+     * @param vFilter
+     */
+    ListAtivo(vFilter) {
+        return this.http.post(this.fullRoute + `/listAtivo`, vFilter);
+    }
+    /**  Table Field padrão de ativo */
+    get defaultAtivo() {
+        var control = this.fb.control(true);
+        const field = new TableField("Ativo", "ativo", control, InputType.Bool);
+        field.configuration = new InputBoolConfiguration(InputBoolType.toggle);
+        return field;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: HttpServiceAtivo, deps: [{ token: i1.HttpClient }, { token: i2.FormBuilder }, { token: i3.GenericService }, { token: i4.NavController }, { token: i5.ApiUrlProviderService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: HttpServiceAtivo, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: HttpServiceAtivo, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: i2.FormBuilder }, { type: i3.GenericService }, { type: i4.NavController }, { type: i5.ApiUrlProviderService }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaHR0cC5hdGl2by5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvc2FwcGhpcmUtaW9uLWZyYW1ld29yay9zcmMvbGliL3NlcnZpY2VzL3dlYi9odHRwLmF0aXZvLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBQy9DLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQztBQUM3QyxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFDbEQsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUczQyxPQUFPLEVBQUUsc0JBQXNCLEVBQUUsYUFBYSxFQUFDLE1BQU0sNkRBQTZELENBQUM7QUFDbkgsT0FBTyxFQUFFLFdBQVcsRUFBZSxNQUFNLGdCQUFnQixDQUFDO0FBQzFELE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLDRCQUE0QixDQUFDO0FBQ25FLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUVyRCxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sa0NBQWtDLENBQUM7QUFDOUQsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLG9DQUFvQyxDQUFDOzs7Ozs7O0FBSy9ELE1BQU0sT0FBZ0IsZ0JBQTBCLFNBQVEsV0FBYztJQUVwRSxZQUNxQixJQUEwQixFQUMxQixFQUEyQixFQUMzQixjQUE4QixFQUM5QixhQUE2QixFQUM3QixxQkFBNEM7UUFFL0QsS0FBSyxDQUFDLElBQUksRUFBRSxFQUFFLEVBQUUsY0FBYyxFQUFFLGFBQWEsRUFBRSxxQkFBcUIsQ0FBQyxDQUFDO1FBTm5ELFNBQUksR0FBSixJQUFJLENBQXNCO1FBQzFCLE9BQUUsR0FBRixFQUFFLENBQXlCO1FBQzNCLG1CQUFjLEdBQWQsY0FBYyxDQUFnQjtRQUM5QixrQkFBYSxHQUFiLGFBQWEsQ0FBZ0I7UUFDN0IsMEJBQXFCLEdBQXJCLHFCQUFxQixDQUF1QjtJQUdqRSxDQUFDO0lBRUQ7O09BRUc7SUFDSCxNQUFNLENBQUMsRUFBVTtRQUNmLE9BQU8sSUFBSSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQVUsSUFBSSxDQUFDLFNBQVMsR0FBRyxXQUFXLEVBQUUsRUFBRSxFQUFFLEVBQUUsQ0FBQyxDQUFDO0lBQ3ZFLENBQUM7SUFFRDs7O09BR0c7SUFDSCxTQUFTLENBQWtCLE9BQXFCO1FBQzlDLE9BQU8sSUFBSSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUksSUFBSSxDQUFDLFNBQVMsR0FBRyxZQUFZLEVBQUUsT0FBTyxDQUFDLENBQUM7SUFDbkUsQ0FBQztJQUVELG1DQUFtQztJQUNuQyxJQUFJLFlBQVk7UUFDZCxJQUFJLE9BQU8sR0FBRyxJQUFJLENBQUMsRUFBRSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQztRQUNwQyxNQUFNLEtBQUssR0FBRyxJQUFJLFVBQVUsQ0FBQyxPQUFPLEVBQUUsT0FBTyxFQUFFLE9BQU8sRUFBRSxTQUFTLENBQUMsSUFBSSxDQUFDLENBQUM7UUFDeEUsS0FBSyxDQUFDLGFBQWEsR0FBRyxJQUFJLHNCQUFzQixDQUFDLGFBQWEsQ0FBQyxNQUFNLENBQUMsQ0FBQztRQUN2RSxPQUFPLEtBQUssQ0FBQztJQUNmLENBQUM7K0dBakNtQixnQkFBZ0I7bUhBQWhCLGdCQUFnQixjQUZ4QixNQUFNOzs0RkFFRSxnQkFBZ0I7a0JBSHJDLFVBQVU7bUJBQUM7b0JBQ1YsVUFBVSxFQUFFLE1BQU07aUJBQ25CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmF2Q29udHJvbGxlciB9IGZyb20gJ0Bpb25pYy9hbmd1bGFyJztcclxuaW1wb3J0IHsgRm9ybUJ1aWxkZXIgfSBmcm9tICdAYW5ndWxhci9mb3Jtcyc7XHJcbmltcG9ydCB7IEh0dHBDbGllbnQgfSBmcm9tICdAYW5ndWxhci9jb21tb24vaHR0cCc7XHJcbmltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuaW1wb3J0IHsgT2JzZXJ2YWJsZSB9IGZyb20gJ3J4anMnO1xyXG5cclxuaW1wb3J0IHsgSW5wdXRCb29sQ29uZmlndXJhdGlvbiwgSW5wdXRCb29sVHlwZX0gZnJvbSAnLi4vLi4vY29tcG9uZW50cy9pbnB1dHMvaW5wdXQtYm9vbC9pbnB1dC1ib29sLmNvbmZpZ3VyYXRpb24nO1xyXG5pbXBvcnQgeyBIdHRwU2VydmljZSwgVmlld1JldG9ybm8gfSBmcm9tICcuL2h0dHAuc2VydmljZSc7XHJcbmltcG9ydCB7IEFwaVVybFByb3ZpZGVyU2VydmljZSB9IGZyb20gJy4vYXBpLXVybC1wcm92aWRlci5zZXJ2aWNlJztcclxuaW1wb3J0IHsgR2VuZXJpY1NlcnZpY2UgfSBmcm9tICcuLi9nZW5lcmljcy5zZXJ2aWNlJztcclxuaW1wb3J0IHsgVmlld0ZpbHRyb3MgfSBmcm9tICcuLi8uLi9jbGFzc2VzL2ZpbHRlcnMvdmlldy1maWx0cm9zJztcclxuaW1wb3J0IHsgVGFibGVGaWVsZCB9IGZyb20gJy4uLy4uL2NsYXNzZXMvaW5wdXRzL3RhYmxlLWZpZWxkJztcclxuaW1wb3J0IHsgSW5wdXRUeXBlIH0gZnJvbSAnLi4vLi4vY29tcG9uZW50cy9pbnB1dHMvaW5wdXQtdHlwZSc7XHJcblxyXG5ASW5qZWN0YWJsZSh7XHJcbiAgcHJvdmlkZWRJbjogJ3Jvb3QnXHJcbn0pXHJcbmV4cG9ydCBhYnN0cmFjdCBjbGFzcyBIdHRwU2VydmljZUF0aXZvPFYgPSBhbnk+IGV4dGVuZHMgSHR0cFNlcnZpY2U8Vj4ge1xyXG5cclxuICBjb25zdHJ1Y3RvcihcclxuICAgIHByb3RlY3RlZCBvdmVycmlkZSBodHRwICAgICAgICAgIDogSHR0cENsaWVudCxcclxuICAgIHByb3RlY3RlZCBvdmVycmlkZSBmYiAgICAgICAgICAgIDogRm9ybUJ1aWxkZXIsIFxyXG4gICAgcHJvdGVjdGVkIG92ZXJyaWRlIGdlbmVyaWNTZXJ2aWNlOiBHZW5lcmljU2VydmljZSxcclxuICAgIHByb3RlY3RlZCBvdmVycmlkZSBuYXZDb250cm9sbGVyIDogTmF2Q29udHJvbGxlcixcclxuICAgIHByb3RlY3RlZCBvdmVycmlkZSBhcGlVcmxQcm92aWRlclNlcnZpY2U6IEFwaVVybFByb3ZpZGVyU2VydmljZSxcclxuICApIHsgXHJcbiAgICBzdXBlcihodHRwLCBmYiwgZ2VuZXJpY1NlcnZpY2UsIG5hdkNvbnRyb2xsZXIsIGFwaVVybFByb3ZpZGVyU2VydmljZSk7XHJcbiAgfVxyXG5cclxuICAvKipcclxuICAgKiBUcm9jYSBvIHN0YXR1cyBkZSBhdGl2byBkYSBlbnRpZGFkZVxyXG4gICAqL1xyXG4gIEF0aXZhcihpZDogbnVtYmVyKTogT2JzZXJ2YWJsZTxib29sZWFuPiB7XHJcbiAgICByZXR1cm4gdGhpcy5odHRwLnBvc3Q8Ym9vbGVhbj4odGhpcy5mdWxsUm91dGUgKyBgL2F0aXZhci8ke2lkfWAsIHt9KTtcclxuICB9XHJcblxyXG4gIC8qKlxyXG4gICAqIExpc3RhIHRvZG9zIG9zIGRhZG9zIGF0aXZvc1xyXG4gICAqIEBwYXJhbSB2RmlsdGVyXHJcbiAgICovXHJcbiAgTGlzdEF0aXZvPFQgPSBWaWV3UmV0b3Jubz4odkZpbHRlcj86IFZpZXdGaWx0cm9zKTogT2JzZXJ2YWJsZTxUPiB7XHJcbiAgICByZXR1cm4gdGhpcy5odHRwLnBvc3Q8VD4odGhpcy5mdWxsUm91dGUgKyBgL2xpc3RBdGl2b2AsIHZGaWx0ZXIpO1xyXG4gIH1cclxuXHJcbiAgLyoqICBUYWJsZSBGaWVsZCBwYWRyw6NvIGRlIGF0aXZvICovXHJcbiAgZ2V0IGRlZmF1bHRBdGl2bygpOiBUYWJsZUZpZWxkIHtcclxuICAgIHZhciBjb250cm9sID0gdGhpcy5mYi5jb250cm9sKHRydWUpO1xyXG4gICAgY29uc3QgZmllbGQgPSBuZXcgVGFibGVGaWVsZChcIkF0aXZvXCIsIFwiYXRpdm9cIiwgY29udHJvbCwgSW5wdXRUeXBlLkJvb2wpO1xyXG4gICAgZmllbGQuY29uZmlndXJhdGlvbiA9IG5ldyBJbnB1dEJvb2xDb25maWd1cmF0aW9uKElucHV0Qm9vbFR5cGUudG9nZ2xlKTsgXHJcbiAgICByZXR1cm4gZmllbGQ7XHJcbiAgfVxyXG59Il19

package/esm2022/lib/services/web/http.service.mjs

@@ -0,0 +1,175 @@
+import { BehaviorSubject, firstValueFrom } from 'rxjs';
+import { HttpClient, HttpEventType } from '@angular/common/http';
+import { FormBuilder, FormGroup } from '@angular/forms';
+import { Injectable } from '@angular/core';
+import { NavController } from '@ionic/angular';
+import { ApiUrlProviderService } from './api-url-provider.service';
+import { GenericService } from '../../services/generics.service';
+import { TableField } from '../../classes/inputs/table-field';
+import { InputType } from '../../components/inputs/input-type';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "@angular/forms";
+import * as i3 from "../../services/generics.service";
+import * as i4 from "@ionic/angular";
+import * as i5 from "./api-url-provider.service";
+export class HttpService {
+    constructor(http, fb, genericService, navController, apiUrlProviderService) {
+        this.http = http;
+        this.fb = fb;
+        this.genericService = genericService;
+        this.navController = navController;
+        this.apiUrlProviderService = apiUrlProviderService;
+    }
+    get fullRoute() {
+        return this.apiUrlProviderService.apiUrl + this.route;
+    }
+    /**
+     * Retorna os dados de acordo com os filtros
+     * @param vFilter Filtra os dados (Pesquisa, Paginação e IComparison)
+    */
+    List(vFilter) {
+        return this.http.post(this.fullRoute + `/list`, vFilter);
+    }
+    /** Retorna o dado da tabela associada com a rota com o id indicado
+     * @param id id do dado
+    */
+    Get(id) {
+        return this.http.get(this.fullRoute + `/get/${id}`);
+    }
+    /** Salva as alterações no dado recebido */
+    Save(obj, view) {
+        if (view) {
+            view.submitted = true;
+        }
+        var object = obj;
+        if (obj instanceof FormGroup) {
+            if (obj.invalid) {
+                const r = new BehaviorSubject(null);
+                r.error("[ Invalid Form ]");
+                r.complete();
+                this.genericService.PresentToast("Verifique os campos!");
+                return r;
+            }
+            object = obj.value;
+        }
+        const formData = new FormData();
+        this.FilesToForm(object, formData);
+        if (obj instanceof FormGroup && this.hasFileForm && !view) {
+            console.error("[ FormGroup contains file, but view isnt passed ]");
+        }
+        else if (view) {
+            return this._Save(formData, view);
+        }
+        return this.http.post(this.fullRoute + `/save`, formData);
+    }
+    /** Exclui a entidade */
+    Delete(id) {
+        return this.http.delete(this.fullRoute + `/delete/` + id);
+    }
+    /** Retorna todos os dados */
+    Load(vFiltros) {
+        return firstValueFrom(this.List(vFiltros));
+    }
+    get lstTableFields() { return []; }
+    get lstTableFieldsView() { return this.lstTableFields; }
+    get defaultId() {
+        var control = this.fb.control(0);
+        const field = new TableField("id", "id", control, InputType.Number);
+        field.hidden = true;
+        field.hiddenView = true;
+        return field;
+    }
+    get defaultIdEmpresa() {
+        var control = this.fb.control(0);
+        const field = new TableField("Empresa", "idEmpresa", control, InputType.Select);
+        field.hiddenView = true;
+        field.hidden = true;
+        return field;
+    }
+    get hasFileForm() { return this.lstTableFieldsView.filter(p => p.type == InputType.File).length > 0; }
+    _Save(formData, view) {
+        view.loading = true;
+        const subject = new BehaviorSubject(null);
+        this.http.post(this.fullRoute + `/save`, formData, {
+            reportProgress: true,
+            observe: 'events',
+        }).subscribe({
+            next: (rez) => {
+                if (rez.type == HttpEventType.UploadProgress) {
+                    const res = rez.loaded / rez.total;
+                    subject.next(rez);
+                    view.progress = res;
+                }
+                else if (rez.type == HttpEventType.Response) {
+                    view.loading = false;
+                    view.submitted = false;
+                    view.Refresh();
+                    const id = Number(rez.body);
+                    //[ Redirect to view/id | redirectPath ]
+                    if (view.id == 0) {
+                        this.RedirectRoute(id, view.redirectPath, view.GetCurrentRouting());
+                    }
+                }
+            },
+            error: (err) => {
+                subject.error(err);
+                view.loading = false;
+                view.submitted = false;
+                subject.complete();
+            },
+            complete: () => {
+                this.genericService.PresentToastSuccess();
+                subject.complete();
+            }
+        });
+        return subject;
+    }
+    RedirectRoute(id, redirectPath, activatedRoute) {
+        if (!redirectPath) {
+            return;
+        }
+        const path = redirectPath.replace(":id", id.toString());
+        this.navController.navigateRoot([`../${path}`], { relativeTo: activatedRoute });
+    }
+    FilesToForm(object, formData) {
+        //TODO FIX
+        Object.entries(object).forEach((prop) => {
+            if (this.lstTableFieldsView.find(p => prop[0] == p.index && p.type == InputType.File)) {
+                const formValue = prop[1];
+                if (formValue && typeof (formValue) != "string") {
+                    var lstFiles = formValue;
+                    lstFiles.forEach(e => {
+                        if (e instanceof File) {
+                            const file = e;
+                            const name = `file-${formValue.indexOf(file)}-${prop[0]}`;
+                            formData.append(name, e, e.name);
+                        }
+                        else {
+                            var file = e;
+                            const fileToUpload = file.blob;
+                            const name = `file-${formValue.indexOf(file)}-${prop[0]}`;
+                            formData.append(name, fileToUpload, fileToUpload.name);
+                        }
+                    });
+                    object[prop[0]] = "";
+                }
+            }
+        });
+        formData.append('view', JSON.stringify(object));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: HttpService, deps: [{ token: i1.HttpClient }, { token: i2.FormBuilder }, { token: i3.GenericService }, { token: i4.NavController }, { token: i5.ApiUrlProviderService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: HttpService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: HttpService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: i2.FormBuilder }, { type: i3.GenericService }, { type: i4.NavController }, { type: i5.ApiUrlProviderService }] });
+export class ViewRetorno {
+    constructor() {
+        this.lstDados = [];
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"http.service.js","sourceRoot":"","sources":["../../../../../../projects/sapphire-ion-framework/src/lib/services/web/http.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { BehaviorSubject, Observable, firstValueFrom } from 'rxjs';\r\nimport { HttpClient, HttpEventType } from '@angular/common/http';\r\nimport { FormBuilder, FormGroup } from '@angular/forms';\r\nimport { Injectable, inject } from '@angular/core';\r\nimport { ActivatedRoute } from '@angular/router';\r\nimport { NavController } from '@ionic/angular';\r\nimport { PickedFile } from '@capawesome/capacitor-file-picker';\r\n\r\n\r\nimport { ApiUrlProviderService } from './api-url-provider.service';\r\nimport { HttpServiceAtivo } from './http.ativo.service';\r\nimport { GenericService } from '../../services/generics.service';\r\nimport { ViewFiltros } from '../../classes/filters/view-filtros';\r\nimport { TableField } from '../../classes/inputs/table-field';\r\nimport { InputType } from '../../components/inputs/input-type';\r\nimport { View } from '../../components/default/default-view/view';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport abstract class HttpService<V = any> {\r\n\r\n  public abstract route: string; \r\n  public abstract title: string; \r\n\r\n  constructor(\r\n    protected http          : HttpClient,\r\n    protected fb            : FormBuilder, \r\n    protected genericService: GenericService,\r\n    protected navController : NavController,\r\n    protected apiUrlProviderService: ApiUrlProviderService,\r\n  ) { }\r\n\r\n  public get fullRoute(): string{\r\n    return this.apiUrlProviderService.apiUrl + this.route\r\n  }\r\n\r\n  /** \r\n   * Retorna os dados de acordo com os filtros \r\n   * @param vFilter Filtra os dados (Pesquisa, Paginação e IComparison)\r\n  */\r\n  List(vFilter?: ViewFiltros): Observable<ViewRetorno<V>>{\r\n    return this.http.post<ViewRetorno<V>>(this.fullRoute + `/list`, vFilter);\r\n  }\r\n\r\n  /** Retorna o dado da tabela associada com a rota com o id indicado \r\n   * @param id id do dado\r\n  */\r\n  Get(id: number): Observable<V> { \r\n    return this.http.get<V>(this.fullRoute +`/get/${id}`);\r\n  }\r\n  \r\n  /** Salva as alterações no dado recebido */\r\n  Save<T = number>(obj: any | V, view?: View<HttpService | HttpServiceAtivo>): Observable<T>{\r\n    if(view){ view.submitted = true; }\r\n\r\n    var object = obj;\r\n    \r\n    if(obj instanceof FormGroup){ \r\n      if(obj.invalid){ \r\n        const r = new BehaviorSubject(null)\r\n        r.error(\"[ Invalid Form ]\");\r\n        r.complete();\r\n        this.genericService.PresentToast(\"Verifique os campos!\")\r\n        return r;\r\n      }\r\n    \r\n      object = obj.value; \r\n    }\r\n\r\n    const formData = new FormData();\r\n    this.FilesToForm(object, formData)\r\n    \r\n    if(obj instanceof FormGroup && this.hasFileForm && !view){ \r\n      console.error(\"[ FormGroup contains file, but view isnt passed ]\") \r\n    } else \r\n    if(view){ \r\n      return this._Save(formData, view); \r\n    } \r\n\r\n    return this.http.post<T>(this.fullRoute + `/save`, formData);\r\n  }\r\n\r\n  /** Exclui a entidade */\r\n  Delete(id: number): Observable<void> {\r\n    return this.http.delete<void>(this.fullRoute + `/delete/`+id);\r\n  }\r\n\r\n  /** Retorna todos os dados */\r\n  public Load(vFiltros?: ViewFiltros): Promise<ViewRetorno<V>>{\r\n    return firstValueFrom(this.List(vFiltros));\r\n  }\r\n\r\n  get lstTableFields()    : TableField[] { return []; } \r\n  get lstTableFieldsView(): TableField[] { return this.lstTableFields; } \r\n\r\n  get defaultId() {\r\n    var control = this.fb.control(0);\r\n    const field = new TableField(\"id\", \"id\", control, InputType.Number); \r\n    field.hidden = true;\r\n    field.hiddenView = true;\r\n    return field\r\n  }\r\n\r\n  get defaultIdEmpresa() {\r\n    var control = this.fb.control(0);\r\n    const field = new TableField(\"Empresa\", \"idEmpresa\", control, InputType.Select); \r\n    field.hiddenView = true;\r\n    field.hidden     = true;\r\n    return field;\r\n  }\r\n\r\n  private get hasFileForm(): boolean { return this.lstTableFieldsView.filter(p => p.type == InputType.File).length > 0; } \r\n\r\n  protected _Save(formData: FormData, view: View<HttpService | HttpServiceAtivo>): Observable<any | void>{\r\n    view.loading = true;\r\n\r\n    const subject = new BehaviorSubject<any>(null);\r\n    this.http.post(this.fullRoute +`/save`, formData, {\r\n      reportProgress: true,\r\n      observe: 'events',\r\n    }).subscribe({\r\n      next: (rez) => { \r\n        if(rez.type == HttpEventType.UploadProgress){\r\n          const res = rez.loaded / rez.total!; \r\n          subject.next(rez);\r\n          view.progress = res;  \r\n        }else \r\n        if(rez.type == HttpEventType.Response){\r\n          view.loading   = false; \r\n          view.submitted = false; \r\n          view.Refresh(); \r\n\r\n          const id: number = Number(rez.body)\r\n          //[ Redirect to view/id | redirectPath ]\r\n          if(view.id == 0){ this.RedirectRoute(id, view.redirectPath, view.GetCurrentRouting()); }\r\n        }\r\n      },\r\n      error:(err) => { \r\n        subject.error(err); \r\n        view.loading   = false; \r\n        view.submitted = false; \r\n        subject.complete(); \r\n      },\r\n      complete:() => { \r\n        this.genericService.PresentToastSuccess();\r\n        subject.complete(); \r\n      }\r\n    });\r\n\r\n    return subject;\r\n  }\r\n\r\n  private RedirectRoute(id: number, redirectPath: string, activatedRoute: ActivatedRoute): void {\r\n    if(!redirectPath){ return; }\r\n    const path = redirectPath.replace(\":id\", id.toString());\r\n    this.navController.navigateRoot([`../${path}`], { relativeTo: activatedRoute })\r\n  }\r\n\r\n\r\n  private FilesToForm(object: any, formData: FormData){\r\n    //TODO FIX\r\n    Object.entries(object).forEach((prop) => {\r\n      if(this.lstTableFieldsView.find(p => prop[0] == p.index && p.type == InputType.File)){\r\n        const formValue = prop[1];\r\n        if(formValue && typeof(formValue) != \"string\"){\r\n          var lstFiles = (formValue as any[])\r\n          lstFiles.forEach(e => {\r\n            if(e instanceof File){\r\n              const file: File = e; \r\n              const name = `file-${(formValue as any[]).indexOf(file)}-${prop[0]}`;\r\n              formData.append(name, e, e.name); \r\n            } else {\r\n              var file: PickedFile = e;\r\n              const fileToUpload = <File>file.blob;\r\n              const name = `file-${(formValue as any[]).indexOf(file)}-${prop[0]}`;\r\n              formData.append(name, fileToUpload, fileToUpload.name); \r\n            }\r\n          });\r\n          object[prop[0]]= \"\";\r\n        }\r\n      }\r\n    });\r\n    formData.append('view', JSON.stringify(object));\r\n  }\r\n}\r\n\r\nexport class ViewRetorno<T = any> {\r\n  lstDados: T[] = [];\r\n  total: number;\r\n}"]}

package/esm2022/lib/services/web/storage.service.mjs

@@ -0,0 +1,115 @@
+import { HttpClient, HttpEventType } from '@angular/common/http';
+import { BehaviorSubject } from 'rxjs';
+import { Injectable } from '@angular/core';
+import { ApiUrlProviderService } from './api-url-provider.service';
+import { GenericService } from '../generics.service';
+import { Utils } from '../utils.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "./api-url-provider.service";
+import * as i3 from "../generics.service";
+export class StorageService {
+    constructor(http, apiUrlProviderService, genericService) {
+        this.http = http;
+        this.apiUrlProviderService = apiUrlProviderService;
+        this.genericService = genericService;
+        this.currentlyDownloading = [];
+    }
+    GetProgress(file) {
+        const Download = this.currentlyDownloading.find(p => p.file == file);
+        return Download ? Download.progress : 0;
+    }
+    StartDownload(file, params, post = false) {
+        if (!this.currentlyDownloading.find(p => p.file == file)) {
+            const download = new Download(file);
+            this.currentlyDownloading.push(download);
+            this.HandleDownload(download, params, post);
+            return download;
+        }
+        return this.currentlyDownloading.find(p => p.file == file);
+    }
+    HandleDownload(download, params, post = false) {
+        var request = this.GetFile(download.file, params, post);
+        const requestProgess = new BehaviorSubject(null);
+        download.requestProgess = requestProgess;
+        request.subscribe({
+            next: (event) => {
+                if (event.type === HttpEventType.DownloadProgress) {
+                    download.progress = event.loaded / event.total;
+                    requestProgess.next(download.progress);
+                }
+                else if (event.type === HttpEventType.Response) {
+                    Utils.DownloadFile(event, download.file);
+                    this.currentlyDownloading.splice(this.currentlyDownloading.indexOf(download), 1);
+                    requestProgess.complete();
+                }
+                if (event.status == 404) {
+                    this.genericService.PresentToast("Arquivo não encontrado / Url inválida");
+                    requestProgess.error(event);
+                    requestProgess.complete();
+                }
+            },
+            error: (err) => {
+                this.currentlyDownloading.splice(this.currentlyDownloading.indexOf(download), 1);
+            }
+        });
+        return request;
+    }
+    static SanitizeFileName(v) {
+        try {
+            var filenameEnd = v.split('/')[v.split('/').length - 1];
+            if (filenameEnd.split('.').length <= 2) {
+                return filenameEnd;
+            }
+            else {
+                var lst = filenameEnd.split('.');
+                lst[0] = '';
+                return lst.join('.').replace('.', '');
+            }
+        }
+        catch {
+            return v;
+        }
+    }
+    ;
+    GetFile(fileUrl, params, post = false) {
+        var url;
+        if (fileUrl[0] == '/') {
+            url = fileUrl.slice(1, fileUrl.length - 1);
+        }
+        else {
+            url = `${this.apiUrlProviderService.apiUrl}${fileUrl}`;
+        }
+        url = encodeURI(url).replace(/#/g, '%23');
+        if (!post) {
+            return this.http.get(url, {
+                reportProgress: true,
+                observe: 'events',
+                responseType: 'blob',
+                params: params
+            });
+        }
+        else {
+            return this.http.post(url, params, {
+                reportProgress: true,
+                observe: 'events',
+                responseType: 'blob'
+            });
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: StorageService, deps: [{ token: i1.HttpClient }, { token: i2.ApiUrlProviderService }, { token: i3.GenericService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: StorageService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: StorageService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: i2.ApiUrlProviderService }, { type: i3.GenericService }] });
+export class Download {
+    constructor(file) {
+        this.file = file;
+        this.progress = 0.00001;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"storage.service.js","sourceRoot":"","sources":["../../../../../../projects/sapphire-ion-framework/src/lib/services/web/storage.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient, HttpEventType, HttpResponse } from '@angular/common/http';\r\nimport { BehaviorSubject, Observable } from 'rxjs';\r\nimport { Injectable } from '@angular/core';\r\n\r\nimport { ApiUrlProviderService } from './api-url-provider.service';\r\nimport { GenericService } from '../generics.service';\r\nimport { Utils } from '../utils.service';\r\n\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class StorageService {\r\n\r\n  constructor(\r\n  private http : HttpClient,\r\n  private apiUrlProviderService: ApiUrlProviderService,\r\n  private genericService: GenericService\r\n  ) { }\r\n\r\n  private currentlyDownloading: Download[] = [];\r\n\r\n  public GetProgress(file: string): number{\r\n    const Download = this.currentlyDownloading.find(p => p.file == file)\r\n    return Download ? Download.progress : 0;\r\n  }\r\n\r\n  public StartDownload(file: string, params?: any, post: boolean = false): Download {\r\n    if(!this.currentlyDownloading.find(p => p.file == file)){\r\n      const download = new Download(file);\r\n      this.currentlyDownloading.push(download);\r\n      this.HandleDownload(download, params, post);\r\n      return download;\r\n    }\r\n    return this.currentlyDownloading.find(p => p.file == file);\r\n  }\r\n\r\n  private HandleDownload(download: Download, params?: any, post: boolean = false){\r\n    var request: Observable<any> = this.GetFile(download.file, params, post);\r\n\r\n    const requestProgess = new BehaviorSubject<any>(null);\r\n    download.requestProgess = requestProgess;\r\n    request.subscribe({\r\n      next: (event) => {\r\n        if (event.type === HttpEventType.DownloadProgress) { \r\n          download.progress = event.loaded / event.total; \r\n          requestProgess.next(download.progress);\r\n        } else \r\n        if (event.type === HttpEventType.Response) {\r\n          Utils.DownloadFile(event, download.file);\r\n          this.currentlyDownloading.splice(this.currentlyDownloading.indexOf(download), 1);\r\n          requestProgess.complete(); \r\n        }\r\n        if(event.status == 404){\r\n          this.genericService.PresentToast(\"Arquivo não encontrado / Url inválida\")\r\n          requestProgess.error(event); \r\n          requestProgess.complete(); \r\n        }\r\n      },\r\n      error: (err) => {\r\n        this.currentlyDownloading.splice(this.currentlyDownloading.indexOf(download), 1)\r\n      }\r\n    });\r\n    return request;\r\n  }\r\n\r\n  public static SanitizeFileName(v): string{\r\n    try{\r\n      var filenameEnd: string  = v.split('/')[v.split('/').length - 1]\r\n      \r\n      if(filenameEnd.split('.').length <= 2){\r\n        return filenameEnd;\r\n      }else{\r\n        var lst = filenameEnd.split('.');\r\n        lst[0] = '';\r\n        return lst.join('.').replace('.', '');\r\n      }\r\n    }catch{\r\n      return v;\r\n    }\r\n  };\r\n\r\n  public GetFile(fileUrl: string, params?: any, post: boolean = false): Observable<any> {\r\n    var url: string;\r\n    if(fileUrl[0] == '/'){ \r\n      url = fileUrl.slice(1, fileUrl.length - 1);\r\n    }else{\r\n      url = `${this.apiUrlProviderService.apiUrl}${fileUrl}`;\r\n    }\r\n    url = encodeURI(url).replace(/#/g, '%23')\r\n\r\n    if(!post){\r\n      return this.http.get(url, {\r\n        reportProgress: true,\r\n        observe: 'events',\r\n        responseType: 'blob',\r\n        params: params\r\n      });\r\n    }else{\r\n      return this.http.post(url, params, {\r\n        reportProgress: true,\r\n        observe: 'events',\r\n        responseType: 'blob'\r\n      });\r\n    }\r\n  }\r\n}\r\n\r\nexport class Download {\r\n  requestProgess: Observable<any>;\r\n  progress      : number = 0.00001;\r\n  constructor(public file: string){}\r\n}"]}

package/esm2022/public-api.mjs

@@ -0,0 +1,5 @@
+/*
+ * Public API Surface of ion-sapphire-framework
+ */
+export * from './lib/index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL3NhcHBoaXJlLWlvbi1mcmFtZXdvcmsvc3JjL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGFBQWEsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qXHJcbiAqIFB1YmxpYyBBUEkgU3VyZmFjZSBvZiBpb24tc2FwcGhpcmUtZnJhbWV3b3JrXHJcbiAqL1xyXG5cclxuZXhwb3J0ICogZnJvbSAnLi9saWIvaW5kZXgnOyJdfQ==

package/esm2022/sapphire-ion-framework.mjs

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