@media-quest/builder 0.0.25 → 0.0.26

package/src/sum-score/sum-score-manager.ts

@@ -0,0 +1,154 @@
+import { SumScoreVariableDto } from "./sum-score-variable";
+import { SumScoreMemberShipID, SumScoreVariableID } from "../primitives/ID";
+import { SumScoreMembershipDto } from "./sum-score-membership";
+import { DUtil } from "@media-quest/engine";
+
+const cloneItem = <const T extends object>(item: T): T => ({ ...item });
+
+export class SumScoreManager implements Iterable<SumScoreVariableDto> {
+  public static readonly create = (
+    variables: Array<SumScoreVariableDto>,
+    memberships: Array<SumScoreMembershipDto>,
+  ): SumScoreManager => {
+    return new SumScoreManager(variables, memberships);
+  };
+
+  private _variables: SumScoreVariableDto[];
+  private _memberShips: SumScoreMembershipDto[];
+
+  private constructor(variables: SumScoreVariableDto[], memberships: SumScoreMembershipDto[]) {
+    this._variables = [...variables];
+    this._memberShips = [...memberships];
+  }
+
+  get variables(): ReadonlyArray<SumScoreVariableDto> {
+    return [...this._variables];
+  }
+  get memberShips(): ReadonlyArray<SumScoreMembershipDto> {
+    return [...this._memberShips];
+  }
+
+  toJson(): { variables: SumScoreVariableDto[]; memberShips: SumScoreMembershipDto[] } {
+    const variables = this._variables.map(cloneItem);
+    const memberShips = this._memberShips.map(cloneItem);
+    return { variables, memberShips };
+  }
+
+  /**
+   * Deletes a variable by its ID.
+   * @param {SumScoreVariableID} id - The ID of the variable to delete.
+   * @return An object containing the deleted variable and the deleted memberships.
+   */
+  variableDeleteById(id: SumScoreVariableID) {
+    const toDelete = this.variableGetById(id);
+    if (!toDelete) return false;
+
+    const keepMemberships: SumScoreMembershipDto[] = [];
+    const toDeleteMemberships: SumScoreMembershipDto[] = [];
+
+    this._memberShips.forEach((memberShip) => {
+      if (memberShip.sumScoreId === id) {
+        toDeleteMemberships.push(memberShip);
+      } else {
+        keepMemberships.push(memberShip);
+      }
+    });
+    this._variables = this._variables.filter((v) => v.id !== id);
+    this._memberShips = keepMemberships;
+    return { variableDeleted: toDelete, membershipsDeleted: toDeleteMemberships };
+    // this._memberShips = this._memberShips.filter((m) => m !== id);
+  }
+
+  variableAddNew(data: {
+    name?: string;
+    description?: string;
+    useAvg?: boolean;
+  }): SumScoreVariableDto {
+    const ssv: SumScoreVariableDto = {
+      id: SumScoreVariableID.create(),
+      basedOn: [],
+      description: "",
+      name: "",
+      useAvg: true,
+    };
+    this._variables.push(ssv);
+    return ssv;
+  }
+
+  variableGetById(id: SumScoreVariableID) {
+    return this._variables.find((variable) => variable.id === id) ?? false;
+  }
+
+  variableUpdate(
+    sumScoreVariableId: SumScoreVariableID,
+    changes: { name?: string; description?: string; useAvg?: boolean },
+  ) {
+    const maybeVariable = this.variableGetById(sumScoreVariableId);
+    if (!maybeVariable) {
+      return false;
+    }
+    if (typeof changes.name === "string") {
+      maybeVariable.name = changes.name;
+    }
+    if (typeof changes.description === "string") {
+      maybeVariable.description = changes.description;
+    }
+    if (typeof changes.useAvg === "boolean") {
+      maybeVariable.useAvg = changes.useAvg;
+    }
+    return true;
+  }
+
+  [Symbol.iterator](): Iterator<SumScoreVariableDto> {
+    return this._variables[Symbol.iterator]();
+  }
+
+  membershipAdd(
+    sumScoreVariableID: SumScoreVariableID,
+    varId: string,
+    weight?: number,
+  ): SumScoreMembershipDto | false {
+    let variableExist = false;
+    let memberShipIsMissing = false;
+
+    // const variableExists = this._variables.some((v) => {
+    //
+    // });
+    this._memberShips.forEach((m) => {
+      if (m.sumScoreId === sumScoreVariableID && m.varId === varId) {
+        variableExist = true;
+      }
+    });
+
+    if (variableExist) {
+      return false;
+    }
+    if (memberShipIsMissing) {
+      return false;
+    }
+
+    const membership: SumScoreMembershipDto = {
+      id: SumScoreMemberShipID.create(),
+      sumScoreId: sumScoreVariableID,
+      varId: varId,
+      weight: DUtil.isNumber(weight) ? weight : 1,
+    };
+
+    this._memberShips.push(membership);
+    return membership;
+  }
+
+  membershipGetById(id: SumScoreMemberShipID): SumScoreMembershipDto | false {
+    // return false;
+    return this._memberShips.find((m) => m.id === id) ?? false;
+  }
+
+  membershipDelete(id: SumScoreMemberShipID) {
+    this._memberShips = this._memberShips.filter((m) => m.id === id);
+  }
+
+  membershipGetByVarId(varId: string): SumScoreMembershipDto[] {
+    const filtered = this._memberShips.filter((m) => m.varId === varId);
+    return filtered.map(cloneItem);
+  }
+}

