ming-demo3/lib/components/meta/util.js

mdf metaui web

"use strict";

var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.parseControls = exports.parseContainer = void 0;

var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));

var _react = _interopRequireDefault(require("react"));

var MetaComponents = _interopRequireWildcard(require("./index"));

var _env = _interopRequireDefault(require("../../helpers/env"));

var _extend = require("@mdf/cube/lib/extend");

var BasicComponents = _interopRequireWildcard(require("../basic"));

var Row = BasicComponents.Row,
    Col = BasicComponents.Col;
var ControlTypesByChildrenField = _env["default"].ControlTypesByChildrenField;
var allComponentsMap = Object.assign({}, BasicComponents);
var allMetaComponentsMap = {};
var BasicComponentsMap = {};
var MetaComponentsMap = {};

var initComponents = function initComponents() {
  if (typeof cb !== 'undefined' && cb && _extend.extendComp) {
    allComponentsMap = Object.assign(allComponentsMap, _extend.extendComp.basic);
    allMetaComponentsMap = Object.assign(allMetaComponentsMap, _extend.extendComp.meta);
  }

  BasicComponentsMap = {};

  for (var attr in allComponentsMap) {
    BasicComponentsMap[attr.toLocaleLowerCase()] = allComponentsMap[attr];
  }

  MetaComponentsMap = {};

  for (var attr in allMetaComponentsMap) {
    MetaComponentsMap[attr.toLocaleLowerCase()] = allMetaComponentsMap[attr];
  }

  if (typeof cb !== 'undefined') {
    cb.allComponentsMap = allComponentsMap;
  }
};

