@communecter/cocolight-api-client 1.0.8 → 1.0.10

package/src/api/Project.js

@@ -1,131 +1,325 @@
-import { EntityMixin } from "./EntityMixin.js";
-import { NewsMixin } from "./NewsMixin.js";
-import { UtilMixin } from "./UtilMixin.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 {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.");
 
-  constructor(apiClient, { id, slug } = {}) {
-    if (!id && !slug) {
-      throw new Error("Vous devez fournir un id ou un slug pour créer un User.");
+    if (!parent) throw new ApiError("Parent is required.");
+
+    this.deps = deps;
+
+    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 ApiError("Invalid parent for Project.");
     }
-    this.apiClient = apiClient;
-    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));
+  }
+
+  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;
   }
 
-  /**
-   * 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 };
-    return this._getNews(data);
+  async refresh() {
+    if (!this.id) throw new ApiError("Impossible de rafraîchir sans ID.");
+    return this.get();
   }
 
-  /**
-   * 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 = {}) {
-    data.parentId = this.id;
-    data.parentType = this.getEntityType();
-    return this.callIsConnected(() => this._addNews(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
+    
+          // faire ça ou alors resfresh() pour re-synchroniser
+          // this.#serverData = data.map;
+        }
+      }
+    }
   }
+
+  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;
+      }
+    }
   
+    return hasChanged;
+  }
+
+  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;
+    
+      return Object.fromEntries(
+        Object.entries(val).map(([key, obj]) => [
+          key,
+          {
+            type: obj?.type ?? null,
+            name: obj?.name ?? null
+          }
+        ])
+      );
+    }
+  };
+
+  async project(projectData = {}, ) {
+    try {
+      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 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;
+    }
+  }
+
 }
 
-// Incorporation du mixin dans Project
-Object.assign(Project.prototype, EntityMixin, UtilMixin, NewsMixin);
-  
+Object.assign(Project.prototype, UtilMixin, MutualEntityMixin, EntityMixin, NewsMixin, DraftStateMixin);