package/src/sum-score/sum-score-membership.ts

@@ -0,0 +1,45 @@
+import { SumScoreMemberShipID, SumScoreVariableID } from "../primitives/ID";
+import { BuilderObject } from "../BuilderObject";
+import { DUtil } from "@media-quest/engine";
+
+export interface SumScoreMembershipDto {
+  id: SumScoreMemberShipID;
+  sumScoreId: SumScoreVariableID;
+  varId: string;
+  weight: number;
+}
+
+export class SumScoreMemberShip extends BuilderObject<
+  "builder-sum-score-membership",
+  SumScoreMembershipDto
+> {
+  readonly objectType = "builder-sum-score-membership";
+  toJson(): SumScoreMembershipDto {
+    throw new Error("Method not implemented.");
+  }
+  clone(): SumScoreMembershipDto {
+    throw new Error("Method not implemented.");
+  }
+
+  static create = (
+    sumScoreVariableId: SumScoreVariableID,
+    varId: string,
+    weight?: number,
+  ): SumScoreMemberShip => {
+    const id = SumScoreMemberShipID.create();
+    const w = DUtil.isNumber(weight) ? weight : 1;
+    return new SumScoreMemberShip(id, sumScoreVariableId, varId, w);
+  };
+
+  get isValid() {
+    return true;
+  }
+  private constructor(
+    readonly id: SumScoreMemberShipID,
+    readonly sumScoreId: SumScoreVariableID,
+    readonly varId: string,
+    readonly weight: number,
+  ) {
+    super({ id, sumScoreId, varId, weight });
+  }
+}

package/src/sum-score/sum-score-variable.spec.ts

