@communecter/cocolight-api-client 1.0.9 → 1.0.11

package/src/api/User.js

@@ -1,34 +1,67 @@
-import { ApiResponseError } from "../error.js";
-import { News } from "./News.js";
-import { EntityMixin } from "../mixin/EntityMixin.js";
-import { NewsMixin } from "../mixin/NewsMixin.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 {Object} [deps={}] - Dépendances injectées (ex: User).
-   * @param {EndpointApi} deps.EndpointApi - Classe EndpointApi pour éviter les dépendances circulaires.
+   *
+   * @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 = {}, deps = {}) {
+  constructor(apiClient, data = {}, deps = {}) {
+    this.__entityTag = "User";
+
     if(!deps.EndpointApi){
-      throw new Error("EndpointApi class must be injected to avoid circular dependency.");
+      throw new ApiError("EndpointApi class must be injected to avoid circular dependency.");
     }
-    if (!id && !slug) {
-      throw new Error("Vous devez fournir un id ou un slug pour créer un User.");
+    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.deps = deps;
 
     // Gérer les deux cas : fonction constructeur ou instance
@@ -37,47 +70,59 @@ export class User {
     } else if (typeof deps.EndpointApi === "object") {
       this.endpointApi = deps.EndpointApi;
     } else {
-      throw new Error("deps.EndpointApi doit être une classe ou une instance valide.");
+      throw new ApiError("deps.EndpointApi doit être une classe ou une instance valide.");
     }
-  
-    this.#id = id || null;
-    this.#slug = slug || null;
-    this.#data = data;
+
+    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() {
@@ -88,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,
@@ -95,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.endpointApi.meInfoUrl();
+        this._setData(data);
         return data;
       } else {
         const data = await this.getPublicProfile();
+        this._setData(data);
         return data;
       }
     });
@@ -123,12 +187,74 @@ export class User {
     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.endpointApi.updateSettings(data));
+    await this.callIsMe(() => this.endpointApi.updateSettings(data));
+    await this.refresh();
   }
 
   /**
@@ -167,7 +293,7 @@ export class User {
      * 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.endpointApi.check({ slug });
     } catch (error) {
@@ -183,13 +309,143 @@ export class User {
    * 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.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 = {}) {
@@ -205,26 +461,76 @@ export class User {
       throw new ApiResponseError("Erreur lors de la récupération des actualités.", 500, arrayObjetNews);
     }
     const rawNewsList = arrayObjetNews.map((newsData) =>
-      News.fromServerData(newsData, this, { User, EndpointApi: this.deps.EndpointApi })
+      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 News(this, newsData, { User, EndpointApi : this.deps.EndpointApi });
+      const news = new this.deps.News(this, newsData, { User, EndpointApi : this.deps.EndpointApi });
       if (newsData.id) {
         await news.get();
       }
       return news;
     } catch (error) {
-      console.error("[Api.user.news] Erreur lors de la création d'une instance news :", error.message);
+      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,26 +1,48 @@
 // UserApi.js
 import ApiClient from "../ApiClient.js";
-import { ApiResponseError } from "../error.js";
+import { ApiError, 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 {
   constructor(options) {
     // Injection de dépendance : ApiClient est créé à partir des options
     this.client = new ApiClient(options);
+    // si l'option "tokenStorageStrategy" est définie, on l'utilise pour créer une instance de ApiClient
     this.loggedUser = null;
   }
+
+  get isConnected() {
+    return this.client.isConnected;
+  }
+  get userId() {
+    return this.client.userId;
+  }
+  
   // Méthode d'authentification : récupère les données utilisateur depuis un endpoint
   async login(email, password) {
     return this.client.safeCall(async () => {
     // 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, { EndpointApi });
+      this.loggedUser = new User(this.client, response.data.user, { EndpointApi, Organization, Project, News });
       return this.loggedUser;
     });
   }
 
+  async meIsconnected() {
+    if(!this.client.isConnected || !this.client.userId) {
+      throw new ApiError("User not connected", 401);
+    }
+    this.client._logger.info("UserApi", "meIsconnected", this.client.userId);
+    this.loggedUser = new User(this.client, { id: this.client.userId }, { EndpointApi, Organization, Project, News });
+    return this.loggedUser;
+  }
+
+
   async register({
     name,
     username,
@@ -46,4 +68,5 @@ export class UserApi {
       return response.data;
     });
   }
+
 }