@beinformed/ui 1.65.12 → 1.65.14

package/src/models/filters/BaseFilterModel.js

@@ -1,146 +0,0 @@
-// @flow
-import BaseModel from "../base/BaseModel";
-
-import {
-  PARAMETER_SEPARATOR,
-  PARAMETER_TYPES,
-} from "../../constants/Constants";
-
-import type { ModelOptions } from "../types";
-
-/**
- * Base class for filters
- */
-export default class BaseFilterModel extends BaseModel {
-  _context: Object;
-  _listKey: string;
-
-  /**
-   */
-  constructor(
-    data: Object,
-    contributions: Object,
-    modelOptions?: ModelOptions,
-  ) {
-    super(data, contributions, modelOptions);
-
-    if (this.contributions.listKey) {
-      this.listkey = this.contributions.listKey;
-    }
-  }
-
-  /**
-   */
-  get key(): string {
-    return this.data.name;
-  }
-
-  /**
-   * Get the type of a filter.
-   */
-  get type(): string {
-    return this.contributions.type
-      ? this.contributions.type.replace("filter", "")
-      : "string";
-  }
-
-  /**
-   * Returns the parameter type, when the filter can only be used in  a POST request the type is 'bodyParameter', else 'queryParameter'.
-   */
-  get parameterType(): $Values<typeof PARAMETER_TYPES> {
-    const parameterType = this.getContribution("parameterType");
-    switch (parameterType) {
-      case "bodyParameter":
-        return PARAMETER_TYPES.BODY;
-      default:
-        return PARAMETER_TYPES.QUERY;
-    }
-  }
-
-  /**
-   * Inidiates if filter is multiplechoice
-   */
-  get isMultiple(): boolean {
-    return this.getContribution("multiplechoice", false);
-  }
-
-  /**
-   * Getting context data
-   */
-  get context(): Object {
-    return this._context;
-  }
-
-  /**
-   * Set context of filter
-   */
-  set context(context: Object) {
-    this._context = context;
-  }
-
-  /**
-   */
-  get contextid(): string {
-    return this.getContribution("contextid", "");
-  }
-
-  /**
-   * Getting the context label
-   */
-  get contextLabel(): string {
-    return this.context?.label ?? "";
-  }
-
-  /**
-   * Getting key of the list these filters apply to
-   */
-  get listkey(): string {
-    return this._listKey;
-  }
-
-  /**
-   * Set key of list this filter belongs to
-   */
-  set listkey(key: string) {
-    this._listKey = key;
-  }
-
-  /**
-   * Getting the label of the filter
-   */
-  get label(): string {
-    return this.getContribution("label", "");
-  }
-
-  /**
-   * Getting the name of the filter
-   */
-  get name(): string {
-    if (this.listkey) {
-      return this.listkey + PARAMETER_SEPARATOR + this.param;
-    }
-
-    return this.param;
-  }
-
-  /**
-   * Getting the param name of the filter
-   */
-  get param(): string {
-    return this.data.param ?? this.data.name;
-  }
-
-  /**
-   * Inidicates if filter is a quick search filter
-   */
-  isQuickSearch(): boolean {
-    return this.contributions.quicksearch === true;
-  }
-
-  /**
-   * Get assistant message
-   */
-  get assistantMessage(): string | null {
-    return this.getContribution("assistant");
-  }
-}

package/src/models/filters/ConceptIndexFilterModel.js

