@communecter/cocolight-api-client 1.0.7 → 1.0.9

package/src/api/News.js

@@ -0,0 +1,286 @@
+import { ApiError } from "../error.js";
+import { NewsMixin } from "../mixin/NewsMixin.js";
+import { UtilMixin } from "../mixin/UtilMixin.js";
+
+// News.js
+export class News {
+  // Champs privés pour protéger l'état
+  #draftData = {};
+  // Data d'une news venant du serveur
+  #serverData = null;
+
+  /**
+   * Crée une instance de News.
+   * @param {(Organization|Project|User)} parent - L'instance de l'element parent (ex: Organization, Project, User).
+   * @param {Object} identifier - Objet contenant { id }
+   * @param {Object} deps - Dépendances injectées (ex: User).
+   * @param {EndpointApi} deps.EndpointApi - Classe EndpointApi pour éviter les dépendances circulaires.
+   * @param {User} deps.User - Classe User pour éviter les dépendances circulaires.
+   */
+
+  constructor(parent, data = {}, deps = {}) {
+    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 to avoid circular dependency.");
+    }
+    if (!parent) {
+      throw new ApiError("Parent is required.");
+    }
+    this.deps = deps;
+    this.UserClass = deps.User;
+    this.apiClient = parent.apiClient;
+
+    // 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.#draftData = { ...data };
+    this.parent = parent;
+
+  }
+  
+  // Getters en lecture seule pour chaque propriété
+  get id() {
+    return this.#draftData.id || null;
+  }
+      
+  get isConnected() {
+    return this.apiClient.isConnected;
+  }
+
+  get draftData() {
+    return this.#draftData;
+  }
+  
+  get serverData() {
+    return this.#serverData;
+  }
+
+  get userId() {
+    return this.apiClient.userId;
+  }
+  
+  get isMe() {
+    return this.isConnected && this.userId === this.parent.id;
+  }
+
+  getEntityType() {
+    return "news";
+  }
+
+  static fromServerData(data, parent, deps) {
+    const instance = new News(parent, { id: data.id }, deps);
+  
+    // Injecte les données serveur
+    instance.#serverData = { ...data };
+  
+    // Construit les données draft à partir du serverData
+    instance.#draftData = instance._getDraftFromServerData(data);
+  
+    return instance;
+  }
+
+  async refresh() {
+    if (!this.id) throw new ApiError("Impossible de rafraîchir sans ID.");
+    return this.get();
+  }
+
+  /**
+   * Récupérer des actualités par IDs : Récupère des actualités à partir d’une liste d’identifiants.
+   * Constant : GET_NEWS_BY_ID
+   */
+  async get() {
+    if(!this.id) {
+      throw new ApiError("Vous devez fournir un id pour récupérer une news.");
+    }
+    const newsArray = await this.callIsConnected(() => this.endpointApi.getNewsById({ ids: [this.id] }));
+    if (newsArray && newsArray.length > 0) {
+      this.#serverData = newsArray[0];
+      this.#draftData = this._getDraftFromServerData(this.#serverData);
+      return this.#serverData;
+    }
+    throw new ApiError(`Aucune actualité trouvée pour l'ID ${this.id}`);
+  }
+
+  _getDraftFromServerData(data) {
+    // je veux copier que certaine info si présente dans le draftData
+    // - newsArray[0].scope.type > draftData.scope
+    // - newsArray[0].text > draftData.text
+    // - newsArray[0].tags > draftData.tags
+    // - newsArray[0].mentions > draftData.mentions > draftData.mentions.count integer
+    // - newsArray[0].mediaImg > draftData.mediaImg > draftData.mediaImg.images > un array id
+    // - newsArray[0].mediaFile > draftData.mediaFile > draftData.mediaFile.files > un array id
+    const transformed = this._pickProps(
+      data,
+      ["scope", "text", "tags", "mentions", "mediaImg", "mediaFile"],
+      {
+        scope: (val) => val?.type,
+        mentions: (val) =>
+          Array.isArray(val)
+            ? val.map((mention) => ({
+              ...mention,
+              count: parseInt(mention.count)
+            }))
+            : [],
+        mediaImg: (val) => {
+          const images = val?.images?.map((img) => img.id).filter(Boolean) || [];
+          return images.length > 0
+            ? {
+              countImages: parseInt(val.countImages) || images.length,
+              images
+            }
+            : undefined;
+        },
+        mediaFile: (val) => {
+          const files = val?.files?.map((file) => file.id).filter(Boolean) || [];
+          return files.length > 0
+            ? {
+              countFiles: parseInt(val.countFiles) || files.length,
+              files
+            }
+            : undefined;
+        }
+      }
+    );
+  
+    return {
+      id: data.id,
+      ...Object.fromEntries(Object.entries(transformed).filter(([, v]) => v !== undefined))
+    };
+  }
+  
+  /**
+   * Ajouter une actualité : Ajoute une nouvelle actualité.
+   * Constant : ADD_NEWS | UPDATE_NEWS
+   */
+  async save() {
+
+    // si le texte est vide, on met un espace pour que le champ soit pris en compte car sur le serveur
+    // il y a une vérification de la taille du texte je pense
+    if(this.#draftData?.text === ""){
+      this.#draftData.text = " ";
+    }
+
+    const payload = { ...this.#draftData };
+    payload.parentId = this.parent.id;
+    payload.parentType = this.parent.getEntityType();
+  
+    if (!this.id) {
+      const reponseData = await this.callIsConnected(() => this.endpointApi.addNews(payload));
+      this.#draftData.id = reponseData.object.id;
+      // TODO : voir si j'ai ce qui faut dans reponseData de ADD_NEWS pour mettre à jour #serverData
+      // c'est dans reponseData.object
+      if(reponseData?.object){
+        this.#serverData = { ...reponseData.object };
+      }
+      // await this.refresh();
+      return reponseData;
+    } else {
+      if(payload.id){
+        delete payload.id;
+      }
+      const reponseData = await this.callIsConnected(() => this.endpointApi.updateNews({ ...payload, idNews: this.id }));
+      // TODO : voir si j'ai ce qui faut dans reponseData de UPDATE_NEWS pour mettre à jour #serverData
+      // c'est dans reponseData.object
+      if(reponseData?.object){
+        this.#serverData = { ...reponseData.object };
+      }
+      // await this.refresh();
+      return reponseData;
+    }
+  }
+
+
+  async addMention({ slug, id }) {
+    try {
+      if (!slug && !id) {
+        throw new ApiError("Vous devez fournir un slug ou un id pour ajouter une mention.");
+      }
+      const userInstance = new this.UserClass(this.apiClient, { id, slug }, null , { EndpointApi: this.endpointApi  });
+      const user = await userInstance.getProfil();
+      if (!this.#draftData.mentions) {
+        this.#draftData.mentions = [];
+      }
+      // Vérification si la mention existe déjà
+      if (this.#draftData.mentions.find((mention) => mention.id === user.id)) {
+        // Si la mention existe déjà, on incrémente le compteur
+        this.#draftData.mentions = this.#draftData.mentions.map((mention) => {
+          if (mention.id === user.id) {
+            mention.count += 1;
+          }
+          return mention;
+        });
+        return this.#draftData.mentions;
+      }
+      const mention = { id: user.id, slug: user.slug, type: userInstance.getEntityType(), name: user.name, value:  user.name, count: 1 };
+      this.#draftData.mentions.push(mention);
+      return this.#draftData.mentions;
+    } catch (error) {
+      this.apiClient._logger.error("Erreur lors de l'ajout de la mention :", error);
+      throw error;
+    }
+
+  }
+
+  /**
+   * Ajouter une image à une actualité : Ajoute une images à une actualité.
+   * Constant : ADD_IMAGE_NEWS
+   */
+  async addImage(image) {
+    image = await this.validateImage(image);
+    const data = { pathParams: { folder: this.parent.getEntityType(), ownerId: this.parent.id }, newsImage: image  };
+    const dataImage = await this.callIsConnected(() => this.endpointApi.addImageNews(data));
+    if (this.#draftData.mediaImg) {
+      this.#draftData.mediaImg.countImages = this.#draftData.mediaImg.countImages + 1;
+      this.#draftData.mediaImg.images.push(dataImage.id);
+    } else {
+      this.#draftData.mediaImg = { countImages: 1, images: [dataImage.id] };
+    }
+    return dataImage;
+  }
+
+  /**
+   * Ajouter un fichier à une actualité : Ajoute un fichier à une actualité.
+   * Constant : ADD_FILE_NEWS
+   */
+  async addFile(file) {
+    file = await this.validateFile(file);
+    const data = { pathParams: { folder: this.parent.getEntityType(), ownerId: this.parent.id }, newsFile: file };
+    const dataFile = await this.callIsConnected(() =>this.endpointApi.addFileNews(data));
+    if (this.#draftData.mediaFile) {
+      this.#draftData.mediaFile.countFiles = this.#draftData.mediaFile.countFiles + 1;
+      this.#draftData.mediaFile.files.push(dataFile);
+    } else {
+      this.#draftData.mediaFile = { countFiles: 1, files: [dataFile] };
+    }
+    return dataFile;
+  }
+
+  /**
+   * Supprimer une actualité : Supprime une actualité existante.
+   * Constant : DELETE_NEWS
+   */
+  async delete() {
+    if(!this.id) {
+      throw new ApiError("Vous devez fournir un id pour supprimer une news.");
+    }
+    const data = { pathParams: { id: this.id } };
+    await this.callIsConnected(() => this.endpointApi.deleteNews(data));
+    this.#draftData = {};
+    this.#serverData = null;
+    this.#draftData.id = null;
+    this._isDeleted = true;
+  }
+    
+}
+
+// Incorporation du mixin dans Organization
+Object.assign(News.prototype, UtilMixin, NewsMixin);
+  

