@communecter/cocolight-api-client 1.0.20 → 1.0.21

package/src/api/Organization.js

@@ -1,3 +1,4 @@
+import { ApiResponseError } from "../error.js";
 import BaseEntity from "./BaseEntity.js";
 
 export class Organization extends BaseEntity {
@@ -132,6 +133,82 @@ export class Organization extends BaseEntity {
     return super.getSubscribers(data);
   }
 
+  /**
+   * Récupérer les membres de l'organisation.
+   * 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.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 membres et la liste des membres.
+   */
+  async getMembers(data = {}, options = {}) {
+    const { isAdmin, 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 }
+      // };
+    } else {
+      delete data?.pathParams;
+      data.filters = this._buildMemberFilters(this.id, { isAdmin, isInviting, roles });
+    }
+  
+    const fetchFn = this.isMe
+      ? () => this.callIsMe(() => this.endpointApi.getMembersAdmin(data))
+      : () => this.endpointApi.getMembersNoAdmin(data);
+  
+    const arrayObjet = await fetchFn();
+    if (!Array.isArray(arrayObjet.results)) {
+      throw new ApiResponseError("Erreur lors de la récupération des membres", 500, arrayObjet.results);
+    }
+
+    // lier les entités au objets
+    const rawList = this._linkEntities(arrayObjet.results);
+
+    return {
+      count: arrayObjet.count?.poi ?? 0,
+      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.
    *

package/src/api/User.js

@@ -25,29 +25,14 @@ export class User extends BaseEntity {
     ["PROFIL_IMAGE", "updateImageProfil"]
   ]);
 
-  /**
-   * Champs par défaut pour les schemas json ou l'on extrait les fields. (pour les if/else/then)
-   * 
-   * @property {Object} defaultFields - Un objet contenant les propriétés par défaut pour l'entité User.
-   */
   defaultFields = {
     typeElement: this.getEntityType(), 
   };
     
-  /**
-       * Champs à supprimer de draft lors de la construction du proxy.
-       * 
-       * @property {Array<string>} removeFields - Un tableau de chaînes représentant les champs à supprimer.
-       */
   removeFields = [
     "typeElement",
   ];
       
-  /**
-       * Transformateurs appliqués lors de la lecture du draft.
-       *
-       * @type {Object<string, function>}
-       */
   transforms = {
     github: (val, full) => full?.socialNetwork?.github,
     gitlab: (val, full) => full?.socialNetwork?.gitlab,
@@ -95,8 +80,6 @@ export class User extends BaseEntity {
     if (!deps.News) throw new ApiError("News class must be injected.");
       
     super(parent, data, deps);
-
-    // this.__entityTag = "User";
   }
       
   get slug() {
@@ -121,7 +104,7 @@ export class User extends BaseEntity {
         this._setData(data);
         return data;
       } else {
-        const data = await this.getPublicProfile();
+        const data = await this._getPublicProfile();
         this._setData(data);
         return data;
       }
@@ -318,26 +301,24 @@ export class User extends BaseEntity {
       };
     }
   
-    const arrayObjetOrganizations = await fetchFn();
+    const arrayObjet = await fetchFn();
   
-    if (!Array.isArray(arrayObjetOrganizations.results)) {
-      throw new ApiResponseError("Erreur lors de la récupération des organisations.", 500, arrayObjetOrganizations.results);
+    if (!Array.isArray(arrayObjet.results)) {
+      throw new ApiResponseError("Erreur lors de la récupération des organisations.", 500, arrayObjet.results);
     }
   
     // nettoyage du count
-    delete arrayObjetOrganizations?.count?.spam;
+    delete arrayObjet?.count?.spam;
   
     // calcul du total
-    const totalCount = Object.values(arrayObjetOrganizations.count || {}).reduce((acc, val) => acc + val, 0);
-    arrayObjetOrganizations.count.total = totalCount;
+    const totalCount = Object.values(arrayObjet.count || {}).reduce((acc, val) => acc + val, 0);
+    arrayObjet.count.total = totalCount;
   
-    const rawOrganizationsList = arrayObjetOrganizations.results.map(
-      (d) => this.linkEntity?.(d.collection, d) ?? d
-    );
+    const rawList = this._linkEntities(arrayObjet.results);
   
     return {
-      count: arrayObjetOrganizations.count,
-      results: rawOrganizationsList
+      count: arrayObjet.count,
+      results: rawList
     };
   }
 
@@ -379,19 +360,17 @@ export class User extends BaseEntity {
       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 arrayObjet = await this.endpointApi.getFriendsAdmin(data);
+    if(!Array.isArray(arrayObjet.results)){
+      throw new ApiResponseError("Erreur lors de la récupération des amis administrables.", 500, arrayObjet);
 
     }
 
-    const rawFriendsList = arrayObjetFriends.results.map(
-      (d) => this.linkEntity?.(d.collection, d) ?? d
-    );
+    const rawList = this._linkEntities(arrayObjet.results);
 
     return {
-      count: arrayObjetFriends?.count?.citoyens ?? 0,
-      results: rawFriendsList
+      count: arrayObjet?.count?.citoyens ?? 0,
+      results: rawList
     };
   }
 
@@ -412,19 +391,17 @@ export class User extends BaseEntity {
       };
     }
   
-    const arrayObjetSubscriptions = await fetchFn();
-    if (!Array.isArray(arrayObjetSubscriptions.results)) {
-      throw new ApiResponseError("Erreur lors de la récupération des abonnements.", 500, arrayObjetSubscriptions.results);
+    const arrayObjet = await fetchFn();
+    if (!Array.isArray(arrayObjet.results)) {
+      throw new ApiResponseError("Erreur lors de la récupération des abonnements.", 500, arrayObjet.results);
     }
 
     // lier les entités au objets
-    const rawSubscriptionsList = arrayObjetSubscriptions.results.map(
-      (d) => this.linkEntity?.(d.collection, d) ?? d
-    );
+    const rawList = this._linkEntities(arrayObjet.results);
 
     return {
-      count: arrayObjetSubscriptions.count,
-      results: rawSubscriptionsList
+      count: arrayObjet.count,
+      results: rawList
     };
   }   
 

package/src/mixin/DraftStateMixin.js

@@ -1,176 +0,0 @@
-// DraftStateMixin.js
-import { ApiError, ApiValidationError } from "../error.js";
-
-export const DraftStateMixin = {
-
-  /**
-   * Crée un proxy combinant draft + serveur, avec transformations facultatives.
-   * @param {Object} server
-   * @param {Object} draft
-   * @param {Array} allowedFields - champs autorisés dans le draft
-   * @param {Object} [transforms={}] - transformateurs de lecture
-   * @param {Object} [options={}] - options
-   * @returns {Proxy}
-   */
-  _createDraftProxy(apiClient, server = {}, draft = {}, allowedFields = [], transforms = {}, options = {}) {
-    return new Proxy({}, {
-      get: (_, prop) => {
-        const val = prop in draft ? draft[prop] : server[prop];
-        const transformer = transforms[prop];
-        return typeof transformer === "function" ? transformer(val) : val;
-      },
-
-      set: (_, prop, value) => {
-        if (!allowedFields.includes(prop)) {
-          const message = `[DraftProxy] Le champ "${prop}" n'est pas autorisé.`;
-          if (options.throwOnError) {
-            throw new ApiValidationError(message, 400, null, {
-              field: prop,
-              value,
-              allowedFields
-            });
-          }
-          apiClient._logger.warn(message);
-          return false;
-        }
-        draft[prop] = value;
-        return true;
-      },
-
-      deleteProperty: (_, prop) => {
-        if (!allowedFields.includes(prop)) return false;
-        delete draft[prop];
-        return true;
-      },
-
-      has: (_, prop) => prop in draft || prop in server,
-      ownKeys: () => [...new Set([...Object.keys(server), ...Object.keys(draft)])],
-      getOwnPropertyDescriptor: () => ({ enumerable: true, configurable: true })
-    });
-  },
-
-  _extractWritableFields(schema = {}, data = {}, ctx = { defs: {}, visited: new Set() }) {
-    if (!schema || typeof schema !== "object") return [];
-    if (schema.$id && ctx.visited.has(schema.$id)) return [];
-    if (schema.$id) ctx.visited.add(schema.$id);
-    ctx.defs = schema.$defs || schema.definitions || ctx.defs;
-
-    const fields = [];
-
-    if (schema.$ref) {
-      const refKey = schema.$ref.replace(/^#\/?(\$defs|definitions)\//, "");
-      const resolved = ctx.defs?.[refKey];
-      if (resolved) fields.push(...this._extractWritableFields(resolved, data, ctx));
-    }
-
-    if (schema.allOf) {
-      schema.allOf.forEach(s => fields.push(...this._extractWritableFields(s, data, ctx)));
-    }
-
-    if (schema.if && schema.then) {
-      const condition = schema.if?.properties;
-      let matches = true;
-      if (condition) {
-        for (const key in condition) {
-          const expected = condition[key]?.const;
-          if (data[key] !== expected) {
-            matches = false;
-            break;
-          }
-        }
-      }
-      if (matches && schema.then) {
-        fields.push(...this._extractWritableFields(schema.then, data, ctx));
-      } else if (!matches && schema.else) {
-        fields.push(...this._extractWritableFields(schema.else, data, ctx));
-      }
-    }
-
-    if (schema.properties) {
-      fields.push(...Object.entries(schema.properties)
-        // eslint-disable-next-line no-unused-vars
-        .filter(([_, def]) => def.readOnly !== true && def.const === undefined)
-        .map(([key]) => key));
-    }
-
-    return [...new Set(fields)];
-  },
-
-  _buildDraftAndProxy({ data = {}, serverData = null, constant, apiClient, transforms = {}, throwOnError = true, removeFields = [] }) {
-    const constants = Array.isArray(constant) ? constant : [constant];
-    const combinedSchema = {
-      allOf: [],
-      $defs: {}
-    };
-    
-    for (const key of constants) {
-      const sch = apiClient.getRequestSchema(key);
-      if (!sch) throw new ApiError(`Unable to find schema for ${key}.`);
-    
-      // Extraire et fusionner les $defs
-      if (sch.$defs) {
-        for (const [defKey, defVal] of Object.entries(sch.$defs)) {
-          if (combinedSchema.$defs[defKey]) {
-            apiClient._logger.warn(`Duplicate $defs key '${defKey}' from schema '${key}'`);
-          } else {
-            combinedSchema.$defs[defKey] = defVal;
-          }
-        }
-      }
-    
-      combinedSchema.allOf.push(sch);
-    }
-    const draft = {};
-    let allowed = this._extractWritableFields(combinedSchema, data);
-
-    if (data.id && allowed.indexOf("id") === -1) {
-      allowed.push("id");
-    }
-    if (data.slug && allowed.indexOf("slug") === -1) {  
-      allowed.push("slug");
-    }
-
-    allowed = allowed.filter(k => !removeFields.includes(k));
-
-    for (const key of allowed) {
-      const raw = data[key];
-      const transformed = typeof transforms[key] === "function" ? transforms[key](raw, data) : raw;
-      if (transformed !== undefined) draft[key] = transformed;
-    }
-
-    const proxy = this._createDraftProxy(apiClient, serverData, draft, allowed, transforms, { throwOnError });
-
-    return { draft, proxy };
-  },
-
-  _extractChangedFieldsFromSchema(apiClient, constant, data = {}, getInitialDraft, removeFields = []) {
-    const schema = apiClient.getRequestSchema(constant);
-    let allowed = this._extractWritableFields(schema, data);
-    const changed = {};
-    const initialDraft = getInitialDraft?.() || {};
-  
-    // on enlève les champs qui ne sont pas dans le draft
-    // ou qui sont dans removeFields
-    allowed = allowed.filter(k => !removeFields.includes(k));
-
-    for (const key of allowed) {
-      // on verifie que le champ existe dans le draft
-      // sinon on ne le prend pas en compte
-
-      if (data[key] === undefined) continue;
-  
-      const current = data[key];
-      const initial = initialDraft[key];
-  
-      const changedValue =
-        JSON.stringify(current) !== JSON.stringify(initial);
-  
-      if (changedValue) {
-        changed[key] = current;
-      }
-    }
-  
-    return Object.keys(changed).length > 0 ? changed : null;
-  }
-  
-};