@media-quest/builder 0.0.1 → 0.0.2

package/src/rulebuilder/Builder-rule.spec.ts

@@ -0,0 +1,207 @@
+import { BuilderRule, type BuilderRuleDto } from "./Builder-rule";
+import { RuleBuilderTestUtils as U } from "./RuleBuilder-test-utils";
+import { RuleInput } from "./RuleInput";
+import type { BuilderConditionGroupDto } from "./Builder-condition-group";
+
+const { createBuilderVariables_A_H } = U;
+let questionVariables = createBuilderVariables_A_H();
+const createDto = (): {
+    ruleInput: RuleInput;
+    builderRuleDto: BuilderRuleDto;
+} => {
+    const v1 = U.createRuleVariable("v1", 2);
+    const v2 = U.createRuleVariable("v2", 2);
+    const v3 = U.createRuleVariable("v3", 2);
+    const v4 = U.createRuleVariable("v4", 2);
+    const vg1 = U.createRuleVariable("vg1", 2);
+    const vg2 = U.createRuleVariable("vg2", 2);
+    const vg3 = U.createRuleVariable("vg3", 2);
+    const vg4 = U.createRuleVariable("vg4", 2);
+    const variableList = [v1, v2, v3, v4, vg1, vg2, vg3, vg4];
+    const tagAction1 = U.excludeByTagAction("tag1");
+    const tagAction2 = U.excludeByTagAction("tag2");
+    const tagAction3 = U.excludeByTagAction("tag3");
+    const tagAction4 = U.excludeByTagAction("tag4");
+    const pageAction1 = U.excludeByPageIdAction(v1.varId);
+    const pageAction2 = U.excludeByPageIdAction(v2.varId);
+    const pageAction3 = U.excludeByPageIdAction(v3.varId);
+    const pageAction4 = U.excludeByPageIdAction(v4.varId);
+
+    // const pageAction =
+    // const excludeByTagList = [];
+    const ruleInput = new RuleInput(
+        variableList,
+        [],
+        [pageAction1, pageAction2, pageAction3, pageAction4],
+        [tagAction1, tagAction2, tagAction3, tagAction4],
+        []
+    );
+    const c1 = U.createConditionDto(v1);
+    const c2 = U.createConditionDto(v2);
+    const c3 = U.createConditionDto(v3);
+    const c4 = U.createConditionDto(v4);
+    const cg1 = U.createConditionDto(vg1);
+    const cg2 = U.createConditionDto(vg2);
+    const cg3 = U.createConditionDto(vg3);
+    const cg4 = U.createConditionDto(vg4);
+    const group3: BuilderConditionGroupDto = {
+        kind: "condition-group",
+        name: "group3",
+        type: "all",
+        conditions: [cg1, cg2, cg3, cg4],
+    };
+
+    const builderRuleDto1: BuilderRuleDto = {
+        type: "any",
+        jumpToPage: false,
+        excludePages: [v1.varId, v3.varId],
+        excludeTags: [tagAction1.tag, tagAction2.tag],
+        name: "kitchen-sink",
+        conditions: [c1, c2, group3, c3, c4],
+    };
+
+    return { ruleInput, builderRuleDto: builderRuleDto1 };
+};
+let dto: BuilderRuleDto = {
+    name: "test-rule",
+    conditions: [],
+    type: "all",
+    excludePages: [],
+    excludeTags: [],
+    jumpToPage: false,
+};
+
+const excludeByTagActionList = U.excludeByTagActionList();
+const pageActions = questionVariables.map((q) => U.excludeByPageIdAction(q.varId, q.pageNumber));
+let ruleInput = new RuleInput(questionVariables, [], [...pageActions], excludeByTagActionList, []);
+
+let rule: BuilderRule = BuilderRule.fromDto(dto, ruleInput);
+
+beforeEach(() => {
+    rule = BuilderRule.fromDto(dto, ruleInput);
+});
+
+describe("Builder Rule", () => {
+    test("Can create rule", () => {
+        expect(rule).toBeInstanceOf(BuilderRule);
+    });
+    test("Can add condition", () => {
+        rule.addCondition();
+        expect(rule.conditions.length).toBe(1);
+    });
+    test("Can delete condition", () => {
+        const r1 = rule.addCondition();
+        const r2 = rule.addCondition();
+        const r3 = rule.addCondition();
+        const r4 = rule.addCondition();
+        const r5 = rule.addCondition();
+        expect(rule.conditionCount).toBe(5);
+        const result = rule.deleteCondition(r3);
+        expect(result).toBeTruthy();
+        expect(rule.conditionCount).toBe(4);
+        expect(rule.conditions[0]).toBe(r1);
+        expect(rule.conditions[1]).toBe(r2);
+        expect(rule.conditions[2]).toBe(r4);
+        expect(rule.conditions[3]).toBe(r5);
+        expect(rule.deleteCondition(r3)).toBeFalsy();
+        // expect(rule.conditions[0]).toBe(r1);
+    });
+    test("Can delete condition-group", () => {
+        const r1 = rule.addCondition();
+        const r2 = rule.addConditionGroup();
+        const r3 = rule.addConditionGroup();
+        const r4 = rule.addCondition();
+        const r5 = rule.addConditionGroup();
+        expect(rule.conditionCount).toBe(5);
+        const result = rule.deleteCondition(r2);
+        expect(result).toBeTruthy();
+        expect(rule.conditionCount).toBe(4);
+        expect(rule.conditions[0]).toBe(r1);
+        expect(rule.conditions[1]).toBe(r3);
+        expect(rule.conditions[2]).toBe(r4);
+        expect(rule.conditions[3]).toBe(r5);
+        expect(rule.deleteCondition(r2)).toBeFalsy();
+        expect(rule.deleteCondition(r1)).toBeTruthy();
+        expect(rule.deleteCondition(r5)).toBeTruthy();
+        expect(rule.conditionCount).toBe(2);
+    });
+
+    test("Conditions have no operators available before variable is set.", () => {
+        const c1 = rule.addCondition();
+        expect(c1.operatorsSelectItems.length).toBe(0);
+
+        const a = c1.variableSelectItemsInUniverse[0]?.data ?? false;
+        c1.variable = a;
+        expect(c1.operatorsSelectItems.length).toBe(2);
+    });
+
+    test("Conditions  and actions in dto will exist: ", () => {
+        const v1 = ruleInput.questionVars[0];
+        const v2 = ruleInput.questionVars[1];
+        const tag1 = ruleInput.excludeByTagActions[0];
+        const pageAction1 = ruleInput.excludeByPageIdActions[0];
+
+        const dtoWithOneCondition: BuilderRuleDto = {
+            ...dto,
+            excludePages: [pageAction1.pageId],
+            excludeTags: [tag1.tag],
+            jumpToPage: v1.varId,
+            conditions: [
+                {
+                    kind: "condition",
+                    name: "condition 1",
+                    variableId: v1.varId,
+                    operator: "equal",
+                    value: v1.options[0].value,
+                },
+                {
+                    kind: "condition-group",
+                    type: "all",
+                    name: "condtion-grup-from-testing.",
+                    conditions: [
+                        {
+                            name: "nested-condition",
+                            kind: "condition",
+                            value: v2.options[0].value,
+                            operator: "equal",
+                            variableId: v2.varId,
+                        },
+                    ],
+                },
+            ],
+        };
+
+        const rule = BuilderRule.fromDto(dtoWithOneCondition, ruleInput);
+        // console.log(rule);
+        expect(rule.conditions.length).toBe(2);
+        const excludeTags = rule.toJson().excludeTags;
+        expect(excludeTags.length).toBe(1);
+        expect(rule.jumpToActionManager).toBeTruthy();
+    });
+
+    test("fromJSON -> toJSON -> are equal.", () => {
+        const data = createDto();
+
+        const localRule = BuilderRule.fromDto(data.builderRuleDto, data.ruleInput);
+
+        const json = localRule.toJson();
+        expect(data.builderRuleDto).toStrictEqual(json);
+    });
+
+    test("invalid tags will be removed.", () => {
+        const ruleInput = new RuleInput([], [], [], U.excludeByTagActionList(), []);
+        const dto: BuilderRuleDto = {
+            conditions: [],
+            excludePages: [],
+            excludeTags: ["tag3", "tag1"],
+            jumpToPage: false,
+            name: "Rule-name-in-test",
+            type: "all",
+        };
+
+        const localRule = BuilderRule.fromDto(dto, ruleInput);
+
+        expect(ruleInput.excludeByTagActions.length).toStrictEqual(10);
+        expect(ruleInput.excludeByTagActions.length).toStrictEqual(10);
+    });
+});

