@sapphire-ion/framework 1.2.41 → 1.2.43

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/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;
+  }
+}

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;
+  };
+}