@beinformed/ui 1.65.13 → 1.65.14

package/src/models/grouping/GroupingModel.js

@@ -1,232 +0,0 @@
-// @flow
-import AttributeCollection from "../attributes/AttributeCollection";
-import type { AttributeType, ModelOptions } from "../types";
-
-/**
- * Group information model
- * Put GroupModel here because of possible circular dependency with GroupingModel below
- */
-export class GroupModel {
-  _group: Object;
-  _context: Object;
-  _attributeCollection: AttributeCollection;
-  _grouping: ?GroupingModel;
-
-  /**
-   */
-  constructor(
-    group: Object,
-    context: Object,
-    contributions: Array<Object>,
-    modelOptions?: ModelOptions,
-  ) {
-    this._group = group;
-    this._context = context;
-
-    this._attributeCollection = new AttributeCollection(
-      group,
-      context.attributes,
-      { ...modelOptions, isReadonly: true },
-    );
-
-    if (group.grouping) {
-      this._grouping = new GroupingModel(
-        { ...group.grouping, dynamicschema: group.dynamicschema },
-        contributions,
-        modelOptions,
-      );
-    }
-  }
-
-  /**
-   */
-  get type(): string {
-    return this._group.type;
-  }
-
-  /**
-   */
-  get id(): string {
-    return this._group._id || "unknown";
-  }
-
-  /**
-   */
-  get label(): string {
-    return this._context.label;
-  }
-
-  /**
-   */
-  get attributeCollection(): AttributeCollection {
-    return this._attributeCollection;
-  }
-
-  /**
-   */
-  get grouping(): ?GroupingModel {
-    return this._grouping;
-  }
-
-  /**
-   * Retrieve array of reference id's
-   */
-  get reference(): Array<number> {
-    return this._group.reference || [];
-  }
-
-  /**
-   */
-  hasAttributeByKey(key: string): boolean {
-    if (this.attributeCollection.hasAttributeByKey(key)) {
-      return true;
-    }
-
-    if (this.grouping) {
-      return this.grouping.hasAttributeByKey(key);
-    }
-
-    return false;
-  }
-
-  /**
-   */
-  getAttributeByKey(key: string): AttributeType | null {
-    if (this.attributeCollection.hasAttributeByKey(key)) {
-      return this.attributeCollection.getAttributeByKey(key);
-    }
-
-    if (this.grouping) {
-      return this.grouping.getAttributeByKey(key);
-    }
-
-    return null;
-  }
-}
-
-type Context = {
-  prefix: string,
-  label: string,
-  metadata: Object,
-  attributes: Array<Object>,
-};
-
-/**
- * Grouping model to group lists
- */
-export default class GroupingModel {
-  _prefix: string | null;
-  _groups: Array<GroupModel> = [];
-
-  /**
-   */
-  constructor(
-    data: Object,
-    contexts: Array<Context>,
-    modelOptions?: ModelOptions,
-  ) {
-    this._prefix = data && data.prefix ? data.prefix : null;
-
-    if (data?.group) {
-      this._groups = this.createGroup(data, contexts, modelOptions);
-    }
-  }
-
-  /**
-   */
-  createGroup(
-    data: Object,
-    contributions: Array<Context>,
-    modelOptions?: ModelOptions,
-  ): Array<Object> {
-    const context = this.getContextFromContributionsByPrefix(
-      contributions,
-      this._prefix,
-    );
-
-    return data.group.map((group) => {
-      const dynamicschema = this.getDynamicSchema(group, data.dynamicschema);
-      return new GroupModel(
-        {
-          ...group,
-          dynamicschema,
-        },
-        context,
-        contributions,
-        modelOptions,
-      );
-    });
-  }
-
-  /**
-   * add grouped prefix to the dynamicschema
-   */
-  getDynamicSchema(group: Object, dynamicschema: Object): Object {
-    if (dynamicschema) {
-      if (
-        this._prefix &&
-        dynamicschema[group.type] &&
-        !dynamicschema[this._prefix + group.type]
-      ) {
-        dynamicschema[this._prefix + group.type] = dynamicschema[group.type];
-      }
-      return dynamicschema;
-    }
-    return null;
-  }
-
-  /**
-   * Retrieve groups of grouping
-   */
-  get groups(): Array<GroupModel> {
-    return this._groups;
-  }
-
-  /**
-   * Inidicates if Grouping has one or more groups
-   */
-  hasGroups(): boolean {
-    return this._groups.length > 0;
-  }
-
-  /**
-   * Get context of grouping
-   */
-  getContextFromContributionsByPrefix(
-    contexts: Array<Object>,
-    prefix: string | null,
-  ): Object {
-    if (contexts && prefix !== null) {
-      return contexts.find((context) => context.prefix === prefix) || {};
-    }
-
-    return {};
-  }
-
-  /**
-   */
-  hasAttributeByKey(key: string): boolean {
-    return this.groups.some((group: GroupModel) =>
-      group.hasAttributeByKey(key),
-    );
-  }
-
-  /**
-   */
-  getAttributeByKey(key: string): AttributeType | null {
-    const groupByKey = this.groups.find((group: GroupModel) =>
-      group.hasAttributeByKey(key),
-    );
-
-    if (groupByKey) {
-      return groupByKey.getAttributeByKey(key);
-    }
-    return null;
-  }
-
-  /**
-   */
-  getGroupByAttributeKey(key: string): ?GroupModel {
-    return this.groups.find((group) => group.hasAttributeByKey(key));
-  }
-}

