angular-generate 2.2.1

package/src/other/taf-add-import-to-module/index_spec.js

@@ -0,0 +1,23 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const schematics_1 = require("@angular-devkit/schematics");
+const testing_1 = require("@angular-devkit/schematics/testing");
+const path = require("path");
+const collectionPath = path.join(__dirname, '../collection.json');
+describe('config-add-import-to-module', () => {
+    it('works', () => __awaiter(void 0, void 0, void 0, function* () {
+        const runner = new testing_1.SchematicTestRunner('schematics', collectionPath);
+        const tree = yield runner.runSchematic('config-add-import-to-module', {}, schematics_1.Tree.empty());
+        expect(tree.files).toEqual([]);
+    }));
+});
+//# sourceMappingURL=index_spec.js.map

package/src/other/taf-add-import-to-module/index_spec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index_spec.js","sourceRoot":"","sources":["index_spec.ts"],"names":[],"mappings":";;;;;;;;;;;AAAA,2DAAkD;AAClD,gEAAyE;AACzE,6BAA6B;AAE7B,MAAM,cAAc,GAAG,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,oBAAoB,CAAC,CAAC;AAElE,QAAQ,CAAC,6BAA6B,EAAE,GAAG,EAAE;IAC3C,EAAE,CAAC,OAAO,EAAE,GAAS,EAAE;QACrB,MAAM,MAAM,GAAG,IAAI,6BAAmB,CAAC,YAAY,EAAE,cAAc,CAAC,CAAC;QACrE,MAAM,IAAI,GAAG,MAAM,MAAM,CAAC,YAAY,CAAC,6BAA6B,EAAE,EAAE,EAAE,iBAAI,CAAC,KAAK,EAAE,CAAC,CAAC;QAExF,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;IACjC,CAAC,CAAA,CAAC,CAAC;AACL,CAAC,CAAC,CAAC"}

package/src/service/api/index.d.ts

@@ -0,0 +1,2 @@
+import { Rule } from '@angular-devkit/schematics';
+export declare function api(_options: any): Rule;

package/src/service/api/index.js

