ronds-metadata 1.2.10 → 1.2.12

package/es/comps/MetadataEdit/components/MetaFieldsEdit.js

@@ -0,0 +1,419 @@
+import "antd/es/button/style";
+import _Button from "antd/es/button";
+import "antd/es/switch/style";
+import _Switch from "antd/es/switch";
+import "antd/es/input-number/style";
+import _InputNumber from "antd/es/input-number";
+import "antd/es/select/style";
+import _Select from "antd/es/select";
+import _extends from "@babel/runtime/helpers/esm/extends";
+import "antd/es/input/style";
+import _Input from "antd/es/input";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import "antd/es/form/style";
+import _Form from "antd/es/form";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import { MinusCircleOutlined, PlusOutlined } from '@ant-design/icons';
+import React from 'react';
+import { RULE_TYPES_OPTIONS } from '../constant';
+import { useMetaType } from '../hooks';
+import MetadataForm from '../../MetadataForm';
+import { MetadataService } from '../../../framework/metadata/MetadataService';
+
+var MetaFieldsEdit = function MetaFieldsEdit(props) {
+  var type = props.type,
+      defaultValues = props.defaultValues,
+      onChange = props.onChange;
+
+  var _Form$useForm = _Form.useForm(),
+      _Form$useForm2 = _slicedToArray(_Form$useForm, 1),
+      form = _Form$useForm2[0];
+
+  var _React$useState = React.useState({}),
+      _React$useState2 = _slicedToArray(_React$useState, 2),
+      ruleTypes = _React$useState2[0],
+      setRuleTypes = _React$useState2[1];
+
+  var _React$useState3 = React.useState({}),
+      _React$useState4 = _slicedToArray(_React$useState3, 2),
+      refIds = _React$useState4[0],
+      setRefIds = _React$useState4[1];
+
+  var _React$useState5 = React.useState({}),
+      _React$useState6 = _slicedToArray(_React$useState5, 2),
+      refSchema = _React$useState6[0],
+      setRefSchema = _React$useState6[1];
+
+  var _React$useState7 = React.useState({}),
+      _React$useState8 = _slicedToArray(_React$useState7, 2),
+      refValues = _React$useState8[0],
+      setRefValues = _React$useState8[1];
+
+  var metaType = useMetaType('扩展规则');
+
+  var processSpecialRuleData = /*#__PURE__*/function () {
+    var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(_refId, idx) {
+      var server, res, _schema, _properties, _refSchema;
+
+      return _regeneratorRuntime.wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              server = new MetadataService();
+              _context.next = 3;
+              return server.GetMetadataDetailById(_refId);
+
+            case 3:
+              res = _context.sent;
+              _schema = JSON.parse(res.schema);
+              _properties = _schema[0].properties;
+
+              if (_refId === 'com.ronds.schema.default.Rule.Form') {
+                _properties = _properties.filter(function (it) {
+                  return it.id === 'common' || it.id === 'common-en-US' || it.id === type;
+                });
+              }
+
+              _schema[0].properties = _properties;
+              _refSchema = refSchema;
+              _refSchema[idx] = _schema;
+              setRefSchema(_objectSpread({}, _refSchema));
+
+            case 11:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, _callee);
+    }));
+
+    return function processSpecialRuleData(_x, _x2) {
+      return _ref.apply(this, arguments);
+    };
+  }();
+
+  var onRefSelectChange = React.useCallback( /*#__PURE__*/function () {
+    var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(value, index) {
+      var _refIds, _refSchema, newData;
+
+      return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+        while (1) {
+          switch (_context2.prev = _context2.next) {
+            case 0:
+              _refIds = refIds;
+
+              if (!(value && value.indexOf('Rule.Form') > -1)) {
+                _context2.next = 6;
+                break;
+              }
+
+              _context2.next = 4;
+              return processSpecialRuleData(value, index);
+
+            case 4:
+              _context2.next = 9;
+              break;
+
+            case 6:
+              _refSchema = refSchema;
+              _refSchema[index] = undefined;
+              setRefSchema(_objectSpread({}, _refSchema));
+
+            case 9:
+              _refIds[index] = value;
+              setRefIds(_objectSpread({}, _refIds));
+              newData = form.getFieldValue('fields');
+              newData[index].id = value;
+              form.setFieldsValue({
+                fields: newData
+              });
+
+            case 14:
+            case "end":
+              return _context2.stop();
+          }
+        }
+      }, _callee2);
+    }));
+
+    return function (_x3, _x4) {
+      return _ref2.apply(this, arguments);
+    };
+  }(), [form]);
+  var processInitRule = React.useCallback( /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
+    var _defaultValues, _refIds, _ruleTypes;
+
+    return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+      while (1) {
+        switch (_context3.prev = _context3.next) {
+          case 0:
+            _defaultValues = [{
+              id: 'Rule.Form',
+              refId: 'com.ronds.schema.default.Rule.Form',
+              type: 'ref',
+              value: {}
+            }];
+            _refIds = refIds;
+            _ruleTypes = ruleTypes;
+
+            if (!(_defaultValues[0].refId.indexOf('Rule.Form') > -1)) {
+              _context3.next = 6;
+              break;
+            }
+
+            _context3.next = 6;
+            return processSpecialRuleData(_defaultValues[0].refId, 0);
+
+          case 6:
+            _refIds[0] = _defaultValues[0].refId;
+            setRefIds(_objectSpread({}, _refIds));
+            _ruleTypes[0] = 'ref';
+            setRuleTypes(_objectSpread({}, _ruleTypes));
+            form.setFieldsValue({
+              fields: _defaultValues
+            });
+
+          case 11:
+          case "end":
+            return _context3.stop();
+        }
+      }
+    }, _callee3);
+  })), [form]);
+  var processDefaultValues = React.useCallback( /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4() {
+    var _ruleTypes, _refIds, i;
+
+    return _regeneratorRuntime.wrap(function _callee4$(_context4) {
+      while (1) {
+        switch (_context4.prev = _context4.next) {
+          case 0:
+            if (!defaultValues) {
+              _context4.next = 17;
+              break;
+            }
+
+            _ruleTypes = ruleTypes;
+            _refIds = refIds;
+            form.setFieldsValue({
+              fields: defaultValues
+            });
+            i = 0;
+
+          case 5:
+            if (!(i < defaultValues.length)) {
+              _context4.next = 15;
+              break;
+            }
+
+            _ruleTypes[i] = defaultValues[i].type;
+
+            if (!(defaultValues[i].type === 'ref')) {
+              _context4.next = 12;
+              break;
+            }
+
+            if (!(defaultValues[i].refId.indexOf('Rule.Form') > -1)) {
+              _context4.next = 11;
+              break;
+            }
+
+            _context4.next = 11;
+            return processSpecialRuleData(defaultValues[i].refId, i);
+
+          case 11:
+            _refIds[i] = defaultValues[i].refId;
+
+          case 12:
+            i++;
+            _context4.next = 5;
+            break;
+
+          case 15:
+            setRefIds(_objectSpread({}, _refIds));
+            setRuleTypes(_objectSpread({}, _ruleTypes));
+
+          case 17:
+          case "end":
+            return _context4.stop();
+        }
+      }
+    }, _callee4);
+  })), [form]);
+  React.useEffect(function () {
+    if (defaultValues) {
+      processDefaultValues();
+    } else {
+      processInitRule();
+    }
+  }, [defaultValues, processInitRule, processDefaultValues]);
+
+  var onFinish = function onFinish(values) {
+    var _fields = values.fields;
+
+    for (var i = 0; i < _fields.length; i++) {
+      if (_fields[i].type === 'ref') {
+        _fields[i].value = refValues[i] || _fields[i].value;
+      }
+    }
+
+    onChange && onChange(_fields);
+  };
+
+  var onRefRulesValuesChange = function onRefRulesValuesChange(values, idx) {
+    var _refValues = refValues;
+    _refValues[idx] = _refValues[idx] ? _objectSpread(_objectSpread({}, _refValues[idx]), values) : _objectSpread({}, values);
+    setRefValues(_objectSpread({}, _refValues));
+  };
+
+  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(_Form, {
+    className: "metadata-edit",
+    style: {
+      position: 'relative'
+    },
+    form: form,
+    name: "control-hooks",
+    onFinish: onFinish
+  }, /*#__PURE__*/React.createElement("div", {
+    style: {
+      padding: '10px'
+    }
+  }, /*#__PURE__*/React.createElement(_Form.List, {
+    name: "fields"
+  }, function (fields, _ref5) {
+    var add = _ref5.add,
+        remove = _ref5.remove;
+    return /*#__PURE__*/React.createElement(React.Fragment, null, fields.map(function (field, index) {
+      var _defaultValues$index;
+
+      return /*#__PURE__*/React.createElement("div", {
+        key: "".concat(field.key)
+      }, /*#__PURE__*/React.createElement("div", {
+        style: {
+          display: 'flex',
+          alignItems: 'flex-start'
+        }
+      }, /*#__PURE__*/React.createElement(_Form.Item, _extends({
+        className: "pr-10"
+      }, field, {
+        label: "\u89C4\u5219\u540D\u79F0",
+        name: [field.name, 'id'],
+        fieldKey: [field.fieldKey, 'id'],
+        rules: [{
+          required: true
+        }]
+      }), /*#__PURE__*/React.createElement(_Input, null)), /*#__PURE__*/React.createElement(_Form.Item, _extends({
+        className: "pr-10"
+      }, field, {
+        label: "\u89C4\u5219\u7C7B\u578B",
+        name: [field.name, 'type'],
+        fieldKey: [field.fieldKey, 'type'],
+        rules: [{
+          required: true
+        }]
+      }), /*#__PURE__*/React.createElement(_Select, {
+        style: {
+          width: '120px'
+        },
+        onChange: function onChange(value) {
+          var _ruleTypes = ruleTypes;
+          _ruleTypes[index] = value;
+          setRuleTypes(_objectSpread({}, _ruleTypes));
+        },
+        options: RULE_TYPES_OPTIONS,
+        getPopupContainer: function getPopupContainer(triggerNode) {
+          return triggerNode.parentNode;
+        }
+      })), ruleTypes[index] === 'text' && /*#__PURE__*/React.createElement(_Form.Item, _extends({}, field, {
+        label: "\u89C4\u5219\u503C",
+        name: [field.name, 'value'],
+        fieldKey: [field.fieldKey, 'value'],
+        rules: [{
+          required: true
+        }]
+      }), /*#__PURE__*/React.createElement(_Input, {
+        style: {
+          width: '120px'
+        }
+      })), ruleTypes[index] === 'number' && /*#__PURE__*/React.createElement(_Form.Item, _extends({}, field, {
+        label: "\u89C4\u5219\u503C",
+        name: [field.name, 'value'],
+        fieldKey: [field.fieldKey, 'value'],
+        rules: [{
+          required: true
+        }]
+      }), /*#__PURE__*/React.createElement(_InputNumber, {
+        style: {
+          width: '120px'
+        }
+      })), ruleTypes[index] === 'bool' && /*#__PURE__*/React.createElement(_Form.Item, _extends({}, field, {
+        label: "\u89C4\u5219\u503C",
+        name: [field.name, 'value'],
+        fieldKey: [field.fieldKey, 'value'],
+        rules: [{
+          required: true
+        }]
+      }), /*#__PURE__*/React.createElement(_Switch, null)), ruleTypes[index] === 'ref' && /*#__PURE__*/React.createElement(_Form.Item, _extends({}, field, {
+        label: "Ref",
+        name: [field.name, 'refId'],
+        fieldKey: [field.fieldKey, 'refId'],
+        rules: [{
+          required: true
+        }]
+      }), /*#__PURE__*/React.createElement(_Select, {
+        showSearch: true,
+        style: {
+          width: '120px'
+        },
+        onChange: function onChange(value) {
+          onRefSelectChange(value, index);
+        },
+        options: metaType || [],
+        filterOption: function filterOption(input, option) {
+          return (option === null || option === void 0 ? void 0 : option.label.indexOf(input)) >= 0;
+        },
+        getPopupContainer: function getPopupContainer(triggerNode) {
+          return triggerNode.parentNode;
+        },
+        allowClear: true
+      })), /*#__PURE__*/React.createElement("div", {
+        style: {
+          lineHeight: '88px',
+          paddingLeft: '15px'
+        }
+      }, /*#__PURE__*/React.createElement(MinusCircleOutlined, {
+        onClick: function onClick() {
+          return remove(field.name);
+        }
+      }))), (refIds[index] || refSchema[index]) && /*#__PURE__*/React.createElement("div", {
+        style: {
+          border: '1px solid var(--ronds-metadata-color-border-1)',
+          padding: '10px',
+          marginBottom: '10px'
+        }
+      }, /*#__PURE__*/React.createElement(MetadataForm, {
+        initialValues: defaultValues && defaultValues.length > 0 && ((_defaultValues$index = defaultValues[index]) === null || _defaultValues$index === void 0 ? void 0 : _defaultValues$index.value),
+        refId: refIds[index],
+        isFoldForm: true,
+        schema: refSchema[index],
+        onValuesChange: function onValuesChange(values, allValues) {
+          onRefRulesValuesChange(allValues, index);
+        }
+      })));
+    }), /*#__PURE__*/React.createElement(_Form.Item, null, /*#__PURE__*/React.createElement(_Button, {
+      type: "dashed",
+      onClick: function onClick() {
+        return add();
+      },
+      block: true,
+      icon: /*#__PURE__*/React.createElement(PlusOutlined, null)
+    }, "\u6DFB\u52A0\u6269\u5C55\u89C4\u5219")));
+  }), /*#__PURE__*/React.createElement(_Form.Item, null, /*#__PURE__*/React.createElement(_Button, {
+    type: "primary",
+    block: true,
+    htmlType: "submit"
+  }, "\u786E\u5B9A")))));
+};
+
+export default MetaFieldsEdit;