package/src/api/Organization.js

@@ -1,4 +1,9 @@
-import { EntityMixin } from "./EntityMixin.js";
+import { ApiResponseError } from "../error.js";
+import { News } from "./News.js";
+import { User } from "./User.js";
+import { EntityMixin } from "../mixin/EntityMixin.js";
+import { NewsMixin } from "../mixin/NewsMixin.js";
+import { UtilMixin } from "../mixin/UtilMixin.js";
 
 // Organization.js
 export class Organization {
@@ -11,13 +16,29 @@ export class Organization {
    * Crée une instance de Organization.
    * @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 } = {}) {
+  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 un User.");
+      throw new Error("Vous devez fournir un id ou un slug pour créer une instance User.");
     }
     this.apiClient = apiClient;
+    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 Error("deps.EndpointApi doit être une classe ou une instance valide.");
+    }
+
     this.#id = id || null;
     this.#slug = slug || null;
   }
@@ -26,6 +47,10 @@ export class Organization {
   get id() {
     return this.#id;
   }
+
+  _id(newId) {
+    this.#id = newId;
+  }
       
   get slug() {
     return this.#slug;
@@ -64,16 +89,145 @@ export class Organization {
      *
      * @returns {Promise<Object>} Le profil complet.
      */
-  async getProfile() {
+  async getProfil() {
     return this.apiClient.safeCall(async () => {
-      const response = await this.getPublicProfile();
-      this._setData(response.data);
-      return response.data;
+      const data = await this.getPublicProfile();
+      this._setData(data);
+      return data;
     });
   }
   
+  /**
+   * 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));
+  }
+    
+  /**
+     * 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));
+  }
+    
+  /**
+   * 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));
+  }
+    
+  /**
+   * 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));
+  }
+    
+  /**
+   * 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);
+      }
+      throw error;
+    }
+    const data = { typeElement: this.getEntityType(), id: this.id, slug };
+    return this.callIsConnected(() => this.endpointApi.updateBlockSlug(data));
+  }
+    
+  /**
+   * 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));
+  }
+
+  /**
+   * 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);
+    }
+    const rawNewsList = arrayObjetNews.map((newsData) =>
+      News.fromServerData(newsData, this, { User, EndpointApi: this.deps.EndpointApi })
+    );
+    return this._createFilteredProxy(rawNewsList);
+  }
+
+  async news(newsData) {
+    try {
+      const news = new News(this, newsData, { User, EndpointApi : this.deps.EndpointApi });
+      if (newsData.id) {
+        await news.get();
+      }
+      return news;
+    } catch (error) {
+      console.error("[Api.project.news] Erreur lors de la création d'une instance news :", error.message);
+      throw error;
+    }
+  }
+    
 }
 
 // Incorporation du mixin dans Organization
-Object.assign(Organization.prototype, EntityMixin);
+Object.assign(Organization.prototype, EntityMixin, UtilMixin, NewsMixin);
   

package/src/api/Project.js

@@ -1,4 +1,9 @@
-import { EntityMixin } from "./EntityMixin.js";
+import { ApiResponseError } from "../error.js";
+import { News } from "./News.js";
+import { User } from "./User.js";
+import { EntityMixin } from "../mixin/EntityMixin.js";
+import { NewsMixin } from "../mixin/NewsMixin.js";
+import { UtilMixin } from "../mixin/UtilMixin.js";
 
 // Project.js
 export class Project {
@@ -11,13 +16,29 @@ export class Project {
    * 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 } = {}) {
+  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 un User.");
+      throw new Error("Vous devez fournir un id ou un slug pour créer une instance Project.");
     }
     this.apiClient = apiClient;
+    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 Error("deps.EndpointApi doit être une classe ou une instance valide.");
+    }
+
     this.#id = id || null;
     this.#slug = slug || null;
   }
@@ -26,6 +47,10 @@ export class Project {
   get id() {
     return this.#id;
   }
+
+  _id(newId) {
+    this.#id = newId;
+  }
       
   get slug() {
     return this.#slug;
@@ -64,16 +89,146 @@ export class Project {
      *
      * @returns {Promise<Object>} Le profil complet.
      */
-  async getProfile() {
+  async getProfil() {
     return this.apiClient.safeCall(async () => {
-      const response = await this.getPublicProfile();
-      this._setData(response.data);
-      return response.data;
+      const data = await this.getPublicProfile();
+      this._setData(data);
+      return data;
     });
   }
+
+  /**
+   * 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));
+  }
+
+
+  /**
+   * 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));
+  }
+
+  /**
+   * 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));
+  }
+    
+  /**
+   * 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));
+  }
+
+  /**
+   * 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);
+      }
+      throw error;
+    }
+    const data = { typeElement: this.getEntityType(), id: this.id, slug };
+    return this.callIsConnected(() => this.endpointApi.updateBlockSlug(data));
+  }
+
+  /**
+   * 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));
+  }
+    
+  /**
+   * 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);
+    }
+    const rawNewsList = arrayObjetNews.map((newsData) =>
+      News.fromServerData(newsData, this, { User, EndpointApi: this.deps.EndpointApi })
+    );
+    return this._createFilteredProxy(rawNewsList);
+  }
+
+  async news(newsData) {
+    try {
+      const news = new News(this, newsData, { User, EndpointApi : this.deps.EndpointApi });
+      if (newsData.id) {
+        await news.get();
+      }
+      return news;
+    } catch (error) {
+      console.error("[Api.project.news] Erreur lors de la création d'une instance news :", error.message);
+      throw error;
+    }
+  }
   
 }
 
 // Incorporation du mixin dans Project
-Object.assign(Project.prototype, EntityMixin);
+Object.assign(Project.prototype, EntityMixin, UtilMixin, NewsMixin);