@@ -1,43 +0,0 @@
-// @flow
-import FilterModel from "../filters/FilterModel";
-import ChoiceAttributeModel from "../attributes/ChoiceAttributeModel";
-
-import type { IFilter, ModelOptions } from "../types";
-
-/**
- * The concept index model is a special filter used to index all first concept label letters in de modelcatalog.
- */
-export default class ConceptIndexFilterModel
-  extends FilterModel
-  implements IFilter
-{
-  /**
-   * Construct a filter
-   */
-  constructor(
-    data: Object,
-    contributions: Object,
-    modelOptions?: ModelOptions,
-  ) {
-    super(data, contributions, modelOptions);
-
-    if (this.attribute instanceof ChoiceAttributeModel) {
-      const attribute: ChoiceAttributeModel = this.attribute;
-
-      if (attribute && data.options) {
-        const selectedValues = data.options
-          .filter((option) => option.selected)
-          .map((option) => option.key);
-
-        data.options
-          .filter((option) => !attribute.options.hasOptionByCode(option.key))
-          .forEach((option) => {
-            attribute.options.addOption(selectedValues, {
-              code: option.key,
-              label: option.key,
-            });
-          });
-      }
-    }
-  }
-}

package/src/models/filters/FilterCollection.js

@@ -1,227 +0,0 @@
-// @flow
-import BaseCollection from "../base/BaseCollection";
-
-import StringFilterModel from "../filters/StringFilterModel";
-import RangeFilterModel from "../filters/RangeFilterModel";
-import AssignmentFilterModel from "../filters/AssignmentFilterModel";
-import ConceptIndexFilterModel from "../filters/ConceptIndexFilterModel";
-import CompositeAttributeModel from "../attributes/CompositeAttributeModel";
-import FilterModel from "../filters/FilterModel";
-
-import type { AttributeType, IFilter, ModelOptions } from "../types";
-import { PARAMETER_TYPES } from "../../constants";
-
-/**
- * Contains a collection of filters
- */
-export default class FilterCollection extends BaseCollection<IFilter> {
-  /**
-   * Construct a collection of filters
-   */
-  constructor(
-    data: Object = {},
-    contributions: Object = {},
-    modelOptions?: ModelOptions,
-  ) {
-    super();
-
-    if (data && contributions && Array.isArray(contributions.filter)) {
-      this.collection = contributions.filter
-        .filter((filterContribution) => Object.keys(filterContribution)[0])
-        .map((filterContribution) => {
-          const [filterKey] = Object.keys(filterContribution);
-          const filterData = data[filterKey];
-          const filterContributionByKey = filterContribution[filterKey];
-
-          const filter = this.createFilter(
-            filterKey,
-            {
-              ...filterData,
-              dynamicschema: contributions.dynamicschema,
-            },
-            filterContributionByKey,
-            modelOptions,
-          );
-
-          if (contributions.listkey) {
-            filter.listkey = contributions.listkey;
-          }
-
-          if (contributions.contexts && filterContributionByKey.contextid) {
-            const filterContext = contributions.contexts.find(
-              (context) => context.id === filterContributionByKey.contextid,
-            );
-            if (filterContext) {
-              filter.context = filterContext;
-            }
-          }
-
-          return filter;
-        });
-    }
-  }
-
-  /**
-   */
-  createFilter(
-    filterKey: string,
-    data: Object,
-    contributions: Object,
-    modelOptions?: ModelOptions,
-  ): IFilter {
-    const type = contributions.type || "stringfilter";
-    if (type === "choicefilter" && filterKey === "index") {
-      return new ConceptIndexFilterModel(data, contributions, modelOptions);
-    }
-
-    if (type.includes("rangefilter")) {
-      return new RangeFilterModel(data, contributions, modelOptions);
-    }
-
-    if (type === "assignmentfilter") {
-      return new AssignmentFilterModel(data, contributions, modelOptions);
-    }
-
-    if (type === "stringfilter") {
-      return new StringFilterModel(data, contributions, modelOptions);
-    }
-
-    return new FilterModel(data, contributions, modelOptions);
-  }
-
-  /**
-   * Call the reset function on all filters
-   *
-   * @see {IFilter#reset()}
-   */
-  reset(): FilterCollection {
-    this.collection = this.collection.map((filter) => filter.reset());
-
-    return this;
-  }
-
-  /**
-   * Checks if range attribute key equals key
-   */
-  checkRangeFilterByAttributeKey(
-    filter: RangeFilterModel,
-    key: string,
-  ): boolean {
-    const rangeAttribute = filter.attribute;
-
-    if (rangeAttribute instanceof CompositeAttributeModel) {
-      return (
-        rangeAttribute.key === key ||
-        (rangeAttribute.start && rangeAttribute.start.key === key) ||
-        (rangeAttribute.end && rangeAttribute.end.key === key)
-      );
-    }
-
-    return false;
-  }
-
-  /**
-   * Check if assignment filter attribute matches key
-   */
-  checkAssignmentFilterByAttributeKey(
-    filter: AssignmentFilterModel,
-    key: string,
-  ): boolean {
-    return (
-      filter.key === key ||
-      filter.user?.key === key ||
-      filter.assignmenttype?.key === key
-    );
-  }
-
-  /**
-   */
-  getFilterByName(name: string): IFilter | null {
-    return this.find((filter) => filter.name === name) || null;
-  }
-
-  /**
-   * Getting the filter by name
-   */
-  getFilterByAttributeKey(key: string): IFilter | null {
-    return (
-      this.find((filter) => {
-        if (filter instanceof RangeFilterModel) {
-          return this.checkRangeFilterByAttributeKey(filter, key);
-        }
-
-        if (filter instanceof AssignmentFilterModel) {
-          return this.checkAssignmentFilterByAttributeKey(filter, key);
-        }
-
-        if (filter instanceof FilterModel) {
-          return filter.attribute.key === key;
-        }
-
-        return false;
-      }) || null
-    );
-  }
-
-  /**
-   * Update Filter by input name and value
-   */
-  update(attribute: AttributeType, value: string): void {
-    const filterToUpdate = attribute.parentKey
-      ? this.getFilterByAttributeKey(attribute.parentKey)
-      : this.getFilterByAttributeKey(attribute.key);
-
-    if (!filterToUpdate) {
-      throw new Error(`Can not find filter by attribute key: ${attribute.key}`);
-    }
-
-    const newFilter = filterToUpdate.clone();
-    newFilter.update(attribute, value);
-
-    this.collection = this.collection.map((filter) => {
-      if (filter.name === newFilter.name) {
-        return newFilter;
-      }
-
-      return filter;
-    });
-  }
-
-  /**
-   * Retrieve if all filters are valid
-   */
-  get isValid(): boolean {
-    return this.collection.every((filter) => filter.isValid);
-  }
-
-  /**
-   * Indicates if an active filter is present in the collection
-   */
-  hasActiveFilters(): boolean {
-    return this.collection.some((filter) => filter.isActive());
-  }
-
-  /**
-   * Retrieve all filters with a value
-   */
-  getActiveFilters(): Array<IFilter> {
-    return this.collection.filter((filter) => filter.isActive());
-  }
-
-  /**
-   */
-  get formdata(): { [string]: any } | null {
-    const bodyFields = this.filter(
-      (f) =>
-        f.parameterType === PARAMETER_TYPES.BODY && f.hasValue() && f.formdata,
-    );
-
-    if (bodyFields.length === 0) {
-      return null;
-    }
-
-    return bodyFields.reduce((data, f) => {
-      return Object.assign(data, f.formdata);
-    }, {});
-  }
-}

