@sapphire-ion/framework 1.2.63 → 1.3.1

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

@@ -0,0 +1,150 @@
+import { Observable, firstValueFrom } from 'rxjs';
+import { NavController } from '@ionic/angular';
+import { Preferences } from '@capacitor/preferences';
+import { HttpClient } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { jwtDecode } from 'jwt-decode';
+
+import { ApiUrlProviderService } from '../services/web/api-url-provider.service';
+import { EnvironmentService } from './environment.service';
+import { Utils } from './utils.service';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class AuthService {
+
+  constructor(
+    private http: HttpClient,
+    private navController: NavController,
+    private coreService: EnvironmentService,
+    private apiUrlProviderService: ApiUrlProviderService 
+  ) {
+    this.SetToken();
+  }
+
+  private localUserKey      : string = this.coreService.environment.applicationName.toUpperCase() + "_USER_KEY";
+  private localAdminKey     : string = this.coreService.environment.applicationName.toUpperCase() + "_ADMIN_KEY";
+  public  currentToken: string | null = null;
+
+  async SetToken(): Promise<void> {
+    const Token      = await this.LoadToken();
+    const TokenAdmin = await this.LoadTokenAdmin();
+    if(this.isTokenValid(Token)){
+      this.currentToken = await this.JWToken();
+    }
+
+    if(TokenAdmin && this.isTokenValid(TokenAdmin)){
+      this._isAdmin = true;
+    }
+
+    return;
+  }
+
+  async Loggout(): Promise<void> {
+    await Preferences.remove({ key: this.localUserKey });
+    await Preferences.remove({ key: this.localAdminKey });
+    this.currentToken = null;
+    this.navController.navigateRoot("login");
+  }
+  
+  _isAdmin: boolean = false;
+  get isAdmin(){ return this._isAdmin;  }
+
+  async Login(credentials: Authentication): Promise<any> {
+    try{
+      const JWToken = await firstValueFrom(this.ApiLogin(credentials));
+      await this.SaveToken(JWToken);
+      await this.SetToken();
+      return (jwtDecode(JWToken));
+    }
+    catch (Error){
+      throw Error;
+    }
+  }
+
+  async BypassLogin(id: number): Promise<any> {
+    try{
+      const JWToken = await firstValueFrom(this.ApiBypassLogin(id));
+      await this.SaveToken(JWToken);
+      await this.SetToken();
+      return (jwtDecode(JWToken));
+    }
+    catch (Error){
+      throw Error;
+    }
+  }
+
+  ApiLogin(credentials: Authentication): Observable<string> {
+    return this.http.post<string>(this.apiUrlProviderService.apiUrl + 'auth', credentials);
+  }
+  ApiBypassLogin(id: number): Observable<string> {
+    return this.http.get<string>(this.apiUrlProviderService.apiUrl + `auth/${id}`);
+  }
+
+  async SaveToken(JWToken: string): Promise<void>{
+    if((jwtDecode(JWToken) as Token).id == 1){ 
+      await Preferences.set({ key: this.localAdminKey, value: JWToken});
+    }
+    await Preferences.set({ key: this.localUserKey, value: JWToken })
+  }
+
+  async LoadToken(): Promise<Token | null | any> {
+    const JWToken = (await Preferences.get({ key: this.localUserKey})).value;
+    if(JWToken){
+      const ParsedObject = jwtDecode(JWToken);
+      return ParsedObject;
+    }else{
+      return null;
+    }
+  }
+  async LoadTokenAdmin(): Promise<Token | null | any> {
+    const JWToken = (await Preferences.get({ key: this.localAdminKey})).value;
+    if(JWToken){
+      const ParsedObject = jwtDecode(JWToken);
+      return ParsedObject;
+    }else{
+      return null;
+    }
+  }
+
+  async JWToken(): Promise<string> {
+    const JWToken: string = (await Preferences.get({ key: this.localUserKey })).value;
+    return JWToken;
+  }
+
+  async GetBearer(): Promise<string>{
+    return `Bearer ${await this.JWToken()}`
+  }
+
+  public isTokenValid(Token: any): boolean{
+    if(!Token){ return false; }else
+    return !(Utils.UNIXToDate(Token.exp) < new Date())
+  }
+}
+
+class Authentication{
+  public Apelido: string = null;
+  public Senha  : string = null;
+}
+
+class Token {
+  [prop: string]: any;
+  Acesso   : number = 0;
+  Apelido  : string = "";
+  Nome     : string = "";
+  id       : number = 0;
+  idEmpresa: number = 0;
+  
+  constructor(){}
+  
+  patch(token: Token | any): void{
+    for(let prop of Object.getOwnPropertyNames(token)){
+      if(Number((token[prop]))){
+        this[prop] = Number(token[prop]); 
+        continue;
+      }
+      this[prop] = token[prop];
+    }
+  }
+}

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

