rb-document-form-constructor 0.3.0 → 0.3.4

package/dist/rb-document-form-constructor.esm.js

@@ -1,3 +1,4 @@
+import Vue from 'vue';
 import crypto from 'crypto';
 
 const UtFormConfig = {
@@ -79,6 +80,20 @@ const UtFormConfig = {
       }
     });
     return fields;
+  },
+
+  parseFacets(formConfig) {
+    let facets = [];
+    formConfig.sections.every(section => {
+      section.columns.every(c => {
+        c.fields.forEach(f => {
+          if (!facets.indexOf(f.facet)) {
+            facets.push(f.facet);
+          }
+        });
+      });
+    });
+    return facets;
   }
 
 };
@@ -4841,6 +4856,12 @@ let __applyRefProps = function (input, refConfig) {
   }
 };
 
+let __filterInputsByMultiple = function (inputs, multiple) {
+  return inputs.filter(i => {
+    return i.multiple && multiple || !i.multiple && !multiple;
+  });
+};
+
 let fcInputs = {
   string: {
     text: 'Текст',
@@ -5006,26 +5027,40 @@ const UtFormConstructor = {
   },
 
   getInputTypes(field) {
+    let inputs = [];
+
     if (!field) {
-      return [];
+      return inputs;
     }
 
     if (field.dict && !this.config.refInputs[field.ref]) {
-      return this.config.dictInputs;
+      inputs = __filterInputsByMultiple(this.config.dictInputs, field.multiple);
+    } else if (field.ref) {
+      inputs = __filterInputsByMultiple(this.config.refInputs[field.ref], field.multiple);
+    } else {
+      inputs = __filterInputsByMultiple(this.config.primitiveInputs[field.type], field.multiple);
     }
 
-    if (field.ref) {
-      return this.config.refInputs[field.ref];
-    }
+    return inputs;
+  },
 
-    return this.config.primitiveInputs[field.type];
+  hasMultipleInputTypes(field) {
+    let inputs = this.getInputTypes({ ...field,
+      multiple: true
+    });
+    return inputs && inputs.length > 0;
   },
 
   getDefaultInput(field) {
     let input = null;
+    let inputs = this.getInputTypes(field);
+
+    if (!inputs) {
+      input = this.primitiveInputs[0];
+    }
 
     if (field.ref && this.config.refInputs[field.ref]) {
-      input = __clone(this.config.refInputs[field.ref][0]);
+      input = __clone(inputs[0]);
 
       __applyDefaultProps(input);
 
@@ -5033,12 +5068,12 @@ const UtFormConstructor = {
         __applyRefProps(input, this.config.refInputConfigs[field.ref][input.name]);
       }
     } else if (field.dict) {
-      input = __clone(this.config.dictInputs[0]);
+      input = __clone(inputs[0]);
       input.props.dict.default = field.ref;
 
       __applyDefaultProps(input);
     } else {
-      input = __clone(this.config.primitiveInputs[field.type][0]);
+      input = __clone(inputs[0]);
 
       __applyDefaultProps(input);
     }
@@ -5080,17 +5115,12 @@ const UtFormConstructor = {
   runRule(context, script) {
     context = context ? context : {};
     context['console'] = console;
-    let appendScript = '';
-    /*for(let v in context) {
-        appendScript = appendScript + `var ${v} = this.${v};\n`;
-    }
-    appendScript = appendScript? appendScript + '\n': '';*/
 
     let func = function (script) {
       return notevil(script, context);
     };
 
-    func.call(context, appendScript + script);
+    func.call(context, script);
   }
 
 };
@@ -10972,13 +11002,24 @@ var script$3 = {
       type: Object,
       default: () => ({})
     },
-    validationState: {
-      type: Object,
-      default: () => ({})
+    refDataSuffix: {
+      type: String,
+      default: 'Data'
     }
   },
+
+  data() {
+    return {
+      validationState: {}
+    };
+  },
+
   methods: {
     onEventFired(eventName, event, field) {
+      if (eventName === 'input' && field.ref) {
+        this.doc[field.name + this.refDataSuffix] = null;
+      }
+
       if (field.rules) {
         field.rules.forEach(rule => {
           if (rule.event === eventName && rule.script) {
@@ -10991,6 +11032,34 @@ var script$3 = {
           }
         });
       }
+    },
+
+    validate() {
+      this.formConfig.sections.forEach(s => {
+        s.columns.forEach(c => {
+          c.fields.forEach(f => {
+            if (f.required && this.doc[f.name] == null) {
+              Vue.set(this.validationState, f.name, false);
+              Vue.set(this.validationState, `${f.name}__feedback`, `Поле ${f.labelRu} обязательно`);
+            } else {
+              Vue.set(this.validationState, f.name, null);
+            }
+
+            this.onEventFired('validate', {
+              validationState: this.validationState,
+              doc: this.doc
+            }, f);
+          });
+        });
+      });
+
+      for (let fieldName in this.validationState) {
+        if (this.validationState[fieldName] === false) {
+          return false;
+        }
+      }
+
+      return true;
     }
 
   },
@@ -11071,7 +11140,7 @@ var __vue_render__$3 = function () {
             },
             expression: "doc[field.name]"
           }
-        }, 'component', field.input.propsData, false))], 1)], 1)], 1) : _vm._e()];
+        }, 'component', field.input.propsData, false)), _vm._v(" "), !_vm.validationState[field.name] ? _c('b-form-invalid-feedback', [_vm._v("\n                                    " + _vm._s(_vm.validationState[field.name + "__feedback"]) + "\n                                ")]) : _vm._e()], 1)], 1)], 1) : _vm._e()];
       })], 2);
     }), 0)]) : _vm._e();
   }), 0);