var parseContainer = function parseContainer(container, viewModel, width, height, index, hasTree, handleClick, parents) {
  initComponents();
  var containerType = container.cControlType && container.cControlType.trim().toLocaleLowerCase();
  var key = container.groupId;
  var config = {};

  if (container.cStyle) {
    try {
      Object.assign(config, JSON.parse(container.cStyle));
    } catch (e) {}
  }

  var ComName = MetaComponentsMap[containerType];
  if (ComName) return _react["default"].createElement(ComName, {
    key: key,
    meta: container,
    viewModel: viewModel
  });

  switch (containerType) {
    case 'checkorgcomp':
      return _react["default"].createElement(MetaComponents.CheckOrgComp, {
        key: key,
        meta: container,
        model: viewModel
      });

    case 'listheader':
      return _react["default"].createElement(MetaComponents.ListHeader, {
        key: key,
        meta: container,
        model: viewModel,
        hasTree: hasTree,
        handleClick: handleClick
      });

    case 'cardheader':
      if (_env["default"].INTERACTIVE_MODE === 'touch') return null;
      return _react["default"].createElement(MetaComponents.CardHeader, {
        key: key,
        meta: container,
        model: viewModel
      });

    case 'toolbar':
      return _react["default"].createElement(MetaComponents.Toolbar, {
        key: key,
        align: container.cAlign,
        config: container.cStyle,
        delay: container.childrenField ? false : true,
        controls: container.controls,
        model: viewModel
      });

    case 'table':
      return _react["default"].createElement(MetaComponents.TableContainer, {
        key: key,
        meta: container,
        config: container.cStyle,
        width: width,
        height: height,
        viewModel: viewModel,
        parents: parents
      });

    case 'flatrowcontainer':
      return _react["default"].createElement(MetaComponents.FlatRowContainer, {
        key: key,
        meta: container,
        viewModel: viewModel,
        config: container.cStyle,
        width: width,
        height: height
      });

    case 'checkboxcontainer':
      return _react["default"].createElement(MetaComponents.CheckboxContainer, {
        key: key,
        meta: container,
        viewModel: viewModel
      });

    case 'treetable':
      return _react["default"].createElement(MetaComponents.TreeTableContainer, {
        key: key,
        meta: container,
        width: width,
        height: height,
        viewModel: viewModel
      });

    case 'tablecontrol':
      return _react["default"].createElement(MetaComponents.TableControl, {
        key: key,
        meta: container,
        width: width,
        viewModel: viewModel
      });

    case 'treecard':
      return _react["default"].createElement(MetaComponents.TreeCardContainer, {
        meta: container,
        viewModel: viewModel,
        width: width,
        index: index
      });

    case 'rpttable':
      return _react["default"].createElement(MetaComponents.RptTableContainer, {
        key: key,
        meta: container,
        width: width,
        viewModel: viewModel
      });

    case 'total':
      return _react["default"].createElement(MetaComponents.TotalContainer, {
        key: key,
        meta: container,
        viewModel: viewModel
      });

    case 'searchtree':
      return _react["default"].createElement(MetaComponents.SearchTree, {
        key: key,
        config: container.cStyle,
        model: viewModel.get(container.cCode),
        height: height
      });

    case 'tabpage':
    case 'tab_h':
      return _react["default"].createElement(MetaComponents.CardTabs, {
        key: key,
        meta: container,
        viewModel: viewModel,
        width: width,
        height: height,
        index: index
      });

    case 'linetabs':
      return _react["default"].createElement(MetaComponents.LineTabs, {
        meta: container,
        viewModel: viewModel,
        width: width,
        height: height,
        config: config
      });

    case 'groupcontainer':
      return _react["default"].createElement(MetaComponents.GroupContainer, {
        config: container.cStyle,
        meta: container,
        viewModel: viewModel,
        width: width,
        index: index
      });

    case 'title':
      return _react["default"].createElement(MetaComponents.Title, {
        key: key,
        meta: container,
        viewModel: viewModel
      });

    case 'footer':
      if (_env["default"].INTERACTIVE_MODE === 'touch') return null;
      return _react["default"].createElement(MetaComponents.Footer, {
        key: key,
        meta: container,
        viewModel: viewModel
      });

    case 'fileupload':
      return _react["default"].createElement(MetaComponents.FileUpload, {
        key: key
      });

    case 'modal':
      return null;

    case 'convenientquery':
      return _react["default"].createElement(MetaComponents.ConvenientQuery, {
        model: viewModel,
        cols: container.iCols || 3,
        config: config,
        autoExpand: false
      });

    case 'ecsuite':
      return _react["default"].createElement(MetaComponents.Ecsuite, {
        key: key,
        appendId: key,
        viewModel: viewModel,
        config: config
      });

    case 'listareamap':
      return _react["default"].createElement(MetaComponents.ListAreaMap, {
        cStyle: container.cStyle,
        width: width,
        height: height,
        meta: container,
        model: viewModel
      });

    case 'hotareamapdesign':
      return _react["default"].createElement(MetaComponents.HotAreaMapDesign, {
        config: container.config,
        cStyle: container.cStyle,
        width: width,
        height: height,
        model: viewModel,
        onSave: container.onSave,
        meta: container
      });

    case 'hotareamapdisplay':
      return _react["default"].createElement(MetaComponents.HotAreaMapDisplay, {
        cStyle: container.cStyle,
        width: width,
        height: height,
        model: viewModel,
        meta: container
      });

    default:
      {
        var leftComs = [],
            otherComs = [];
        var flag = false;

        if (container.containers) {
          container.containers.forEach(function (item) {
            var subContainerWidthPercent = getSubContainerWidthPercent(container, item);
            var subContainerWidth, widthClass;

            if (subContainerWidthPercent !== 100) {
              subContainerWidth = width * subContainerWidthPercent / 100;
              widthClass = "viewContainer width-percent-".concat(subContainerWidthPercent.toFixed(0));
              flag = true;
            }

            var component = parseContainer(item, viewModel, subContainerWidth || width, height, index, hasTree, handleClick, parents);

            switch (item.cAlign && item.cAlign.trim().toLocaleLowerCase()) {
              case 'left':
                leftComs.push(component);
                break;

              default:
                otherComs.push(widthClass ? _react["default"].createElement("div", {
                  className: widthClass
                }, component) : component);
                break;
            }
          });
        } else if (container.controls) {
          var component = parseControls(container, viewModel, width);
          otherComs.push(component);
        } else {
          console.warn("::::[util] ,info:  container ");
          return null;
        }

        var className = getContainerClassName(container);
        if (leftComs.length) return _react["default"].createElement(Row, {
          style: {
            display: 'flex',
            height: '100%'
          },
          className: className
        }, _react["default"].createElement("div", {
          className: "form-left Manual-calculation-left"
        }, leftComs), _react["default"].createElement("div", {
          className: "form-base  Manual-calculation"
        }, otherComs));
        if (!className) return flag ? _react["default"].createElement(Row, {
          className: "clearfix"
        }, otherComs) : otherComs;
        return _react["default"].createElement(Row, {
          className: className
        }, otherComs);
      }
  }
};

exports.parseContainer = parseContainer;

var getRelatedModel = function getRelatedModel(control, childrenField, viewModel) {
  var relatedModel = null;
  var controlType = control.cControlType && control.cControlType.trim().toLocaleLowerCase() || 'input';
  var modelKey = control.cItemName;

  if (ControlTypesByChildrenField.indexOf(controlType) > -1) {
    relatedModel = childrenField && viewModel.get(childrenField);
  } else {
    relatedModel = childrenField && viewModel.get(childrenField) && viewModel.get(childrenField).getEditRowModel && viewModel.get(childrenField).getEditRowModel().get(modelKey);
    if (!relatedModel) relatedModel = viewModel.get(modelKey);
  }

  return relatedModel;
};