@@ -0,0 +1,164 @@
+import { Injectable } from '@angular/core';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class CryptoService {
+
+  key: CryptoKey;
+
+  constructor(
+  ) { }
+
+  Initialize(){
+
+  }
+}
+
+
+//[ Array Buffer ]
+
+/**
+ * Converts a string to an ArrayBuffer using UTF-8 encoding
+ * @param str - The string to convert
+ * @returns An ArrayBuffer containing the UTF-8 encoded string
+ */
+function StringToArrayBuffer(str: string): ArrayBuffer {
+  const encoder = new TextEncoder()
+  return encoder.encode(str).buffer as ArrayBuffer
+}
+
+/**
+ * Converts an ArrayBuffer to a string using UTF-8 encoding
+ * @param buffer - The ArrayBuffer to convert
+ * @returns A decoded string
+ */
+function ArrayBufferToString(buffer: ArrayBuffer): string {
+  const decoder = new TextDecoder()
+  return decoder.decode(buffer)
+}
+
+//------------------------------------------------------------
+
+// More compact base64 encoding (URL-safe with no padding)
+
+const iterations: number = 10;
+
+// More compact base64 encoding (URL-safe with no padding)
+function toBase64Url(buffer: ArrayBuffer): string {
+  let binary = ""
+  const bytes = new Uint8Array(buffer)
+  for (let i = 0; i < bytes.byteLength; i++) {
+    binary += String.fromCharCode(bytes[i])
+  }
+  // Standard base64 encoding
+  const base64 = btoa(binary)
+  // Make URL safe and remove padding
+  return base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "")
+}
+
+// Decode the compact base64 encoding
+function fromBase64Url(base64url: string): ArrayBuffer {
+  // Add padding if needed
+  let base64 = base64url
+  if (base64.length % 4 !== 0) {
+    base64 += "=".repeat(4 - (base64.length % 4))
+  }
+  // Convert back to standard base64
+  base64 = base64.replace(/-/g, "+").replace(/_/g, "/")
+
+  const binaryString = atob(base64)
+  const bytes = new Uint8Array(binaryString.length)
+  for (let i = 0; i < binaryString.length; i++) {
+    bytes[i] = binaryString.charCodeAt(i)
+  }
+  return bytes.buffer
+}
+
+async function CreateKey(passwordBuffer: Uint8Array, salt: Uint8Array, iv: Uint8Array){
+  try {
+    // Import the password as a key
+    const importedKey    = await window.crypto.subtle.importKey("raw", passwordBuffer, { name: "PBKDF2" }, false, ["deriveKey",])
+
+    // Derive the actual encryption key
+    const key = await window.crypto.subtle.deriveKey(
+      { name: "PBKDF2", salt, iterations: iterations, hash: "SHA-128" }, 
+      importedKey,
+      { name: "AES-GCM", length: 128 },
+      false,
+      ["encrypt"],
+    )
+
+    // Use the more compact base64url encoding
+    return key;
+
+  } catch (error) {
+    console.error("Encryption error:", error)
+    throw error
+  }
+}
+
+// Encrypt a string with a key
+async function EncryptString(plaintext: string, passwordBuffer: Uint8Array, salt: Uint8Array, iv: Uint8Array): Promise<string> {
+  try {
+    // Import the password as a key
+    const importedKey    = await window.crypto.subtle.importKey("raw", passwordBuffer, { name: "PBKDF2" }, false, ["deriveKey",])
+
+    // Derive the actual encryption key
+    const key = await window.crypto.subtle.deriveKey(
+      { name: "PBKDF2", salt, iterations: iterations, hash: "SHA-256" }, 
+      importedKey,
+      { name: "AES-GCM", length: 256 },
+      false,
+      ["encrypt"],
+    )
+
+    // Encrypt the data
+    const encryptedData = await window.crypto.subtle.encrypt({ name: "AES-GCM", iv }, key, StringToArrayBuffer(plaintext))
+
+    // Use the more compact base64url encoding
+    return toBase64Url(encryptedData)
+  } catch (error) {
+    console.error("Encryption error:", error)
+    throw error
+  }
+}
+
+async function decryptString(encryptedBase64Url: string, password: string, salt: Uint8Array, iv: Uint8Array): Promise<string> {
+  try {
+    // Import the password as a key
+    const passwordBuffer = StringToArrayBuffer(password)
+    const importedKey = await window.crypto.subtle.importKey("raw", passwordBuffer, { name: "PBKDF2" }, false, [
+      "deriveKey",
+    ])
+
+    // Derive the same key using the fixed salt
+    const key = await window.crypto.subtle.deriveKey(
+      {
+        name: "PBKDF2",
+        salt,
+        iterations: iterations,
+        hash: "SHA-256",
+      },
+      importedKey,
+      { name: "AES-GCM", length: 256 },
+      false,
+      ["decrypt"],
+    )
+
+    // Decrypt the data
+    const decryptedData = await window.crypto.subtle.decrypt(
+      {
+        name: "AES-GCM",
+        iv,
+      },
+      key,
+      fromBase64Url(encryptedBase64Url),
+    )
+
+    return ArrayBufferToString(decryptedData)
+  } catch (error) {
+    console.error("Decryption error:", error)
+    throw error
+  }
+}

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