@@ -11413,7 +11482,11 @@ var __vue_render__$2 = function () {
     attrs: {
       "value": 'click'
     }
-  }, [_vm._v("\n                                        Клик\n                                    ")])], 1)], 1)], 1), _vm._v(" "), _c('b-col', {
+  }, [_vm._v("\n                                        Клик\n                                    ")]), _vm._v(" "), _c('b-form-select-option', {
+    attrs: {
+      "value": 'validate'
+    }
+  }, [_vm._v("\n                                        Валидация\n                                    ")])], 1)], 1)], 1), _vm._v(" "), _c('b-col', {
     attrs: {
       "lg": "12"
     }
@@ -11589,6 +11662,14 @@ var script$1 = {
 
     rules() {
       return UtFormConstructor.getAvailableFieldRules(this.field);
+    },
+
+    hasMultipleInputTypes() {
+      return UtFormConstructor.hasMultipleInputTypes(this.field);
+    },
+
+    multiple() {
+      return this.field && this.field.multiple;
     }
 
   },
@@ -11612,6 +11693,11 @@ var script$1 = {
 
     currentInputName() {
       this.field.input = UtFormConstructor.getInputTypeByName(this.currentInputName, this.field);
+    },
+
+    multiple() {
+      let input = UtFormConstructor.getDefaultInput(this.field);
+      this.currentInputName = input.name;
     }
 
   },
@@ -11790,7 +11876,8 @@ var __vue_render__$1 = function () {
     }
   }, [_c('b-checkbox', {
     attrs: {
-      "size": "lg"
+      "size": "lg",
+      "disabled": !_vm.hasMultipleInputTypes
     },
     model: {
       value: _vm.field.multiple,
@@ -11799,7 +11886,7 @@ var __vue_render__$1 = function () {
       },
       expression: "field.multiple"
     }
-  }, [_vm._v("Множественное")])], 1)], 1), _vm._v(" "), _c('b-form-row', [_c('b-col', {
+  }, [_vm._v("\n                        Множественное\n                    ")])], 1)], 1), _vm._v(" "), _c('b-form-row', [_c('b-col', {
     attrs: {
       "lg": "12"
     }