@communecter/cocolight-api-client 1.0.9 → 1.0.11

package/src/api/Project.js

@@ -1,234 +1,325 @@
-import { ApiResponseError } from "../error.js";
-import { News } from "./News.js";
-import { User } from "./User.js";
+import { ApiError } from "../error.js";
+import { DraftStateMixin } from "../mixin/DraftStateMixin.js";
 import { EntityMixin } from "../mixin/EntityMixin.js";
+import { MutualEntityMixin } from "../mixin/MutualEntityMixin.js";
 import { NewsMixin } from "../mixin/NewsMixin.js";
 import { UtilMixin } from "../mixin/UtilMixin.js";
 
-// Project.js
 export class Project {
-  // Champs privés pour protéger l'état
-  #id;
-  #slug;
-  #data = null;
+  #draftData = {};
+  #initialDraftData = {};
+  #serverData = null;
+
+  static entityType = "projects";
+
+  static SCHEMA_CONSTANTS = [
+    "ADD_PROJECT",
+    "UPDATE_BLOCK_DESCRIPTION",
+    "UPDATE_BLOCK_INFO",
+    "UPDATE_BLOCK_SOCIAL",
+    "UPDATE_BLOCK_LOCALITY",
+    "UPDATE_BLOCK_SLUG",
+    "PROFIL_IMAGE"
+  ];
+
+  static ADD_BLOCKS = new Map([
+    ["ADD_PROJECT", "addProject"],
+    ["PROFIL_IMAGE", "updateImageProfil"]
+  ]);
+
+  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 Project.
-   * @param {ApiClient} apiClient - L'instance d'ApiClient.
-   * @param {Object} identifier - Objet contenant { id } ou { slug }.
-   * @param {Object} [deps={}] - Dépendances injectées (ex: User).
-   * @param {EndpointApi} deps.EndpointApi - Classe EndpointApi pour éviter les dépendances circulaires.
-   */
-
-  constructor(apiClient, { id, slug } = {}, deps = {}) {
-    if(!deps.EndpointApi){
-      throw new Error("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 une instance Project.");
-    }
-    this.apiClient = apiClient;
+   * 
+   * @param {ApiClient|User|Organization|Project} parent - Instance de ApiClient, User, Organization ou Project.
+   * @param {Object} [data={}] - Données de l'organisation.
+   * @param {Object} [deps={}] - Dépendances injectées.
+   * @param {function|object} deps.EndpointApi - Classe ou instance de EndpointApi pour les appels API.
+   * @param {function} deps.User - Classe User pour la gestion des utilisateurs.
+   * @param {function} deps.News - Classe News pour la gestion des actualités.
+   * 
+   * @throws {ApiError} Si le parent n'est pas valide ou si les dépendances ne sont pas injectées correctement.
+   */  
+  constructor(parent, data = {}, deps = {}) {
+    this.__entityTag = "Project";
+
+    if (!deps.EndpointApi) throw new ApiError("EndpointApi class must be injected to avoid circular dependency.");
+    if (!deps.User) throw new ApiError("User class must be injected.");
+    if (!deps.News) throw new ApiError("News class must be injected.");
+
+    if (!parent) throw new ApiError("Parent is required.");
+
     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;
+    this.EndpointApiClass = deps.EndpointApi;
+
+    if (parent?.__entityTag === "ApiClient") {
+      this.apiClient = parent;
+      this.parent = null;
+    } else if (parent?.__entityTag === "User" || parent?.__entityTag === "Organization" || parent?.__entityTag === "Project") {
+      this.apiClient = parent.apiClient;
+      this.parent = parent;
     } else {
-      throw new Error("deps.EndpointApi doit être une classe ou une instance valide.");
+      throw new ApiError("Invalid parent for Project.");
     }
 
-    this.#id = id || null;
-    this.#slug = slug || null;
+    this.endpointApi = typeof deps.EndpointApi === "function"
+      ? new deps.EndpointApi(this.apiClient)
+      : (typeof deps.EndpointApi === "object"
+        ? deps.EndpointApi
+        : (() => { throw new ApiError("deps.EndpointApi must be a class or instance."); })());
+
+    const { draft, proxy } = this.buildDraftAndProxy({
+      data: { ...data, ...this.defaultFields },
+      serverData: this.#serverData,
+      constant: Project.SCHEMA_CONSTANTS,
+      apiClient: this.apiClient,
+      transforms: this.transforms,
+      removeFields: this.removeFields
+    });
+
+    this.#initialDraftData = JSON.parse(JSON.stringify(draft));
+    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;
-  }
-      
-  get slug() {
-    return this.#slug;
+    this.#draftData.id = newId;
   }
 
-  _slug(newSlug) {
-    this.#slug = newSlug;
-  }
-      
   get isConnected() {
     return this.apiClient.isConnected;
   }
 
-  get data() {
-    return this.#data;
+  get userId() {
+    return this.apiClient.userId;
+  }
+
+  get draftData() {
+    return this.#draftData;
   }
 
-  _setData(newData) {
-    this.#data = newData;
+  get initialDraftData() {
+    return this.#initialDraftData;
   }
 
-  get userId() {
-    return this.apiClient.userId;
+  get serverData() {
+    return this.#serverData;
   }
-  
+
   get isMe() {
-    return this.isConnected && this.userId === this.id;
+    return this.isConnected && this.userId === this.parent?.id;
   }
 
   getEntityType() {
-    return "projects";
+    return Project.entityType;
   }
 
-  /**
-     * Récupère le profil complet de l'organisation.
-     *
-     * @returns {Promise<Object>} Le profil complet.
-     */
-  async getProfil() {
-    return this.apiClient.safeCall(async () => {
-      const data = await this.getPublicProfile();
-      this._setData(data);
-      return data;
-    });
+  _updateInitialDraftSnapshot() {
+    this.#initialDraftData = JSON.parse(JSON.stringify(this.#draftData));
   }
 
-  /**
-   * Mettre à jour les paramètres d'un élément : Mise à jour des paramètres spécifiques d'un élément.
-   * Constant : UPDATE_SETTINGS
-   * @param {Object} data - Les données à envoyer.
-   * @param {string} data.type - data.type
-   * @param {undefined} data.value - data.value
-   * @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 updateSettings(data = {}) {
-    data.idEntity = this.id;
-    data.typeEntity = this.getEntityType();
-    return this.callIsConnected(() => this.endpointApi.updateSettings(data));
-  }
- 
-  /**
-   * Mettre à jour la description d'un élément : Permet de mettre à jour la description courte et complète d'un élément.
-   * Constant : UPDATE_BLOCK_DESCRIPTION
-   * @param {Object} data - Les données à envoyer.
-   * @param {string} data.descMentions - Mentions dans la description (default: "")
-   * @param {string} data.shortDescription - Courte description
-   * @param {string} data.description - Description complète
-   * @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 updateDescription(data = {}) {
-    data.typeElement = this.getEntityType();
-    data.id = this.id;
-    return this.callIsConnected(() => this.endpointApi.updateBlockDescription(data));
+  hasChanges() {
+    return JSON.stringify(this.#draftData) !== JSON.stringify(this.#initialDraftData);
   }
 
+  _setData(newData) {
+    this.#serverData = { ...newData };
+    const { draft, proxy } = this.buildDraftAndProxy({
+      data: { ...newData, ...this.defaultFields },
+      serverData: this.#serverData,
+      constant: Project.SCHEMA_CONSTANTS,
+      apiClient: this.apiClient,
+      transforms: this.transforms,
+      removeFields: this.removeFields
+    });
+    this.#initialDraftData = JSON.parse(JSON.stringify(draft));
+    this.#draftData = draft;
+    this.data = proxy;
+  }
 
-  /**
-   * Mettre à jour les informations d'un élément : Permet de mettre à jour les informations générales d'un élément (nom, contacts, etc.).
-   * Constant : UPDATE_BLOCK_INFO
-   */
-  async updateInfo(data = {}) {
-    data.typeElement = this.getEntityType();
-    data.id = this.id;
-    return this.callIsConnected(() => this.endpointApi.updateBlockInfo(data));
+  async refresh() {
+    if (!this.id) throw new ApiError("Impossible de rafraîchir sans ID.");
+    return this.get();
   }
 
-  /**
-   * Mettre à jour les réseaux sociaux d'un élément : Permet de mettre à jour les liens vers les réseaux sociaux d'un élément.
-   * Constant : UPDATE_BLOCK_SOCIAL
-   */
-  async updateSocial(data = {}) {
-    data.typeElement = this.getEntityType();
-    data.id = this.id;
-    return this.callIsConnected(() => this.endpointApi.updateBlockSocial(data));
+  async save() {
+
+    if(!this.isConnected){
+      throw new ApiError("Impossible de sauvegarder sans être connecté.");
+    }
+
+    const payload = { ...this.#draftData };
+  
+    if (!this.id) {
+      await this._add(payload);
+      // this._updateInitialDraftSnapshot();
+      await this.refresh();
+      return this.#serverData;
+    } else {
+      const hasChanged = await this._update(payload);
+      if (hasChanged) {
+        // this._updateInitialDraftSnapshot();
+        await this.refresh();
+      }
+      return this.#serverData;
+    }
+  
   }
+
+  async _add(payload){
+    // si pas d'id on le crée
+    payload.id = this._newId();
+    // on enlève le slug mais il ne devrait pas être là
+    if(payload.slug){
+      delete payload.slug;
+    }
+
+    for (const [constant, methodName] of Project.ADD_BLOCKS) {
+      const blockData = this.extractChangedFieldsFromSchema(
+        this.apiClient,
+        constant,
+        { ...payload, ...this.defaultFields},
+        () => {}
+      );
+      if (blockData && Object.keys(blockData).length > 0) {
+        const data = await this[methodName](blockData);
+
+        if (!this.id && data?.map?.id) {
+          this.#draftData.id = data.map.id;
+          this.#draftData.slug = data.map.slug;
+          // on met à jour le slug dans le draftData
     
-  /**
-   * Mettre à jour les localités d'un élément : Permet de mettre à jour l'adresse et les informations géographiques d'un élément.
-   * Constant : UPDATE_BLOCK_LOCALITY
-   */
-  async updateLocality(data = {}) {
-    data.typeElement = this.getEntityType();
-    data.id = this.id;
-    return this.callIsConnected(() => this.endpointApi.updateBlockLocality(data));
+          // faire ça ou alors resfresh() pour re-synchroniser
+          // this.#serverData = data.map;
+        }
+      }
+    }
   }
 
-  /**
-   * 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) {
-    try {
-      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);
+  async _update(payload){
+    // on enlève l'id car il existe déjà dans les appels API je laisse slug car il peut être changer en update ici
+    // if(payload.slug){
+    //   delete payload.slug;
+    // }
+    if(payload.id){
+      delete payload.id;
+    }
+
+    let hasChanged = false;
+
+    // Sinon, on fait les updates en blocs
+    for (const [constant, methodName] of Project.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;
       }
-      throw error;
     }
-    const data = { typeElement: this.getEntityType(), id: this.id, slug };
-    return this.callIsConnected(() => this.endpointApi.updateBlockSlug(data));
+  
+    return hasChanged;
   }
 
-  /**
-   * 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) {
-    image = await this.validateImage(image);
-    const data = { pathParams: { folder: this.getEntityType(), ownerId: this.id }, profil_avatar: image };
-    return this.callIsConnected(() => this.endpointApi.profilImage(data));
+  addProject(data = {}) {
+
+    // le parent n'est pas me donc on doit ajouter le parent
+    if (!this.isMe) {
+      data.parent = {};
+      data.parent[`${this.parent.id}`] = {
+        type: this.parent.getEntityType(),
+        name: this.parent.name
+      };
+    }
+
+    return this.callIsConnected(() => this.endpointApi.addProject(data));
   }
+
+  static fromServerData(data, parent, deps) {
+    const instance = new Project(parent, {}, deps);
+    instance.#serverData = { ...data };
+
+    const { draft, proxy } = instance.buildDraftAndProxy({
+      data: { ...data, ...instance.defaultFields },
+      serverData: instance.#serverData,
+      constant: Project.SCHEMA_CONSTANTS,
+      apiClient: instance.apiClient,
+      transforms: instance.transforms,
+      removeFields: instance.removeFields
+    });
+
+    instance.#draftData = draft;
+    instance.data = proxy;
+
+    return instance;
+  }
+
+
+  defaultFields = {
+    typeElement: this.getEntityType()
+  };
+
+  removeFields = [
+    "typeElement"
+  ];
+  
+  // role = admin c'est bizarre car en faite c'est gérer dans links sur user et l'orga
+  // links.members.${this.userId}.isAdmin === true
+  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,
+    parent: (val) => {
+      if (!val || typeof val !== "object") return null;
     
-  /**
-   * Récupérer les actualités : Récupère la liste d’actualités selon plusieurs critères.
-   * Constant : GET_NEWS
-   * @param {Object} data - Les données à envoyer.
-   * @param {number} data.dateLimit - Limite de date timestamp ou 0 (default: 0)
-   * @param {object} data.search - data.search
-   * @param {string} data.search.name - Nom ou terme recherché (default: "")
-   * @param {number} data.indexStep - Nombre de résultats par page (default: 12)
-   * @returns {Promise<Object>} - Les données de réponse.
-   * @throws {ApiResponseError} - En cas d'erreur détectée dans la réponse.
-   * @throws {Error} - En cas d'erreur inattendue.
-   */
-  async getNews(data = {}) {
-    data.pathParams = { type: this.getEntityType(), id: this.id };
-    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);
+      return Object.fromEntries(
+        Object.entries(val).map(([key, obj]) => [
+          key,
+          {
+            type: obj?.type ?? null,
+            name: obj?.name ?? null
+          }
+        ])
+      );
     }
-    const rawNewsList = arrayObjetNews.map((newsData) =>
-      News.fromServerData(newsData, this, { User, EndpointApi: this.deps.EndpointApi })
-    );
-    return this._createFilteredProxy(rawNewsList);
-  }
+  };
 
-  async news(newsData) {
+  async project(projectData = {}, ) {
     try {
-      const news = new News(this, newsData, { User, EndpointApi : this.deps.EndpointApi });
-      if (newsData.id) {
-        await news.get();
+      const project = new Project(this, projectData, { User: this.deps.User, News: this.deps.News, EndpointApi : this.deps.EndpointApi });
+      if (projectData.id || projectData.slug) {
+        await project.get();
       }
-      return news;
+      return project;
     } catch (error) {
-      console.error("[Api.project.news] Erreur lors de la création d'une instance news :", error.message);
+      this.apiClient._logger.error(`[Api.${this.__entityTag}.project] Erreur lors de la création d'une instance project :`, error.message);
       throw error;
     }
   }
-  
+
 }
 
-// Incorporation du mixin dans Project
-Object.assign(Project.prototype, EntityMixin, UtilMixin, NewsMixin);
-  
+Object.assign(Project.prototype, UtilMixin, MutualEntityMixin, EntityMixin, NewsMixin, DraftStateMixin);