@sapphire-ion/framework 1.2.63 → 1.3.1

package/src/lib/services/route/route.provider.service.ts

@@ -0,0 +1,49 @@
+import { Observable, tap, share, finalize } from 'rxjs';
+import { Injectable } from '@angular/core';
+
+import { RouteCacheService } from './route.cache.service';
+import { Menu } from '../../components/drawer/menu';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class RouteProviderService  {
+
+  loadFrom: Observable<Menu[]> | Menu[] = [];
+  private routeCacheService: RouteCacheService = new RouteCacheService();
+  private loading$: Observable<Menu[]> | null = null;
+
+  constructor(
+  ) { }
+
+  resolver: Promise<Menu[]>
+
+  GetData(): Observable<Menu[]> {
+    // If a request is already in progress, return that Observable
+    if (this.loading$) {
+      return this.loading$;
+    }
+
+    if(Array.isArray(this.loadFrom)){
+      this.routeCacheService.setCachedData(this.loadFrom);
+    }
+
+    const cachedData = this.routeCacheService.getCachedData();
+
+    if (cachedData) {
+      return new Observable(observer => {
+        observer.next(cachedData);
+        observer.complete();
+      });
+    } else {
+      // Store the loading Observable and make sure to reset it when it completes
+      this.loading$ = (this.loadFrom as Observable<Menu[]>).pipe(
+        tap(data => this.routeCacheService.setCachedData(data)),
+        finalize(() => this.loading$ = null),
+        share() // Share the same subscription with multiple subscribers
+      );
+      
+      return this.loading$;
+    }
+  }
+}

package/src/lib/services/usuario.service.ts

@@ -0,0 +1,44 @@
+import { HttpClient } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { FormBuilder, Validators } from '@angular/forms';
+import { NavController } from '@ionic/angular';
+
+import { InputStringConfiguration, InputStringType } from '../components/inputs/input-string/input-string.configuration';
+import { ApiUrlProviderService } from '../services/web/api-url-provider.service';
+import { HttpServiceAtivo } from '../services/web/http.ativo.service';
+import { GenericService } from './generic.service';
+import { TableField } from '../classes/inputs/table-field';
+import { InputType } from '../components/inputs/input-type';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class UsuarioService extends HttpServiceAtivo {
+
+  public override route: string = "usuario"; 
+  public override title: string = "Usuario"; 
+
+  constructor(
+    protected override http: HttpClient,
+    protected override fb: FormBuilder,
+    protected override genericService: GenericService,
+    protected override navController : NavController,
+    protected override apiUrlProviderService : ApiUrlProviderService,
+  ) { 
+    super(http, fb, genericService, navController, apiUrlProviderService);
+  }
+
+  override get lstTableFields(){
+    var lst: TableField[] = [];
+
+    lst[0] = this.defaultId;
+    lst[1] = new TableField("Nome"   , "nome"   , this.fb.control(null, Validators.required), InputType.String)
+    lst[2] = new TableField("Apelido", "apelido", this.fb.control(null, Validators.required), InputType.String)
+    lst[3] = new TableField("Senha"  , "senha"  , this.fb.control(null, Validators.required), InputType.String)
+    lst[3].hiddenView = true;
+    lst[3].configuration = new InputStringConfiguration(InputStringType.Password);
+    lst[4] = this.defaultAtivo;
+
+    return lst;
+  };
+}

package/src/lib/services/utils.service.ts