@@ -0,0 +1,17 @@
+import { Inject, Injectable } from "@angular/core";
+import { EnvironmentInjectionToken } from "../core.module";
+import { Environment } from "../classes/environment";
+
+@Injectable({
+    providedIn: 'root'
+})
+export class EnvironmentService {
+    constructor(@Inject(EnvironmentInjectionToken) private config: Environment) {
+        this._environment = this.config;
+    }
+
+    private _environment: Environment
+    get environment(): Environment{
+        return this._environment;
+    }
+}

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

@@ -0,0 +1,85 @@
+import { Injectable } from "@angular/core";
+import { ActivatedRoute } from "@angular/router";
+import { Title } from '@angular/platform-browser';
+import { AlertButton, AlertController, ToastController } from "@ionic/angular";
+
+import { EnvironmentService } from './environment.service';
+
+@Injectable({
+  providedIn: 'root'
+})
+
+export class GenericService{
+  constructor(
+    private toastController: ToastController,
+    private alertController: AlertController,
+    private titleController: Title,
+    private coreService: EnvironmentService,
+  ){}
+
+  public async PresentToast(message: string, icon = 'alert-circle') {
+    const toast = await this.toastController.create({
+      message: message,
+      duration: 1750,
+      icon: icon,
+      position: 'bottom',
+      translucent: false, 
+    });
+
+    await toast.present();
+  }
+  
+  public async PresentToastSuccess(message: string = "Salvo com sucesso!") {
+    const toast = await this.toastController.create({
+      message: message,
+      duration: 1750,
+      icon: 'checkmark-circle',
+      position: 'bottom',
+      translucent: false,
+    });
+
+    await toast.present();
+    return toast.onDidDismiss();
+  }
+
+  public static CancelButton: AlertButton = {
+    text: 'Cancelar',
+    role: 'cancel',
+  }
+  public static ConfirmButton : AlertButton = {
+    text: 'OK',
+    role: 'confirm',
+  }
+  static defaultAlertButtons: AlertButton[] = [GenericService.ConfirmButton];
+
+  public async PresentAlert(header: string, message: string, buttons: AlertButton[] = GenericService.defaultAlertButtons) {
+    const alert = await this.alertController.create({
+      header:  header,
+      message: message,
+      buttons: buttons,
+    });
+    await alert.present();
+    return alert.onDidDismiss();
+  }
+
+  public SetTitle(title: string){
+    this.titleController.setTitle(this.coreService.environment.applicationName + " | " + title)
+  }
+
+  public GetId(activatedRoute: ActivatedRoute, depth: number = 2): number | null{
+    try{
+      var Route = activatedRoute;
+      for(let i = 0; i < depth; i++){
+        Route = Route.parent;
+      }
+      if(Route.snapshot.paramMap.has('id')){
+        return Number(Route.snapshot.paramMap.get('id'));
+      }
+      else{
+        return 0;
+      }
+    }catch{
+      return null;
+    }
+  }
+}