@@ -0,0 +1,508 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.api = void 0;
+const strings_1 = require("@angular-devkit/core/src/utils/strings");
+const schematics_1 = require("@angular-devkit/schematics");
+// You don't have to export the function as default. You can also have more than one rule factory
+// per file.
+function api(_options) {
+    let { projectName, Config } = _options;
+    let serviceName = "api";
+    return (tree) => {
+        // Le composant existe dèja
+        let c_path = `/src/app/service/${serviceName}/${serviceName}.service.ts`;
+        let c_path_idb = `/src/app/service/idb/idb.service.ts`;
+        if (tree.exists(c_path) && tree.exists(c_path_idb)) {
+            console.warn(`Le service ${serviceName} && IdbService existe dèja : ${c_path}`);
+            return tree;
+        }
+        // le composant n'existe pas encore
+        return (0, schematics_1.chain)([
+            // création du service
+            (0, schematics_1.externalSchematic)("@schematics/angular", "service", { project: projectName, name: `service/${serviceName}/${serviceName}` }),
+            // modification des fichiers
+            (tree) => {
+                // modifier le fichier TS
+                tree.overwrite(`src/app/service/${serviceName}/${serviceName}.service.ts`, // service/api/api.service.ts
+                get_ts_content(projectName, Config));
+            },
+            // création du service
+            (0, schematics_1.externalSchematic)("@schematics/angular", "service", { project: projectName, name: `service/idb/idb` }),
+            // modification des fichiers
+            (tree) => {
+                // modifier le fichier TS
+                tree.overwrite(`src/app/service/idb/idb.service.ts`, // service/api/api.service.ts
+                get_ts_content_idb(projectName));
+            }
+        ]);
+    };
+}
+exports.api = api;
+function get_ts_content(projectName, Config) {
+    let module = "home";
+    let les_tables = Config.les_modules.find((un_module) => un_module.module == module).les_tables;
+    let items = les_tables.map((une_table) => {
+        return `
+        {
+          text: "${(0, strings_1.classify)(une_table.table)}",
+          path: "/${module}/${une_table.table}",
+          icon: "bi bi-speedometer",
+          privileges: [],
+          items: [],
+          show_on_sidebar: true,
+          les_actions: [
+            { id: "add_${une_table.table}", description: "Ajouter un ${une_table.table}" },
+            { id: "edit_${une_table.table}", description: "Modifier un ${une_table.table}" },
+            { id: "delete_${une_table.table}", description: "Supprimer un ${une_table.table}" },
+            { id: "liste_${une_table.table}", description: "Lister les ${une_table.table}" },
+          ]
+        }
+    `;
+    }).join(",");
+    let api_base_url = Config.config_base_url;
+    return `import { HttpClient, HttpHeaders } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { Router } from '@angular/router';
+import { JwtHelperService } from '@auth0/angular-jwt';
+import { IdbService } from '../idb/idb.service';
+import Swal from 'sweetalert2';
+import { Location } from '@angular/common';
+import moment from 'moment';
+import { lastValueFrom } from 'rxjs';
+
+
+@Injectable({
+  providedIn: 'root'
+})
+export class ApiService {
+  local_storage_prefixe = "${projectName}";
+  api_base_url = "${api_base_url}";
+  menu: any = [];
+  network: any = {
+    token: undefined,
+    status: true,
+    message: "Aucun probléme détecté",
+  }
+  token: any = {
+    token: null,
+    // token_decoded: null,
+    user_connected: null,
+    // is_expired: null,
+    // date_expiration: null
+  }
+
+  current_entreprise: any =JSON.parse(localStorage.getItem("current_entreprise")?? '{}');
+  id_current_entreprise: any = localStorage.getItem("id_current_entreprise") ?? '{}';
+  id_current_privilege: any = localStorage.getItem("id_current_privilege") ?? '{}';
+  user_permissions: any = localStorage.getItem("user_permissions") ?? '[]';
+  loading_current_entreprise = false;
+
+  constructor(private http: HttpClient, private route: Router, private idb: IdbService,public _location: Location) { }
+  // sauvegardes
+  async get_from_local_storage(key: string): Promise<any> {
+    try {
+      let res: any = await this.idb.get_from_indexedDB(key)
+      return res
+    } catch (error) {
+      console.error("erreur de recuperation", error)
+      return null
+    }
+  }
+  async save_on_local_storage(key: string, value: any): Promise<void> {
+    await this.idb.save_on_indexedDB(key, value);
+  }
+  async delete_from_local_storage(key: string) {
+    await this.idb.delete_from_indexedDB(key);
+  }
+
+
+  async get_token() {
+    // //le token n'est pas encore chargé
+    // if (this.network.token == undefined) {
+    //   this.network.token = await this.get_from_local_storage("token").token
+    //   if (this.network.token != undefined && this.network.token != null) {// token existant
+    //     this.update_data_from_token()// mise a jour du token
+    //   }
+    // } else {// token dèja chargé
+    //   this.update_data_from_token()// mise a jour du token
+    // }
+    // console.warn((await this.get_from_local_storage("token")).token)
+       if (this.token.token == null) {
+      this.update_data_from_token();
+    }
+    return (await this.get_from_local_storage("token"))?.token
+  }
+  async get_token_profil() {
+    return (await this.get_from_local_storage("token"))?.data
+  }
+  
+  // Les routes HTTP 
+  async api_post(path: string, data_to_send: any): Promise<any> {
+    let api_url = this.api_base_url + path;
+    const httpOptions = {
+      headers: new HttpHeaders({
+        Authorization: "Bearer " + await this.get_token(),
+      })
+    };
+    try {
+      return await lastValueFrom(this.http.post(api_url, data_to_send, httpOptions));
+    } catch (error: any) {
+      this.on_api_post_error(error);
+      throw error;
+    }
+  }
+
+  on_api_get_error(error: any) {
+    this.network.status = false;
+    this.network.message = error;
+    this.Swal_info("Merci de vérifier votre connexion");
+  }
+
+  async api_get(path: string): Promise<any> {
+    let api_url = this.api_base_url + path;
+    const httpOptions = {
+      headers: new HttpHeaders({
+        Authorization: "Bearer " + await this.get_token(),
+      })
+    };
+    try {
+      return await lastValueFrom(this.http.get(api_url, httpOptions));
+    } catch (error: any) {
+      this.on_api_get_error(error);
+      throw error;
+    }
+  }
+
+  async api_delete(path: string): Promise<any> {
+    let api_url = this.api_base_url + path;
+    const httpOptions = {
+      headers: new HttpHeaders({
+        Authorization: "Bearer " + await this.get_token(),
+      })
+    };
+    try {
+      return await lastValueFrom(this.http.delete(api_url, httpOptions));
+    } catch (error: any) {
+      this.on_api_get_error(error);
+      throw error;
+    }
+  }
+
+  async api_put(path: string, data_to_send: any): Promise<any> {
+    let api_url = this.api_base_url + path;
+    const httpOptions = {
+      headers: new HttpHeaders({
+        Authorization: "Bearer " + await this.get_token(),
+      })
+    };
+    try {
+      return await lastValueFrom(this.http.put(api_url, data_to_send, httpOptions));
+    } catch (error: any) {
+      this.on_api_post_error(error);
+      throw error;
+    }
+  }
+
+  async api_post_login(path: string, data_to_send: any): Promise<any> {
+    let api_url = this.api_base_url + path;
+    try {
+      return await lastValueFrom(this.http.post(api_url, data_to_send));
+    } catch (error: any) {
+      this.on_api_post_error(error);
+      throw error;
+    }
+  }
+
+  on_api_post_error(error: any) {
+    this.network.status = false;
+    this.network.message = error;
+    this.Swal_info("Merci de vérifier votre connexion");
+  }
+
+
+  async update_data_from_token() {
+    let token_key = (await this.get_from_local_storage("token"))
+    // const helper = new JwtHelperService();
+    // const decodedToken = helper.decodeToken(token_key);
+    // const expirationDate = helper.getTokenExpirationDate(token_key);
+    // const isExpired = helper.isTokenExpired(token_key);
+
+    this.token = {
+      token: token_key?.token,
+      // token_decoded: decodedToken,
+      user_connected: token_key?.data,
+      // is_expired: isExpired,
+      // date_expiration: expirationDate
+    }
+    if (this.token?.is_expired) {
+      this.on_token_expire()
+    }
+  }
+  on_token_expire() {
+    this.Swal_info("Votre session s'est expiré! Veuillez vous connecter à nouveau")
+    this.delete_from_local_storage("token")
+    this.route.navigate(['/public/login'])
+  }
+
+  Swal_success(title: any) {
+    let succes = Swal.fire({
+      position: 'top-end',
+      icon: 'success',
+      title: title,
+      showConfirmButton: false,
+      timer: 1000,
+      toast: true,
+      timerProgressBar: true,
+    });
+    return succes
+  }
+
+  Swal_error(title: any) {
+    let succes = Swal.fire({
+      position: 'top-end',
+      icon: 'error',
+      title: title,
+      showConfirmButton: false,
+      timer: 1500,
+      toast: true,
+      timerProgressBar: true,
+    });
+    return succes
+  }
+  Swal_info(title: any) {
+    let succes = Swal.fire({
+      position: 'top-end',
+      icon: 'info',
+      title: title,
+      showConfirmButton: false,
+      timer: 1500,
+      toast: true,
+      timerProgressBar: true,
+    });
+    return succes
+  }
+  Swal_blue(title: any) {
+    let succes = Swal.fire({
+      position: 'top-end',
+      icon: 'info',
+      title: title,
+      showConfirmButton: false,
+      timer: 1500,
+      toast: true,
+      timerProgressBar: true,
+    });
+    return succes
+  }
+  is_already_selected(id: any, form: any, condition: string) {//la fonction désactive les options déja sélectionné dans le select
+    let is_in=form.filter((one_detail: any) => one_detail[condition] == id)[0]?.[condition];
+    return is_in;
+  }
+
+  format_date(date_string: string) {
+    return {
+      full: moment(date_string).locale("fr").format("dddd Do MMMM YYYY"),// 27 février 2023
+      jma: moment(date_string).locale("fr").format("Do MMMM YYYY"),// jeudi ...
+      jma2: moment(date_string).locale("fr").format("DD-MM-YYYY"),// 01-11-2023
+      jma3: moment(date_string).locale("fr").format("YYYY-MM-DD"),// 2023-10-21
+      jma3_hour: moment(date_string).locale("fr").format("YYYY-MM-DD HH:mm"),// 2023-10-21 14:50
+      full_datetime: moment(date_string).locale("fr").format("dddd Do MMMM YYYY à HH:mm"),// 27 février 2023
+    }
+  }
+  format_current_date() {
+    return {
+      full: moment().locale("fr").format("dddd Do MMMM YYYY"),// 27 février 2023
+      jma: moment().locale("fr").format("Do MMMM YYYY"),// jeudi ...
+      jma2: moment().locale("fr").format("DD-MM-YYYY"),// 01-11-2023
+      jma3: moment().locale("fr").format("YYYY-MM-DD"),// 2023-10-21
+      jma3_hour: moment().locale("fr").format("YYYY-MM-DD HH:mm"),// 2023-10-21 14:50
+      full_datetime: moment().locale("fr").format("dddd Do MMMM YYYY à HH:mm"),// 27 février 2023
+    }
+  }
+
+    les_droits: any = {
+    // Gestion de la parti commerciale
+    "produit.add": [1, 5, 6, 8],
+    "produit.edit": [1, 5, 6, 8],
+  };
+
+  full_menu: any[] = [
+    {
+      menu_header: "Projet",
+      items: [${items}]
+    },];
+
+      can(action: string) {
+    // Vérifie d’abord qu’on a bien les permissions chargées
+    if (!this.user_permissions || !Array.isArray(this.user_permissions)) {
+      return false;
+    }
+
+    // On vérifie si l’action existe dans le tableau des permissions
+    return this.user_permissions.some((perm: any) => perm.id === action);
+  }
+
+custom_menu() {
+    if (!this.user_permissions || !Array.isArray(this.user_permissions)) {
+      this.user_permissions = JSON.parse(localStorage.getItem("user_permissions") ?? '[]');
+    }
+    // Liste des IDs d’actions autorisées (ex: ["add_Vente", "edit_produit"])
+    const permission_ids = this.user_permissions.map((p: any) => p.id);
+
+    this.menu = this.full_menu
+      .map((section: any) => {
+        const new_section = { ...section };
+
+        // Ne garde que les items avec au moins une action autorisée
+        new_section.items = section.items.filter((item: any) => {
+          if (!item.les_actions || item.les_actions.length === 0) return false;
+
+          // Vérifie si au moins une action de l’item est dans les permissions
+          return item.les_actions.some((act: any) =>
+            permission_ids.includes(act.id)
+          );
+        });
+
+        return new_section;
+      })
+      // Supprime les sections vides
+      .filter((section: any) => section.items.length > 0);
+
+    console.log('MENU Adapté aux privileges:', this.menu);
+  }
+
+    retour() {
+    this._location.back()
+  }
+
+    formatNumber(value: any): string {
+    if (!value || isNaN(Number(value))) {
+      return value; // Retourne la valeur telle quelle si elle est null, vide ou non numérique
+    }
+    return Number(value).toLocaleString('fr-FR'); // Utilise Number.toLocaleString pour formater le nombre
+  }
+
+}`;
+}
+function get_ts_content_idb(projectName) {
+    return `import { Injectable } from '@angular/core';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class IdbService {
+    private dbName = '${projectName}';
+    private storeName = 'db';
+    private local_storage_prefixe = 'jt_';
+  
+    constructor() {
+      this.initDB();
+    }
+  
+    // Initialiser IndexedDB
+    private initDB(): void {
+      const request = indexedDB.open(this.dbName, 1);
+  
+      request.onupgradeneeded = (event: any) => {
+        const db = event.target.result;
+  
+        // Crée une object store s'il n'existe pas déjà
+        if (!db.objectStoreNames.contains(this.storeName)) {
+          db.createObjectStore(this.storeName, { keyPath: 'key' });
+        }
+      };
+  
+      request.onerror = (event) => {
+        console.error('Erreur lors de l’ouverture d’IndexedDB :', event);
+      };
+  
+      request.onsuccess = (event) => {
+        console.log('IndexedDB initialisé avec succès');
+      };
+    }
+  
+    // Récupérer une valeur par clé
+    async get_from_indexedDB(key: string): Promise<any> {
+      return new Promise((resolve, reject) => {
+        const prefixedKey = this.local_storage_prefixe + key;
+        const request = indexedDB.open(this.dbName);
+  
+        request.onsuccess = (event: any) => {
+          const db = event.target.result;
+          const transaction = db.transaction(this.storeName, 'readonly');
+          const store = transaction.objectStore(this.storeName);
+  
+          const getRequest = store.get(prefixedKey);
+          getRequest.onsuccess = () => {
+            resolve(getRequest.result ? getRequest.result.value : null);
+          };
+          getRequest.onerror = () => {
+            console.error('Erreur de récupération depuis IndexedDB');
+            reject(getRequest.error);
+          };
+        };
+  
+        request.onerror = () => {
+          console.error('Erreur d’accès à IndexedDB');
+          reject(request.error);
+        };
+      });
+    }
+  
+    // Sauvegarder une valeur
+    async save_on_indexedDB(key: string, value: any): Promise<void> {
+      return new Promise((resolve, reject) => {
+        const prefixedKey = this.local_storage_prefixe + key;
+        const request = indexedDB.open(this.dbName);
+  
+        request.onsuccess = (event: any) => {
+          const db = event.target.result;
+          const transaction = db.transaction(this.storeName, 'readwrite');
+          const store = transaction.objectStore(this.storeName);
+  
+          const putRequest = store.put({ key: prefixedKey, value });
+          putRequest.onsuccess = () => {
+            resolve();
+          };
+          putRequest.onerror = () => {
+            console.error('Erreur lors de la sauvegarde dans IndexedDB');
+            reject(putRequest.error);
+          };
+        };
+  
+        request.onerror = () => {
+          console.error('Erreur d’accès à IndexedDB');
+          reject(request.error);
+        };
+      });
+    }
+  
+    // Supprimer une valeur par clé
+    async delete_from_indexedDB(key: string): Promise<void> {
+      return new Promise((resolve, reject) => {
+        const prefixedKey = this.local_storage_prefixe + key;
+        const request = indexedDB.open(this.dbName);
+  
+        request.onsuccess = (event: any) => {
+          const db = event.target.result;
+          const transaction = db.transaction(this.storeName, 'readwrite');
+          const store = transaction.objectStore(this.storeName);
+  
+          const deleteRequest = store.delete(prefixedKey);
+          deleteRequest.onsuccess = () => {
+            resolve();
+          };
+          deleteRequest.onerror = () => {
+            console.error('Erreur lors de la suppression dans IndexedDB');
+            reject(deleteRequest.error);
+          };
+        };
+  
+        request.onerror = () => {
+          console.error('Erreur d’accès à IndexedDB');
+          reject(request.error);
+        };
+      });
+    }
+  }`;
+}
+//# sourceMappingURL=index.js.map