package/src/models/grouping/__tests__/GroupingModel.spec.js

@@ -1,80 +0,0 @@
-import GroupingModel from "../GroupingModel";
-import StringAttributeModel from "../../attributes/StringAttributeModel";
-
-describe("groupingModel", () => {
-  it("should be able to create an empty GroupingModel object", () => {
-    const grouping = new GroupingModel({});
-
-    expect(grouping).toBeInstanceOf(GroupingModel);
-    expect(grouping.groups).toStrictEqual([]);
-    expect(grouping.hasGroups()).toBe(false);
-    expect(grouping.getContextFromContributionsByPrefix()).toStrictEqual({});
-    expect(grouping.hasAttributeByKey("key")).toBe(false);
-    expect(grouping.getAttributeByKey("key")).toBeNull();
-    expect(grouping.getGroupByAttributeKey("key")).toBeUndefined();
-  });
-
-  it("should be able to create a GroupingModel with GroupModels", () => {
-    const data = {
-      _id: "Person",
-      prefix: "G1_",
-      group: [
-        {
-          type: "Person",
-          _id: 1,
-          G1_Name: "Stephen King",
-          G1_DateOfBirth: "1947-08-01",
-          reference: [14, 16, 18, 20, 69, 72],
-        },
-      ],
-    };
-    const contributions = [
-      {
-        prefix: "G1_",
-        label: "Person",
-        metadata: {
-          _id: {
-            type: "number",
-          },
-          type: {
-            type: "string",
-          },
-        },
-        attributes: [
-          {
-            G1_Name: {
-              type: "string",
-              label: "Name",
-              displaysize: 50,
-            },
-          },
-          {
-            G1_DateOfBirth: {
-              type: "date",
-              label: "Date of birth",
-              formatlabel: "dd-mm-jjjj",
-              format: "dd-MM-yyyy",
-            },
-          },
-        ],
-      },
-    ];
-    const grouping = new GroupingModel(data, contributions);
-
-    expect(grouping.hasGroups()).toBe(true);
-    expect(
-      grouping.getContextFromContributionsByPrefix(contributions, "G1_"),
-    ).toStrictEqual(contributions[0]);
-    expect(grouping.hasAttributeByKey("G1_Name")).toBe(true);
-    expect(grouping.getAttributeByKey("G1_Name")).toBeInstanceOf(
-      StringAttributeModel,
-    );
-
-    const group = grouping.getGroupByAttributeKey("G1_Name");
-    expect(group.type).toBe("Person");
-    expect(group.id).toBe(1);
-    expect(group.label).toBe("Person");
-    expect(group.grouping).toBeUndefined();
-    expect(group.reference).toStrictEqual([14, 16, 18, 20, 69, 72]);
-  });
-});