@legalplace/tagextractor 1.0.0

package/src/libs/DataPopulator.ts

@@ -0,0 +1,321 @@
+import { Types } from '@legalplace/referencesparser'
+import ConditionsRunner from './ConditionsRunner'
+
+type OVC_TYPE = {
+  options: {
+    [key: string]: boolean[]
+  }
+  variables: {
+    [key: string]: (number | string)[]
+  }
+}
+
+class DataPopulator {
+  private references: Types.ReferencesType
+
+  private ovc: OVC_TYPE
+
+  private conditionsRunner: ConditionsRunner
+
+  private id?: number
+
+  private index?: number
+
+  private dataMap: ConditionDataMap
+
+  private data: ConditionData = {
+    o: {},
+    v: {},
+    c: {
+      o: {},
+      s: {},
+      v: {}
+    }
+  }
+
+  constructor(conditionsRunner: ConditionsRunner, references: Types.ReferencesType, ovc: OVC_TYPE, dataMap: ConditionDataMap, id?: number, index?: number) {
+    this.id = id
+    this.ovc = ovc
+    this.index = index
+    this.dataMap = dataMap
+    this.references = references
+    this.conditionsRunner = conditionsRunner
+
+    // Populating variables
+    this.populateVariables()
+
+    // Populating options
+    this.populateOptions()
+
+    // Populating conditions
+    this.populateConditions()
+  }
+
+  /**
+   * Returns resulting data object
+   */
+  public getData(): Readonly<ConditionData> {
+    return this.data
+  }
+
+  private populateConditions(): void {
+    // Sections
+    for (let i = 0; i < this.dataMap.c.s.length; i += 1) {
+      const sectionId = this.dataMap.c.s[i]
+      const sectionCondition = this.sectionConditionValue(sectionId)
+      this.data.c.s[sectionId] = [sectionCondition !== false]
+    }
+
+    // Options
+    for (let i = 0; i < this.dataMap.c.o.length; i += 1) {
+      const optionId = this.dataMap.c.o[i]
+      const optionCondition = [...this.getOptionConditions(optionId)];
+      this.data.c.o[optionId] = optionCondition === undefined ? [false] : optionCondition
+    }
+
+    // Variables
+    for (let i = 0; i < this.dataMap.c.v.length; i += 1) {
+      const variableId = this.dataMap.c.v[i]
+      const variableCondition = [...this.getVariablesConditions(variableId)]
+      this.data.c.v[variableId] = variableCondition === undefined ? [false] : variableCondition
+    }
+  }
+/**
+   * Returns a give option's conditions
+   * @param optionId Option's id
+   */
+  private getOptionConditions(optionId: number): Readonly<boolean[]> {
+    const conditions = this.optionConditionValue(optionId);
+    if (conditions === undefined) return [true];
+    if (this.id === undefined || this.index === undefined) {
+      return conditions;
+    }
+
+    // Getting variable parent option
+    const optionRootParent = this.getOptionRootParent(optionId);
+    const optionRootRelations = this.references.relations.options[optionRootParent];
+    if (
+      optionRootRelations.children.options.includes(this.id) ||
+      optionRootRelations.dependants.includes(this.id) ||
+      this.id === optionRootParent
+    ) {
+      if (conditions !== undefined && conditions[this.index] === false)
+        return [false];
+      return [conditions[this.index]];
+    }
+
+    return conditions;
+  }
+
+  /**
+   * Returns a give variables conditions
+   * @param variableId Variable's id
+   */
+  private getVariablesConditions(variableId: number): Readonly<boolean[]> {
+    const conditions = this.variableConditionValue(variableId);
+    if (conditions === undefined) return [true];
+    if (this.id === undefined || this.index === undefined) {
+      return conditions;
+    }
+
+    // Getting variable parent option
+    const variableRootParent = this.getVariableRootParent(variableId);
+    const variableRootRelations = this.references.relations.options[variableRootParent];
+    if (
+      variableRootRelations.children.options.includes(this.id) ||
+      variableRootRelations.dependants.includes(this.id) ||
+      this.id === variableRootParent
+    ) {
+      return [conditions[this.index]];
+    }
+
+    return conditions;
+  }
+
+  /**
+   * Populates variables according to the current dataMap object
+   */
+  private populateVariables(): void {
+    for (let i = 0; i < this.dataMap.v.length; i += 1) {
+      const variableId = this.dataMap.v[i]
+      const variableReference = this.references.variables[variableId]
+      let values = this.getVariableValues(variableId)
+
+      const parseNumber = (v: string) => {
+        const result = parseFloat(v)
+        return Number.isNaN(result) ? '' : result
+      }
+      // If variable is of type number
+      if (variableReference.type === 'number') {
+        values = values.map(v => (typeof v === 'number' ? v : parseNumber(v)))
+      }
+
+      // Adding variables
+      this.data.v[variableId] = [...values]
+    }
+  }
+
+  /**
+   * Returns a give variables value
+   * @param variableId Variable's id
+   */
+  private getVariableValues(variableId: number): Readonly<(string | number)[]> {
+    const conditions = this.variableConditionValue(variableId)
+    const value = this.ovc.variables[variableId]
+    if (this.id === undefined || this.index === undefined) {
+      return value
+    }
+
+    // Getting variable parent option
+    const variableRootParent = this.getVariableRootParent(variableId)
+    const variableRootRelations = this.references.relations.options[variableRootParent]
+    if (variableRootRelations.children.options.includes(this.id) || variableRootRelations.dependants.includes(this.id) || this.id === variableRootParent) {
+      // TODO: Replace fAl$e with a safer solution
+      if (conditions !== undefined && conditions[this.index] === false) return ['fAl$e']
+      return [value[this.index]]
+    }
+
+    const cleanValues = this.cleanArrayFromNullValues([...value])
+
+    if (conditions === undefined) return cleanValues
+
+    return cleanValues.map((currentValue, index) => {
+      if (conditions[index] === false) return 'fAl$e'
+      return currentValue
+    })
+  }
+
+  /**
+   * Return a given variable root option relations
+   * @param variableId Variable's id
+   */
+  private getVariableRootParent(variableId: number) {
+    const variableParents = this.references.relations.variables[variableId].parents
+    return variableParents[variableParents.length - 1]
+  }
+
+  /**
+   * Cleans values array from any null value by replacing it
+   * with an empty string
+   * @param arr Values array
+   */
+  private cleanArrayFromNullValues(arr: (string | number | null)[]): (string | number)[] {
+    return arr.map(v => (v === null ? '' : v))
+  }
+
+  /**
+   * Populates options data object accodring to current dataMap object
+   */
+  populateOptions() {
+    for (let i = 0; i < this.dataMap.o.length; i += 1) {
+      const optionId = this.dataMap.o[i]
+      const inputs = this.getOptionInputs(optionId)
+
+      // Adding option
+      this.data.o[optionId] = [...inputs]
+    }
+  }
+
+  /**
+   * Returns a give option's inputs
+   * @param optionId Option's id
+   */
+  private getOptionInputs(optionId: number): Readonly<boolean[]> {
+    const conditions = this.optionConditionValue(optionId)
+    const inputs = this.ovc.options[optionId]
+    if (this.id === undefined || this.index === undefined) {
+      return inputs
+    }
+
+    // Getting variable parent option
+    const optionRootParent = this.getOptionRootParent(optionId)
+    const optionRootRelations = this.references.relations.options[optionRootParent]
+    if (optionRootRelations.children.options.includes(this.id) || optionRootRelations.dependants.includes(this.id) || this.id === optionRootParent) {
+      if (conditions !== undefined && conditions[this.index] === false) return [false]
+      return [inputs[this.index]]
+    }
+
+    if (conditions === undefined) return inputs
+
+    return inputs.map((value, index) => {
+      if (conditions[index] === false) return false
+      return value
+    })
+  }
+
+  /**
+   * Returns option's root parent
+   * @param optionId Root parent
+   */
+  private getOptionRootParent(optionId: number) {
+    const optionParents = this.references.relations.options[optionId].parents
+    return optionParents.length > 0 ? optionParents[optionParents.length - 1] : optionId
+  }
+
+  /**
+   * Calculates option's condition
+   */
+  private optionConditionValue(optionId: number) {
+    // Getting option conditions
+    const conditions = this.references.conditions.options[optionId]
+    if (conditions === undefined) return undefined
+
+    // Getting option inputs length
+    const inputs = this.ovc.options[optionId]
+
+    return inputs.map((input, index) => {
+      return this.conditionsRunner.executeCondition(conditions, optionId, index, 'options')
+    })
+  }
+
+  /**
+   * Calculates variable's condition
+   */
+  private variableConditionValue(variableId: number) {
+    // Getting variable conditions
+    const conditions = this.references.conditions.variables[variableId]
+    if (conditions === undefined) return undefined
+
+    // Getting variable inputs length
+    const inputs = this.ovc.variables[variableId]
+
+    const result = inputs.map((input, index) => {
+      return this.conditionsRunner.executeCondition(conditions, variableId, index, 'variables')
+    })
+
+    return result
+  }
+
+  /**
+   * Calculates section's condition
+   */
+  private sectionConditionValue(sectionId: number) {
+    // Getting section conditions
+    const conditions = this.references.conditions.sections.main[sectionId]
+    if (conditions === undefined) return undefined
+
+    return this.conditionsRunner.executeCondition(conditions, 0, 0, 'sections')
+  }
+}
+
+export interface ConditionDataMap {
+  o: number[]
+  v: number[]
+  c: {
+    o: number[]
+    s: number[]
+    v: number[]
+  }
+}
+
+export interface ConditionData {
+  o: Record<string, boolean[]>
+  v: Record<string, (string | number)[]>
+  c: {
+    o: Record<string, boolean[]>
+    s: Record<string, boolean[]>
+    v: Record<string, boolean[]>
+  }
+}
+
+export default DataPopulator

