reneco-hierarchized-picker 0.5.4-beta.1 → 0.5.5

package/dist/cjs/reneco-hierarchized-picker_2.cjs.entry.js

@@ -18247,37 +18247,45 @@ class RawDataManager {
   }
   // Fetch node ID from fullpath
   async fetchNodeIdFromFullpath(fullpath, options) {
-    // const payload = {...this.optionsManager.getOptions().options, fullpath};
-    let payload;
-    switch (options.origin) {
-      case "thesaurus":
-        payload = {
-          "iStartNode": this.optionsManager.getOptions().options.StartNodeID,
-          "sValue": fullpath,
-          "sTypeField": "fullpath"
-        };
-        break;
-      case "position":
-        payload = {
-          "value": fullpath,
-          "startNodeId": this.optionsManager.getOptions().options.StartNodeID,
-        };
-        break;
-      default:
-        throw new Error(`Invalid origin: ${options.origin}, only 'thesaurus' and 'position' implemented for now...`);
-    }
-    const endpoint = this.getApiNodeFromFullpathURL(options);
     let fullpathid = 0;
-    await this.makeRequest('POST', endpoint, payload).then((result) => {
-      if (result.exist) {
-        if (options.origin === 'thesaurus')
+    if (options.origin === 'classification') {
+      const endpoint = this.getApiNodeFromFullpathURL(options);
+      const encodedFullpath = encodeURIComponent(fullpath);
+      await this.makeRequest('GET', `${endpoint}?fullpath=${encodedFullpath}`).then((result) => {
+        if (result.ID) {
+          fullpathid = result.ID;
+        }
+      });
+    }
+    else {
+      let payload;
+      switch (options.origin) {
+        case "thesaurus":
+          payload = {
+            "iStartNode": this.optionsManager.getOptions().options.StartNodeID,
+            "sValue": fullpath,
+            "sTypeField": "fullpath"
+          };
+          break;
+        case "position":
+          payload = {
+            "value": fullpath,
+            "startNodeId": this.optionsManager.getOptions().options.StartNodeID,
+          };
+          break;
+        default:
+          throw new Error(`Invalid origin: ${options.origin}, only 'thesaurus', 'position' and 'classification' implemented...`);
+      }
+      const endpoint = this.getApiNodeFromFullpathURL(options);
+      await this.makeRequest('POST', endpoint, payload).then((result) => {
+        if (options.origin === 'thesaurus' && result.exist) {
           fullpathid = result.topic.TTop_PK_ID;
-        if (options.origin === 'position')
+        }
+        else if (options.origin === 'position' && result.exist) {
           fullpathid = result.position.ID;
-        if (options.origin === 'classification')
-          fullpathid = result.node.ID;
-      }
-    });
+        }
+      });
+    }
     return fullpathid;
   }
   // Get API URL for node existence check
@@ -18289,7 +18297,10 @@ class RawDataManager {
       case 'position':
         return `${trimmedBaseUrl}/PositionExistByFp`;
       case 'classification':
-        return `${trimmedBaseUrl}/exists`;
+        const baseUrl = this.baseUrl.substring(0, this.baseUrl.indexOf('/classification/') + '/classification/'.length);
+        const urlParts = this.baseUrl.split('/');
+        const context = urlParts[urlParts.length - 1] || 'Thesaurus';
+        return `${baseUrl}fullpath/${context}/`;
       default:
         throw new Error(`Invalid origin: ${options.origin}`);
     }

package/dist/collection/core/raw-data-manager.js