package/src/rulebuilder/Builder-rule.ts

@@ -0,0 +1,165 @@
+import {
+  BuilderCondition,
+  type BuilderConditionDto
+} from './Builder-condition';
+import {
+  BuilderConditionGroup,
+  type BuilderConditionGroupDto,
+  type ConditionGroupType
+} from './Builder-condition-group';
+import type { RuleInput } from './RuleInput';
+import { BuilderObject } from '../BuilderObject';
+import { TagActionManager } from './tag-action-manager';
+import { PageActionManager } from './page-action-manager';
+import { JumpToActionManager } from './jump-to-action-manager';
+
+export interface BuilderRuleDto {
+  readonly type: ConditionGroupType;
+  readonly name: string;
+  readonly conditions: ReadonlyArray<
+    BuilderConditionDto | BuilderConditionGroupDto
+  >;
+  readonly excludeTags: ReadonlyArray<string>;
+  readonly excludePages: ReadonlyArray<string>;
+  readonly jumpToPage: string | false;
+}
+export class BuilderRule extends BuilderObject<'builder-rule', BuilderRuleDto> {
+  readonly objectType: 'builder-rule' = 'builder-rule';
+  private _type: ConditionGroupType = 'all';
+  public name = 'Rule name';
+  // public countNumber = 1;
+  private readonly _conditions: Array<
+    BuilderCondition | BuilderConditionGroup
+  > = [];
+
+  private _tagActionManager: TagActionManager;
+  private _pageActionManager: PageActionManager;
+  readonly jumpToActionManager: JumpToActionManager;
+  public static readonly fromDto = (
+    dto: BuilderRuleDto,
+    input: RuleInput
+  ): BuilderRule => {
+    return new BuilderRule(dto, input);
+  };
+
+  protected constructor(
+    private readonly dto: BuilderRuleDto,
+    private readonly _ruleInput: RuleInput
+  ) {
+    super(dto);
+    const conditionInput = this._ruleInput.getConditionInput();
+    this.name = dto.name ?? '';
+    this._type = dto.type ?? 'any';
+    this._conditions = dto.conditions.reduce<
+      Array<BuilderCondition | BuilderConditionGroup>
+    >((acc, curr) => {
+      if (curr.kind === 'condition') {
+        const condition = BuilderCondition.fromDto(curr, conditionInput);
+        acc.push(condition);
+      }
+      if (curr.kind === 'condition-group') {
+        const conditionGroup = BuilderConditionGroup.fromDto(
+          curr,
+          conditionInput
+        );
+        acc.push(conditionGroup);
+      }
+      return acc;
+    }, []);
+    // TODO CHECK WITH CURRENT OPTIONS.
+    this._pageActionManager = new PageActionManager(
+      _ruleInput.excludeByPageIdActions,
+      dto.excludePages
+    );
+    // this.excludeByPageIdDtoList.push(...dto.excludePages);
+    this._tagActionManager = new TagActionManager(
+      _ruleInput.excludeByTagActions,
+      dto.excludeTags
+    );
+
+    this.jumpToActionManager = new JumpToActionManager(
+      _ruleInput.jumpToPageActions,
+      dto.jumpToPage
+    );
+  }
+
+  get conditions(): ReadonlyArray<BuilderConditionGroup | BuilderCondition> {
+    return this._conditions;
+  }
+
+  getTagActions() {
+    return this._tagActionManager.selectItems;
+  }
+
+  getValidPageActions() {
+    return this._pageActionManager.selectItems;
+  }
+
+  get conditionCount() {
+    return this._conditions.length;
+  }
+
+  set type(type: ConditionGroupType) {
+    if (BuilderConditionGroup.isConditionGroupType(type)) {
+      this._type = type;
+    }
+  }
+
+  get type() {
+    return this._type;
+  }
+
+  deleteCondition(
+    condition: BuilderCondition | BuilderConditionGroup
+  ): boolean {
+    const index = this._conditions.indexOf(condition);
+    if (index < 0) {
+      return false;
+    }
+    this._conditions.splice(index, 1);
+    return true;
+  }
+
+  addCondition(): BuilderCondition {
+    const condition = BuilderCondition.create(
+      this._ruleInput.getConditionInput()
+    );
+    this._conditions.push(condition);
+    return condition;
+  }
+
+  addConditionGroup(): BuilderConditionGroup {
+    const dto: BuilderConditionGroupDto = {
+      kind: 'condition-group',
+      name: '',
+      type: 'all',
+      conditions: []
+    };
+    const newGroup = BuilderConditionGroup.fromDto(
+      dto,
+      this._ruleInput.questionVars
+    );
+    this._conditions.push(newGroup);
+    return newGroup;
+  }
+
+  clone(): BuilderRuleDto {
+    return this.toJson();
+  }
+
+  toJson(): BuilderRuleDto {
+    const conditions = this._conditions.map(c => c.toJson());
+    const excludePages = this._pageActionManager.getCurrentSelection();
+    const excludeTags = this._tagActionManager.getCurrentSelection();
+    const jumpToPage = this.jumpToActionManager.getSelectedPageId();
+    const dto: BuilderRuleDto = {
+      type: this._type,
+      name: this.name,
+      conditions,
+      excludePages,
+      jumpToPage,
+      excludeTags
+    };
+    return dto;
+  }
+}