@@ -0,0 +1,151 @@
+import { SumScore } from "./sum-score";
+import { SumScoreVariableDto } from "./sum-score-variable";
+import { SumScoreVariableID } from "../primitives/ID";
+import { SumScoreAnswer } from "./sum-score-answer";
+
+const createAnswer = (value: number): SumScoreAnswer => {
+  const varId = "v" + value;
+  const varLabel = "label for " + varId;
+  const valueLabel = "label for value " + value;
+  return {
+    varId,
+    varLabel,
+    value,
+    valueLabel,
+  };
+};
+
+const createSumScore = (basedOn: SumScoreVariableDto["basedOn"]) => {
+  const id = SumScoreVariableID.create();
+  const sumVar1: SumScoreVariableDto = {
+    id,
+    name: "",
+    description: "",
+    useAvg: true,
+    basedOn,
+  };
+  return sumVar1;
+};
+
+const a0 = createAnswer(0);
+const a1 = createAnswer(1);
+const a2 = createAnswer(2);
+const a3 = createAnswer(3);
+const a4 = createAnswer(4);
+const a5 = createAnswer(5);
+const a6 = createAnswer(6);
+const a7 = createAnswer(7);
+const a8 = createAnswer(8);
+const a9 = createAnswer(9);
+
+const all = [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9];
+
+describe("Sum score sum-score.", () => {
+  test("Is allowed SumScoreValue", () => {
+    expect(SumScore.isAllowedValue(-1)).toBeFalsy();
+    expect(SumScore.isAllowedValue(0)).toBeTruthy();
+    expect(SumScore.isAllowedValue(1)).toBeTruthy();
+    expect(SumScore.isAllowedValue(2)).toBeTruthy();
+    expect(SumScore.isAllowedValue(3)).toBeTruthy();
+    expect(SumScore.isAllowedValue(4)).toBeTruthy();
+    expect(SumScore.isAllowedValue(5)).toBeTruthy();
+    expect(SumScore.isAllowedValue(6)).toBeTruthy();
+    expect(SumScore.isAllowedValue(7)).toBeTruthy();
+    expect(SumScore.isAllowedValue(8)).toBeTruthy();
+    expect(SumScore.isAllowedValue(9)).toBeFalsy();
+    expect(SumScore.isAllowedValue(999)).toBeFalsy();
+  });
+
+  test("Will calculate 2", () => {
+    const ss1 = createSumScore([
+      { varId: a1.varId, varLabel: a1.varLabel, weight: 1 },
+      { varId: a2.varId, varLabel: a2.varLabel, weight: 1 },
+      { varId: a9.varId, varLabel: a9.varLabel, weight: 1 },
+    ]);
+    const score = SumScore.calculate(ss1, all);
+    expect(score.sumScore).toBe(3);
+    expect(score.basedOn.length).toBe(3);
+    expect(score.avg).toBe(1.5);
+    expect(score.skippedBy9Count).toBe(1);
+  });
+  test("Will calculate 5 values", () => {
+    const ss1 = createSumScore([
+      { varId: a1.varId, varLabel: a1.varLabel, weight: 1 },
+      { varId: a2.varId, varLabel: a2.varLabel, weight: 1 },
+      { varId: a4.varId, varLabel: a4.varLabel, weight: 1 },
+      { varId: a5.varId, varLabel: a5.varLabel, weight: 1 },
+      { varId: a6.varId, varLabel: a6.varLabel, weight: 1 },
+      { varId: a9.varId, varLabel: a9.varLabel, weight: 0.5 },
+    ]);
+    const score = SumScore.calculate(ss1, all);
+    expect(score.sumScore).toBe(18);
+    expect(score.avg).toBe(3.6);
+    const basedOn1 = score.basedOn[0];
+    expect(basedOn1.value).toBe(a1.value);
+    expect(basedOn1.weight).toBe(1);
+    expect(basedOn1.varId).toBe(a1.varId);
+    expect(basedOn1.varLabel).toBe(a1.varLabel);
+  });
+  test("Will not include 9 in includedAnswersCount", () => {
+    const ss1 = createSumScore([
+      { varId: a0.varId, varLabel: a0.varLabel, weight: 1 },
+      { varId: a1.varId, varLabel: a1.varLabel, weight: 1 },
+      { varId: a5.varId, varLabel: a5.varLabel, weight: 1 },
+      { varId: a9.varId, varLabel: a9.varLabel, weight: 1 },
+    ]);
+    const score = SumScore.calculate(ss1, all);
+    expect(score.sumScore).toBe(6);
+    expect(score.avg).toBe(2);
+    expect(score.includedAnswerCount).toBe(3);
+  });
+  test("Will calculate weight", () => {
+    const ss1 = createSumScore([
+      { varId: a1.varId, varLabel: a1.varLabel, weight: 1 },
+      { varId: a8.varId, varLabel: a8.varLabel, weight: 0.5 },
+    ]);
+    const score = SumScore.calculate(ss1, all);
+    expect(score.sumScore).toBe(5);
+  });
+  test("Will calculate many weighted variables.", () => {
+    const ss1 = createSumScore([
+      { varId: a1.varId, varLabel: a1.varLabel, weight: 1 },
+      { varId: a2.varId, varLabel: a2.varLabel, weight: 0.5 },
+      { varId: a5.varId, varLabel: a5.varLabel, weight: 1.2 },
+      { varId: a8.varId, varLabel: a8.varLabel, weight: 2 },
+    ]);
+    const score = SumScore.calculate(ss1, all);
+    expect(score.sumScore).toBe(24);
+  });
+  test("Will count missing answers (missingAnswersCount)", () => {
+    const ss1 = createSumScore([
+      { varId: a1.varId, varLabel: a1.varLabel },
+      { varId: a2.varId, varLabel: a2.varLabel },
+      { varId: a3.varId, varLabel: a3.varLabel },
+      { varId: a5.varId, varLabel: a5.varLabel },
+      { varId: a9.varId, varLabel: a9.varLabel },
+    ]);
+    const missing5InDataSet = [a1, a2, a8];
+    const score = SumScore.calculate(ss1, missing5InDataSet);
+    expect(score.sumScore).toBe(3);
+    expect(score.includedAnswerCount).toBe(2);
+    expect(score.missingAnswerCount).toBe(3);
+    expect(score.avg).toBe(1.5);
+    expect(score.basedOn.length).toBe(2);
+    expect(score.avg).toBe(1.5);
+    expect(score.errorMessages.length).toBe(0);
+  });
+  test("includedAnswerCount + missingAnswerCount + skippedBy9Count = SumScoreVariable.basedOn.length", () => {
+    const ss1 = createSumScore([
+      { varId: a0.varId, varLabel: a0.varLabel },
+      { varId: a1.varId, varLabel: a1.varLabel },
+      { varId: a2.varId, varLabel: a2.varLabel },
+      { varId: a9.varId, varLabel: a9.varLabel },
+    ]);
+    const answers = [a1, a7, a8, a9];
+    const score = SumScore.calculate(ss1, answers);
+
+    expect(score.includedAnswerCount + score.missingAnswerCount + score.skippedBy9Count).toBe(
+      ss1.basedOn.length,
+    );
+  });
+});

