@media-quest/builder 0.0.2 → 0.0.4

package/src/rulebuilder/Builder-rule.ts

@@ -1,86 +1,66 @@
-import {
-  BuilderCondition,
-  type BuilderConditionDto
-} from './Builder-condition';
+import { BuilderCondition, type BuilderConditionDto } from "./condition/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';
+  type ConditionGroupType,
+} from "./condition/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";
+import { Condition, DUtil, PageQueCommand, PageQueRules, Rule } from "@media-quest/engine";
+import { ExcludeByPageAction, ExcludeByTagAction, JumpToPageAction } from "./RuleAction";
+import { RuleBuilderTestUtils } from "./RuleBuilder-test-utils";
+import jumpToPageAction = RuleBuilderTestUtils.jumpToPageAction;
 
 export interface BuilderRuleDto {
   readonly type: ConditionGroupType;
   readonly name: string;
-  readonly conditions: ReadonlyArray<
-    BuilderConditionDto | BuilderConditionGroupDto
-  >;
+  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';
+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 readonly _conditions: Array<BuilderCondition | BuilderConditionGroup> = [];
 
-  private _tagActionManager: TagActionManager;
+  private readonly _tagActionManager: TagActionManager;
   private _pageActionManager: PageActionManager;
   readonly jumpToActionManager: JumpToActionManager;
-  public static readonly fromDto = (
-    dto: BuilderRuleDto,
-    input: RuleInput
-  ): BuilderRule => {
+  public static readonly fromDto = (dto: BuilderRuleDto, input: RuleInput): BuilderRule => {
     return new BuilderRule(dto, input);
   };
 
   protected constructor(
     private readonly dto: BuilderRuleDto,
-    private readonly _ruleInput: RuleInput
+    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') {
+    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
-        );
+      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._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
-    );
+    this._tagActionManager = new TagActionManager(_ruleInput.excludeByTagActions, dto.excludeTags);
+
+    this.jumpToActionManager = new JumpToActionManager(_ruleInput.jumpToPageActions, dto.jumpToPage);
   }
 
   get conditions(): ReadonlyArray<BuilderConditionGroup | BuilderCondition> {
@@ -109,9 +89,7 @@ export class BuilderRule extends BuilderObject<'builder-rule', BuilderRuleDto> {
     return this._type;
   }
 
-  deleteCondition(
-    condition: BuilderCondition | BuilderConditionGroup
-  ): boolean {
+  deleteCondition(condition: BuilderCondition | BuilderConditionGroup): boolean {
     const index = this._conditions.indexOf(condition);
     if (index < 0) {
       return false;
@@ -121,24 +99,19 @@ export class BuilderRule extends BuilderObject<'builder-rule', BuilderRuleDto> {
   }
 
   addCondition(): BuilderCondition {
-    const condition = BuilderCondition.create(
-      this._ruleInput.getConditionInput()
-    );
+    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: []
+      kind: "condition-group",
+      name: "",
+      type: "all",
+      conditions: [],
     };
-    const newGroup = BuilderConditionGroup.fromDto(
-      dto,
-      this._ruleInput.questionVars
-    );
+    const newGroup = BuilderConditionGroup.fromDto(dto, this._ruleInput.questionVars);
     this._conditions.push(newGroup);
     return newGroup;
   }
@@ -148,7 +121,7 @@ export class BuilderRule extends BuilderObject<'builder-rule', BuilderRuleDto> {
   }
 
   toJson(): BuilderRuleDto {
-    const conditions = this._conditions.map(c => c.toJson());
+    const conditions = this._conditions.map((c) => c.toJson());
     const excludePages = this._pageActionManager.getCurrentSelection();
     const excludeTags = this._tagActionManager.getCurrentSelection();
     const jumpToPage = this.jumpToActionManager.getSelectedPageId();
@@ -158,8 +131,74 @@ export class BuilderRule extends BuilderObject<'builder-rule', BuilderRuleDto> {
       conditions,
       excludePages,
       jumpToPage,
-      excludeTags
+      excludeTags,
     };
     return dto;
   }
+  toEngineRule(): PageQueRules {
+    const conditions: Condition[] = [];
+    this._conditions.forEach((c) => {
+      if (c) {
+        if (c instanceof BuilderCondition) {
+          const simpleCondition = c.toEngineCondition();
+          if (simpleCondition) {
+            conditions.push(simpleCondition);
+          }
+        }
+        if (c instanceof BuilderConditionGroup) {
+          const complexCondition = c.toEngineConditionComplex();
+          if (complexCondition) conditions.push(complexCondition);
+        }
+      }
+    });
+    let all: Condition[] = [];
+    let some: Condition[] = [];
+
+    if (this.type === "all") {
+      all = [...conditions];
+    }
+    const pageQueCommands: Array<PageQueCommand> = [];
+    const maybeJumpToPage = this.jumpToActionManager.selected;
+    if (maybeJumpToPage) {
+      const jumpCommand: PageQueCommand = {
+        kind: "PAGE_QUE_JUMP_TO_PAGE_COMMAND",
+        target: "PAGE_QUE",
+        targetId: "PAGE_QUE",
+        payload: { pageId: maybeJumpToPage.data.pageId },
+      };
+      pageQueCommands.push(jumpCommand);
+    }
+
+    const excludePageByIdList = this._pageActionManager.getEngineAction().map((a) => a.pageId);
+    if (excludePageByIdList.length) {
+      const command: PageQueCommand = {
+        kind: "PAGE_QUE_EXCLUDE_BY_PAGE_ID_COMMAND",
+        target: "PAGE_QUE",
+        targetId: "PAGE_QUE",
+        payload: { pageIds: [...excludePageByIdList] },
+      };
+      pageQueCommands.push(command);
+    }
+    const excludeTags = this._tagActionManager.getEngineActions().map((tagA) => tagA.tag);
+    if (excludeTags.length) {
+      const excludeTagsCommand: PageQueCommand = {
+        kind: "PAGE_QUE_EXCLUDE_BY_TAG_COMMAND",
+        target: "PAGE_QUE",
+        targetId: "PAGE_QUE",
+        payload: { tagIds: [...excludeTags] },
+      };
+      pageQueCommands.push(excludeTagsCommand);
+    }
+
+    const id = DUtil.randomObjectId();
+    const rule: PageQueRules = {
+      id: "",
+      description: this.name,
+      all,
+      some,
+      onFailure: [],
+      onSuccess: pageQueCommands,
+    };
+    return rule;
+  }
 }

package/src/rulebuilder/Rule2.ts

@@ -0,0 +1,87 @@
+import { BuilderVariableType } from "./RuleVariable";
+import { BuilderOperator } from "./condition/Builder-operator";
+import { BuilderConditionDto } from "./condition/Builder-condition";
+
+type ConditionType = "all" | "any" | "";
+
+type SolveResultType = "TRUE" | "FALSE" | "NOT_ENOUGH_DATA" | "ERROR";
+
+type SolveErrorReason =
+  | "INVALID_FACT_TYPE"
+  | "INVALID_OPERATOR"
+  | "INVALID_VALUE"
+  | "INVALID_VARIABLE"
+  | "UNIMPLEMENTED_VARIABLE_TYPE"
+  | "UNIMPLEMENTED_OPERATOR";
+
+type IsTrue = { readonly type: "IS_TRUE" };
+type IsFalse = { readonly type: "IS_FALSE" };
+type IsMissingFacts = { readonly type: "MISSING_FACTS"; readonly missingVariables: ReadonlyArray<string> };
+type HasError = {
+  readonly type: "HAS_ERROR";
+  readonly reason: SolveErrorReason;
+  readonly data: Record<string, string>;
+};
+export type SolveResult = IsFalse | IsTrue | IsMissingFacts | HasError;
+
+export interface Fact2 {
+  readonly variableType: "numeric";
+  readonly value: number;
+  readonly valueLabel: string;
+  readonly variableId: string;
+  readonly variableLabel: string;
+}
+
+class FactCollection {
+  constructor(private readonly facts: ReadonlyArray<Fact2>) {}
+  byId(variableId: string): Fact2 | false {
+    const result = this.facts.find((fact) => fact.variableId === variableId);
+    if (!result) {
+      return false;
+    }
+    return result;
+  }
+}
+interface Solvable {
+  isTrue(facts: FactCollection): boolean;
+  solve(facts: FactCollection): SolveResult;
+}
+interface IsValid {
+  isValid(): boolean;
+}
+export class Condition implements Solvable, IsValid {
+  constructor(private readonly dto: BuilderConditionDto) {}
+  isTrue(facts: FactCollection): boolean {
+    const op = this.dto.operator;
+    if (!BuilderOperator.is(op)) {
+      return false;
+    }
+
+    const fact = facts.byId(this.dto.variableId);
+
+    if (!fact) {
+      return false;
+    }
+
+    if (fact.variableType !== "numeric" && typeof fact.value !== "number") {
+      return false;
+    }
+
+    return false;
+  }
+  isValid(): boolean {
+    return false;
+  }
+
+  solve(facts: FactCollection): SolveResult {
+    return { type: "HAS_ERROR", reason: "UNIMPLEMENTED_VARIABLE_TYPE", data: {} }; // TODO
+  }
+}
+export class ConditionGroup {}
+export class Rule2 {
+  private _count = -1;
+  constructor(
+    private readonly dto: any,
+    private readonly _ruleInput: any,
+  ) {}
+}