@@ -88,37 +88,45 @@ export class RawDataManager {
   }
   // Fetch node ID from fullpath
   async fetchNodeIdFromFullpath(fullpath, options) {
-    // const payload = {...this.optionsManager.getOptions().options, fullpath};
-    let payload;
-    switch (options.origin) {
-      case "thesaurus":
-        payload = {
-          "iStartNode": this.optionsManager.getOptions().options.StartNodeID,
-          "sValue": fullpath,
-          "sTypeField": "fullpath"
-        };
-        break;
-      case "position":
-        payload = {
-          "value": fullpath,
-          "startNodeId": this.optionsManager.getOptions().options.StartNodeID,
-        };
-        break;
-      default:
-        throw new Error(`Invalid origin: ${options.origin}, only 'thesaurus' and 'position' implemented for now...`);
-    }
-    const endpoint = this.getApiNodeFromFullpathURL(options);
     let fullpathid = 0;
-    await this.makeRequest('POST', endpoint, payload).then((result) => {
-      if (result.exist) {
-        if (options.origin === 'thesaurus')
+    if (options.origin === 'classification') {
+      const endpoint = this.getApiNodeFromFullpathURL(options);
+      const encodedFullpath = encodeURIComponent(fullpath);
+      await this.makeRequest('GET', `${endpoint}?fullpath=${encodedFullpath}`).then((result) => {
+        if (result.ID) {
+          fullpathid = result.ID;
+        }
+      });
+    }
+    else {
+      let payload;
+      switch (options.origin) {
+        case "thesaurus":
+          payload = {
+            "iStartNode": this.optionsManager.getOptions().options.StartNodeID,
+            "sValue": fullpath,
+            "sTypeField": "fullpath"
+          };
+          break;
+        case "position":
+          payload = {
+            "value": fullpath,
+            "startNodeId": this.optionsManager.getOptions().options.StartNodeID,
+          };
+          break;
+        default:
+          throw new Error(`Invalid origin: ${options.origin}, only 'thesaurus', 'position' and 'classification' implemented...`);
+      }
+      const endpoint = this.getApiNodeFromFullpathURL(options);
+      await this.makeRequest('POST', endpoint, payload).then((result) => {
+        if (options.origin === 'thesaurus' && result.exist) {
           fullpathid = result.topic.TTop_PK_ID;
-        if (options.origin === 'position')
+        }
+        else if (options.origin === 'position' && result.exist) {
           fullpathid = result.position.ID;
-        if (options.origin === 'classification')
-          fullpathid = result.node.ID;
-      }
-    });
+        }
+      });
+    }
     return fullpathid;
   }
   // Get API URL for node existence check
@@ -130,7 +138,10 @@ export class RawDataManager {
       case 'position':
         return `${trimmedBaseUrl}/PositionExistByFp`;
       case 'classification':
-        return `${trimmedBaseUrl}/exists`;
+        const baseUrl = this.baseUrl.substring(0, this.baseUrl.indexOf('/classification/') + '/classification/'.length);
+        const urlParts = this.baseUrl.split('/');
+        const context = urlParts[urlParts.length - 1] || 'Thesaurus';
+        return `${baseUrl}fullpath/${context}/`;
       default:
         throw new Error(`Invalid origin: ${options.origin}`);
     }

package/dist/custom-elements/index.js

@@ -18244,37 +18244,45 @@ class RawDataManager {
   }
   // Fetch node ID from fullpath
   async fetchNodeIdFromFullpath(fullpath, options) {
-    // const payload = {...this.optionsManager.getOptions().options, fullpath};
-    let payload;
-    switch (options.origin) {
-      case "thesaurus":
-        payload = {
-          "iStartNode": this.optionsManager.getOptions().options.StartNodeID,
-          "sValue": fullpath,
-          "sTypeField": "fullpath"
-        };
-        break;
-      case "position":
-        payload = {
-          "value": fullpath,
-          "startNodeId": this.optionsManager.getOptions().options.StartNodeID,
-        };
-        break;
-      default:
-        throw new Error(`Invalid origin: ${options.origin}, only 'thesaurus' and 'position' implemented for now...`);
-    }
-    const endpoint = this.getApiNodeFromFullpathURL(options);
     let fullpathid = 0;
-    await this.makeRequest('POST', endpoint, payload).then((result) => {
-      if (result.exist) {
-        if (options.origin === 'thesaurus')
+    if (options.origin === 'classification') {
+      const endpoint = this.getApiNodeFromFullpathURL(options);
+      const encodedFullpath = encodeURIComponent(fullpath);
+      await this.makeRequest('GET', `${endpoint}?fullpath=${encodedFullpath}`).then((result) => {
+        if (result.ID) {
+          fullpathid = result.ID;
+        }
+      });
+    }
+    else {
+      let payload;
+      switch (options.origin) {
+        case "thesaurus":
+          payload = {
+            "iStartNode": this.optionsManager.getOptions().options.StartNodeID,
+            "sValue": fullpath,
+            "sTypeField": "fullpath"
+          };
+          break;
+        case "position":
+          payload = {
+            "value": fullpath,
+            "startNodeId": this.optionsManager.getOptions().options.StartNodeID,
+          };
+          break;
+        default:
+          throw new Error(`Invalid origin: ${options.origin}, only 'thesaurus', 'position' and 'classification' implemented...`);
+      }
+      const endpoint = this.getApiNodeFromFullpathURL(options);
+      await this.makeRequest('POST', endpoint, payload).then((result) => {
+        if (options.origin === 'thesaurus' && result.exist) {
           fullpathid = result.topic.TTop_PK_ID;
-        if (options.origin === 'position')
+        }
+        else if (options.origin === 'position' && result.exist) {
           fullpathid = result.position.ID;
-        if (options.origin === 'classification')
-          fullpathid = result.node.ID;
-      }
-    });
+        }
+      });
+    }
     return fullpathid;
   }
   // Get API URL for node existence check
