@legalplace/tagextractor 1.0.0

package/dist/libs/OvcConverter.js

@@ -0,0 +1,132 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __spreadArrays = (this && this.__spreadArrays) || function () {
+    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+    for (var r = Array(s), k = 0, i = 0; i < il; i++)
+        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+            r[k] = a[j];
+    return r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var OvcConverter = (function () {
+    function OvcConverter() {
+    }
+    OvcConverter.prototype.convertToOptionsVariables = function (ovc, references) {
+        var _this = this;
+        var inputs = {
+            options: {},
+            variables: {}
+        };
+        if (typeof ovc !== 'object')
+            return inputs;
+        if (typeof ovc.o === 'object') {
+            Object.keys(ovc.o).forEach(function (id) {
+                var currentOption = ovc.o[id];
+                if (Array.isArray(currentOption)) {
+                    var occurences_1 = currentOption.length;
+                    inputs.options = __assign(__assign({}, inputs.options), _this.pushStaticChildren(inputs.options, id, occurences_1, references));
+                    currentOption.forEach(function (childId, index) {
+                        var sanitizedId = typeof childId === 'string' && childId.split('_').length > 0
+                            ? childId.split('_')[0]
+                            : childId;
+                        if (!Object.prototype.hasOwnProperty.call(inputs.options, id)) {
+                            inputs.options[id] = new Array(occurences_1).fill(false);
+                        }
+                        if (typeof sanitizedId === 'string' &&
+                            sanitizedId.trim().length === 0) {
+                            return;
+                        }
+                        if (!Object.prototype.hasOwnProperty.call(inputs.options, sanitizedId)) {
+                            inputs.options[sanitizedId] = new Array(occurences_1).fill(false);
+                        }
+                        inputs.options = __assign(__assign({}, inputs.options), _this.pushStaticChildren(inputs.options, sanitizedId, occurences_1, references));
+                        inputs.options[sanitizedId][index] = true;
+                    });
+                }
+                else {
+                    if (typeof currentOption === 'string' &&
+                        currentOption.trim().length === 0)
+                        return;
+                    inputs.options[currentOption] = [true];
+                }
+            });
+        }
+        if (typeof ovc.c === 'object') {
+            Object.keys(ovc.c).forEach(function (id) {
+                var currentCheckbox = ovc.c[id];
+                if (typeof id === 'string' && id.trim().length === 0)
+                    return;
+                if (Array.isArray(currentCheckbox)) {
+                    inputs.options[id] = currentCheckbox;
+                }
+                else {
+                    inputs.options[id] = [currentCheckbox];
+                }
+            });
+        }
+        if (typeof ovc.v === 'object') {
+            Object.keys(ovc.v).forEach(function (id) {
+                var currentVariable = ovc.v[id];
+                if (Array.isArray(currentVariable)) {
+                    inputs.variables[id] = currentVariable;
+                    var parentsTree = references.relations.variables[id].parents;
+                    var parentOption = inputs.options["" + parentsTree[parentsTree.length - 1]];
+                    if (Array.isArray(parentOption)) {
+                        var occurences = parentOption.length;
+                        if (currentVariable.length < occurences) {
+                            inputs.variables[id] = __spreadArrays(currentVariable, Array(occurences - currentVariable.length).fill(''));
+                        }
+                    }
+                }
+                else {
+                    inputs.variables[id] = [currentVariable];
+                }
+            });
+        }
+        return inputs;
+    };
+    OvcConverter.prototype.isOvc = function (_obj) {
+        if (typeof _obj !== 'object' || _obj === null)
+            return false;
+        var ovcKeys = ['o', 'v', 'c'];
+        var foundKeys = Object.keys(_obj)
+            .map(function (key) { return (ovcKeys.includes(key) ? 1 : 0); })
+            .reduce(function (a, b) { return a + b; }, 0);
+        return foundKeys > 1;
+    };
+    OvcConverter.prototype.isOptionsVariables = function (_obj) {
+        if (typeof _obj !== 'object' || _obj === null)
+            return false;
+        var optionsVariablesKeys = ['options', 'variables'];
+        var foundKeys = Object.keys(_obj)
+            .map(function (key) { return (optionsVariablesKeys.includes(key) ? 1 : 0); })
+            .reduce(function (a, b) { return a + b; }, 0);
+        return foundKeys === 2;
+    };
+    OvcConverter.prototype.pushStaticChildren = function (inputOptions, id, occurences, references) {
+        var result = __assign({}, inputOptions);
+        var intId = typeof id === 'number' ? id : parseInt(id, 10);
+        var options = references.relations.options[intId].children.options;
+        var staticOptions = options.filter(function (childId) {
+            return references.options[childId].meta.type === 'static';
+        });
+        staticOptions.forEach(function (childId) {
+            if (!Object.prototype.hasOwnProperty.call(result, childId)) {
+                result[childId] = new Array(occurences).fill(false);
+            }
+        });
+        return result;
+    };
+    return OvcConverter;
+}());
+exports.default = new OvcConverter();

package/dist/types/inputs.type.d.ts

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

package/dist/types/inputs.type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/ovc.type.d.ts

@@ -0,0 +1,12 @@
+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/dist/types/ovc.type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/tags.type.d.ts

@@ -0,0 +1,19 @@
+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/dist/types/tags.type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/model.ts

@@ -0,0 +1,84 @@
+import { ModelV3 } from "@legalplace/models-v3-types"
+
+export const model: ModelV3 = {
+  "documents": {
+    "main": {
+      "name": "main",
+      "sections": [{
+        "id": 1,
+        "label": "Titre de la section",
+        "options": [1, 2]
+      }, {
+        "id": 2,
+        "label": "Titre de la section",
+        "options": [3]
+      }]
+    }
+  },
+  "options": {
+    "1": {
+      "meta": {
+        "type": "hidden",
+        "label": "Text de la question",
+        "output": "<p><span style=\"font-weight:bold;\">[var:1]</span><span style=\"font-weight:bold;\">  </span>  \n  <span style=\"font-weight:bold;\">[var:2]</span><span style=\"font-weight:bold;\"></span></p><p></p><p>[var:1]  [var:2]</p><p></p><p>blablabla</p><p>blablabla</p>",
+        "step": "*",
+        "id": 1
+      },
+      "variables": [],
+      "options": []
+    },
+    "2": {
+      "meta": {
+        "type": "static",
+        "id": 2,
+        "label": "Question",
+        "step": "*"
+      },
+      "options": [],
+      "variables": [1, 2]
+    },
+    "3": {
+      "meta": {
+        "type": "checkbox",
+        "id": 3,
+        "step": "*",
+        "label": "Case à cocher",
+        "tags": ["test", "test2"]
+      },
+      "options": [],
+      "variables": []
+    }
+  },
+  "variables": {
+    "1": {
+      "type": "text",
+      "id": 1,
+      "label": "ChampA",
+      "step": "*",
+      "mandatory": false,
+      "placeholder": "",
+      "tags": ["Hello"]
+    },
+    "2": {
+      "type": "text",
+      "id": 2,
+      "label": "ChampB",
+      "step": "*",
+      "mandatory": false,
+      "placeholder": "",
+      "tags": ["Hello"]
+    }
+  },
+  "customization": {}
+}
+
+export const ovc = {
+  "o": {},
+  "v": {
+    "1": "cccc",
+    "2": "dddddd"
+  },
+  "c": {
+    "3": false
+  }
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@legalplace/tagextractor",
+  "version": "1.0.0",
+  "description": "TagExtractor",
+  "main": "dist/index.js",
+  "repository": "https://git.legalplace.eu/legalplace/tagextractor",
+  "author": "Moncef Hammou <moncef@legalplace.fr> <moncef@legalplace.fr>",
+  "license": "MIT",
+  "scripts": {
+    "format": "prettier --single-quote --no-semi --trailing-comma none --write \"src/**/*.{js,ts,tsx}\"",
+    "lint": "tsc && eslint ./src/ --ext ts,js",
+    "lint:fix": "tsc && eslint 'src/**/*.{js,jsx,ts,tsx}' --fix",
+    "test": "jest",
+    "build": "tsc"
+  },
+  "dependencies": {
+    "@legalplace/lplogic": "^2.1.4",
+    "@legalplace/models-v3-types": "^3.4.47",
+    "@legalplace/referencesparser": "^1.5.0",
+    "crypto": "^1.0.1",
+    "typescript": "3.9.3"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.7.2",
+    "@babel/preset-typescript": "^7.7.2",
+    "@types/jest": "^24.0.15",
+    "@types/node": "^12.12.6",
+    "@typescript-eslint/eslint-plugin": "^2.6.1",
+    "@typescript-eslint/parser": "^2.6.1",
+    "airbnb-standard": "^1.0.0",
+    "eslint": "^6.6.0",
+    "eslint-config-airbnb-base": "^14.0.0",
+    "eslint-config-prettier": "^6.5.0",
+    "eslint-plugin-import": "^2.18.2",
+    "eslint-plugin-prettier": "^3.1.1",
+    "jest": "^24.8.0",
+    "prettier": "1.19.1",
+    "redux-mock-store": "^1.5.3",
+    "ts-jest": "^24.0.2"
+  }
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+import TagsExtractor from './libs/Extractor'
+
+export default TagsExtractor;

package/src/libs/ConditionsRunner.ts

@@ -0,0 +1,99 @@
+/* eslint-disable max-len */
+import LpLogic from '@legalplace/lplogic'
+import { Types } from '@legalplace/referencesparser'
+import { ConditionV3 } from '@legalplace/models-v3-types'
+import DataPopulator, { ConditionDataMap } from './DataPopulator'
+import InputsType from '../types/inputs.type'
+
+class ConditionsRunner {
+  private references: Types.ReferencesType
+
+  private ovc: InputsType
+
+  constructor(references: Types.ReferencesType, ovc: InputsType) {
+    this.references = references
+    this.ovc = ovc
+  }
+
+  isOptionRelatedToOption(optionA: number, optionB: number): boolean {
+    // Getting B relations
+    const OptionBParents = this.references.relations.options[optionB].parents
+    const OptionBRoot = OptionBParents[OptionBParents.length - 1]
+    const OptionBRootRelations = OptionBRoot ? this.references.relations.options[OptionBRoot] : undefined
+
+    // Checking if B option is related to the option that changed
+    if (OptionBRootRelations) {
+      if (optionA === optionB || OptionBRootRelations.children.options.includes(optionA) || OptionBRootRelations.dependants.includes(optionA)) {
+        return true
+      }
+    }
+
+    return false
+  }
+
+  isVariableRelatedToOption(variableId: number, optionId: number): boolean {
+    // Variable parent
+    const variableParentId = this.references.relations.variables[variableId].parents[0]
+
+    // Getting B relations
+    const optionParents = this.references.relations.options[variableParentId].parents
+    const optionRoot = optionParents[optionParents.length - 1]
+    const optionRootRelations = optionRoot ? this.references.relations.options[optionRoot] : undefined
+
+    // Checking if B option is related to the option that changed
+    if (optionRootRelations) {
+      if (optionRootRelations.children.options.includes(optionId) || optionRootRelations.dependants.includes(optionId)) {
+        return true
+      }
+    }
+
+    return false
+  }
+
+  isVariableRelatedToVariable(variableA: number, variableB: number): boolean {
+    // Getting variables options
+    const optionA = this.references.relations.variables[variableA].parents[0]
+    const optionB = this.references.relations.variables[variableB].parents[0]
+
+    // Getting B relations
+    const OptionBParents = this.references.relations.options[optionB].parents
+    const OptionBRoot = OptionBParents[OptionBParents.length - 1]
+    const OptionBRootRelations = OptionBRoot ? this.references.relations.options[OptionBRoot] : undefined
+
+    // Checking if B option is related to the option that changed
+    if (OptionBRootRelations) {
+      if (optionA === optionB || OptionBRootRelations.children.options.includes(optionA) || OptionBRootRelations.dependants.includes(optionA)) {
+        return true
+      }
+    }
+
+    return false
+  }
+
+  executeCondition(
+    condition: {
+      dataMap: ConditionDataMap
+      conditions: ConditionV3
+    },
+    id: number,
+    index: number,
+    conditionType: 'options' | 'optionValidator' | 'variables' | 'prefillers' | 'variableValidator' | 'sections' | 'documents'
+  ): any {
+    if (Array.isArray(condition)) return condition.map(_condition => this.executeCondition(_condition, id, index, conditionType))
+
+    // Populating Data
+    let currentData
+    if (conditionType === 'options' || conditionType === 'optionValidator') {
+      currentData = new DataPopulator(this, this.references, this.ovc, condition.dataMap, id, index).getData()
+    } else if (conditionType === 'variables' || conditionType === 'prefillers' || conditionType === 'variableValidator') {
+      const dataId = this.references.relations.variables[id].parents[0]
+      currentData = new DataPopulator(this, this.references, this.ovc, condition.dataMap, dataId, index).getData()
+    } else if (conditionType === 'sections' || conditionType === 'documents') {
+      currentData = new DataPopulator(this, this.references, this.ovc, condition.dataMap, id, index).getData()
+    }
+
+    return LpLogic(condition.conditions, currentData)
+  }
+}
+
+export default ConditionsRunner