@communecter/cocolight-api-client 1.0.22 → 1.0.23

package/src/api/Organization.js

@@ -138,25 +138,55 @@ export class Organization extends BaseEntity {
    * Constant : GET_MEMBERS_ADMIN / GET_MEMBERS_NO_ADMIN
    * @param {Object} data - Les données de requête.
    * @param {Object} options - Options supplémentaires.
+   * @param {boolean} options.toBeValidated - Indique si les membres doivent être validés.
    * @param {boolean} options.isAdmin - Indique si l'utilisateur est admin.
+   * @param {boolean} options.isAdminPending - Indique si l'utilisateur est en attente de validation pour être admin.
    * @param {boolean} options.isInviting - Indique si l'utilisateur est en attente d'invitation.
    * @param {Array} options.roles - Liste des rôles à filtrer.
    * @returns {Promise<Object>} - Un objet contenant le nombre de membres et la liste des membres.
+   * @throws {ApiResponseError} - Si une erreur se produit lors de la récupération des contributeurs.
+   * 
+   * @example
+   * // Récupérer tous les membres
+   * const members = await organization.getMembers();
+   * 
+   * // Récupérer les membres avec validation en attente
+   * const membersToBeValidated = await organization.getMembers({}, { toBeValidated: true });
+   * 
+   * // Récupérer les membres avec un rôle spécifique
+   * const membersWithRole = await organization.getMembers({}, { roles: ['admin'] });
+   * 
+   * // Récupérer les membres en attente d'invitation
+   * const invitingMembers = await organization.getMembers({}, { isInviting: true });
+   * 
+   * // Récupérer les membres admin
+   * const adminMembers = await organization.getMembers({}, { isAdmin: true });
+   * 
+   * // Récupérer les membres admin et en attente d'invitation
+   * const adminInvitingMembers = await organization.getMembers({}, { isAdmin: true, isInviting: true });
+   * 
+   * // Récupérer les membres avec validation en attente et admin
+   * const adminToBeValidatedMembers = await organization.getMembers({}, { toBeValidated: true, isAdmin: true });
+   * 
+   * // Récupérer les membres en attente de validation pour être admin
+   * const adminPendingMembers = await organization.getMembers({}, { isAdminPending: true });
+   * 
+   * 
    */
   async getMembers(data = {}, options = {}) {
-    const { isAdmin, isInviting, roles = [] } = options;
+    const { toBeValidated, isAdmin, isAdminPending, isInviting, roles = [] } = options;
 
     if(this.isMe){
       data.pathParams = { type: this.getEntityType(), id: this.id };
-      // NOTE : dans le schema je crois que si pas de data.filters alors le default ce fait avec data.pathParams
       // data.filters = {
       //   [`links.memberOf.${this.id}`]: { "$exists": true },
       //   [`links.memberOf.${this.id}.toBeValidated`]: { "$exists": false },
       //   [`links.memberOf.${this.id}.isInviting`]: { "$exists": false }
       // };
+      data.filters = this._buildLinkFilters(this.id, { linkType: "memberOf", toBeValidated, isAdmin, isAdminPending, isInviting, roles });
     } else {
       delete data?.pathParams;
-      data.filters = this._buildMemberFilters(this.id, { isAdmin, isInviting, roles });
+      data.filters = this._buildLinkFilters(this.id, { linkType: "memberOf", toBeValidated: "false", isAdmin, isInviting, roles });
     }
   
     const fetchFn = this.isMe
@@ -172,43 +202,11 @@ export class Organization extends BaseEntity {
     const rawList = this._linkEntities(arrayObjet.results);
 
     return {
-      count: arrayObjet.count?.poi ?? 0,
+      count: arrayObjet.count,
       results: rawList
     };
   }
 
-  _buildMemberFilters(id, { isAdmin, isInviting, roles }) {
-
-    if (typeof isAdmin !== "undefined" && typeof isAdmin !== "boolean") {
-      throw new TypeError("isAdmin doit être un booléen.");
-    }
-    if (typeof isInviting !== "undefined" && typeof isInviting !== "boolean") {
-      throw new TypeError("isInviting doit être un booléen.");
-    }
-    if (!Array.isArray(roles)) {
-      throw new TypeError("roles doit être un tableau de chaînes.");
-    }
-    
-    const filters = {
-      [`links.memberOf.${id}`]: { $exists: true },
-      [`links.memberOf.${id}.toBeValidated`]: { $exists: false }
-    };
-  
-    if (isInviting === true || isInviting === false) {
-      filters[`links.memberOf.${id}.isInviting`] = { $exists: isInviting };
-    }
-  
-    if (isAdmin === true) {
-      filters[`links.memberOf.${id}.isAdmin`] = { $exists: true };
-    }
-  
-    if (Array.isArray(roles) && roles.length > 0) {
-      filters[`links.memberOf.${id}.roles`] = { $in: roles };
-    }
-  
-    return filters;
-  }
-
   /**
    * Crée une instance de projet et récupère son profil si nécessaire.
    *
@@ -267,5 +265,78 @@ export class Organization extends BaseEntity {
   async news(newsData = {}) {
     return super.news(newsData);
   }
+  
+  /**
+   * ───────────────────────────────
+   *  Lien utilisateur ↔ organisation
+   *  (rejoindre, valider, quitter, devenir admin)
+   * ───────────────────────────────
+   */
+
+
+  /**
+   * Envoie une demande pour rejoindre l'organisation en tant que membre.
+   * L'action est soumise à validation par un administrateur de l'organisation.
+   *
+   * @returns {Promise<Object>} - Résultat de la requête d'adhésion.
+   * @throws {ApiError} - Si l'utilisateur n'est pas connecté ou si l'entité ne supporte pas l'action.
+   */
+  async requestToJoin(){
+    return super.requestToJoin();
+  }
+
+  /**
+   * Envoie une demande pour rejoindre l'organisation en tant qu'administrateur.
+   * L'action est soumise à validation par un administrateur existant.
+   *
+   * @returns {Promise<Object>} - Résultat de la requête d'administration.
+   * @throws {ApiError} - Si l'utilisateur n'est pas connecté ou si l'entité ne supporte pas l'action.
+   */
+  async requestToJoinAdmin(){
+    return super.requestToJoinAdmin();
+  }
+
+  /**
+   * Accepte une invitation à rejoindre l'organisation.
+   * Cette action valide un lien en attente avec l'option `isInviting`.
+   *
+   * @returns {Promise<Object>} - Résultat de la validation du lien.
+   * @throws {ApiError} - Si aucune invitation n'est en attente ou si l'entité ne supporte pas l'action.
+   */
+  async acceptInvitation(){
+    return super.acceptInvitation();
+  }
+
+  /**
+   * Quitte l'organisation, que ce soit en tant que membre ou administrateur.
+   * Cette action supprime le lien entre l'utilisateur et l'organisation.
+   *
+   * @returns {Promise<Object>} - Résultat de la déconnexion.
+   * @throws {ApiError} - Si l'utilisateur n'est pas connecté ou non membre.
+   */
+  async leave() {
+    return super.leave();
+  }
+
+  /**
+   * Suivre une organisation.
+   * Cette action permet à l'utilisateur de suivre l'organisation.
+   * 
+   * @returns {Promise<Object>} - Résultat de l'action de suivi.
+   * @throws {ApiError} - Si l'utilisateur n'est pas connecté ou si l'entité ne supporte pas l'action.
+   */
+  async follow() {
+    return super.follow();
+  }
+
+  /**
+   * Se désabonne d'une organisation.
+   * 
+   * @returns {Promise<Object>} - Résultat de la désinscription.
+   * @throws {ApiError} - Si l'utilisateur n'est pas connecté ou si l'entité n'est pas enregistrée.
+   */
+  async unfollow() {
+    return super.unfollow();
+  }
 
 }

package/src/api/Poi.js

@@ -154,5 +154,27 @@ export class Poi extends BaseEntity {
   async news(newsData = {}) {
     return super.news(newsData);
   }
+
+  /**
+   * Suivre un POI.
+   * Cette action permet à l'utilisateur de suivre un POI.
+   * 
+   * @returns {Promise<Object>} - Résultat de l'action de suivi.
+   * @throws {ApiError} - Si l'utilisateur n'est pas connecté ou si l'entité ne supporte pas l'action.
+   */
+  async follow() {
+    return super.follow();
+  }
+
+  /**
+   * Se désabonne d'un POI.
+   * 
+   * @returns {Promise<Object>} - Résultat de la désinscription.
+   * @throws {ApiError} - Si l'utilisateur n'est pas connecté ou si l'entité n'est pas enregistrée.
+   */
+  async unfollow() {
+    return super.unfollow();
+  }
+
   
 }

package/src/api/Project.js

@@ -1,3 +1,4 @@
+import { ApiResponseError } from "../error.js";
 import BaseEntity from "./BaseEntity.js";
 
 export class Project extends BaseEntity {
@@ -153,6 +154,70 @@ export class Project extends BaseEntity {
     return super.getSubscribers(data);
   }
 
+  /**
+   * Récupérer les contributeurs d'un projet.
+   * Constant : GET_CONTRIBUTORS_ADMIN / GET_CONTRIBUTORS_NO_ADMIN
+   * @param {Object} data - Les données de requête.
+   * @param {Object} options - Options supplémentaires.
+   * @param {boolean} options.toBeValidated - Indique si les contributeurs doivent être validés.
+   * @param {boolean} options.isAdmin - Indique si l'utilisateur est admin.
+   * @param {boolean} options.isInviting - Indique si l'utilisateur est en attente d'invitation.
+   * @param {Array} options.roles - Liste des rôles à filtrer.
+   * @returns {Promise<Object>} - Un objet contenant le nombre de contributeurs et la liste des contributeurs.
+   * @throws {ApiResponseError} - Si une erreur se produit lors de la récupération des contributeurs.
+   * 
+   * @example
+   * // Récupérer tous les contributeurs
+   * const contributors = await project.getContributors();
+   * 
+   * // Récupérer les contributeurs avec validation en attente
+   * const contributorsToBeValidated = await project.getContributors({}, { toBeValidated: true });
+   * 
+   * // Récupérer les contributeurs avec un rôle spécifique
+   * const contributorsWithRole = await project.getContributors({}, { roles: ["admin"] });
+   * 
+   * // Récupérer les contributeurs administrateurs
+   * const adminContributors = await project.getContributors({}, { isAdmin: true });
+   * 
+   * // Récupérer les contributeurs en attente d'invitation
+   * const invitingContributors = await project.getContributors({}, { isInviting: true });
+   * 
+   */
+  async getContributors(data = {}, options = {}) {
+    const { toBeValidated, isAdmin, isInviting, isAdminPending, roles = [] } = options;
+
+    if(this.isMe){
+      data.pathParams = { type: this.getEntityType(), id: this.id };
+      // NOTE : dans le schema je crois que si pas de data.filters alors le default ce fait avec data.pathParams
+      // data.filters = {
+      //   [`links.projects.${this.id}`]: { "$exists": true },
+      //   [`links.projects.${this.id}.toBeValidated`]: { "$exists": false },
+      //   [`links.projects.${this.id}.isInviting`]: { "$exists": false }
+      // };
+      data.filters = this._buildLinkFilters(this.id, { linkType: "projects", toBeValidated, isAdmin, isAdminPending, isInviting, roles });
+    } else {
+      delete data?.pathParams;
+      data.filters = this._buildLinkFilters(this.id, { linkType: "projects", toBeValidated: "false", isAdmin, isInviting, roles });
+    }
+  
+    const fetchFn = this.isMe
+      ? () => this.callIsMe(() => this.endpointApi.getContributorsAdmin(data))
+      : () => this.endpointApi.getContributorsNoAdmin(data);
+  
+    const arrayObjet = await fetchFn();
+    if (!Array.isArray(arrayObjet.results)) {
+      throw new ApiResponseError("Erreur lors de la récupération des contributeurs", 500, arrayObjet.results);
+    }
+
+    // lier les entités au objets
+    const rawList = this._linkEntities(arrayObjet.results);
+
+    return {
+      count: arrayObjet.count,
+      results: rawList
+    };
+  }
+
   /**
    * Crée une instance de projet et récupère son profil si nécessaire.
    *
@@ -212,4 +277,76 @@ export class Project extends BaseEntity {
     return super.news(newsData);
   }
 
+  /**
+   * ───────────────────────────────
+   *  Lien utilisateur ↔ projet
+   *  (rejoindre, valider, quitter, devenir admin)
+   * ───────────────────────────────
+   */
+
+  /**
+   * Envoie une demande pour rejoindre le projet en tant que contributeur.
+   * L'action est soumise à validation par un administrateur du projet.
+   *
+   * @returns {Promise<Object>} - Résultat de la requête d'adhésion.
+   * @throws {ApiError} - Si l'utilisateur n'est pas connecté ou si le projet ne supporte pas l'action.
+   */
+  async requestToJoin(){
+    return super.requestToJoin();
+  }
+
+  /**
+   * Envoie une demande pour devenir administrateur du projet.
+   * L'action est soumise à validation par un administrateur existant.
+   *
+   * @returns {Promise<Object>} - Résultat de la requête d'administration.
+   * @throws {ApiError} - Si l'utilisateur n'est pas connecté ou si le projet ne supporte pas l'action.
+   */
+  async requestToJoinAdmin(){
+    return super.requestToJoinAdmin();
+  }
+
+  /**
+   * Accepte une invitation à rejoindre le projet.
+   * Cette action valide un lien en attente avec l'option `isInviting`.
+   *
+   * @returns {Promise<Object>} - Résultat de la validation du lien.
+   * @throws {ApiError} - Si aucune invitation n'est en attente ou si le projet ne supporte pas l'action.
+   */
+  async acceptInvitation(){
+    return super.acceptInvitation();
+  }
+
+  /**
+   * Quitte le projet, que ce soit en tant que contributeur ou administrateur.
+   * Cette action supprime le lien entre l'utilisateur et le projet.
+   *
+   * @returns {Promise<Object>} - Résultat de la déconnexion.
+   * @throws {ApiError} - Si l'utilisateur n'est pas connecté ou non contributeur.
+   */
+  async leave() {
+    return super.leave();
+  }
+
+  /**
+   * Suivre un projet.
+   * Cette action permet à l'utilisateur de suivre le projet.
+   * 
+   * @returns {Promise<Object>} - Résultat de l'action de suivi.
+   * @throws {ApiError} - Si l'utilisateur n'est pas connecté ou si l'entité ne supporte pas l'action.
+   */
+  async follow() {
+    return super.follow();
+  }
+
+  /**
+   * Se désabonne d'un projet.
+   * 
+   * @returns {Promise<Object>} - Résultat de la désinscription.
+   * @throws {ApiError} - Si l'utilisateur n'est pas connecté ou si l'entité n'est pas enregistrée.
+   */
+  async unfollow() {
+    return super.unfollow();
+  }
+
 }

package/src/api/User.js

@@ -81,7 +81,7 @@ export class User extends BaseEntity {
       
     super(parent, data, deps);
   }
-      
+
   get slug() {
     return this._draftData.slug || null;
   }
@@ -90,6 +90,14 @@ export class User extends BaseEntity {
     return this.isConnected && this.userId === this.id;
   }
 
+  get parentIsMe() {
+    return super.isMe;
+  }
+
+  get isActingUser() {
+    return this.parentIsMe && !this.isMe;
+  }
+
   /**
      * Récupère le profil complet de l'utilisateur.
      * Si l'utilisateur est connecté, on appelle le endpoint ME_INFO_URL,
@@ -181,23 +189,7 @@ export class User extends BaseEntity {
   }
 
   static fromServerData(data, parent, deps) {
-    const instance = new User(parent.apiClient, data, deps);
-    instance._serverData = { ...data };
-    // est ce que je besoin de ça si il est contruit dans le constructeur ?
-    // il doit y avaoir une raison pour les autres objets
-    const { draft, proxy } = instance._buildDraftAndProxy({
-      data: { ...data, ...instance.defaultFields },
-      serverData: instance._serverData,
-      constant: User.SCHEMA_CONSTANTS,
-      apiClient: instance.apiClient,
-      transforms: instance.transforms,
-      removeFields: instance.removeFields
-    });
-
-    instance._draftData = draft;
-    instance.data = proxy;
-
-    return instance;
+    return new User(parent.apiClient, data, deps);
   }
 
   /**
@@ -451,6 +443,18 @@ export class User extends BaseEntity {
     return filteredBadges;
   }
 
+  async user(userData) {
+    if(!this.isMe){
+      throw new ApiError("Vous devez être connecté et être l'utilisateur");
+    }
+    if (!userData.id && !userData.slug) {
+      throw new ApiError("Vous devez fournir un id ou un slug pour créer un User.");
+    }
+    const user = new User(this, userData, this.deps);
+    await user.get();
+    return user;
+  }
+
   /**
    * Crée une instance d'organisation et récupère son profil si nécessaire.
    *
@@ -535,6 +539,209 @@ export class User extends BaseEntity {
     return super.badge(badgeData);
   }
 
+  /**
+   * ───────────────────────────────
+   *  Lien utilisateur ↔ utilisateur (ami)
+   *  (demander, valider, se retirer)
+   * ───────────────────────────────
+   */
+
+  /**
+   * Envoie une demande d'amitié à cet utilisateur.
+   * L'utilisateur ciblé devra valider la demande pour établir la relation.
+   *
+   * @returns {Promise<Object>} - Résultat de la requête.
+   * @throws {ApiError} - Si l'utilisateur n'est pas connecté ou si l'action est interdite.
+   */
+  async sendFriendRequest() {
+    if (!this.isActingUser) {
+      throw new ApiError("Vous devez être connecté pour envoyer une demande d'amis.");
+    }
+
+    this._checkLinkableEntity();
+    if (!this.id) {
+      throw new ApiError(`${this.constructor.name} non enregistrée.`);
+    }
+
+    const { connectTypeConnect } = this._getLinkMeta();
+    const userLink = this._getLinkFromConnectedUser();
+
+    if (!userLink) {
+      const data = {
+        parentType: this.getEntityType(),
+        parentId: this.id,
+        connectType: connectTypeConnect
+      };
+      const retour = await this.endpointApi.connect(data);
+      // TODO : reflechier au moyen de remplir parent.serverData et this.serverData avec les data de retour pour eviter un refresh
+      await this.parent.refresh();
+      return retour;
+    }
+
+    if (userLink.isInviting && userLink.invitorId === this.id) {
+      return this.acceptFriendRequest();
+    }
+
+    if (userLink.isInviting && userLink.invitorId === this.userId) {
+      throw new ApiError("Vous avez déjà envoyé une demande d'amis à cet utilisateur.");
+    }
+
+    throw new ApiError("Vous êtes déjà connecté à cette entité.");
+  }
+
+  /**
+   * Accepte une demande d'amitié envoyée par cet utilisateur.
+   * Cette action établit un lien entre les deux utilisateurs.
+   *
+   * @returns {Promise<Object>} - Résultat de la validation du lien.
+   * @throws {ApiError} - Si aucune invitation n'est en attente ou si l'action est interdite.
+   */
+  async acceptFriendRequest() {
+    if (!this.isActingUser) {
+      throw new ApiError("Vous devez être connecté pour accepter une demande d'amitié.");
+    }
+
+    this._checkLinkableEntity();
+    if (!this.id) {
+      throw new ApiError(`${this.constructor.name} non enregistrée.`);
+    }
+
+    const userLink = this._getLinkFromConnectedUser();
+
+    if (userLink?.isInviting && userLink.invitorId === this.id) {
+      const data = {
+        parentType: this.getEntityType(),
+        parentId: this.id,
+        linkOption: "isInviting"
+      };
+      const retour = await this.endpointApi.linkValidate(data);
+      // TODO : reflechier au moyen de remplir parent.serverData et this.serverData avec les data de retour pour eviter un refresh
+      await this.parent.refresh();
+      return retour;
+    }
+
+    throw new ApiError("Vous n'avez pas d'invitation à valider.");
+  }
+
+  /**
+   * Supprime la relation d'amitié avec cet utilisateur.
+   * Cette action annule tout lien existant entre les deux profils.
+   *
+   * @returns {Promise<Object>} - Résultat de la suppression.
+   * @throws {ApiError} - Si aucune relation n'existe.
+   */
+  async removeFriend() {
+    if (!this.isActingUser) {
+      throw new ApiError("Vous devez être connecté pour supprimer un ami.");
+    }
+
+    this._checkLinkableEntity();
+    if (!this.id) {
+      throw new ApiError(`${this.constructor.name} non enregistrée.`);
+    }
+
+    const { connectTypeDisconnect } = this._getLinkMeta();
+    const userLink = this._getLinkFromConnectedUser();
+
+    if (!userLink) {
+      throw new ApiError("Vous n'êtes pas connecté à cette entité.");
+    }
+
+    const data = {
+      parentType: this.getEntityType(),
+      parentId: this.id,
+      connectType: connectTypeDisconnect
+    };
+    const retour = await this.endpointApi.disconnect(data);
+    // TODO : reflechier au moyen de remplir parent.serverData et this.serverData avec les data de retour pour eviter un refresh
+    await this.parent.refresh();
+    return retour;
+  }
+    
+
+  requestToJoin() {
+    throw new ApiError("l'utilisation de requestToJoin n'est pas autorisée sur un utilisateur.");
+  }
+
+  requestToJoinAdmin() {
+    throw new ApiError("l'utilisation de requestToJoinAdmin n'est pas autorisée sur un utilisateur.");
+  }
+
+  acceptInvitation() {
+    throw new ApiError("l'utilisation de acceptInvitation n'est pas autorisée sur un utilisateur.");
+  }
+
+  leave() {
+    throw new ApiError("l'utilisation de leave n'est pas autorisée sur un utilisateur.");
+  }
+
+  /**
+   * Suivre un utilisateur
+   * Cette action permet à l'utilisateur connecté de suivre un autre utilisateur.
+   * Elle nécessite que l'utilisateur soit connecté.
+   * 
+   * @returns {Promise<Object>} - Résultat de la requête.
+   * @throws {ApiError} - Si l'utilisateur n'est pas connecté ou si l'action est interdite.
+   */
+  async follow() {
+    if (!this.isActingUser) {
+      throw new ApiError("Vous devez être connecté pour suivre un utilisateur.");
+    }
+    if (!this.id) {
+      throw new ApiError(`${this.constructor.name} non enregistrée.`);
+    }
+
+    const userLink = this.parent?.serverData?.links?.["follows"]?.[this.id] || null;
+
+    if (!userLink) {
+      const data = {
+        parentType: this.getEntityType(),
+        parentId: this.id
+      };
+      const retour = await this.endpointApi.follow(data);
+      // TODO : reflechier au moyen de remplir parent.serverData et this.serverData avec les data de retour pour eviter un refresh
+      await this.parent.refresh();
+      return retour;
+    }
+
+    throw new ApiError("Vous êtes déjà abonné à cet utilisateur.");
+  }
+
+  /**
+   * Se désabonner d'un utilisateur
+   * Cette action permet à l'utilisateur connecté de se désabonner d'un autre utilisateur.
+   * Elle nécessite que l'utilisateur soit connecté.
+   * 
+   * @returns {Promise<Object>} - Résultat de la requête.
+   * @throws {ApiError} - Si l'utilisateur n'est pas connecté ou si l'action est interdite.
+   */
+  async unfollow() {
+    if (!this.isActingUser) {
+      throw new ApiError("Vous devez être connecté pour vous désabonner d'un utilisateur.");
+    }
+    if (!this.id) {
+      throw new ApiError(`${this.constructor.name} non enregistrée.`);
+    }
+
+    const userLink = this.parent?.serverData?.links?.["follows"]?.[this.id] || null;
+
+    if (userLink) {
+      const data = {
+        parentType: this.getEntityType(),
+        parentId: this.id,
+        connectType: "followers"
+      };
+      const retour = await this.endpointApi.disconnect(data);
+      // TODO : reflechir au moyen de remplir parent.serverData et this.serverData avec les data de retour pour eviter un refresh
+      await this.parent.refresh();
+      return retour;
+    }
+
+    throw new ApiError("Vous n'êtes pas abonné à cet utilisateur.");
+  }
+
+
+
 }
 
 // Incorporation des mixins dans User