@beinformed/ui 1.57.0-contextpath.0 → 1.57.0

package/src/hooks/useModularUIBasic.js

@@ -1,10 +1,8 @@
 // @flow
+import { useMemo } from "react";
 import { useModularUI } from "./useModularUI";
-
 import { useLocation } from "./useRouter";
-
 import { IllegalStateException } from "../exceptions";
-
 import type { ModularUIModel, Href } from "../models";
 
 export type UseModularUIBasicOptions<T: ModularUIModel> = {
@@ -16,22 +14,13 @@ export type UseModularUIBasicOptions<T: ModularUIModel> = {
   cache?: boolean,
 };
 
-/**
- */
-export const useModularUIBasic = <T: ModularUIModel>(
-  key: string,
-  href: string | Href,
-  options: UseModularUIBasicOptions<T> = {
-    expectedModels: [],
-    targetModel: undefined,
-    forceTargetModel: false,
-    origin: undefined,
-    contextPath: undefined,
-  },
-): T | null => {
-  const location = useLocation();
-
-  const useModularUIOptions = {
+// Helper to create useModularUI options
+const createUseModularUIOptions = <T: ModularUIModel>(
+  options: UseModularUIBasicOptions<T>,
+  href: string,
+  location: any,
+): Object => {
+  const baseOptions = {
     targetModel: undefined,
     forceTargetModel: undefined,
     isReload: false,
@@ -39,48 +28,75 @@ export const useModularUIBasic = <T: ModularUIModel>(
     contextPath: undefined,
     cache: false,
   };
+
+  // Handle targetModel and forceTargetModel
   if (options.targetModel) {
-    useModularUIOptions.targetModel = options.targetModel;
-    useModularUIOptions.forceTargetModel = options.forceTargetModel;
+    baseOptions.targetModel = options.targetModel;
+    baseOptions.forceTargetModel = options.forceTargetModel;
   }
 
+  // Handle cache option
   if (options.cache) {
-    useModularUIOptions.cache = options.cache;
-  }
-
-  // reload when the modular service starts with the current location
-  if (location.state?.reload && location.pathname.startsWith(href.toString())) {
-    useModularUIOptions.isReload = true;
+    baseOptions.cache = options.cache;
   }
 
-  if (options.origin) {
-    useModularUIOptions.origin = options.origin;
+  // Check for reload if location matches href
+  if (location.state?.reload && location.pathname.startsWith(href)) {
+    baseOptions.isReload = true;
   }
 
-  if (options.contextPath) {
-    useModularUIOptions.contextPath = options.contextPath;
-  }
-
-  // $FlowFixMe[incompatible-call]
-  const modularUI = useModularUI(key, href, useModularUIOptions);
-
-  if (modularUI?.model) {
-    const { model } = modularUI;
+  // Handle origin and contextPath options
+  baseOptions.origin = options.origin ?? baseOptions.origin;
+  baseOptions.contextPath = options.contextPath ?? baseOptions.contextPath;
 
-    const expectedModels = options.expectedModels ?? [];
-    if (expectedModels.length > 0) {
-      const isCorrectModel = expectedModels.some((expectedModel) => {
-        return model.type === expectedModel;
-      });
+  return baseOptions;
+};
 
-      if (!isCorrectModel) {
-        console.error(modularUI, "is not of instance", expectedModels);
-        throw new IllegalStateException("Resolved model has incorrect type");
-      }
+// Helper to validate the model against expectedModels
+const validateModel = (model: any, expectedModels: Array<string>) => {
+  if (expectedModels.length > 0) {
+    const isCorrectModel = expectedModels.some(
+      (expectedModel) => model.type === expectedModel,
+    );
+    if (!isCorrectModel) {
+      console.error(model, "is not of instance", expectedModels);
+      throw new IllegalStateException("Resolved model has incorrect type");
     }
-
-    return model;
   }
+};
 
-  return null;
+/**
+ * useModularUIBasic Hook
+ */
+export const useModularUIBasic = <T: ModularUIModel>(
+  key: string,
+  href: string | Href,
+  options: UseModularUIBasicOptions<T> = {
+    expectedModels: [],
+    targetModel: undefined,
+    forceTargetModel: false,
+    origin: undefined,
+    contextPath: undefined,
+  },
+): T | null => {
+  const location = useLocation();
+  const memoizedHref = useMemo(() => href.toString(), [href]);
+  const useModularUIOptions = useMemo(
+    () => createUseModularUIOptions(options, memoizedHref, location),
+    [options, memoizedHref, location],
+  );
+
+  const modularUI = useModularUI(key, memoizedHref, useModularUIOptions);
+  const expectedModels = useMemo(
+    () => options.expectedModels ?? [],
+    [options.expectedModels],
+  );
+
+  return useMemo((): T | null => {
+    if (modularUI?.model) {
+      validateModel(modularUI.model, expectedModels);
+      return modularUI.model;
+    }
+    return null;
+  }, [expectedModels, modularUI]);
 };

package/src/models/concepts/ConceptDetailModel.js

@@ -273,6 +273,8 @@ export default class ConceptDetailModel extends ResourceModel {
       this._sourceReferences = new SourceReferenceCollection(
         this.getSourceReferencesForCurrentLanguage(availableLocales),
         this.entryDate,
+        this.origin,
+        this.contextPath,
       );
     }
 
@@ -338,11 +340,4 @@ export default class ConceptDetailModel extends ResourceModel {
   isOfConceptType(conceptTypeId: string): boolean {
     return this.conceptType?.isOfConceptType(conceptTypeId) ?? false;
   }
-
-  /**
-   * Indicates if the given metamodel functional identifier exists in the hierarchy of concept types for this concept
-   */
-  hasMetamodelIdInConceptTypeHierarchy(metamodelId: string): boolean {
-    return this.conceptType?.hasMetamodelIdInHierarchy(metamodelId) ?? false;
-  }
 }

package/src/models/concepts/ConceptIndexModel.js

@@ -32,7 +32,13 @@ export default class ConceptIndexModel extends ResourceModel {
     this._concepts = new ResourceCollection();
     this._concepts.collection = this.data._embedded
       ? this.data._embedded.results.map(
-          (concept) => new ConceptLinkModel(concept.concept, this.entryDate),
+          (concept) =>
+            new ConceptLinkModel(
+              concept.concept,
+              this.entryDate,
+              this.origin,
+              this.contextPath,
+            ),
         )
       : [];
   }

package/src/models/concepts/ConceptLinkModel.js

@@ -7,6 +7,7 @@ import { TIMEVERSION_FILTER_NAME } from "../../constants/Constants";
 
 import type { IModelWithChildModels, ModularUIModel } from "../types";
 import type Href from "../href/Href";
+import { getBasePath } from "../../constants";
 /**
  * Link to a concept
  */
@@ -17,14 +18,23 @@ export default class ConceptLinkModel
   _links: ?LinkCollection;
   _entryDate: ?ISO_DATE;
   _conceptType: ?ConceptTypeDetailModel;
+  _origin: string = "";
+  _contextPath: string = getBasePath();
 
   /**
    * Construct ConceptLinkModel
    */
-  constructor(data: Object, entryDate: ?ISO_DATE = null) {
+  constructor(
+    data: Object,
+    entryDate: ?ISO_DATE = null,
+    origin?: string,
+    contextPath?: string,
+  ) {
     super(data, {});
 
     this._entryDate = entryDate;
+    this._origin = origin || "";
+    this._contextPath = contextPath || getBasePath();
   }
 
   /**
@@ -97,6 +107,9 @@ export default class ConceptLinkModel
         Array.isArray(this.data._links)
           ? this.data._links[0]
           : this.data._links,
+        null,
+        this._contextPath,
+        this._origin,
       );
     }
 
@@ -156,7 +169,6 @@ export default class ConceptLinkModel
   /**
    */
   asLinkModel(): LinkModel {
-    // TODO SBO: origin and contextpath
     const link = LinkModel.create(this.key, this.selfhref.href, this.label);
     link.href = this.selfhref;
 
@@ -169,11 +181,4 @@ export default class ConceptLinkModel
   isOfConceptType(conceptTypeId: string): boolean {
     return this.conceptType?.isOfConceptType(conceptTypeId) ?? false;
   }
-
-  /**
-   * Indicates if the given metamodel functional identifier exists in the hierarchy of concept types for this concept
-   */
-  hasMetamodelIdInConceptTypeHierarchy(metamodelId: string): boolean {
-    return this.conceptType?.hasMetamodelIdInHierarchy(metamodelId) ?? false;
-  }
 }

package/src/models/concepts/ConceptTypeDetailModel.js

@@ -2,7 +2,6 @@
 import ResourceModel from "../base/ResourceModel";
 
 import type ModularUIResponse from "../../modularui/ModularUIResponse";
-import type LinkCollection from "../links/LinkCollection";
 
 /**
  * Model for concept details, available through modelcatalog
@@ -12,8 +11,8 @@ class ConceptTypeDetailModel extends ResourceModel {
    * The name of the concept type consists of the functional id of the kmt and the functional id of the concept type separated by a #.<br>
    * For example BEI_CaseManagement#Case
    */
-  get name(): string {
-    return this.getData("name", "");
+  get kmtId(): string {
+    return this.getData("kmtId", "");
   }
 
   /**
@@ -119,31 +118,10 @@ class ConceptTypeDetailModel extends ResourceModel {
     return this.getData("sectionReferenceTypes", []);
   }
 
-  /**
-   */
-  get conceptTypeHierarchy(): LinkCollection {
-    return this.links.getLinksByGroup("conceptTypeHierarchy");
-  }
-
   /**
    */
   isOfConceptType(conceptTypeId: string): boolean {
-    return (
-      this.conceptTypeHierarchy?.hasLinkByKey(conceptTypeId) ||
-      this.conceptTypeHierarchy?.hasLinkByHref(conceptTypeId) ||
-      this.selfhref.equals(conceptTypeId)
-    );
-  }
-
-  /**
-   * Indicates if the given metamodel functional identifier exists in the hierarchy of concept types
-   */
-  hasMetamodelIdInHierarchy(metamodelId: string): boolean {
-    return (
-      this.conceptTypeHierarchy?.all.some((link) =>
-        link.key.startsWith(metamodelId + "#"),
-      ) || false
-    );
+    return this.selfhref.equals(conceptTypeId);
   }
 }
 

package/src/models/concepts/SourceReferenceCollection.js

@@ -11,13 +11,20 @@ export default class SourceReferenceCollection extends BaseCollection<SourceRefe
   constructor(
     sourceReferences: Array<Object> = [],
     entryDate: ?ISO_DATE = null,
+    origin?: string,
+    contextPath?: string,
   ) {
     super();
 
     this.collection = sourceReferences
       ? sourceReferences.map(
           (sourceReference) =>
-            new SourceReferenceModel(sourceReference, entryDate),
+            new SourceReferenceModel(
+              sourceReference,
+              entryDate,
+              origin,
+              contextPath,
+            ),
         )
       : [];
   }

package/src/models/concepts/SourceReferenceModel.js

@@ -3,18 +3,28 @@ import { createHashFromHref } from "../../utils/helpers/createHash";
 
 import ContentLinkModel from "../content/ContentLinkModel";
 import Href from "../href/Href";
+import { getBasePath } from "../../constants";
 
 /**
  */
 class SourceReferenceModel {
   _sourceReference: Object;
   _entryDate: ?ISO_DATE;
+  _origin: string = "";
+  _contextPath: string = getBasePath();
 
   /**
    */
-  constructor(sourceReference: Object, entryDate: ?ISO_DATE = null) {
+  constructor(
+    sourceReference: Object,
+    entryDate: ?ISO_DATE = null,
+    origin?: string,
+    contextPath?: string,
+  ) {
     this._sourceReference = sourceReference;
     this._entryDate = entryDate;
+    this._origin = origin || "";
+    this._contextPath = contextPath || getBasePath();
   }
 
   /**
@@ -31,14 +41,20 @@ class SourceReferenceModel {
         section,
       },
       this._entryDate,
+      this._origin,
+      this._contextPath,
     );
   }
 
   /**
    */
   get selfhref(): Href {
-    // TODO SBO: origin and context
-    return new Href(this._sourceReference._links.self.href, "SourceReference");
+    return new Href(
+      this._sourceReference._links.self.href,
+      "SourceReference",
+      this._origin,
+      this._contextPath,
+    );
   }
 
   /**

package/src/models/concepts/__mock__/conceptindex.js

@@ -0,0 +1,15 @@
+import ConceptIndexModel from "../ConceptIndexModel";
+import ModularUIResponse from "../../../modularui/ModularUIResponse";
+
+import data from "./conceptindex_data.json";
+import contributions from "./conceptindex_contributions.json";
+
+const conceptIndexResponse = ModularUIResponse.create({
+  key: "ConceptSearch",
+  data,
+  contributions,
+});
+
+const conceptIndex = new ConceptIndexModel(conceptIndexResponse);
+
+export { conceptIndex };

package/src/models/concepts/__mock__/conceptindex_contributions.json

@@ -0,0 +1,86 @@
+{
+  "ConceptSearch": {
+    "label": "Concept search",
+    "resourcetype": "ConceptSearch",
+    "filter": [
+      {
+        "index": {
+          "type": "choicefilter",
+          "label": "Index",
+          "layouthint": ["combobox"],
+          "multiplechoice": false,
+          "optionMode": "dynamic"
+        }
+      },
+      {
+        "label": {
+          "type": "stringfilter",
+          "label": "Label",
+          "multiplechoice": false
+        }
+      },
+      {
+        "type": {
+          "type": "choicefilter",
+          "label": "Type",
+          "layouthint": ["checkbox"],
+          "multiplechoice": true,
+          "optionMode": "lookup"
+        }
+      },
+      {
+        "modelCategory": {
+          "type": "choicefilter",
+          "label": "Model category",
+          "layouthint": ["checkbox"],
+          "multiplechoice": true,
+          "optionMode": "static",
+          "options": [
+            {
+              "key": "BusinessDesign",
+              "label": "Business design"
+            },
+            {
+              "key": "FLINT",
+              "label": "FLINT"
+            },
+            {
+              "key": "Requirements",
+              "label": "Requirements"
+            },
+            {
+              "key": "Scenarios",
+              "label": "Scenarios"
+            }
+          ]
+        }
+      },
+      {
+        "entryDate": {
+          "type": "datefilter",
+          "label": "Entry date",
+          "format": "dd-MM-yyyy",
+          "formatlabel": "dd-mm-yyyy",
+          "operator": "greater-than-or-equal"
+        }
+      }
+    ],
+    "results": {
+      "concept": {
+        "metadata": {
+          "_id": {
+            "type": "string"
+          }
+        },
+        "attributes": [
+          {
+            "label": {
+              "type": "string",
+              "label": "concept label"
+            }
+          }
+        ]
+      }
+    }
+  }
+}