@communecter/cocolight-api-client 1.0.18 → 1.0.19

package/src/api/User.js

@@ -6,9 +6,10 @@ import { UtilMixin } from "../mixin/UtilMixin.js";
 
 // User.js
 export class User {
-  #draftData = {};
-  #initialDraftData = {};
-  #serverData = null;
+  _draftData = {};
+  _initialDraftData = {};
+  _serverData = null;
+  _calledFromSave = false;
 
   static entityType = "citoyens";
 
@@ -41,12 +42,15 @@ export class User {
    * @param {function|object} deps.EndpointApi - Classe ou instance de EndpointApi.
    * @param {function} deps.Organization - Classe Organization.
    * @param {function} deps.Project - Classe Project.
+   * @param {function} deps.Event - Classe Events.
+   * @param {function} deps.Poi - Classe Poi.
+   * @param {function} deps.Badge - Classe Badge.
    * @param {function} deps.News - Classe News.
    *
    * @throws {ApiError} - Si des dépendances nécessaires sont manquantes ou invalides.
    */
 
-  constructor(apiClient, data = {}, deps = {}) {
+  constructor(parent, data = {}, deps = {}) {
     this.__entityTag = "User";
 
     if(!deps.EndpointApi){
@@ -58,9 +62,20 @@ export class User {
 
     if (!deps.Organization) throw new ApiError("Organization class must be injected.");
     if (!deps.Project) throw new ApiError("Project class must be injected.");
+    if (!deps.Event) throw new ApiError("Event class must be injected.");
+    if (!deps.Poi) throw new ApiError("Poi class must be injected.");
+    if (!deps.Badge) throw new ApiError("Badge class must be injected.");
     if (!deps.News) throw new ApiError("News class must be injected.");
 
-    this.apiClient = apiClient;
+    if (parent?.__entityTag === "ApiClient") {
+      this.apiClient = parent;
+      this.parent = null;
+    } else if (parent?.apiClient) {
+      this.apiClient = parent.apiClient;
+      this.parent = parent;
+    } else {
+      throw new ApiError("Parent invalide ou ApiClient manquant.");
+    }
 
     this.deps = deps;
 
@@ -73,32 +88,32 @@ export class User {
       throw new ApiError("deps.EndpointApi doit être une classe ou une instance valide.");
     }
 
-    this.#serverData = null;
+    this._serverData = null;
     
     const { draft, proxy } = this._buildDraftAndProxy({
       data: { ...data, ...this.defaultFields },
-      serverData: this.#serverData,
+      serverData: this._serverData,
       constant: User.SCHEMA_CONSTANTS,
       apiClient: this.apiClient,
       transforms: this.transforms,
       removeFields: this.removeFields
     });
     
-    this.#initialDraftData = JSON.parse(JSON.stringify(draft)); // snapshot propre
-    this.#draftData = draft;
+    this._initialDraftData = JSON.parse(JSON.stringify(draft)); // snapshot propre
+    this._draftData = draft;
     this.data = proxy;
   }
 
   get id() {
-    return this.#draftData.id || null;
+    return this._draftData.id || null;
   }
 
   _id(newId) {
-    this.#draftData.id = newId;
+    this._draftData.id = newId;
   }
       
   get slug() {
-    return this.#draftData.slug || null;
+    return this._draftData.slug || null;
   }
   
   get isConnected() {
@@ -106,18 +121,18 @@ export class User {
   }
 
   _setData(newData) {
-    this.#serverData = { ...newData };
+    this._serverData = { ...newData };
 
     const { draft, proxy } = this._buildDraftAndProxy({
       data: { ...newData, ...this.defaultFields },
-      serverData: this.#serverData,
+      serverData: this._serverData,
       constant: User.SCHEMA_CONSTANTS,
       apiClient: this.apiClient,
       transforms: this.transforms,
       removeFields: this.removeFields
     });
-    this.#initialDraftData = JSON.parse(JSON.stringify(draft));
-    this.#draftData = draft;
+    this._initialDraftData = JSON.parse(JSON.stringify(draft));
+    this._draftData = draft;
     this.data = proxy;
   }
 
@@ -134,15 +149,15 @@ export class User {
   }
 
   get draftData() {
-    return this.#draftData;
+    return this._draftData;
   }
 
   get initialDraftData() {
-    return this.#initialDraftData;
+    return this._initialDraftData;
   }
   
   get serverData() {
-    return this.#serverData;
+    return this._serverData;
   }
 
   async refresh() {
@@ -199,16 +214,20 @@ export class User {
     if(!this.isMe){
       throw new ApiError("Vous devez être connecté et être l'utilisateur pour sauvegarder.");
     }
-
-    const payload = { ...this.#draftData };
+    this._calledFromSave = true;
+    try{
+      const payload = { ...this._draftData };
   
-    if (this.id) {
-      const hasChanged = await this._update(payload);
-      if (hasChanged) {
+      if (this.id) {
+        const hasChanged = await this._update(payload);
+        if (hasChanged) {
         // this._updateInitialDraftSnapshot();
-        await this.refresh();
+          await this.refresh();
+        }
+        return this._serverData;
       }
-      return this.#serverData;
+    } finally {
+      this._calledFromSave = false;
     }
   
   }
@@ -220,6 +239,10 @@ export class User {
    * @returns {Promise<boolean>} - Indique s'il y a eu une modification réelle.
    */
   async _update(payload){
+    if (!this._calledFromSave) {
+      throw new Error("utilisation invalide de _update, utilisez save");
+    }
+
     if(payload.id){
       delete payload.id;
     }
@@ -244,6 +267,26 @@ export class User {
     return hasChanged;
   }
 
+  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;
+  }
+
   /**
    * Mettre à jour les paramètres utilisateur : Mise à jour des paramètres spécifiques d'un utilisateur.
    * Constant : UPDATE_SETTINGS
@@ -346,14 +389,8 @@ export class User {
     const totalCount = Object.values(arrayObjetOrganizations.count || {}).reduce((acc, val) => acc + val, 0);
     arrayObjetOrganizations.count.total = totalCount;
   
-    // transformation des résultats
-    const rawOrganizationsList = arrayObjetOrganizations.results.map((orgData) =>
-      this.deps.Organization.fromServerData(orgData, this, {
-        User,
-        Project: this.deps.Project,
-        News: this.deps.News,
-        EndpointApi: this.deps.EndpointApi
-      })
+    const rawOrganizationsList = arrayObjetOrganizations.results.map(
+      (d) => this.linkEntity?.(d.collection, d) ?? d
     );
   
     return {
@@ -361,26 +398,6 @@ export class User {
       results: rawOrganizationsList
     };
   }
-  
-  /**
-   * Crée une instance d'organisation et récupère son profil si nécessaire.
-   *
-   * @param {Object} organizationData - Les données nécessaires pour initialiser l'organisation.
-   * @returns {Promise<Organization>} Une promesse qui résout l'objet Organisation créé.
-   * @throws {Error} Si une erreur se produit lors de la création de l'organisation.
-   */
-  async organization(organizationData = {}, ) {
-    try {
-      const organization = new this.deps.Organization(this, organizationData, { User, Project: this.deps.Project, News: this.deps.News, EndpointApi : this.deps.EndpointApi });
-      if (organizationData.id || organizationData.slug) {
-        await organization.get();
-      }
-      return organization;
-    } catch (error) {
-      this.apiClient._logger.error(`[Api.${this.__entityTag}.organization] Erreur lors de la création d'une instance organization :`, error.message);
-      throw error;
-    }
-  }
 
   /**
    * Récupérer les projets d'un utilisateur : Récupère la liste des projets auxquels l'utilisateur contribue.
@@ -409,13 +426,9 @@ export class User {
     if (!Array.isArray(arrayObjetProjects.results)) {
       throw new ApiResponseError("Erreur lors de la récupération des projets.", 500, arrayObjetProjects.results);
     }
-  
-    const rawProjectsList = arrayObjetProjects.results.map((projectData) =>
-      this.deps.Project.fromServerData(projectData, this, {
-        User,
-        News: this.deps.News,
-        EndpointApi: this.deps.EndpointApi
-      })
+
+    const rawProjectsList = arrayObjetProjects.results.map(
+      (d) => this.linkEntity?.(d.collection, d) ?? d
     );
   
     return {
@@ -423,25 +436,39 @@ export class User {
       results: rawProjectsList
     };
   }
-  
+
   /**
-   * Crée une instance de projet et récupère son profil si nécessaire.
-   *
-   * @param {Object} projectData - Les données nécessaires pour initialiser le projet.
-   * @returns {Promise<Project>} Une promesse qui résout l'objet Projet créé.
-   * @throws {Error} Si une erreur se produit lors de la création du projet.
+   * Récupérer les POIs
+   * Constant : GET_POIS_NO_ADMIN / GET_POIS_ADMIN
    */
-  async project(projectData = {}, ) {
-    try {
-      const project = new this.deps.Project(this, projectData, { 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;
+  async getPois(data = {}) {
+    delete data?.pathParams;
+  
+    const fetchFn = this.isMe
+      ? () => this.callIsMe(() => this.endpointApi.getPoisAdmin(data))
+      : () => this.endpointApi.getPoisNoAdmin(data);
+  
+    
+    if (!this.isMe && !data.filters) {
+      data.filters = {
+        [`parent.${this.id}`]: { "$exists": true },
+      };
+    }
+  
+    const arrayObjetPois = await fetchFn();
+    if (!Array.isArray(arrayObjetPois.results)) {
+      throw new ApiResponseError("Erreur lors de la récupération des POIs.", 500, arrayObjetPois.results);
     }
+
+    // lier les entités au objets
+    const rawPoisList = arrayObjetPois.results.map(
+      (d) => this.linkEntity?.(d.collection, d) ?? d
+    );
+
+    return {
+      count: arrayObjetPois.count?.poi ?? 0,
+      results: rawPoisList
+    };
   }
 
   /**
@@ -460,13 +487,191 @@ export class User {
     if(!Array.isArray(arrayObjetNews)){
       throw new ApiResponseError("Erreur lors de la récupération des actualités.", 500, arrayObjetNews);
     }
-    const rawNewsList = arrayObjetNews.map((newsData) =>
-      this.deps.News.fromServerData(newsData, this, { User, EndpointApi: this.deps.EndpointApi })
+
+    const rawNewsList = arrayObjetNews.map(
+      (d) => this.linkEntity?.(d.collection, d) ?? d
     );
 
     return this._createFilteredProxy(rawNewsList);
   }
 
+  /**
+   * Récupérer les amis administrables : Récupère les amis administrée par l’utilisateur.
+   * Constant : GET_FRIENDS_ADMIN
+   * question : qui peut voir la liste d'amis, seulement l'utilisateur connecté ? ou tous les utilisateurs connectés ?
+   * actuellement, c'est tous les utilisateurs connectés
+   */
+  async getFriends(data = {}) {
+    delete data?.pathParams;
+
+    if (!this.isMe){
+      // is not me add id
+      data.pathParams = { id: this.id };
+    }
+
+    const arrayObjetFriends = await this.endpointApi.getFriendsAdmin(data);
+    if(!Array.isArray(arrayObjetFriends.results)){
+      throw new ApiResponseError("Erreur lors de la récupération des amis administrables.", 500, arrayObjetFriends);
+
+    }
+
+    const rawFriendsList = arrayObjetFriends.results.map(
+      (d) => this.linkEntity?.(d.collection, d) ?? d
+    );
+
+    return {
+      count: arrayObjetFriends?.count?.citoyens ?? 0,
+      results: rawFriendsList
+    };
+  }
+
+  /**
+   * Récupérer les suivis
+   * Constant : GET_SUBSCRIPTIONS / GET_SUBSCRIPTIONS_ADMIN
+   */
+  async getSubscriptions(data = {}) {
+    delete data?.pathParams;
+  
+    const fetchFn = this.isMe
+      ? () => this.callIsMe(() => this.endpointApi.getSubscriptionsAdmin(data))
+      : () => this.endpointApi.getSubscriptions(data);
+  
+    if (!this.isMe && !data.filters) {
+      data.filters = {
+        [`links.followers.${this.id}`]: { "$exists": true },
+      };
+    }
+  
+    const arrayObjetSubscriptions = await fetchFn();
+    if (!Array.isArray(arrayObjetSubscriptions.results)) {
+      throw new ApiResponseError("Erreur lors de la récupération des abonnements.", 500, arrayObjetSubscriptions.results);
+    }
+
+    // lier les entités au objets
+    const rawSubscriptionsList = arrayObjetSubscriptions.results.map(
+      (d) => this.linkEntity?.(d.collection, d) ?? d
+    );
+
+    return {
+      count: arrayObjetSubscriptions.count,
+      results: rawSubscriptionsList
+    };
+  }   
+
+  /**
+   * Récupérer les abonnés
+   * Constant : GET_SUBSCRIBERS
+   */
+  async getSubscribers(data = {}) {
+    delete data?.pathParams;
+  
+    if (!this.isMe && !data.filters) {
+      data.filters = {
+        [`links.follows.${this.id}`]: { "$exists": true },
+      };
+    }
+  
+    const arrayObjetSubscribers = await  this.endpointApi.getSubscribers(data);
+    if (!Array.isArray(arrayObjetSubscribers.results)) {
+      throw new ApiResponseError("Erreur lors de la récupération des abonnés.", 500, arrayObjetSubscribers.results);
+    }
+
+    // lier les entités au objets
+    const rawSubscribersList = arrayObjetSubscribers.results.map(
+      (d) => this.linkEntity?.(d.collection, d) ?? d
+    );
+
+    return {
+      count: arrayObjetSubscribers.count,
+      results: rawSubscribersList
+    };
+  }
+
+  /**
+   * Obtenir la liste des événements
+   * Constant : GET_EVENTS
+   * TODO : il n'est pas fait encore pour GET_EVENTS_ADMIN / GET_EVENTS_NO_ADMIN comme les autres dans endpointApi
+   */
+
+  /**
+   * Liste des badges créés par l'utilisateur
+   * Constant : GET_BADGES
+   */
+  async getBadgesIssuer(data = {}) {
+    delete data?.pathParams;
+  
+    data.filters = data.filters || {};
+    data.filters["$or"] = {};
+    data.filters["$or"][`issuer.${this.id}`] = { "$exists": true };
+
+    const arrayObjetBadges = await this.endpointApi.getBadges(data);
+    if (!Array.isArray(arrayObjetBadges.results)) {
+      throw new ApiResponseError("Erreur lors de la récupération des badges.", 500, arrayObjetBadges.results);
+    }
+
+    // lier les entités au objets
+    const rawBadgesList = arrayObjetBadges.results.map(
+      (d) => this.linkEntity?.(d.collection, d) ?? d
+    );
+
+    return {
+      count: arrayObjetBadges.count?.badges ?? 0,
+      results: rawBadgesList
+    };
+  }
+
+  /**
+   * Liste des badges associés à l'utilisateur
+   * 
+   * TODO : documenté le fonctionnement et sont utilisation avec un exemple
+   */
+  async getBadges(filter = {}) {
+    /*
+      "badges": {
+            "627df5663a0fae60e57f4a31": {
+                "attenteRecepteur": true,
+                "expiredOn": false,
+                "isParcours": "false",
+                "issuedOn": "2023-10-02T14:00:00.000Z",
+                "name": "CODEV",
+                "show": "true",
+            },
+        },
+    */
+
+    const filteredBadges = await this.linkEntitiesFromServerData("badges", filter);
+    // voir si je les met dans objet { count, results }
+    return filteredBadges;
+  }
+
+  /**
+   * Crée une instance d'organisation et récupère son profil si nécessaire.
+   *
+   * @param {Object} organizationData - Les données nécessaires pour initialiser l'organisation.
+   * @returns {Promise<Organization>} Une promesse qui résout l'objet Organisation créé.
+   * @throws {Error} Si une erreur se produit lors de la création de l'organisation.
+   */
+  async organization(organizationData = {}) {
+    if(!this.isMe){
+      throw new ApiError("Vous devez être connecté et être l'utilisateur pour créer une organisation.");
+    }
+    return this.entity("organizations", organizationData);
+  }
+
+  /**
+   * Crée une instance de projet et récupère son profil si nécessaire.
+   *
+   * @param {Object} projectData - Les données nécessaires pour initialiser le projet.
+   * @returns {Promise<Project>} Une promesse qui résout l'objet Projet créé.
+   * @throws {Error} Si une erreur se produit lors de la création du projet.
+   */
+  async project(projectData = {}) {
+    if(!this.isMe){
+      throw new ApiError("Vous devez être connecté et être l'utilisateur pour créer un projet.");
+    }
+    return this.entity("projects", projectData);
+  }
+
   /**
    * Crée une instance de news et la récupère si nécessaire.
    * 
@@ -474,26 +679,62 @@ export class User {
    * @returns {Promise<News>} Une promesse qui résout l'objet News créé.
    * @throws {Error} Si une erreur se produit lors de la création de la news.
    */
-  async news(newsData = {}, ) {
-    try {
-      const news = new this.deps.News(this, newsData, { User, EndpointApi : this.deps.EndpointApi });
-      if (newsData.id) {
-        await news.get();
-      }
-      return news;
-    } catch (error) {
-      this.apiClient._logger.error(`[Api.${this.__entityTag}.news] Erreur lors de la création d'une instance news :`, error.message);
-      throw error;
+  async news(newsData = {}) {
+    if(!this.isMe){
+      throw new ApiError("Vous devez être connecté et être l'utilisateur pour créer une actualité.");
+    }
+    return this.entity("news", newsData);
+  }
+
+  /**
+   * Crée une instance de POI et la récupère si nécessaire.
+   * 
+   * @param {Object} poiData - Les données nécessaires pour initialiser le POI.
+   * @returns {Promise<Poi>} Une promesse qui résout l'objet POI créé.
+   * @throws {Error} Si une erreur se produit lors de la création du POI.
+   */
+  async poi(poiData = {}) {
+    if(!this.isMe){
+      throw new ApiError("Vous devez être connecté et être l'utilisateur pour créer un POI.");
+    }
+    return this.entity("poi", poiData);
+  }
+
+  /**
+   * Crée une instance d'événement et la récupère si nécessaire.
+   * 
+   * @param {Object} eventData - Les données nécessaires pour initialiser l'événement.
+   * @returns {Promise<Event>} Une promesse qui résout l'objet Événement créé.
+   * @throws {Error} Si une erreur se produit lors de la création de l'événement.
+   */
+  async event(eventData = {}) {
+    if(!this.isMe){
+      throw new ApiError("Vous devez être connecté et être l'utilisateur pour créer un événement.");
+    }
+    return this.entity("events", eventData);
+  }
+
+  /**
+   * Crée une instance de badge et la récupère si nécessaire.
+   * 
+   * @param {Object} badgeData - Les données nécessaires pour initialiser le badge.
+   * @returns {Promise<Badge>} Une promesse qui résout l'objet Badge créé.
+   * @throws {Error} Si une erreur se produit lors de la création du badge.
+   */
+  async badge(badgeData = {}) {
+    if(!this.isMe){
+      throw new ApiError("Vous devez être connecté et être l'utilisateur pour créer un badge.");
     }
+    return this.entity("badges", badgeData);
   }
 
   _updateInitialDraftSnapshot() {
-    this.#initialDraftData = JSON.parse(JSON.stringify(this.#draftData));
+    this._initialDraftData = JSON.parse(JSON.stringify(this._draftData));
   }
 
   // TODO: ne fonctionne pas
   hasChanges() {
-    return JSON.stringify(this.#draftData) !== JSON.stringify(this.#initialDraftData);
+    return JSON.stringify(this._draftData) !== JSON.stringify(this._initialDraftData);
   }
 
   /**

package/src/api/UserApi.js

@@ -1,9 +1,12 @@
 // UserApi.js
 import ApiClient from "../ApiClient.js";
 import { ApiError, ApiResponseError } from "../error.js";
+import { Badge } from "./Badge.js";
 import EndpointApi from "./EndpointApi.js";
+import { Event } from "./Event.js";
 import { News } from "./News.js";
 import { Organization } from "./Organization.js";
+import { Poi } from "./Poi.js";
 import { Project } from "./Project.js";
 import { User } from "./User.js";
 
@@ -34,7 +37,7 @@ export class UserApi {
     // Appel à un endpoint d'authentification
       const response = await this.client.callEndpoint("AUTHENTICATE_URL", { email, password });
       // Création d'une instance de LoggedInUser à partir des données reçues
-      this.loggedUser = new User(this.client, response.data.user, { EndpointApi, Organization, Project, News });
+      this.loggedUser = new User(this.client, response.data.user, { EndpointApi, Organization, Project, Event, Poi, Badge, News });
       return this.loggedUser;
     });
   }
@@ -44,7 +47,7 @@ export class UserApi {
       throw new ApiError("User not connected", 401);
     }
     this.client._logger.info("UserApi", "meIsconnected", this.client.userId);
-    this.loggedUser = new User(this.client, { id: this.client.userId }, { EndpointApi, Organization, Project, News });
+    this.loggedUser = new User(this.client, { id: this.client.userId }, { EndpointApi, Organization, Project, Event, Poi, Badge, News });
     return this.loggedUser;
   }