package/src/sum-score/sum-score-variable.ts

@@ -0,0 +1,36 @@
+import { SumScoreVariableID } from "../primitives/ID";
+import { BuilderObject } from "../BuilderObject";
+
+export interface SumScoreVariableDto {
+  id: SumScoreVariableID;
+  name: string;
+  description: string;
+  useAvg: boolean;
+  /**
+   * All variables that the sum-score should be based on.
+   */
+  basedOn: Array<{ varId: string; varLabel: string; weight?: number }>;
+}
+
+export class SumScoreVariable extends BuilderObject<
+  "builder-sum-score-variable",
+  SumScoreVariableDto
+> {
+  readonly objectType = "builder-sum-score-variable";
+  useAvg = true;
+  name = "";
+  description = "";
+  private _basedOn: Array<{ varId: string }> = [];
+  public static readonly create = () => {
+    const id = SumScoreVariableID.create();
+  };
+  private constructor(dto: SumScoreVariableDto) {
+    super(dto);
+  }
+  toJson(): SumScoreVariableDto {
+    throw new Error("Method not implemented.");
+  }
+  clone(): SumScoreVariableDto {
+    throw new Error("Method not implemented.");
+  }
+}

package/src/{variable → sum-score}/sum-score.ts

@@ -1,130 +1,122 @@
-import { BVariable } from "./b-variable";
-import { SumScoreVariableDto } from "./sum-score-variable";
-
-/**
- *
- * A constant Array that contains all legal
- */
-const ALLOWED_VALUES = [0, 1, 2, 3, 4, 5, 6, 7, 8];
-const isAllowedValue = (num: number) => {
-  const notNegative = num >= 0;
-  const lessThanNine = num < 9;
-  return notNegative && lessThanNine;
-};
-
-type BasedOnEntry =
-  | { kind: "missing"; varId: string }
-  | { kind: "invalid-variable"; varId: string; message: string }
-  | { kind: "has-value"; varId: string; value: number; weight: number; varLabel: string };
-
-export interface SumScore {
-  sumScore: number;
-  avg: number; // Alle besvarte spørsmål som ikke er 9.
-  useAvg: boolean;
-  includedAnswerCount: number;
-  missingAnswerCount: number;
-  skippedBy9Count: number; // Antall vetikke / hopp over
-  basedOn: Array<{ varId: string; value: number; weight: number; varLabel: string }>;
-  errorMessages: string[];
-}
-
-const calculate = (
-  sumScoreVariable: SumScoreVariableDto,
-  allVariables: Array<Pick<BVariable, "varId" | "numericValue" | "kind" | "label">>,
-): SumScore => {
-  const legalValues: Array<number> = [...ALLOWED_VALUES];
-
-  // CALCULATE THESE!!
-  let includedAnswerCount = 0;
-  let skippedBy9Count = 0;
-  let missingAnswerCount = 0;
-  let sumScore = 0;
-  const errorMessages: string[] = [];
-  const basedOn: SumScore["basedOn"] = [];
-  const useAvg = !!sumScoreVariable.useAvg;
-
-  const basedOnEntries: BasedOnEntry[] = sumScoreVariable.basedOn.map((scv) => {
-    const maybeVariable = allVariables.find((v) => v.varId === scv.varId);
-    let result: BasedOnEntry = { kind: "missing", varId: scv.varId };
-    if (!maybeVariable) {
-      return result;
-    }
-
-    if (maybeVariable.kind !== "numeric-variable") {
-      result = {
-        kind: "invalid-variable",
-        varId: scv.varId,
-        message: "The actual variable is not a numeric-variable",
-      };
-      return result;
-    }
-    const value = maybeVariable.numericValue ?? BVariable.MISSING;
-    const varLabel = maybeVariable.label;
-    const weight = scv.weight ?? 1;
-    const varId = maybeVariable.varId;
-
-    result = {
-      kind: "has-value",
-      varId,
-      weight,
-      value,
-      varLabel,
-    };
-
-    return result;
-  });
-
-  basedOnEntries.forEach((entry) => {
-    if (entry.kind === "missing") {
-      missingAnswerCount++;
-    }
-    if (entry.kind === "has-value") {
-      const { varId, varLabel, weight, value } = { ...entry };
-      const isAllowed = isAllowedValue(value);
-      if (isAllowed) {
-        basedOn.push({ varId, weight, value, varLabel });
-        sumScore += entry.value * entry.weight;
-        includedAnswerCount++;
-      }
-      if (value === 9) {
-        skippedBy9Count++;
-        basedOn.push({ varId, weight, value, varLabel });
-      }
-    }
-    if (entry.kind === "invalid-variable") {
-      errorMessages.push(entry.message);
-    }
-  });
-
-  const avg = sumScore / includedAnswerCount;
-  const result: SumScore = {
-    avg,
-    useAvg,
-    includedAnswerCount,
-    skippedBy9Count,
-    sumScore,
-    basedOn,
-    missingAnswerCount,
-    errorMessages,
-  };
-  // Calculate avg
-
-  return result;
-};
-const createVariable = (varId: string): SumScoreVariableDto => {
-  return {
-    origin: "sum-score",
-    kind: "numeric-variable",
-    initialValue: 0,
-    min: 0,
-    label: "Sum 123",
-    varId: "sum-score-variable-id",
-    basedOn: [],
-  };
-};
-export const SumScore = {
-  ALLOWED_VALUES,
-  calculate,
-  isAllowedValue,
-  createVariable,
-};
+import { SumScoreVariableDto } from "./sum-score-variable";
+import { SumScoreVariableID } from "../primitives/ID";
+import { SumScoreAnswer } from "./sum-score-answer";
+
+/**
+ *
+ * A constant Array that contains all legal
+ */
+const ALLOWED_VALUES = [0, 1, 2, 3, 4, 5, 6, 7, 8];
+const isAllowedValue = (num: number) => {
+  const notNegative = num >= 0;
+  const lessThanNine = num < 9;
+  return notNegative && lessThanNine;
+};
+
+type BasedOnEntry =
+  | { kind: "missing"; varId: string }
+  | { kind: "invalid-variable"; varId: string; message: string }
+  | { kind: "has-value"; varId: string; value: number; weight: number; varLabel: string };
+
+export interface SumScore {
+  sumScore: number;
+  avg: number; // Alle besvarte spørsmål som ikke er 9.
+  useAvg: boolean;
+  includedAnswerCount: number;
+  missingAnswerCount: number;
+  skippedBy9Count: number; // Antall vetikke / hopp over
+  basedOn: Array<{ varId: string; value: number; weight: number; varLabel: string }>;
+  errorMessages: string[];
+}
+
+const calculate = (
+  sumScoreVariable: SumScoreVariableDto,
+  answers: Array<SumScoreAnswer>,
+): SumScore => {
+  const legalValues: Array<number> = [...ALLOWED_VALUES];
+
+  // CALCULATE THESE!!
+  let includedAnswerCount = 0;
+  let skippedBy9Count = 0;
+  let missingAnswerCount = 0;
+  let sumScore = 0;
+  const errorMessages: string[] = [];
+  const basedOn: SumScore["basedOn"] = [];
+  const useAvg = sumScoreVariable.useAvg;
+
+  const basedOnEntries: BasedOnEntry[] = sumScoreVariable.basedOn.map((scv) => {
+    const maybeAnswer = answers.find((v) => v.varId === scv.varId);
+    let result: BasedOnEntry = { kind: "missing", varId: scv.varId };
+    if (!maybeAnswer) {
+      return result;
+    }
+
+    const value = maybeAnswer.value;
+    const varLabel = maybeAnswer.varLabel;
+    const weight = scv.weight ?? 1;
+    const varId = maybeAnswer.varId;
+
+    result = {
+      kind: "has-value",
+      varId,
+      weight,
+      value,
+      varLabel,
+    };
+
+    return result;
+  });
+
+  basedOnEntries.forEach((entry) => {
+    if (entry.kind === "missing") {
+      missingAnswerCount++;
+    }
+    if (entry.kind === "has-value") {
+      const { varId, varLabel, weight, value } = { ...entry };
+      const isAllowed = isAllowedValue(value);
+      if (isAllowed) {
+        basedOn.push({ varId, weight, value, varLabel });
+        sumScore += entry.value * entry.weight;
+        includedAnswerCount++;
+      }
+      if (value === 9) {
+        skippedBy9Count++;
+        basedOn.push({ varId, weight, value, varLabel });
+      }
+    }
+    if (entry.kind === "invalid-variable") {
+      errorMessages.push(entry.message);
+    }
+  });
+
+  const avg = sumScore / includedAnswerCount;
+  const result: SumScore = {
+    avg,
+    useAvg,
+    includedAnswerCount,
+    skippedBy9Count,
+    sumScore,
+    basedOn,
+    missingAnswerCount,
+    errorMessages,
+  };
+  // Calculate avg
+
+  return result;
+};
+const createVariable = (): SumScoreVariableDto => {
+  const id = SumScoreVariableID.create();
+  return {
+    id,
+    name: "",
+    useAvg: true,
+    description: "",
+    basedOn: [],
+  };
+};
+export const SumScore = {
+  ALLOWED_VALUES,
+  calculate,
+  isAllowedValue,
+  createVariable,
+};