package/src/libs/Extractor.ts

@@ -0,0 +1,146 @@
+import { ModelV3 } from "@legalplace/models-v3-types";
+import { ReferencesParser, Types } from '@legalplace/referencesparser'
+import InputsType from "../types/inputs.type";
+import OvcType from "../types/ovc.type";
+import TagsType from "../types/tags.type";
+import ConditionsRunner from "./ConditionsRunner";
+import OvcConverter from "./OvcConverter";
+
+class TagsExtractor {
+  private references: Types.ReferencesType;
+
+  private inputs: InputsType;
+
+  private conditionsRunner: ConditionsRunner
+
+  private tags: TagsType = {
+    options: {},
+    variables: {}
+  }
+
+  constructor(model: ModelV3, ovc: OvcType | InputsType) {
+    // Parsing references
+    this.references = new ReferencesParser(model).references
+
+    // Converting inputs if needed
+    this.inputs = OvcConverter.isOptionsVariables(ovc) ? ovc : OvcConverter.convertToOptionsVariables(ovc, this.references)
+
+    // Initiaing Conditions runner
+    this.conditionsRunner = new ConditionsRunner(this.references, this.inputs);
+
+    // Extracting tags from options
+    this.extractFromOptions();
+
+    // Extracting tags from variables
+    this.extractFromVariables();
+  }
+
+  public get getTags() {
+    return this.tags
+  }
+
+  /**
+   * Reads Options
+   */
+  private extractFromOptions() {
+    Object.keys(this.references.options).forEach(id => {
+      const {tags, label} = this.references.options[id].meta
+
+      if(Array.isArray(tags) && tags.length > 0) {
+
+        // Getting condition
+        const conditions = this.optionConditionValue(parseInt(id, 10))
+        
+        this.inputs.options[id].forEach((v, index) => {
+
+          tags.forEach((tag) => {
+            if(this.tags.options[tag] === undefined) this.tags.options[tag] = []
+
+            console.log(conditions[index], conditions)
+            this.tags.options[tag].push({
+              id: parseInt(id, 10),
+              index,
+              label: label,
+              condition: conditions[index],
+              value: this.inputs.options[id][index]
+            })
+          })
+
+        })
+
+      }
+
+    })
+  }
+
+  /**
+   * Reads Variables
+   */
+  private extractFromVariables() {
+    Object.keys(this.references.variables).forEach(id => {
+      const {tags, label} = this.references.variables[id]
+
+      if(Array.isArray(tags) && tags.length > 0) {
+
+        // Getting condition
+        const conditions = this.variableConditionValue(parseInt(id, 10))
+        
+        this.inputs.variables[id].forEach((v, index) => {
+
+          tags.forEach((tag) => {
+            if(this.tags.variables[tag] === undefined) this.tags.variables[tag] = []
+            this.tags.variables[tag].push({
+              id: parseInt(id, 10),
+              index,
+              label: label,
+              condition: conditions[index],
+              value: this.inputs.variables[id][index]
+            })
+          })
+
+        })
+
+      }
+
+    })
+  }
+
+
+  /**
+   * Calculates option's condition
+   */
+  private optionConditionValue(optionId: number) {
+    // Getting option conditions
+    const conditions = this.references.conditions.options[optionId]
+
+    // Getting option inputs length
+    const inputs = this.inputs.options[optionId]
+    
+    if (conditions === undefined) return inputs.map(() => true)
+
+    return inputs.map((input, index) => {
+      return this.conditionsRunner.executeCondition(conditions, optionId, index, 'options')
+    })
+  }
+
+  /**
+   * Calculates variable's condition
+   */
+  private variableConditionValue(variableId: number) {
+    // Getting variable conditions
+    const conditions = this.references.conditions.variables[variableId]
+
+    // Getting variable inputs length
+    const inputs = this.inputs.variables[variableId]
+
+    if (conditions === undefined) return inputs.map(() => true)
+
+    const result = inputs.map((input, index) => {
+      return this.conditionsRunner.executeCondition(conditions, variableId, index, 'variables')
+    })
+
+    return result
+  }
+}
+
+export default TagsExtractor