package/src/service/api/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"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"}

package/src/service/api/index_spec.d.ts

@@ -0,0 +1 @@
+export {};

package/src/service/api/index_spec.js

@@ -0,0 +1,23 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const schematics_1 = require("@angular-devkit/schematics");
+const testing_1 = require("@angular-devkit/schematics/testing");
+const path = require("path");
+const collectionPath = path.join(__dirname, '../collection.json');
+describe('service/api', () => {
+    it('works', () => __awaiter(void 0, void 0, void 0, function* () {
+        const runner = new testing_1.SchematicTestRunner('schematics', collectionPath);
+        const tree = yield runner.runSchematic('service/api', {}, schematics_1.Tree.empty());
+        expect(tree.files).toEqual([]);
+    }));
+});
+//# sourceMappingURL=index_spec.js.map

package/src/service/api/index_spec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index_spec.js","sourceRoot":"","sources":["index_spec.ts"],"names":[],"mappings":";;;;;;;;;;;AAAA,2DAAkD;AAClD,gEAAyE;AACzE,6BAA6B;AAE7B,MAAM,cAAc,GAAG,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,oBAAoB,CAAC,CAAC;AAElE,QAAQ,CAAC,aAAa,EAAE,GAAG,EAAE;IAC3B,EAAE,CAAC,OAAO,EAAE,GAAS,EAAE;QACrB,MAAM,MAAM,GAAG,IAAI,6BAAmB,CAAC,YAAY,EAAE,cAAc,CAAC,CAAC;QACrE,MAAM,IAAI,GAAG,MAAM,MAAM,CAAC,YAAY,CAAC,aAAa,EAAE,EAAE,EAAE,iBAAI,CAAC,KAAK,EAAE,CAAC,CAAC;QAExE,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;IACjC,CAAC,CAAA,CAAC,CAAC;AACL,CAAC,CAAC,CAAC"}

package/src/templates/add/add.html.d.ts

@@ -0,0 +1 @@
+export declare function get_html_content(table: any): string;