@@ -0,0 +1,216 @@
+import { ActionSheetButton, ActionSheetController } from '@ionic/angular';
+import { FilePicker, PickFilesResult, PickedFile, PickFilesOptions } from '@capawesome/capacitor-file-picker';
+import { Camera, CameraResultType, CameraSource } from '@capacitor/camera';
+import { OverlayEventDetail } from '@ionic/core';
+import { Injectable } from '@angular/core';
+import moment from 'moment';
+import { Buffer } from 'buffer';
+import mime from 'mime';
+import { InputFileConfiguration } from '../components/inputs/input-file/input-file.configuration';
+import { Capacitor } from '@capacitor/core';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class UtilsService{
+
+  constructor(private actionSheetController: ActionSheetController) {
+  }
+
+  /** Retorna um array de arquivos de acordo com o tipo de configutação */
+  async SelectFile(configuration: InputFileConfiguration): Promise<File>{
+    enum SelectType {
+      camera = 1,
+      galery = 2,
+      file   = 3,
+      deny   = 4,
+    }
+
+    const btnCamera: ActionSheetButton = { text: 'Câmera'            , icon: 'camera'      , data: SelectType.camera }
+    const btnGalery: ActionSheetButton = { text: 'Galeria'           , icon: 'image'       , data: SelectType.galery }
+    const btnFile  : ActionSheetButton = { text: 'Selecionar Arquivo', icon: 'document'    , data: SelectType.file   }
+    const btnDeny  : ActionSheetButton = { text: 'Cancelar'          , icon: 'close-circle', data: SelectType.deny, role: 'cancel', };
+
+    const isApp = (!document.URL.startsWith('http') || document.URL.startsWith('http://localhost:8080'));
+
+    var lstBtn: any[] = [];
+    if(isApp){ 
+      lstBtn.push(btnCamera); 
+      lstBtn.push(btnGalery);
+    }
+    lstBtn.push(btnFile);
+    lstBtn.push(btnDeny);
+
+    var res: OverlayEventDetail<any>;
+    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: Promise<PickFilesResult> = FilePicker.pickFiles({ types: configuration.types, limit: 1 });
+      const files: PickedFile[] = (await res).files;
+      return files.map(p => <File>p.blob)[0];
+    }
+  } 
+}
+
+export class Utils {
+  /** Converte de unix para Date object */
+  static UNIXToDate(unix_timestamp: number): Date {
+    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: string, onInvalidDateString: string = '-'): string{
+    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: string, onInvalidDateString: string = '-'): string{
+    if(!iso){ return onInvalidDateString; }
+    return moment(iso).format("DD/MM/YYYY");
+  }
+
+  static GenerateGUID(): string {
+    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: string | Blob, fileName: string){
+    var blob: Blob = null;
+    if(!(file instanceof Blob)){
+      blob = await Utils.Base64ToBlob(file, Utils.FindMimeFromNameOrExtension(fileName));
+    }
+    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);
+  }
+
+  public static async BlobToBase64(blob: Blob): Promise<string> {
+    const ab = await blob.arrayBuffer();
+    return Buffer.from(ab).toString("base64");
+  }
+
+  public static async Base64ToBlob(base64: string, mimeType: string): Promise<Blob> {
+    return new Blob([Buffer.from(base64, "base64")], { type: mimeType })
+  }
+
+  public static async GetPhoto(params?: {
+    quality?: number,
+    source?: CameraSource
+  }): Promise<{
+    blob: Blob
+    fileName: string
+  }>{
+    const quality = params?.quality || 70;
+    const source  = params?.source || CameraSource.Camera;
+    const ph   = await Camera.getPhoto({ 
+      resultType: CameraResultType.Uri, 
+      source : source,
+      quality: quality
+    });
+    const file = await fetch(ph.webPath);
+    const blob = await file.blob();
+    return { blob, fileName: ph.path.split('/').at(-1) };
+  }
+
+  public static async PickFile(options?: PickFilesOptions): Promise<{
+    blob: Blob,
+    mimeType: string,
+    name: string,
+    size: number,
+  }[]> {
+    const Pick = await FilePicker.pickFiles(options);
+    let lstBlob = Pick.files.map(async vFile => {
+      let blob = null;
+      if(Capacitor.isNativePlatform()){
+        blob = new Blob([await (await fetch(Capacitor.convertFileSrc(vFile.path))).blob()], { type: vFile.mimeType });
+      }
+      else{
+        blob = vFile.blob;
+      }
+      return {
+        blob,
+        mimeType: vFile.mimeType,
+        name: vFile.name,
+        size: vFile.size,
+      };
+    });
+    return Promise.all(lstBlob);    
+  }
+
+  static FindMimeFromNameOrExtension(pathOrExtension: string){
+    return mime.getType(pathOrExtension) || 'application/octet-stream';
+  }
+}
+
+export function Search<T = any>(items: T[], Search: string, bindLabel: ((obj: T) => string)): T[] {
+  return items.filter(p => bindLabel(p)?.toLowerCase().includes(Search.toLowerCase()));
+}
+
+export function Timeout(timeout: number): Promise<void>{
+  return new Promise(resolve => setTimeout(resolve, timeout));
+}
+
+//[ Base 64 ]
+function DecodeBase64<T>(b64: string): T{
+  return JSON.parse(Buffer.from(b64, 'base64').toString('utf-8'));
+}
+
+function DecodeBase64AsString(b64: string) {
+  return Buffer.from(b64, 'base64').toString('utf-8');
+}
+
+function EncodeBase64(obj: any | string): string{
+  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;

package/src/lib/services/web/api-url-provider.service.ts

@@ -0,0 +1,48 @@
+import { Injectable, OnInit } from '@angular/core';
+import { EnvironmentService } from '../environment.service';
+import { Preferences } from '@capacitor/preferences';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class ApiUrlProviderService {
+
+  constructor(
+    private coreService: EnvironmentService,
+  ) { 
+    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;")
+  }
+
+  //#region [ API URL ]
+  public _apiUrl: string = '';
+
+  public get apiUrl(): string{ return this._apiUrl; }
+  public set apiUrl(value: string){
+    this._apiUrl = value;
+  }
+  
+  private _production: boolean;
+
+  public get production() { return this._production; }
+  //#endregion [ API URL ]
+}
+
+// export class ApiUrl{
+//   label     : string; 
+//   value     : string;
+//   production: boolean;
+//   constructor(value: string, port: number, production: boolean, https: boolean = false){
+//     this.production = production;
+//     if(!production){
+//       this.value = `http${https ? 's' : ''}://${value}:${port}/`;
+//       this.label = value;
+//     }else{
+//       this.value = `http${https ? 's' : ''}://${value}/`;
+//       this.label = 'Produção'
+//     }
+//   }
+// }

package/src/lib/services/web/http.ativo.service.ts

@@ -0,0 +1,37 @@
+import { Injectable } from '@angular/core';
+import { Observable } from 'rxjs';
+
+import { InputBoolConfiguration, InputBoolType} from '../../components/inputs/input-bool/input-bool.configuration';
+import { HttpService, ViewRetorno } from './http.service';
+import { ViewFiltros } from '../../classes/filters/view-filtros';
+import { TableField } from '../../classes/inputs/table-field';
+import { InputType } from '../../components/inputs/input-type';
+
+@Injectable({
+  providedIn: 'root'
+})
+export abstract class HttpServiceAtivo<V = any> extends HttpService<V> {
+
+  /**
+   * Troca o status de ativo da entidade
+   */
+  Ativar(id: number): Observable<boolean> {
+    return this.http.post<boolean>(this.fullRoute + `/ativar/${id}`, {});
+  }
+
+  /**
+   * Lista todos os dados ativos
+   * @param vFilter
+   */
+  ListAtivo<T = ViewRetorno>(vFilter?: ViewFiltros): Observable<T> {
+    return this.http.post<T>(this.fullRoute + `/listAtivo`, vFilter);
+  }
+
+  /** Table Field padrão de ativo */
+  get defaultAtivo(): TableField {
+    var control = this.fb.control(true);
+    const field = new TableField("Ativo", "ativo", control, InputType.Bool);
+    field.configuration = new InputBoolConfiguration(InputBoolType.Toggle); 
+    return field;
+  }
+}

package/src/lib/services/web/http.service.ts

@@ -0,0 +1,206 @@
+import { BehaviorSubject, Observable, firstValueFrom } from 'rxjs';
+import { HttpClient, HttpEvent, HttpEventType } from '@angular/common/http';
+import { FormBuilder, FormGroup } from '@angular/forms';
+import { Injectable, inject } from '@angular/core';
+import { ActivatedRoute } from '@angular/router';
+import { NavController } from '@ionic/angular';
+
+import { ApiUrlProviderService } from './api-url-provider.service';
+import { GenericService } from '../generic.service';
+import { ViewFiltros } from '../../classes/filters/view-filtros';
+import { TableField } from '../../classes/inputs/table-field';
+import { InputType } from '../../components/inputs/input-type';
+import { View } from '../../components/default/default-view/view';
+
+@Injectable({
+  providedIn: 'root'
+})
+export abstract class HttpService<V = any> {
+
+  public abstract route: string; 
+  public abstract title: string; 
+
+  constructor(
+    protected http?          : HttpClient,
+    protected fb?            : FormBuilder, 
+    protected genericService?: GenericService,
+    protected navController? : NavController,
+    protected apiUrlProviderService?: ApiUrlProviderService,
+  ) { 
+    this.http                  = inject(HttpClient);
+    this.fb                    = inject(FormBuilder);
+    this.genericService        = inject(GenericService);
+    this.navController         = inject(NavController);
+    this.apiUrlProviderService = inject(ApiUrlProviderService);
+  }
+
+  /**
+   * Retorna a rota completa do serviço
+   * @return string
+   * @example 'https://api.example.com/{route}'
+   */
+  public get fullRoute(): string{
+    return this.apiUrlProviderService.apiUrl + this.route
+  }
+
+  /** 
+   * Retorna os dados de acordo com os filtros 
+   * @param vFilter Filtra os dados (Pesquisa, Paginação e IComparison)
+  */
+  public List(vFilter?: ViewFiltros): Observable<ViewRetorno<V>>{
+    return this.http.post<ViewRetorno<V>>(this.fullRoute + `/list`, vFilter);
+  }
+
+  /** Retorna o dado da tabela associada com a rota com o id indicado 
+   * @param id id do dado
+  */
+  public Get(id: number): Observable<V> { 
+    return this.http.get<V>(this.fullRoute +`/get/${id}`);
+  }
+  
+  /** Salva as alterações no dado recebido */
+  public Save<T = number>(obj: any | FormGroup | V, view?: View<HttpService>): Observable<T>{
+    if(view){ view.submitted = true; }
+
+    var object = obj;
+    
+    if(obj instanceof FormGroup){ 
+      if(obj.invalid){ 
+        const subject = new BehaviorSubject(null)
+        subject.error("[ Invalid Form ]");
+        subject.complete();
+        this.genericService.PresentToast("Verifique os campos!")
+        return subject;
+      }
+    
+      object = obj.value; 
+    }
+
+    const formData = this.FilesToForm(object);
+    formData.append('view', JSON.stringify(object));
+
+    //Check in the case it has a file and the view is not passed
+    if(Object.entries(object).find(p => p[1] instanceof File) && this.hasFileForm && !view){ 
+      console.error("[ FormGroup contains file, but view isnt a valid parameter ]"); 
+    } else 
+    if(view){ 
+      return this._Save(formData, view); 
+    } 
+
+    return this.http.post<T>(this.fullRoute + `/save`, formData);
+  }
+
+  /** Exclui a entidade */
+  public Delete(id: number): Observable<void> {
+    return this.http.delete<void>(this.fullRoute + `/delete/`+id);
+  }
+
+  /** Retorna todos os dados */
+  public Load(vFiltros?: ViewFiltros): Promise<ViewRetorno<V>>{
+    return firstValueFrom(this.List(vFiltros));
+  }
+
+  /** Retorna os campos da tabela */
+  get lstTableFields()    : TableField[] { return []; }
+  /** Retorna os campos da tabela para visualização/edição (se vazio retornara o padrão (lstTableFields)) */ 
+  get lstTableFieldsView(): TableField[] { return this.lstTableFields; } 
+
+  /** Retora o TableField padrão de id */
+  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
+  }
+
+  /** Retora o TableField padrão de idEmpresa */
+  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;
+  }
+
+  private get hasFileForm(): boolean { return this.lstTableFieldsView.filter(p => p.type == InputType.File).length > 0; } 
+
+  protected _Save(formData: FormData, view: View<HttpService>): Observable<any | void>{
+    view.loading = true;
+
+    const subject = new BehaviorSubject<HttpEvent<any>>(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 = Number(rez.body)
+
+          //[ Redirect to view/:id | redirectPath ]
+          if(!view.id && id){ 
+            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;
+  }
+  private RedirectRoute(id: number, redirectPath: string, activatedRoute: ActivatedRoute): void {
+    if (!redirectPath) { return; }
+
+    const path = redirectPath.replace(':id', id.toString());
+
+    // se contém "/from/", precisa subir 2 níveis
+    const currentSegments = activatedRoute.snapshot.url.map(u => u.path);
+    const level = currentSegments.includes('from') ? '../../' : '../';
+
+    this.navController.navigateRoot(
+      [ `${level}${path}` ],
+      {
+        relativeTo: activatedRoute,
+        replaceUrl: true, 
+        state: { __preserveBack: true }
+      }
+    );
+  }
+
+  public FilesToForm(object: V, formData: FormData = new FormData(), lstTableFieldsView: TableField[] | null = null): FormData {
+    if(!lstTableFieldsView){ lstTableFieldsView = this.lstTableFieldsView.filter(p => p.type == InputType.File); }
+
+    for (const [key, value] of Object.entries(object)) {
+      if(lstTableFieldsView.find(p => p.index == key && p.type == InputType.File)){
+        if(value && typeof(value) != "string"){
+          const file = value as File;
+          const name = `file-${key}`;
+          formData.append(name, file, file.name);
+          object[key] = "";
+        }
+      }
+    }
+    return formData;
+  }
+}
+
+export class ViewRetorno<T = any> {
+  lstDados: T[] = [];
+  total: number;
+}