package/src/libs/OvcConverter.ts

@@ -0,0 +1,177 @@
+import { Types } from '@legalplace/referencesparser'
+import InputsType from '../types/inputs.type';
+import OvcType from '../types/ovc.type';
+
+
+class OvcConverter {
+  public convertToOptionsVariables(
+    ovc: OvcType,
+    references: Types.ReferencesType
+  ) {
+    const inputs: InputsType = {
+      options: {},
+      variables: {}
+    }
+
+if (typeof ovc !== 'object') return inputs;
+
+    // Reading options
+    if (typeof ovc.o === 'object') {
+      Object.keys(ovc.o).forEach(id => {
+        const currentOption = ovc.o[id];
+
+        // If it's a multiple
+        if (Array.isArray(currentOption)) {
+          const occurences = currentOption.length;
+          // Adding static childrens
+          inputs.options = {
+            ...inputs.options,
+            ...this.pushStaticChildren(
+              inputs.options,
+              id,
+              occurences,
+              references
+            )
+          };
+          currentOption.forEach((childId, index) => {
+            const sanitizedId =
+              typeof childId === 'string' && childId.split('_').length > 0
+                ? childId.split('_')[0]
+                : childId;
+
+            // Making sure the input exist
+            if (!Object.prototype.hasOwnProperty.call(inputs.options, id)) {
+              inputs.options[id] = new Array(occurences).fill(false);
+            }
+
+            // Making sure the childId is not empty
+            if (
+              typeof sanitizedId === 'string' &&
+              sanitizedId.trim().length === 0
+            ) {
+              return;
+            }
+
+            // Creating input if it doesn't exist
+            if (
+              !Object.prototype.hasOwnProperty.call(inputs.options, sanitizedId)
+            ) {
+              inputs.options[sanitizedId] = new Array(occurences).fill(false);
+            }
+
+            // Adding static childrens
+            inputs.options = {
+              ...inputs.options,
+              ...this.pushStaticChildren(
+                inputs.options,
+                sanitizedId,
+                occurences,
+                references
+              )
+            };
+
+            // Setting current index to true
+            inputs.options[sanitizedId][index] = true;
+          });
+        } else {
+          if (
+            typeof currentOption === 'string' &&
+            currentOption.trim().length === 0
+          )
+            return;
+          inputs.options[currentOption] = [true];
+        }
+      });
+    }
+
+    // Reading checkboxes
+    if (typeof ovc.c === 'object') {
+      Object.keys(ovc.c).forEach(id => {
+        const currentCheckbox = ovc.c[id];
+        if (typeof id === 'string' && id.trim().length === 0) return;
+        // If it's a multiple
+        if (Array.isArray(currentCheckbox)) {
+          inputs.options[id] = currentCheckbox;
+        } else {
+          inputs.options[id] = [currentCheckbox];
+        }
+      });
+    }
+
+    // Reading variables
+    if (typeof ovc.v === 'object') {
+      Object.keys(ovc.v).forEach(id => {
+        const currentVariable = ovc.v[id];
+
+        // If it's a multiple
+        if (Array.isArray(currentVariable)) {
+          inputs.variables[id] = currentVariable;
+          // Getting parentsTree & parent id
+          const parentsTree = references.relations.variables[id].parents;
+          const parentOption =
+            inputs.options[`${parentsTree[parentsTree.length - 1]}`];
+          if (Array.isArray(parentOption)) {
+            const occurences = parentOption.length;
+            if (currentVariable.length < occurences) {
+              inputs.variables[id] = [
+                ...currentVariable,
+                ...Array(occurences - currentVariable.length).fill('')
+              ];
+            }
+          }
+        } else {
+          inputs.variables[id] = [currentVariable];
+        }
+      });
+    }
+
+    return inputs;
+  }
+
+  public isOvc(_obj: InputsType | OvcType): _obj is OvcType {
+    if (typeof _obj !== 'object' || _obj === null) return false
+    const ovcKeys = ['o', 'v', 'c']
+    const foundKeys = Object.keys(_obj)
+      .map((key): number => (ovcKeys.includes(key) ? 1 : 0))
+      .reduce((a, b) => a + b, 0)
+    return foundKeys > 1
+  }
+
+  public isOptionsVariables(_obj: InputsType | OvcType): _obj is InputsType {
+    if (typeof _obj !== 'object' || _obj === null) return false
+    const optionsVariablesKeys = ['options', 'variables']
+    const foundKeys = Object.keys(_obj)
+      .map((key): number => (optionsVariablesKeys.includes(key) ? 1 : 0))
+      .reduce((a, b) => a + b, 0)
+    return foundKeys === 2
+  }
+
+    private pushStaticChildren(
+    inputOptions: InputsType['options'],
+    id: number | string,
+    occurences: number,
+    references: Types.ReferencesType
+  ) {
+    const result = { ...inputOptions };
+    const intId = typeof id === 'number' ? id : parseInt(id, 10);
+
+    // Getting children options and variables
+    const { options } = references.relations.options[intId].children;
+
+    // Getting static children
+    const staticOptions = options.filter(childId => {
+      return references.options[childId].meta.type === 'static';
+    });
+
+    staticOptions.forEach(childId => {
+      // Creating input if it doesn't exist
+      if (!Object.prototype.hasOwnProperty.call(result, childId)) {
+        result[childId] = new Array(occurences).fill(false);
+      }
+    });
+
+    return result;
+  }
+}
+
+export default new OvcConverter()