var parseControls = function parseControls(container, viewModel, width) {
  initComponents();
  var components = [];
  var containerCols = container.iCols || 1;
  var childrenField = container.childrenField;
  var relatedFields = [],
      relatedModels = [],
      relatedControls = {},
      controls = [];
  container.controls.forEach(function (control) {
    if (!control.cStyle) return;

    try {
      var related = JSON.parse(control.cStyle).related;
      if (!related) return;
      if (!control.related) control.related = related;

      if (cb.utils.isArray(related)) {
        related.forEach(function (item) {
          relatedFields.push(item);
          relatedModels.push(getRelatedModel(control, childrenField, viewModel));
        });
      } else {
        relatedFields.push(related);
        relatedModels.push(getRelatedModel(control, childrenField, viewModel));
      }
    } catch (e) {}
  });
  container.controls.forEach(function (control) {
    var index = relatedFields.indexOf(control.cItemName);

    if (index > -1) {
      relatedControls[control.cItemName] = parseControl(control, viewModel, 1, childrenField, width, null, relatedModels[index]);
    } else {
      controls.push(control);
    }
  });
  relatedFields.forEach(function (field, index) {
    var items = field.split('|');
    if (items.length !== 2) return;
    var viewMeta = viewModel.getViewMeta(items[0]);
    if (!viewMeta || !viewMeta.controls) return;
    var relatedControl = viewMeta.controls.find(function (control) {
      return control.cItemName === items[1];
    });
    if (!relatedControl) return;
    relatedControls[relatedModels[index].getName() + field] = parseControl(relatedControl, viewModel, 1, viewMeta.childrenField, width, null, relatedModels[index]);
  });
  controls.forEach(function (control) {
    var related = control.related;
    var relatedControl = [];

    if (related) {
      if (cb.utils.isArray(related)) {
        related.forEach(function (item) {
          if (item.split('|').length === 2) item = control.cItemName + item;
          relatedControl.push(relatedControls[item]);
        });
      } else {
        if (related.split('|').length === 2) related = control.cItemName + related;
        relatedControl.push(relatedControls[related]);
      }
    }

    components.push(parseControl(control, viewModel, containerCols, childrenField, width, relatedControl.length ? relatedControl : null));
  });
  var title;

  if (container.cStyle) {
    var config = null;

    try {
      config = JSON.parse(container.cStyle);
    } catch (e) {
      config = {};
    }

    if (config.title) title = _react["default"].createElement(Col, {
      span: 24
    }, _react["default"].createElement("h3", null, container.cName));
  }

  if (container.cControlType == "collapse") {
    return _react["default"].createElement(MetaComponents.CollapseContainer, null, _react["default"].createElement(Row, {
      key: container.groupId
    }, title, _react["default"].createElement(Col, {
      span: 24
    }, components)));
  }

  return _react["default"].createElement(Row, {
    key: container.groupId
  }, title, _react["default"].createElement(Col, {
    span: 24
  }, components));
};

exports.parseControls = parseControls;

var getContainerClassName = function getContainerClassName(container) {
  if (!container.cStyle) return;
  var config = null;

  try {
    config = JSON.parse(container.cStyle);
  } catch (e) {
    config = {};
  }

  if (!config.classname) return;
  return config.classname;
};

var getSubContainerWidthPercent = function getSubContainerWidthPercent(container, item) {
  var containerCols = container.iCols || 1;
  if (containerCols === 1) return 100;
  var subContainerWidth = 100 / containerCols;

  if (item.cStyle) {
    var config = null;

    try {
      config = JSON.parse(item.cStyle);
    } catch (e) {
      config = {};
    }

    var subContainerCols = config.iColWidth || 1;
    if (subContainerCols > containerCols) subContainerWidth = 100;else if (subContainerCols > 1) subContainerWidth *= subContainerCols;
  }

  return subContainerWidth;
};

var parseControl = function parseControl(control, viewModel, containerCols, childrenField, width, relatedControl, relatedModel) {
  var controlWidth = 100 / containerCols;
  var controlCols = control.iColWidth || 1;
  if (controlCols > containerCols) controlWidth = 100;else if (controlCols > 1) controlWidth *= controlCols;
  var controlType = control.cControlType && control.cControlType.trim().toLocaleLowerCase() || 'input';
  var modelKey = control.cItemName;
  var controlModel = null;

  if (ControlTypesByChildrenField.indexOf(controlType) > -1) {
    controlModel = childrenField && viewModel.get(childrenField);
  } else {
    controlModel = childrenField && viewModel.get(childrenField) && viewModel.get(childrenField).getEditRowModel && viewModel.get(childrenField).getEditRowModel().get(modelKey);
    if (!controlModel) controlModel = viewModel.get(modelKey);
  }

  var ComName = BasicComponentsMap[controlType];
  var component = ComName ? _react["default"].createElement(ComName, (0, _extends2["default"])({
    model: controlModel
  }, control, {
    relatedControl: relatedControl,
    pageModel: viewModel,
    relatedModel: relatedModel
  })) : _react["default"].createElement("h1", null, controlType);
  var className = "viewSetting viewCell width-percent-".concat(controlWidth.toFixed(0));
  return _react["default"].createElement("div", {
    key: modelKey,
    className: className,
    id: "".concat(viewModel.getParams() && viewModel.getParams().billNo, "|").concat(modelKey)
  }, component);
};
//# sourceMappingURL=util.js.map