package/src/rulebuilder/RuleAction.ts

@@ -0,0 +1,20 @@
+export interface ExcludeByPageAction {
+  readonly kind: 'exclude-by-pageId';
+  readonly pageId: string;
+  readonly mainText: string;
+  readonly pageNumber: number;
+}
+
+export interface JumpToPageAction {
+  readonly kind: 'jump-to-page';
+  readonly pageId: string;
+  readonly mainText: string;
+  readonly pageNumber: number;
+}
+
+export interface ExcludeByTagAction {
+  readonly kind: 'exclude-by-tag';
+  readonly tag: string;
+  readonly description: string;
+  readonly pageCount: number;
+}

package/src/rulebuilder/RuleBuilder-test-utils.ts

@@ -0,0 +1,254 @@
+import { BuilderOption } from "../Builder-option";
+import { type BuilderVariable, QuestionVariable } from "./RuleVariable";
+import type { BuilderRuleDto } from "./Builder-rule";
+import type { BuilderConditionGroupDto } from "./Builder-condition-group";
+import type { BuilderConditionDto } from "./Builder-condition";
+import type { BuilderOperator } from "./Builder-operator";
+import type { ExcludeByPageAction, ExcludeByTagAction } from "./RuleAction";
+import { ExcludeByPageIdSelectItem, ExcludeByTagSelectItem } from "./multi-select-item";
+
+export namespace RuleBuilderTestUtils {
+    export const createOptions = () => [
+        BuilderOption.create(0, "Nei"),
+        BuilderOption.create(1, "Ja"),
+        BuilderOption.create(9, "Vet ikke"),
+    ];
+
+    export const excludeByTagAction = (tag: string) => {
+        const pageCount = Math.floor(Math.random() * 10);
+        const action: ExcludeByTagAction = {
+            kind: "exclude-by-tag",
+            tag,
+            description: "Description for tag: " + tag,
+            pageCount,
+        };
+        return action;
+    };
+    export const excludeByPageIdAction = (pageId: string, pageNumber = 1) => {
+        const action: ExcludeByPageAction = {
+            kind: "exclude-by-pageId",
+            mainText: "",
+            pageId,
+            pageNumber,
+        };
+        return action;
+    };
+    export const excludeByTagActionList = () => {
+        const list = [
+            excludeByTagAction("tag1"),
+            excludeByTagAction("tag2"),
+            excludeByTagAction("tag3"),
+            excludeByTagAction("tag4"),
+            excludeByTagAction("tag5"),
+            excludeByTagAction("tag6"),
+            excludeByTagAction("tag7"),
+            excludeByTagAction("tag8"),
+            excludeByTagAction("tag9"),
+            excludeByTagAction("tag10"),
+        ] as const;
+        return list;
+    };
+    export const createRuleVariable = (id: string, pageNumber: number): QuestionVariable =>
+        new QuestionVariable(id, "Har du " + id + "?", createOptions(), pageNumber);
+
+    /**
+     *
+     */
+    export const createBuilderVariables_A_H = (): ReadonlyArray<QuestionVariable> => [
+        createRuleVariable("a", 3),
+        createRuleVariable("b", 4),
+        createRuleVariable("c", 5),
+        createRuleVariable("d", 6),
+        createRuleVariable("e", 7),
+        createRuleVariable("f", 8),
+        createRuleVariable("g", 9),
+        createRuleVariable("h", 10),
+    ];
+
+    export const createConditionDto = (variable: BuilderVariable): BuilderConditionDto => {
+        const operator: BuilderOperator = Math.random() > 0 ? "equal" : "notEqual";
+        const opt = variable.options[0];
+        return {
+            kind: "condition",
+            name: "condition 1",
+            variableId: variable.varId,
+            operator,
+            value: opt.value,
+        };
+    };
+
+    export const createConditionGroupDto = (conditions: BuilderConditionDto[]): BuilderConditionGroupDto => {
+        return {
+            kind: "condition-group",
+            conditions,
+            type: "all",
+            name: "random-group-name",
+        };
+    };
+
+    export const createBuilderRuleDto = (): ReadonlyArray<BuilderRuleDto> => {
+        const variables = createBuilderVariables_A_H();
+        const condition0 = createConditionDto(variables[0]);
+        const condition1 = createConditionDto(variables[1]);
+        const condition3 = createConditionDto(variables[3]);
+        const condition5 = createConditionDto(variables[5]);
+        const group = createConditionGroupDto([condition0, condition3]);
+        // const action1: Exc
+        const rule: BuilderRuleDto = {
+            name: "rule-name",
+            conditions: [condition1, group, condition5],
+            excludeTags: [],
+            excludePages: [],
+            jumpToPage: false,
+            type: "all",
+        };
+        return [];
+    };
+    export const createExcludeByPageIdList = (): ReadonlyArray<ExcludeByPageIdSelectItem> => [
+        ExcludeByPageIdSelectItem.create(
+            {
+                kind: "exclude-by-pageId",
+                pageId: "page_a",
+                pageNumber: 5,
+                mainText: "Har du noen gang vært deprimeri?? ",
+            },
+            false
+        ),
+
+        ExcludeByPageIdSelectItem.create(
+            {
+                kind: "exclude-by-pageId",
+                pageId: "page_b",
+                pageNumber: 5,
+                mainText: "Har du noen gang vært deprimeri?? ",
+            },
+            true
+        ),
+
+        ExcludeByPageIdSelectItem.create(
+            {
+                kind: "exclude-by-pageId",
+                pageId: "page_c",
+                pageNumber: 5,
+                mainText: "Har du noen gang vært deprimeri?? ",
+            },
+            false
+        ),
+
+        ExcludeByPageIdSelectItem.create(
+            {
+                kind: "exclude-by-pageId",
+                pageId: "page_d",
+                pageNumber: 5,
+                mainText: "Har du noen gang vært deprimeri?? ",
+            },
+            false
+        ),
+
+        ExcludeByPageIdSelectItem.create(
+            {
+                kind: "exclude-by-pageId",
+                pageId: "page_e",
+                pageNumber: 5,
+                mainText: "Har du noen gang vært deprimeri?? ",
+            },
+            true
+        ),
+        ExcludeByPageIdSelectItem.create(
+            {
+                kind: "exclude-by-pageId",
+                pageId: "page_f",
+                pageNumber: 5,
+                mainText: "Har du noen gang vært deprimeri?? ",
+            },
+            false
+        ),
+
+        ExcludeByPageIdSelectItem.create(
+            {
+                kind: "exclude-by-pageId",
+                pageId: "page_g",
+                pageNumber: 5,
+                mainText: "Har du noen gang vært deprimeri?? ",
+            },
+            true
+        ),
+
+        ExcludeByPageIdSelectItem.create(
+            {
+                kind: "exclude-by-pageId",
+                pageId: "page_h",
+                pageNumber: 5,
+                mainText: "Har du noen gang vært deprimeri?? ",
+            },
+            false
+        ),
+
+        ExcludeByPageIdSelectItem.create(
+            {
+                kind: "exclude-by-pageId",
+                pageId: "page_i",
+                pageNumber: 5,
+                mainText: "Har du noen gang vært deprimeri?? ",
+            },
+            false
+        ),
+
+        ExcludeByPageIdSelectItem.create(
+            {
+                kind: "exclude-by-pageId",
+                pageId: "page_j",
+                pageNumber: 5,
+                mainText: "Har du noen gang vært deprimeri?? ",
+            },
+            true
+        ),
+    ];
+    export const createExcludeByTagList = () => [
+        ExcludeByTagSelectItem.create(
+            {
+                kind: "exclude-by-tag",
+                tag: "Can_read",
+                pageCount: 5,
+                description: "",
+            },
+            false
+        ),
+        ExcludeByTagSelectItem.create(
+            {
+                kind: "exclude-by-tag",
+                tag: "Is grownup",
+                pageCount: 1,
+                description: "",
+            },
+            true
+        ),
+        ExcludeByTagSelectItem.create(
+            {
+                kind: "exclude-by-tag",
+                tag: "speaks english",
+                pageCount: 3,
+                description: "",
+            },
+            false
+        ),
+        ExcludeByTagSelectItem.create(
+            {
+                kind: "exclude-by-tag",
+                tag: "has work",
+                pageCount: 7,
+                description: "",
+            },
+            false
+        ),
+        ExcludeByTagSelectItem.create(
+            {
+                kind: "exclude-by-tag",
+                tag: "is-depressed",
+                pageCount: 2,
+                description: "",
+            },
+            false
+        ),
+    ];
+}

