@communecter/cocolight-api-client 1.0.22 → 1.0.24

package/src/api/Project.js

@@ -1,3 +1,4 @@
+import { ApiError, ApiResponseError } from "../error.js";
 import BaseEntity from "./BaseEntity.js";
 
 export class Project extends BaseEntity {
@@ -63,7 +64,7 @@ export class Project extends BaseEntity {
 
   async _add(payload) {
     if (!this._calledFromSave) {
-      throw new Error("utilisation invalide de _add, utilisez save");
+      throw new ApiError("utilisation invalide de _add, utilisez save");
     }
 
     payload.id = this._newId?.();
@@ -87,8 +88,12 @@ export class Project extends BaseEntity {
   }
 
   async _update(payload) {
+    if(!this.isAdmin()){
+      throw new ApiError("Vous n'avez pas les droits pour modifier ce projet", 403);
+    }
+
     if (!this._calledFromSave) {
-      throw new Error("utilisation invalide de _update, utilisez save");
+      throw new ApiError("utilisation invalide de _update, utilisez save");
     }
 
     if (payload.id) delete payload.id;
@@ -126,7 +131,7 @@ export class Project extends BaseEntity {
   }
 
   async getOrganizations() {
-    throw new Error(`getOrganizations n'existe pas dans ${this.constructor.name}`);
+    throw new ApiError(`getOrganizations n'existe pas dans ${this.constructor.name}`);
   }
 
   async getProjects(data = {}) {
@@ -134,7 +139,7 @@ export class Project extends BaseEntity {
   }
 
   async getEvents() {
-    throw new Error(`getEvents pas encore implémenté dans ${this.constructor.name}`);
+    throw new ApiError(`getEvents pas encore implémenté dans ${this.constructor.name}`);
   }
 
   async getPois(data = {}) {
@@ -153,6 +158,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.
    *
@@ -161,7 +230,9 @@ export class Project extends BaseEntity {
    * @throws {Error} Si une erreur se produit lors de la création du projet.
    */
   async project(projectData = {}) {
-    // TODO: Vérifier si l'utilisateur est admin du projet
+    if(!this.isAdmin()){
+      throw new ApiError("Vous n'avez pas les droits pour créer un projet dans ce projet", 403);
+    }
     return super.project(projectData);
   }
 
@@ -173,7 +244,9 @@ export class Project extends BaseEntity {
    * @throws {Error} Si une erreur se produit lors de la création du POI.
    */
   async poi(poiData = {}) {
-    // TODO: Vérifier si l'utilisateur est admin de l'organisation
+    if(!this.isAdmin()){
+      throw new ApiError("Vous n'avez pas les droits pour créer un POI dans ce projet", 403);
+    }
     return super.poi(poiData);
   }
 
@@ -185,7 +258,9 @@ export class Project extends BaseEntity {
    * @throws {Error} Si une erreur se produit lors de la création de l'événement.
    */
   async event(eventData = {}) {
-    // TODO: Vérifier si l'utilisateur est admin de l'organisation
+    if(!this.isAdmin()){
+      throw new ApiError("Vous n'avez pas les droits pour créer un événement dans ce projet", 403);
+    }
     return super.event(eventData);
   }
 
@@ -197,7 +272,9 @@ export class Project extends BaseEntity {
    * @throws {Error} Si une erreur se produit lors de la création du badge.
    */
   async badge(badgeData = {}) {
-    // TODO: Vérifier si l'utilisateur est admin de l'organisation
+    if(!this.isAdmin()){
+      throw new ApiError("Vous n'avez pas les droits pour créer un badge dans ce projet", 403);
+    }
     return super.badge(badgeData);
   }
 
@@ -209,7 +286,80 @@ export class Project extends BaseEntity {
    * @throws {Error} Si une erreur se produit lors de la création de la news.
    */
   async news(newsData = {}) {
+    // TODO: qui peut créer une news sur le projet ?
     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,257 @@ 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.userContext.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.userContext.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.userContext.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.userContext?.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.userContext.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.userContext?.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.userContext.refresh();
+      return retour;
+    }
+
+    throw new ApiError("Vous n'êtes pas abonné à cet utilisateur.");
+  }
+
+  /**
+   * Vérifie si l'utilisateur connecté est ami avec cet utilisateur.
+   * 
+   * @returns {boolean} - True si l'utilisateur connecté est ami, sinon false.
+   * @throws {ApiError} - Si l'utilisateur n'est pas connecté.
+   */
+  isFriend() {
+    if (!this.isActingUser) {
+      throw new ApiError("Vous devez être connecté pour vérifier si vous êtes ami.");
+    }
+    this._assertEntityType("citoyens");
+    const userLink = this._getLinkFromConnectedUser();
+    return this._validateUserLink(userLink);
+  }
+
+  /**
+   * Vérifie si l'utilisateur suit l'entité.
+   * 
+   * @returns {boolean} - `true` si l'utilisateur suit l'entité, `false` sinon.
+   * @throws {ApiError}
+   */
+  isFollower() {
+    if (!this.isActingUser) {
+      throw new ApiError("Vous devez être connecté pour vérifier si il vous suit.");
+    }
+    if (!this.id) {
+      throw new ApiError(`${this.constructor.name} non enregistrée.`);
+    }
+    this._assertEntityType("citoyens");
+    return this._isLinked("followers");
+  }
+
+  /**
+   * Vérifie si l'utilisateur est abonné à l'entité.
+   * 
+   * @returns {boolean} - `true` si l'utilisateur est abonné, `false` sinon.
+   * @throws {ApiError}
+   */
+  isFollowing() {
+    if (!this.isActingUser) {
+      throw new ApiError("Vous devez être connecté pour vérifier si vous le suivez.");
+    }
+    if (!this.id) {
+      throw new ApiError(`${this.constructor.name} non enregistrée.`);
+    }
+    this._assertEntityType("citoyens");
+    return this._isLinked("follows");
+  }
+
+
 }
 
 // Incorporation des mixins dans User