package/src/types/inputs.type.ts

@@ -0,0 +1,10 @@
+type InputsType = {
+  options: {
+    [key: string]: boolean[]
+  }
+  variables: {
+    [key: string]: (number | string)[]
+  }
+}
+
+export default InputsType

package/src/types/ovc.type.ts

@@ -0,0 +1,13 @@
+interface OvcType {
+  o: {
+    [k: string]: string | number | (string | number)[]
+  }
+  v: {
+    [k: string]: string | number | (string | number)[]
+  }
+  c: {
+    [k: string]: boolean | boolean[]
+  }
+}
+
+export default OvcType

package/src/types/tags.type.ts

@@ -0,0 +1,22 @@
+interface TagsType {
+  options: Record<string, OptionTagType[]>
+  variables: Record<string, VariableTagType[]>
+}
+
+export interface OptionTagType {
+  id: number;
+  index: number;
+  label: string;
+  condition: boolean;
+  value: boolean
+}
+
+export interface VariableTagType {
+  id: number;
+  index: number;
+  label: string;
+  condition: boolean;
+  value: string | number
+}
+
+export default TagsType

package/test.ts

@@ -0,0 +1,8 @@
+import * as fs from 'fs'
+import { model, ovc} from './model'
+import TagsExtractor from './src'
+
+
+const tags = new TagsExtractor(model, ovc).getTags
+
+console.log(JSON.stringify(tags))