package/src/rulebuilder/RuleInput.ts

@@ -0,0 +1,44 @@
+import type { QuestionVariable, CustomVariable, BuilderVariable } from "./RuleVariable";
+import type { ExcludeByPageAction, ExcludeByTagAction, JumpToPageAction } from "./RuleAction";
+import { JumpToPageSelectItem } from "./SingleSelectItem";
+
+/**
+ * TODO Crate filters for "cardinality" or "order" of a variable;
+ * Return legal lists of variables.
+ */
+export class RuleInput {
+    constructor(
+        private readonly _questionVariables: ReadonlyArray<QuestionVariable>,
+        private readonly _customVariables: ReadonlyArray<CustomVariable>,
+        private readonly _pageIdActions: ReadonlyArray<ExcludeByPageAction>,
+        private readonly _tagActions: ReadonlyArray<ExcludeByTagAction>,
+        private readonly _jumpActions: ReadonlyArray<JumpToPageAction>
+    ) {}
+
+    get questionVars(): ReadonlyArray<QuestionVariable> {
+        return this._questionVariables;
+    }
+
+    getConditionInput(): ReadonlyArray<BuilderVariable> {
+        return [...this.questionVars, ...this.customVars];
+    }
+
+    getJumpToPageOptions(): ReadonlyArray<JumpToPageSelectItem> {
+        return this._jumpActions.map(JumpToPageSelectItem.create);
+    }
+
+    get customVars(): ReadonlyArray<CustomVariable> {
+        return this._customVariables;
+    }
+
+    get excludeByPageIdActions() {
+        return this._pageIdActions;
+    }
+
+    get excludeByTagActions() {
+        return this._tagActions;
+    }
+    get jumpToPageActions() {
+        return this._jumpActions;
+    }
+}