@@ -18286,7 +18294,10 @@ class RawDataManager {
       case 'position':
         return `${trimmedBaseUrl}/PositionExistByFp`;
       case 'classification':
-        return `${trimmedBaseUrl}/exists`;
+        const baseUrl = this.baseUrl.substring(0, this.baseUrl.indexOf('/classification/') + '/classification/'.length);
+        const urlParts = this.baseUrl.split('/');
+        const context = urlParts[urlParts.length - 1] || 'Thesaurus';
+        return `${baseUrl}fullpath/${context}/`;
       default:
         throw new Error(`Invalid origin: ${options.origin}`);
     }

package/dist/esm/reneco-hierarchized-picker_2.entry.js

@@ -18243,37 +18243,45 @@ class RawDataManager {
   }
   // Fetch node ID from fullpath
   async fetchNodeIdFromFullpath(fullpath, options) {
-    // const payload = {...this.optionsManager.getOptions().options, fullpath};
-    let payload;
-    switch (options.origin) {
-      case "thesaurus":
-        payload = {
-          "iStartNode": this.optionsManager.getOptions().options.StartNodeID,
-          "sValue": fullpath,
-          "sTypeField": "fullpath"
-        };
-        break;
-      case "position":
-        payload = {
-          "value": fullpath,
-          "startNodeId": this.optionsManager.getOptions().options.StartNodeID,
-        };
-        break;
-      default:
-        throw new Error(`Invalid origin: ${options.origin}, only 'thesaurus' and 'position' implemented for now...`);
-    }
-    const endpoint = this.getApiNodeFromFullpathURL(options);
     let fullpathid = 0;
-    await this.makeRequest('POST', endpoint, payload).then((result) => {
-      if (result.exist) {
-        if (options.origin === 'thesaurus')
+    if (options.origin === 'classification') {
+      const endpoint = this.getApiNodeFromFullpathURL(options);
+      const encodedFullpath = encodeURIComponent(fullpath);
+      await this.makeRequest('GET', `${endpoint}?fullpath=${encodedFullpath}`).then((result) => {
+        if (result.ID) {
+          fullpathid = result.ID;
+        }
+      });
+    }
+    else {
+      let payload;
+      switch (options.origin) {
+        case "thesaurus":
+          payload = {
+            "iStartNode": this.optionsManager.getOptions().options.StartNodeID,
+            "sValue": fullpath,
+            "sTypeField": "fullpath"
+          };
+          break;
+        case "position":
+          payload = {
+            "value": fullpath,
+            "startNodeId": this.optionsManager.getOptions().options.StartNodeID,
+          };
+          break;
+        default:
+          throw new Error(`Invalid origin: ${options.origin}, only 'thesaurus', 'position' and 'classification' implemented...`);
+      }
+      const endpoint = this.getApiNodeFromFullpathURL(options);
+      await this.makeRequest('POST', endpoint, payload).then((result) => {
+        if (options.origin === 'thesaurus' && result.exist) {
           fullpathid = result.topic.TTop_PK_ID;
-        if (options.origin === 'position')
+        }
+        else if (options.origin === 'position' && result.exist) {
           fullpathid = result.position.ID;
-        if (options.origin === 'classification')
-          fullpathid = result.node.ID;
-      }
-    });
+        }
+      });
+    }
     return fullpathid;
   }
   // Get API URL for node existence check
@@ -18285,7 +18293,10 @@ class RawDataManager {
       case 'position':
         return `${trimmedBaseUrl}/PositionExistByFp`;
       case 'classification':
-        return `${trimmedBaseUrl}/exists`;
+        const baseUrl = this.baseUrl.substring(0, this.baseUrl.indexOf('/classification/') + '/classification/'.length);
+        const urlParts = this.baseUrl.split('/');
+        const context = urlParts[urlParts.length - 1] || 'Thesaurus';
+        return `${baseUrl}fullpath/${context}/`;
       default:
         throw new Error(`Invalid origin: ${options.origin}`);
     }