package/src/models/filters/FilterModel.js

@@ -1,151 +0,0 @@
-// @flow
-import BaseFilterModel from "../filters/BaseFilterModel";
-import createAttribute from "../attributes/_createAttribute";
-import { IllegalStateException } from "../../exceptions";
-
-import type { AttributeType, IFilter, ModelOptions } from "../types";
-
-/**
- */
-export default class FilterModel extends BaseFilterModel implements IFilter {
-  _attribute: AttributeType | null = null;
-
-  /**
-   */
-  constructor(
-    data: Object,
-    contributions: Object,
-    modelOptions?: ModelOptions,
-  ) {
-    super(data, contributions, modelOptions);
-
-    this._attribute = this.createAttribute(
-      this.type,
-      this.param,
-      this.data,
-      this.contributions,
-    );
-  }
-
-  /**
-   * Create attribute through the attribute factory. Create type based on filter key without the filter suffix
-   */
-  createAttribute(
-    type: string,
-    param: string,
-    data: Object,
-    contributions: Object,
-  ): AttributeType | null {
-    if (type === "assignment") {
-      return null;
-    }
-
-    return createAttribute(
-      param,
-      data,
-      {
-        ...contributions,
-        type: type,
-      },
-      this.modelOptions,
-    );
-  }
-
-  /**
-   * Get attribute of filter
-   */
-  get attribute(): AttributeType {
-    if (!this._attribute) {
-      throw new IllegalStateException(
-        `Missing filter attribute on filter model: ${this.label}`,
-      );
-    }
-    return this._attribute;
-  }
-
-  /**
-   * Retrieve the parameters with it's value for this filter
-   */
-  get params(): Array<{ name: string, value: ?string }> {
-    if (!this.param) {
-      return [];
-    }
-
-    return [
-      {
-        name: this.param,
-        value: this.attribute?.value,
-      },
-    ];
-  }
-
-  /**
-   * Getting the value of the filter
-   */
-  get value(): string | null {
-    return this.attribute?.value;
-  }
-
-  /**
-   * Getting the inputvalue of the filter
-   */
-  get inputvalue(): string {
-    return this.attribute?.inputvalue;
-  }
-
-  /**
-   * Indicates if the filter has a value.
-   */
-  hasValue(): boolean {
-    return this.value !== null && this.value !== "";
-  }
-
-  /**
-   * Reset the value of this filter to undefined
-   */
-  reset(): FilterModel {
-    if (this.attribute) {
-      this.attribute.reset();
-    }
-
-    return this;
-  }
-
-  /**
-   * Update this filter with input name and value
-   */
-  update(attribute: AttributeType, value: string) {
-    if (this.attribute) {
-      this.attribute.update(value);
-    }
-  }
-
-  /**
-   * Inidiates if filter is active
-   */
-  isActive(): boolean {
-    return this.attribute?.initvalue !== null;
-  }
-
-  /**
-   * Inidiates if filter is valid
-   */
-  get isValid(): boolean {
-    return this.attribute?.isValid ?? true;
-  }
-
-  /**
-   */
-  get readonlyvalue(): string {
-    if (this.attribute) {
-      return this.attribute.readonlyvalue;
-    }
-    return "";
-  }
-
-  /**
-   */
-  get formdata(): { [string]: any } | null {
-    return this.attribute.formdata ?? null;
-  }
-}

package/src/models/filters/RangeFilterModel.js

@@ -1,36 +0,0 @@
-// @flow
-import FilterModel from "../filters/FilterModel";
-
-import CompositeAttributeModel from "../attributes/CompositeAttributeModel";
-import type { AttributeType, IFilter } from "../types";
-
-/**
- * Range filter, for instance a date range filter or a number range filter
- */
-export default class RangeFilterModel extends FilterModel implements IFilter {
-  /**
-   */
-  update(attribute: AttributeType, value: string) {
-    if (this.attribute instanceof CompositeAttributeModel) {
-      this.attribute.update(value, attribute);
-    } else if (this.attribute != null) {
-      this.attribute.update(value);
-    }
-  }
-
-  /**
-   */
-  get params(): Array<{ name: string, value: ?string }> {
-    if (this.attribute instanceof CompositeAttributeModel) {
-      return this.attribute.children.map((child) => {
-        const { param } = this.data[child.name];
-        return {
-          name: param,
-          value: child.value,
-        };
-      });
-    }
-
-    return [];
-  }
-}