package/src/lib/services/modal-focus-trap.service.ts

@@ -0,0 +1,65 @@
+import { Injectable } from '@angular/core';
+
+/**
+ * Corrige o focus trap em modais do Ionic, permite que o foco não fique preso dentro do modal.
+ * Utilizado para concertar interatividade com popovers e outros elementos que podem ser interativos fora do modal.
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class ModalFocusTrapService {
+  
+  constructor() {
+    this.initGlobalFocusTrapDisable();
+  }
+
+  private initGlobalFocusTrapDisable() {
+    // Wait for the platform to be ready
+    document.addEventListener('DOMContentLoaded', () => {
+      this.setupModalObserver();
+    });
+  }
+
+  private setupModalObserver() {
+    // Create a mutation observer to watch for new modals
+    const observer = new MutationObserver((mutations) => {
+      mutations.forEach((mutation) => {
+        mutation.addedNodes.forEach((node) => {
+          if (node.nodeType === Node.ELEMENT_NODE) {
+            const element = node as Element;
+            
+            // Check if the added node is an ion-modal
+            if (element.tagName?.toLowerCase() === 'ion-modal') {
+              this.disableFocusTrap(element);
+            }
+            
+            // Check for ion-modal children
+            const modals = element.querySelectorAll?.('ion-modal');
+            modals?.forEach(modal => this.disableFocusTrap(modal));
+          }
+        });
+      });
+    });
+
+    // Start observing
+    observer.observe(document.body, {
+      childList: true,
+      subtree: true
+    });
+
+    // Also handle existing modals
+    const existingModals = document.querySelectorAll('ion-modal');
+    existingModals.forEach(modal => this.disableFocusTrap(modal));
+  }
+
+  private disableFocusTrap(modal: Element) {
+    // Add the CSS class
+    modal.classList.add('ion-disable-focus-trap');
+    
+    // Set the property if it exists
+    const modalElement = modal as any;
+    if (modalElement.disableFocusTrap !== undefined) {
+      modalElement.disableFocusTrap = true;
+    }
+  }
+}

package/src/lib/services/navigation-context.service.ts

@@ -0,0 +1,121 @@
+import { Injectable } from '@angular/core';
+import { NavigationEnd, Router } from '@angular/router';
+import { filter } from 'rxjs';
+
+@Injectable({ providedIn: 'root' })
+export class NavigationContextService {
+  private previousUrl: string | null = null;
+  private currentUrl: string | null = null;
+
+  constructor(private router: Router) {
+    this.currentUrl = this.router.url;
+
+    this.router.events.pipe(filter(e => e instanceof NavigationEnd)).subscribe((e: NavigationEnd) => {
+      const nextUrl = e.urlAfterRedirects;
+      const preserve = history.state?.__preserveBack == true;
+    
+      const currentBase = this.currentUrl ? this.getBaseRoute(this.currentUrl) : null;
+      const nextBase    = this.getBaseRoute(nextUrl);
+    
+      const nav = this.router.getCurrentNavigation();
+      const isBack = nav?.trigger == 'popstate';
+    
+      // Redirect técnico - ignora
+      if (preserve) {
+        this.currentUrl = nextUrl;
+        return;
+      }
+    
+      // Navegação interna da mesma view (Ex: Item <-> View Principal)
+      if (currentBase && currentBase == nextBase) {
+        // ajustes no histórico baseando-se estritamente na hierarquia.
+        
+        const cleanNext = nextUrl.split('?')[0].replace(/\/$/, '');
+        const cleanBase = nextBase.replace(/\/$/, '');
+
+        if (cleanNext == cleanBase) {
+          // voltou para a raiz da entidade
+          this.previousUrl = this.getListRoute(nextBase);
+        } else {
+          // voltou de um filho → pai REAL
+          this.previousUrl = this.getParentRoute(nextUrl);
+        }
+
+
+        this.currentUrl = nextUrl;
+        return;
+      }
+    
+      // Chegou numa view base VIA BACK (de outro módulo)
+      if (isBack) {
+        // Se voltou de fora (OS -> Obra), recalcula para garantir
+        const cleanNext = nextUrl.split('?')[0].replace(/\/$/, '');
+        const cleanBase = nextBase.replace(/\/$/, '');
+
+        if (cleanNext === cleanBase) {
+           this.previousUrl = this.getListRoute(nextBase);
+        } else {
+           this.previousUrl = nextBase;
+        }
+
+        this.currentUrl  = nextUrl;
+        return;
+      }
+    
+      // Navegação real (Entrando em um módulo novo ou avançando)
+      this.previousUrl = this.currentUrl;
+      this.currentUrl  = nextUrl;
+    });
+  }
+
+  private getBaseRoute(url: string): string {
+    const parts = url.split('/').filter(Boolean);
+    const base: string[] = [];
+    
+    for (const part of parts) {
+      if (!isNaN(Number(part))) {
+        break;
+      }
+      base.push(part);
+    }
+    return '/' + base.join('/');
+  }
+  
+  private getListRoute(baseRoute: string): string {
+    //verifica se a rota de retorno é a inicial
+    const parts = baseRoute.split('/').filter(Boolean);
+    return '/' + parts[0];
+  }
+
+  private getParentRoute(url: string): string {
+    const clean = url.split('?')[0].replace(/\/$/, '');
+    let parts = clean.split('/').filter(Boolean);
+    // ---- REGRA FROM ----
+    const idx = parts.indexOf('from');
+    if (idx != -1) {
+      // remove o "from" e o parâmetro após ele
+      parts = parts.slice(0, idx);
+      // se o último item for view → remove também
+      if (parts[parts.length - 1] === 'view') {
+        parts.pop();
+      }
+    
+      return '/' + parts.join('/');
+    }
+  
+    // ---- REGRA VIEW ----
+    if (parts.length <= 1) {
+      return '/' + parts.join('/');
+    }
+    if (!isNaN(Number(parts[parts.length - 1]))) {
+      parts.pop();
+    }
+    if (parts[parts.length - 1] === 'view') {
+      parts.pop();
+    }
+    return '/' + parts.join('/');
+  }
+  getBackRoute(): string | null {
+    return this.previousUrl;
+  }
+}

package/src/lib/services/popover-focus-trap.service.ts

@@ -0,0 +1,65 @@
+import { Injectable } from '@angular/core';
+
+/**
+ * Corrige o focus trap em modais do Ionic, permite que o foco não fique preso dentro do popover.
+ * Utilizado para concertar interatividade com popovers e outros elementos que podem ser interativos fora do popover.
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class PopoverFocusTrapService {
+  
+  constructor() {
+    this.initGlobalFocusTrapDisable();
+  }
+
+  private initGlobalFocusTrapDisable() {
+    // Wait for the platform to be ready
+    document.addEventListener('DOMContentLoaded', () => {
+      this.setuppopoverObserver();
+    });
+  }
+
+  private setuppopoverObserver() {
+    // Create a mutation observer to watch for new popovers
+    const observer = new MutationObserver((mutations) => {
+      mutations.forEach((mutation) => {
+        mutation.addedNodes.forEach((node) => {
+          if (node.nodeType === Node.ELEMENT_NODE) {
+            const element = node as Element;
+            
+            // Check if the added node is an ion-popover
+            if (element.tagName?.toLowerCase() === 'ion-popover') {
+              this.disableFocusTrap(element);
+            }
+            
+            // Check for ion-popover children
+            const popovers = element.querySelectorAll?.('ion-popover');
+            popovers?.forEach(popover => this.disableFocusTrap(popover));
+          }
+        });
+      });
+    });
+
+    // Start observing
+    observer.observe(document.body, {
+      childList: true,
+      subtree: true
+    });
+
+    // Also handle existing popovers
+    const existingpopovers = document.querySelectorAll('ion-popover');
+    existingpopovers.forEach(popover => this.disableFocusTrap(popover));
+  }
+
+  private disableFocusTrap(popover: Element) {
+    // Add the CSS class
+    popover.classList.add('ion-disable-focus-trap');
+    
+    // Set the property if it exists
+    const popoverElement = popover as any;
+    if (popoverElement.disableFocusTrap !== undefined) {
+      popoverElement.disableFocusTrap = true;
+    }
+  }
+}

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

@@ -0,0 +1,17 @@
+import { Menu } from "../../components/drawer/menu";
+
+export class RouteCacheService {
+  private cachedData: Menu[] | null = null;
+
+  getCachedData(): Menu[] {
+    return this.cachedData;
+  }
+
+  setCachedData(data: Menu[]): void {
+    this.cachedData = data;
+  }
+
+  isDataCached(): boolean {
+    return this.cachedData != null;
+  }
+}