@communecter/cocolight-api-client 1.0.8 → 1.0.10

package/src/api/User.js

@@ -1,66 +1,128 @@
-import { ApiResponseError } from "../error.js";
-import { EntityMixin } from "./EntityMixin.js";
-import { NewsMixin } from "./NewsMixin.js";
-import { UserMixin } from "./UserMixin.js";
-import { UtilMixin } from "./UtilMixin.js";
+import { ApiError, ApiResponseError } from "../error.js";
+import { DraftStateMixin } from "../mixin/DraftStateMixin.js";
+import { MutualEntityMixin } from "../mixin/MutualEntityMixin.js";
+import { UserMixin } from "../mixin/UserMixin.js";
+import { UtilMixin } from "../mixin/UtilMixin.js";
 
 // User.js
 export class User {
-  // Champs privés pour protéger l'état
-  #id;
-  #slug;
-  #data;
+  #draftData = {};
+  #initialDraftData = {};
+  #serverData = null;
+
+  static entityType = "citoyens";
+
+  static SCHEMA_CONSTANTS = [
+    "UPDATE_BLOCK_DESCRIPTION",
+    "UPDATE_BLOCK_INFO",
+    "UPDATE_BLOCK_SOCIAL",
+    "UPDATE_BLOCK_LOCALITY",
+    "UPDATE_BLOCK_SLUG",
+    "PROFIL_IMAGE"
+  ];
+
+  static UPDATE_BLOCKS = new Map([
+    ["UPDATE_BLOCK_DESCRIPTION", "updateDescription"],
+    ["UPDATE_BLOCK_SOCIAL", "updateSocial"],
+    ["UPDATE_BLOCK_LOCALITY", "updateLocality"],
+    ["UPDATE_BLOCK_INFO", "updateInfo"],
+    ["UPDATE_BLOCK_SLUG", "updateSlug"],
+    ["PROFIL_IMAGE", "updateImageProfil"]
+  ]);
 
   /**
    * Crée une instance de User.
-   * @param {ApiClient} apiClient - L'instance d'ApiClient.
-   * @param {Object} identifier - Objet contenant { id } ou { slug }.
-   * @param {Object} [data={}] - Données supplémentaires.
+   *
+   * @param {ApiClient} apiClient - Le client API connecté.
+   * @param {Object} data - Données initiales (peuvent inclure `id`, `slug`, etc.).
+   * @param {string} [data.id] - ID de l'utilisateur.
+   * @param {string} [data.slug] - Slug de l'utilisateur.
+   * @param {Object} deps - Dépendances injectées.
+   * @param {function|object} deps.EndpointApi - Classe ou instance de EndpointApi.
+   * @param {function} deps.Organization - Classe Organization.
+   * @param {function} deps.Project - Classe Project.
+   * @param {function} deps.News - Classe News.
+   *
+   * @throws {ApiError} - Si des dépendances nécessaires sont manquantes ou invalides.
    */
 
-  constructor(apiClient, { id, slug } = {}, data = {}) {
-    if (!id && !slug) {
-      throw new Error("Vous devez fournir un id ou un slug pour créer un User.");
+  constructor(apiClient, data = {}, deps = {}) {
+    this.__entityTag = "User";
+
+    if(!deps.EndpointApi){
+      throw new ApiError("EndpointApi class must be injected to avoid circular dependency.");
     }
+    if (!data?.id && !data?.slug) {
+      throw new ApiError("Vous devez fournir un id ou un slug pour créer un User.");
+    }
+
+    if (!deps.Organization) throw new ApiError("Organization class must be injected.");
+    if (!deps.Project) throw new ApiError("Project class must be injected.");
+    if (!deps.News) throw new ApiError("News class must be injected.");
+
     this.apiClient = apiClient;
-    this.#id = id || null;
-    this.#slug = slug || null;
-    this.#data = data;
+
+    this.deps = deps;
+
+    // Gérer les deux cas : fonction constructeur ou instance
+    if (typeof deps.EndpointApi === "function") {
+      this.endpointApi = new deps.EndpointApi(this.apiClient);
+    } else if (typeof deps.EndpointApi === "object") {
+      this.endpointApi = deps.EndpointApi;
+    } else {
+      throw new ApiError("deps.EndpointApi doit être une classe ou une instance valide.");
+    }
+
+    this.#serverData = null;
+    
+    const { draft, proxy } = this.buildDraftAndProxy({
+      data: { ...data, ...this.defaultFields },
+      serverData: this.#serverData,
+      constant: User.SCHEMA_CONSTANTS,
+      apiClient: this.apiClient,
+      transforms: this.transforms,
+      removeFields: this.removeFields
+    });
+    
+    this.#initialDraftData = JSON.parse(JSON.stringify(draft)); // snapshot propre
+    this.#draftData = draft;
+    this.data = proxy;
   }
-  
-  // Getters en lecture seule pour chaque propriété
+
   get id() {
-    return this.#id;
+    return this.#draftData.id || null;
   }
 
   _id(newId) {
-    this.#id = newId;
+    this.#draftData.id = newId;
   }
-  
+      
   get slug() {
-    return this.#slug;
-  }
-
-  _slug(newSlug) {
-    this.#slug = newSlug;
+    return this.#draftData.slug || null;
   }
   
   get isConnected() {
     return this.apiClient.isConnected;
   }
 
-  // Getter pour accéder aux données
-  get data() {
-    return this.#data;
-  }
-
-  // Méthode interne qui permet de mettre à jour les données
   _setData(newData) {
-    this.#data = newData;
+    this.#serverData = { ...newData };
+
+    const { draft, proxy } = this.buildDraftAndProxy({
+      data: { ...newData, ...this.defaultFields },
+      serverData: this.#serverData,
+      constant: User.SCHEMA_CONSTANTS,
+      apiClient: this.apiClient,
+      transforms: this.transforms,
+      removeFields: this.removeFields
+    });
+    this.#initialDraftData = JSON.parse(JSON.stringify(draft));
+    this.#draftData = draft;
+    this.data = proxy;
   }
 
   getEntityType() {
-    return "citoyens";
+    return User.entityType;
   }
 
   get userId() {
@@ -71,6 +133,23 @@ export class User {
     return this.isConnected && this.userId === this.id;
   }
 
+  get draftData() {
+    return this.#draftData;
+  }
+
+  get initialDraftData() {
+    return this.#initialDraftData;
+  }
+  
+  get serverData() {
+    return this.#serverData;
+  }
+
+  async refresh() {
+    if (!this.id) throw new ApiError("Impossible de rafraîchir sans ID.");
+    return this.get();
+  }
+
   /**
      * Récupère le profil complet de l'utilisateur.
      * Si l'utilisateur est connecté, on appelle le endpoint ME_INFO_URL,
@@ -78,13 +157,15 @@ export class User {
      *
      * @returns {Promise<Object>} Le profil complet.
      */
-  async getProfil() {
+  async get() {
     return this.apiClient.safeCall(async () => {
       if (this.isMe) {
-        const data = await this._meInfoUrl();
+        const data = await this.endpointApi.meInfoUrl();
+        this._setData(data);
         return data;
       } else {
         const data = await this.getPublicProfile();
+        this._setData(data);
         return data;
       }
     });
@@ -95,7 +176,7 @@ export class User {
    * Constant : CHANGE_PASSWORD
    */
   async changePassword(data = {}) {
-    return this.callIsMe(() => this._changePassword(data));
+    return this.callIsMe(() => this.endpointApi.changePassword(data));
   }
 
   /**
@@ -103,15 +184,77 @@ export class User {
    * Constant : DELETE_ACCOUNT
    */
   async delete(data = {}) {
-    return this.callIsMe(() => this._deleteAccount(data));
+    return this.callIsMe(() => this.endpointApi.deleteAccount(data));
   }
   
+  /**
+   * Sauvegarde les modifications de l'utilisateur en appelant les endpoints correspondants.
+   * Seul l'utilisateur connecté peut se modifier lui-même.
+   *
+   * @returns {Promise<Object>} - Données serveur mises à jour si applicable.
+   * @throws {ApiError} - Si l'utilisateur n'est pas autorisé.
+   */
+  async save() {
+
+    if(!this.isMe){
+      throw new ApiError("Vous devez être connecté et être l'utilisateur pour sauvegarder.");
+    }
+
+    const payload = { ...this.#draftData };
+  
+    if (this.id) {
+      const hasChanged = await this._update(payload);
+      if (hasChanged) {
+        // this._updateInitialDraftSnapshot();
+        await this.refresh();
+      }
+      return this.#serverData;
+    }
+  
+  }
+
+  /**
+   * Met à jour les blocs modifiés de l'utilisateur via les constantes de schéma définies.
+   *
+   * @param {Object} payload - Données courantes à comparer et envoyer.
+   * @returns {Promise<boolean>} - Indique s'il y a eu une modification réelle.
+   */
+  async _update(payload){
+    if(payload.id){
+      delete payload.id;
+    }
+
+    let hasChanged = false;
+
+    // Sinon, on fait les updates en blocs
+    for (const [constant, methodName] of User.UPDATE_BLOCKS) {
+      const blockData = this.extractChangedFieldsFromSchema(
+        this.apiClient,
+        constant,
+        { ...payload, ...this.defaultFields},
+        () => this.initialDraftData,
+        this.removeFields
+      );
+      if (blockData && Object.keys(blockData).length > 0) {
+        await this[methodName](blockData);
+        hasChanged = true;
+      }
+    }
+  
+    return hasChanged;
+  }
+
   /**
    * Mettre à jour les paramètres utilisateur : Mise à jour des paramètres spécifiques d'un utilisateur.
    * Constant : UPDATE_SETTINGS
+   * @param {Object} data - Données à mettre à jour.
+   * @param {"birthDate"|"email"|"locality"|"phone"|"directory"} data.type - Type de paramètre à mettre à jour.
+   * @param {"private"|"public"|"mask"} data.value - Nouvelle valeur du paramètre.
+   * @returns {Promise<void>} - Résultat de la mise à jour.
    */
   async updateSettings(data = {}) {
-    return this.callIsMe(() => this._updateSettings(data));
+    await this.callIsMe(() => this.endpointApi.updateSettings(data));
+    await this.refresh();
   }
 
   /**
@@ -119,7 +262,7 @@ export class User {
    * Constant : UPDATE_BLOCK_DESCRIPTION
    */
   async updateDescription(data = {}) {
-    return this.callIsMe(() => this._updateBlockDescription(data));
+    return this.callIsMe(() => this.endpointApi.updateBlockDescription(data));
   }
   
   /**
@@ -127,7 +270,7 @@ export class User {
      * Constant : UPDATE_BLOCK_INFO
      */
   async updateInfo(data = {}) {
-    return this.callIsMe(() => this._updateBlockInfo(data));
+    return this.callIsMe(() => this.endpointApi.updateBlockInfo(data));
   }
   
   /**
@@ -135,7 +278,7 @@ export class User {
      * Constant : UPDATE_BLOCK_SOCIAL
      */
   async updateSocial(data = {}) {
-    return this.callIsMe(() => this._updateBlockSocial(data));
+    return this.callIsMe(() => this.endpointApi.updateBlockSocial(data));
   }
   
   /**
@@ -143,36 +286,166 @@ export class User {
      * Constant : UPDATE_BLOCK_LOCALITY
      */
   async updateLocality(data = {}) {
-    return this.callIsMe(() => this._updateBlockLocality(data));
+    return this.callIsMe(() => this.endpointApi.updateBlockLocality(data));
   }
   
   /**
      * Mettre à jour le slug d'un élément : Permet de mettre à jour le slug pour une URL simplifiée.
      * Constant : UPDATE_BLOCK_SLUG
      */
-  async updateSlug(slug) {
+  async updateSlug({ slug }) {
     try {
-      await this._check({ slug });
+      await this.endpointApi.check({ slug });
     } catch (error) {
       if(error instanceof ApiResponseError) {
         throw new ApiResponseError("Erreur lors de la vérification du slug.", error.status, error.data);
       }
       throw error;
     }
-    return this.callIsMe(() => this._updateBlockSlug({ slug }));
+    return this.callIsMe(() => this.endpointApi.updateBlockSlug({ slug }));
   }
 
   /**
    * Mettre à jour l'image de profil : Permet de mettre à jour l'image de profil d'un utilisateur ou d'une entité.
    * Constant : PROFIL_IMAGE
    */
-  async updateImageProfil(image) {
+  async updateImageProfil({ profil_avatar: image  }) {
     image = await this.validateImage(image);
-    return this.callIsMe(() => this._profilImage({ profil_avatar: image }));
+    return this.callIsMe(() => this.endpointApi.profilImage({ profil_avatar: image }));
+  }
+  
+  /**
+   * Récupérer les organisations d'un utilisateur : Récupère la liste des organisations auxquelles l'utilisateur appartient.
+   * Constant : GET_ORGANIZATIONS_ADMIN | GET_ORGANIZATIONS_NO_ADMIN
+   */
+  async getOrganizations(data = {}) {
+    delete data?.pathParams;
+  
+    const fetchFn = this.isMe
+      ? () => this.callIsMe(() => this.endpointApi.getOrganizationsAdmin(data))
+      : () => this.endpointApi.getOrganizationsNoAdmin(data);
+  
+    if (!this.isMe && !data.filters) {
+      data.filters = {
+        [`links.members.${this.id}`]: { "$exists": true },
+        [`links.members.${this.id}.toBeValidated`]: { "$exists": false },
+        [`links.members.${this.id}.isInviting`]: { "$exists": false }
+      };
+    }
+  
+    const arrayObjetOrganizations = await fetchFn();
+  
+    if (!Array.isArray(arrayObjetOrganizations.results)) {
+      throw new ApiResponseError("Erreur lors de la récupération des organisations.", 500, arrayObjetOrganizations.results);
+    }
+  
+    // nettoyage du count
+    delete arrayObjetOrganizations?.count?.spam;
+  
+    // calcul du total
+    const totalCount = Object.values(arrayObjetOrganizations.count || {}).reduce((acc, val) => acc + val, 0);
+    arrayObjetOrganizations.count.total = totalCount;
+  
+    // transformation des résultats
+    const rawOrganizationsList = arrayObjetOrganizations.results.map((orgData) =>
+      this.deps.Organization.fromServerData(orgData, this, {
+        User,
+        Project: this.deps.Project,
+        News: this.deps.News,
+        EndpointApi: this.deps.EndpointApi
+      })
+    );
+  
+    return {
+      count: arrayObjetOrganizations.count,
+      results: rawOrganizationsList
+    };
+  }
+  
+  /**
+   * Crée une instance d'organisation et récupère son profil si nécessaire.
+   *
+   * @param {Object} organizationData - Les données nécessaires pour initialiser l'organisation.
+   * @returns {Promise<Organization>} Une promesse qui résout l'objet Organisation créé.
+   * @throws {Error} Si une erreur se produit lors de la création de l'organisation.
+   */
+  async organization(organizationData = {}, ) {
+    try {
+      const organization = new this.deps.Organization(this, organizationData, { User, Project: this.deps.Project, News: this.deps.News, EndpointApi : this.deps.EndpointApi });
+      if (organizationData.id || organizationData.slug) {
+        await organization.get();
+      }
+      return organization;
+    } catch (error) {
+      this.apiClient._logger.error(`[Api.${this.__entityTag}.organization] Erreur lors de la création d'une instance organization :`, error.message);
+      throw error;
+    }
+  }
+
+  /**
+   * Récupérer les projets d'un utilisateur : Récupère la liste des projets auxquels l'utilisateur contribue.
+   * Constant : GET_PROJECTS_ADMIN | GET_PROJECTS_NO_ADMIN
+   */
+  async getProjects(data = {}) {
+    delete data?.pathParams;
+  
+    const fetchFn = this.isMe
+      ? () => this.callIsMe(() => this.endpointApi.getProjectsAdmin(data))
+      : () => this.endpointApi.getProjectsNoAdmin(data);
+  
+    if (!this.isMe && !data.filters) {
+      data.filters = {
+        "$or": {
+          [`links.contributors.${this.id}`]: { "$exists": true },
+          [`parent.${this.id}`]: { "$exists": true }
+        },
+        [`links.contributors.${this.id}`]: { "$exists": true }
+        // TODO : revoir les filtres pour harmoniser avec orga (schema pris de cocolight)
+      };
+    }
+  
+    const arrayObjetProjects = await fetchFn();
+  
+    if (!Array.isArray(arrayObjetProjects.results)) {
+      throw new ApiResponseError("Erreur lors de la récupération des projets.", 500, arrayObjetProjects.results);
+    }
+  
+    const rawProjectsList = arrayObjetProjects.results.map((projectData) =>
+      this.deps.Project.fromServerData(projectData, this, {
+        User,
+        News: this.deps.News,
+        EndpointApi: this.deps.EndpointApi
+      })
+    );
+  
+    return {
+      count: arrayObjetProjects?.count?.projects ?? 0,
+      results: rawProjectsList
+    };
+  }
+  
+  /**
+   * Crée une instance de projet et récupère son profil si nécessaire.
+   *
+   * @param {Object} projectData - Les données nécessaires pour initialiser le projet.
+   * @returns {Promise<Project>} Une promesse qui résout l'objet Projet créé.
+   * @throws {Error} Si une erreur se produit lors de la création du projet.
+   */
+  async project(projectData = {}, ) {
+    try {
+      const project = new this.deps.Project(this, projectData, { User, News: this.deps.News, EndpointApi : this.deps.EndpointApi });
+      if (projectData.id || projectData.slug) {
+        await project.get();
+      }
+      return project;
+    } catch (error) {
+      this.apiClient._logger.error(`[Api.${this.__entityTag}.project] Erreur lors de la création d'une instance project :`, error.message);
+      throw error;
+    }
   }
 
   /**
-   * Récupérer les actualités : Récupère la liste d’actualités selon plusieurs critères.
+   * Récupérer les actualités : Récupère la liste des actualités liées à l'utilisateur.
    * Constant : GET_NEWS
    */
   async getNews(data = {}) {
@@ -183,44 +456,81 @@ export class User {
       // is not me add id
       data.pathParams = { id: this.id };
     }
-    return this._getNews(data);
-  }
-
-  /**
-   * Ajouter une actualité : Ajoute une nouvelle actualité.
-   * Constant : ADD_NEWS
-   * @param {Object} data - Les données à envoyer.
-   * @param {string} data.text - Contenu de l’actualité
-   * @param {string} data.scope - Portée de l'actualité (ex: public, privé...) (default: "public")
-   * @param {boolean} data.markdownActive - Markdown activé (true/false) (default: true)
-   * @param {string} data.type - Type de l'objet, toujours 'news'. (default: "news")
-   * @param {boolean} data.json - Indique que la réponse est au format JSON. (default: true)
-   * @param {array | string} data.tags - Tags : "" pour effacer tous les tags, ou tableau de mots-clés.
-   * @param {object} data.mediaImg - Optionnel. Informations sur les images associées à la news.
-   * @param {number} data.mediaImg.countImages - Nombre d'images.
-   * @param {Array<string>} data.mediaImg.images - Liste des identifiants ou chemins d'images.
-   * @param {object} data.mediaFile - Optionnel. Informations sur les fichiers associés à la news.
-   * @param {number} data.mediaFile.countFiles - Nombre de fichiers.
-   * @param {Array<string>} data.mediaFile.files - Liste des identifiants ou chemins de fichiers.
-   * @param {object} data.mentions - Liste des mentions sous forme d'objet avec des clés dynamiques représentant l'indice de la mention.
-   * @param {Object.<string, object>} data.mentions - Objet dont les clés keys matching ^[0-9]+$
-   * @returns {Promise<Object>} - Les données de réponse.
-   * @throws {ApiResponseError} - En cas d'erreur détectée dans la réponse.
-   * @throws {ApiAuthenticationError} - En cas d'erreur d'authentification.
-   * @throws {Error} - En cas d'erreur inattendue.
-   */
-  async addNews(data = {}) {
-    if (data.parentId) {
-      delete data.parentId;
-    }
-    if (data.parentType) {
-      delete data.parentType;
-    }
-    return this.callIsMe(() => this._addNews(data));
+    const arrayObjetNews =  await this.endpointApi.getNews(data);
+    if(!Array.isArray(arrayObjetNews)){
+      throw new ApiResponseError("Erreur lors de la récupération des actualités.", 500, arrayObjetNews);
+    }
+    const rawNewsList = arrayObjetNews.map((newsData) =>
+      this.deps.News.fromServerData(newsData, this, { User, EndpointApi: this.deps.EndpointApi })
+    );
+
+    return this._createFilteredProxy(rawNewsList);
   }
-    
+
+  /**
+   * Crée une instance de news et la récupère si nécessaire.
+   * 
+   * @param {Object} newsData - Les données nécessaires pour initialiser la news.
+   * @returns {Promise<News>} Une promesse qui résout l'objet News créé.
+   * @throws {Error} Si une erreur se produit lors de la création de la news.
+   */
+  async news(newsData = {}, ) {
+    try {
+      const news = new this.deps.News(this, newsData, { User, EndpointApi : this.deps.EndpointApi });
+      if (newsData.id) {
+        await news.get();
+      }
+      return news;
+    } catch (error) {
+      this.apiClient._logger.error(`[Api.${this.__entityTag}.news] Erreur lors de la création d'une instance news :`, error.message);
+      throw error;
+    }
+  }
+
+  _updateInitialDraftSnapshot() {
+    this.#initialDraftData = JSON.parse(JSON.stringify(this.#draftData));
+  }
+
+  hasChanges() {
+    return JSON.stringify(this.#draftData) !== JSON.stringify(this.#initialDraftData);
+  }
+
+  /**
+   * Champs par défaut pour les schemas json ou l'on extrait les fields. (pour les if/else/then)
+   * 
+   * @property {Object} defaultFields - Un objet contenant les propriétés par défaut pour l'entité User.
+   */
+  defaultFields = {
+    typeElement: this.getEntityType(), 
+  };
+
+  /**
+   * Champs à supprimer de draft lors de la construction du proxy.
+   * 
+   * @property {Array<string>} removeFields - Un tableau de chaînes représentant les champs à supprimer.
+   */
+  removeFields = [
+    "typeElement",
+  ];
+  
+  /**
+   * Transformateurs appliqués lors de la lecture du draft.
+   *
+   * @type {Object<string, function>}
+   */
+  transforms = {
+    github: (val, full) => full?.socialNetwork?.github,
+    gitlab: (val, full) => full?.socialNetwork?.gitlab,
+    facebook: (val, full) => full?.socialNetwork?.facebook,
+    twitter: (val, full) => full?.socialNetwork?.twitter,
+    instagram: (val, full) => full?.socialNetwork?.instagram,
+    diaspora: (val, full) => full?.socialNetwork?.diaspora,
+    mastodon: (val, full) => full?.socialNetwork?.mastodon,
+    telegram: (val, full) => full?.socialNetwork?.telegram,
+    signal: (val, full) => full?.socialNetwork?.signal
+  };
 }
 
 // Incorporation des mixins dans User
-Object.assign(User.prototype, EntityMixin, UtilMixin, UserMixin, NewsMixin);
+Object.assign(User.prototype, MutualEntityMixin, UtilMixin, UserMixin, DraftStateMixin);
   

package/src/api/UserApi.js

@@ -1,6 +1,10 @@
 // UserApi.js
 import ApiClient from "../ApiClient.js";
 import { ApiResponseError } from "../error.js";
+import EndpointApi from "./EndpointApi.js";
+import { News } from "./News.js";
+import { Organization } from "./Organization.js";
+import { Project } from "./Project.js";
 import { User } from "./User.js";
 
 export class UserApi {
@@ -15,7 +19,7 @@ export class UserApi {
     // Appel à un endpoint d'authentification
       const response = await this.client.callEndpoint("AUTHENTICATE_URL", { email, password });
       // Création d'une instance de LoggedInUser à partir des données reçues
-      this.loggedUser = new User(this.client, { id: response.data.user.id }, response.data.user);
+      this.loggedUser = new User(this.client, response.data.user, { EndpointApi, Organization, Project, News });
       return this.loggedUser;
     });
   }