choerodon-ui/pro/es/data-set/utils.js

An enterprise-class UI design language and React-based implementation

import _extends from "@babel/runtime/helpers/extends";
import _objectSpread from "@babel/runtime/helpers/objectSpread2";
import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
import queryString from 'querystringify';
import moment, { isDate, isMoment } from 'moment';
import { isArrayLike } from 'mobx';
import isBoolean from 'lodash/isBoolean';
import isObject from 'lodash/isObject';
import isString from 'lodash/isString';
import isArray from 'lodash/isArray';
import isNumber from 'lodash/isNumber';
import warning from '../../../es/_util/warning';
import { getConfig } from '../../../es/configure';
import isNil from 'lodash/isNil';
import _isEmpty from 'lodash/isEmpty';
import XLSX from 'xlsx';
import { BooleanValue, DataToJSON, FieldType, RecordStatus, SortOrder } from './enum';
import isEmpty from '../_util/isEmpty';
import * as ObjectChainValue from '../_util/ObjectChainValue';
import localeContext, { $l } from '../locale-context';
import formatString from '../formatter/formatString';
import formatNumber from '../formatter/formatNumber';
import formatCurrency from '../formatter/formatCurrency';
import { getPrecision } from '../number-field/utils';
export function useNormal(dataToJSON) {
  return [DataToJSON.normal, DataToJSON['normal-self']].includes(dataToJSON);
}
export function useAll(dataToJSON) {
  return [DataToJSON.all, DataToJSON['all-self']].includes(dataToJSON);
}
export function useSelected(dataToJSON) {
  return [DataToJSON.selected, DataToJSON['selected-self']].includes(dataToJSON);
}
export function useCascade(dataToJSON) {
  return [DataToJSON.dirty, DataToJSON.selected, DataToJSON.all, DataToJSON.normal].includes(dataToJSON);
}
export function useDirty(dataToJSON) {
  return [DataToJSON.dirty, DataToJSON['dirty-self']].includes(dataToJSON);
}
export function append(url, suffix) {
  if (suffix) {
    return url + queryString.stringify(suffix, url.indexOf('?') === -1);
  }

  return url;
}
export function getOrderFields(fields) {
  return _toConsumableArray(fields.values()).filter(function (_ref) {
    var order = _ref.order;
    return order;
  });
}
export function processToJSON(value) {
  if (isDate(value)) {
    value = moment(value);
  }

  if (isMoment(value)) {
    var _getConfig = getConfig('formatter'),
        jsonDate = _getConfig.jsonDate;

    value = jsonDate ? value.format(jsonDate) : +value;
  }

  return value;
}
export var arrayMove = function arrayMove(array, from, to) {
  var startIndex = to < 0 ? array.length + to : to;
  var item = array.splice(from, 1)[0];
  array.splice(startIndex, 0, item);
};

function processOne(value, field) {
  var checkRange = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;

  if (!isEmpty(value)) {
    var range = field.get('range');

    if (range && checkRange) {
      if (isArrayLike(range)) {
        if (isObject(value)) {
          var _range = _slicedToArray(range, 2),
              start = _range[0],
              end = _range[1];

          value[start] = processOne(value[start], field, false);
          value[end] = processOne(value[end], field, false);
        }
      } else if (isArrayLike(value)) {
        value[0] = processOne(value[0], field, false);
        value[1] = processOne(value[1], field, false);
      }
    } else if (value instanceof Date) {
      value = moment(value);
    } else if (!isObject(value)) {
      value = formatString(value, {
        trim: field.get('trim'),
        format: field.get('format')
      });

      switch (field.type) {
        case FieldType["boolean"]:
          {
            var trueValue = field.get(BooleanValue.trueValue);
            var falseValue = field.get(BooleanValue.falseValue);

            if (value !== trueValue) {
              value = falseValue;
            }

            break;
          }

        case FieldType.number:
        case FieldType.currency:
          if (!isNaN(value)) {
            value = Number(value);
          } else {
            value = undefined;
          }

          break;

        case FieldType.string:
        case FieldType.intl:
        case FieldType.email:
        case FieldType.url:
          value = String(value);
          break;

        case FieldType.date:
        case FieldType.dateTime:
        case FieldType.time:
        case FieldType.week:
        case FieldType.month:
        case FieldType.year:
          {
            var _getConfig2 = getConfig('formatter'),
                jsonDate = _getConfig2.jsonDate;

            value = jsonDate ? moment(value, jsonDate) : moment(value);
            break;
          }

        default:
      }
    }
  }

  return value;
}

export function processValue(value, field, init) {
  if (field) {
    var multiple = field.get('multiple');
    var range = field.get('range');

    if (multiple) {
      if (isEmpty(value)) {
        if (init) {
          value = undefined;
        } else {
          value = [];
        }
      } else if (!isArray(value)) {
        if (isString(multiple) && isString(value)) {
          value = value.split(multiple);
        } else {
          value = [value];
        }
      }
    }

    if (isArray(value) && (multiple || !range)) {
      return value.map(function (item) {
        return processOne(item, field);
      });
    }

    return processOne(value, field);
  }

  return value;
} // 处理单个range

var processRangeToText = function processRangeToText(resultValue, field) {
  return resultValue.map(function (item) {
    var valueRange = isMoment(item) ? item.format() : isObject(item) ? item[field.get('textField')] : item.toString();
    return valueRange;
  }).join("~");
};

export function processExportValue(value, field) {
  if (field) {
    var multiple = field.get('multiple');
    var range = field.get('range');

    if (multiple) {
      if (isEmpty(value)) {
        value = [];
      } else if (!isArray(value)) {
        if (isString(multiple) && isString(value)) {
          value = value.split(multiple);
        } else {
          value = [value];
        }
      }
    }

    if (isArray(value) && (multiple || !range)) {
      if (field && !_isEmpty(field.lookup)) {
        return value.map(function (item) {
          return field.getText(processOne(item, field));
        }).join(',');
      }

      return value.map(function (item) {
        var itemValue = processOne(item, field);

        if (field && field.get('textField') && itemValue && isObject(itemValue)) {
          return itemValue[field.get('textField')];
        }

        return itemValue;
      }).join(',');
    }

    if (isArray(value) && multiple && range) {
      if (field && !_isEmpty(field.lookup)) {
        return value.map(function (item) {
          return field.getText(processRangeToText(processOne(item, field), field));
        }).join(',');
      }

      return value.map(function (item) {
        return processRangeToText(processOne(item, field), field);
      }).join(',');
    }

    if (field && !_isEmpty(field.lookup)) {
      return field.getText(processOne(value, field));
    }

    var resultValue = processOne(value, field);

    if (isMoment(resultValue)) {
      return resultValue.format();
    }

    if (field && field.get('textField') && resultValue && isObject(resultValue)) {
      if (range && isArrayLike(resultValue)) {
        return processRangeToText(resultValue, field);
      }

      return resultValue[field.get('textField')];
    }

    return resultValue;
  }

  return value;
}
/**
 * 实现如果名字是带有属性含义`.`找到能够导出的值
 * @param dataItem 一行数据
 * @param name 对应的fieldname
 * @param isBind 是否是从绑定获取值
 */

export function getSplitValue(dataItem, name) {
  var isBind = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
  var nameArray = name.split('.');

  if (nameArray.length > 1) {
    var levelValue = dataItem;

    for (var i = 0; i < nameArray.length; i++) {
      if (!isObject(levelValue)) {
        break;
      }

      if (isBind || i !== 0) {
        levelValue = levelValue[nameArray[i]];
      }
    }

    return levelValue;
  }

  if (isBind) {
    return dataItem[name];
  }

  return dataItem;
}
export function childrenInfoForDelete(json, children) {
  return Object.keys(children).reduce(function (data, name) {
    var child = children[name];

    if (child) {
      data[name] = [childrenInfoForDelete({}, child.children)];
    }

    return data;
  }, json);
}
export function sortTree(children, orderField) {
  if (orderField && children.length > 0) {
    var name = orderField.name,
        order = orderField.order;
    var m = Number.MIN_SAFE_INTEGER;
    children.sort(function (record1, record2) {
      var a = record1.get(name) || m;
      var b = record2.get(name) || m;

      if (isString(a) || isString(b)) {
        return order === SortOrder.asc ? String(a).localeCompare(String(b)) : String(b).localeCompare(String(a));
      }

      return order === SortOrder.asc ? a - b : b - a;
    });
  }

  return children;
} // 递归生成树获取树形结构数据

function availableTree(idField, parentField, parentId, allData) {
  var result = [];
  allData.forEach(function (element) {
    if (element[parentField] === parentId) {
      var childresult = availableTree(idField, parentField, element[idField], allData);
      result = result.concat(element).concat(childresult);
    }
  });
  return result;
} // 获取单个页面能够展示的数据


export function sliceTree(idField, parentField, allData, pageSize) {
  var availableTreeData = [];

  if (allData.length) {
    var parentLength = 0;
    allData.forEach(function (item) {
      if (item) {
        if (isNil(item[parentField]) && !isNil(idField) && parentLength < pageSize) {
          parentLength++;
          var childresult = availableTree(idField, parentField, item[idField], allData);
          availableTreeData = availableTreeData.concat(item).concat(childresult);
        }
      }
    });
  }

  return availableTreeData;
}
export function checkParentByInsert(_ref2) {
  var parent = _ref2.parent;

  if (parent && !parent.current) {
    throw new Error($l('DataSet', 'cannot_add_record_when_head_no_current'));
  }
}

function getValueType(value) {
  return isBoolean(value) ? FieldType["boolean"] : isNumber(value) ? FieldType.number : isString(value) ? FieldType.string : isMoment(value) ? FieldType.date : isObject(value) ? FieldType.object : FieldType.auto;
}

export function getBaseType(type) {
  switch (type) {
    case FieldType.number:
    case FieldType.currency:
      return FieldType.number;

    case FieldType.dateTime:
    case FieldType.time:
    case FieldType.week:
    case FieldType.month:
    case FieldType.year:
      return FieldType.date;

    case FieldType.intl:
    case FieldType.url:
    case FieldType.email:
      return FieldType.string;

    default:
      return type;
  }
}
export function checkFieldType(value, field) {
  if (process.env.NODE_ENV !== 'production') {
    if (!isEmpty(value)) {
      if (isArrayLike(value)) {
        return value.every(function (item) {
          return checkFieldType(item, field);
        });
      }

      var fieldType = getBaseType(field.type);
      var valueType = field.type === FieldType["boolean"] && [field.get(BooleanValue.trueValue), field.get(BooleanValue.falseValue)].includes(value) ? FieldType["boolean"] : getValueType(value);

      if (fieldType !== FieldType.auto && fieldType !== FieldType.reactNode && fieldType !== valueType) {
        warning(false, "Value type error: The value<".concat(value, ">'s type is ").concat(valueType, ", but the field<").concat(field.name, ">'s type is ").concat(fieldType, "."));
        return false;
      }
    }
  }

  return true;
}
var iframe;
/**
 * 目前定义为服务端请求的方法
 * @param url 导出地址
 * @param data 导出传递参数
 * @param method 默认post请求
 */

export function doExport(url, data) {
  var method = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'post';

  if (!iframe) {
    iframe = document.createElement('iframe');
    iframe.id = '_export_window';
    iframe.name = '_export_window';
    iframe.style.cssText = 'position:absolute;left:-10000px;top:-10000px;width:1px;height:1px;display:none';
    document.body.appendChild(iframe);
  }

  var form = document.createElement('form');
  form.target = '_export_window';
  form.method = method;
  form.action = url;
  var s = document.createElement('input');
  s.id = '_request_data';
  s.type = 'hidden';
  s.name = '_request_data';
  s.value = JSON.stringify(data);
  form.appendChild(s);
  document.body.appendChild(form);
  form.submit();
  document.body.removeChild(form);
}
export function findBindFields(myField, fields, excludeSelf) {
  var name = myField.name;
  return _toConsumableArray(fields.values()).filter(function (field) {
    if (field !== myField) {
      var bind = field.get('bind'); // 处理 addField 后校验问题
      // return isString(bind) ? bind.startsWith(`${name}.`) : !excludeSelf;

      return isString(bind) && bind.startsWith("".concat(name, "."));
    }

    return !excludeSelf;
  });
}
export function findBindField(myField, fields, callback) {
  var name = isString(myField) ? myField : myField.name;
  return _toConsumableArray(fields.values()).find(function (field) {
    if (field.name !== name) {
      var bind = field.get('bind');
      return isString(bind) && bind.startsWith("".concat(name, ".")) && (!callback || callback(field));
    }

    return false;
  });
}

function numberSorter(a, b) {
  return a - b;
}

function stringSorter(a, b) {
  return String(a || '').localeCompare(String(b || ''));
}

export function getFieldSorter(field) {
  var name = field.name;

  switch (field.type) {
    case FieldType.number:
    case FieldType.currency:
    case FieldType.date:
    case FieldType.dateTime:
    case FieldType.week:
    case FieldType.month:
    case FieldType.year:
    case FieldType.time:
      return field.order === SortOrder.asc ? function (a, b) {
        return numberSorter(a.get(name), b.get(name));
      } : function (a, b) {
        return numberSorter(b.get(name), a.get(name));
      };

    default:
      return field.order === SortOrder.asc ? function (a, b) {
        return stringSorter(a.get(name), b.get(name));
      } : function (a, b) {
        return stringSorter(b.get(name), a.get(name));
      };
  }
}
export function generateRecordJSONData(array, record, dataToJSON) {
  var normal = useNormal(dataToJSON);
  var json = normal ? !record.isRemoved && record.toData() : record.toJSONData();

  if (json && (normal || useAll(dataToJSON) || !useDirty(dataToJSON) || json.__dirty)) {
    delete json.__dirty;
    array.push(json);
  }
}
export function prepareSubmitData(records, dataToJSON) {
  var created = [];
  var updated = [];
  var destroyed = [];

  function storeWith(status) {
    switch (status) {
      case RecordStatus.add:
        return created;

      case RecordStatus["delete"]:
        return destroyed;

      default:
        return updated;
    }
  }

  records.forEach(function (record) {
    return generateRecordJSONData(storeWith(record.status), record, dataToJSON);
  });
  return [created, updated, destroyed];
}

function defaultAxiosConfigAdapter(config) {
  return config;
}

function generateConfig(config, dataSet, data, params, options) {
  if (isString(config)) {
    return {
      url: config
    };
  }

  if (typeof config === 'function') {
    return config(_objectSpread({}, options, {
      data: data,
      dataSet: dataSet,
      params: params
    }));
  }

  return config;
}

export function axiosConfigAdapter(type, dataSet, data, params, options) {
  var newConfig = {
    data: data,
    params: params,
    method: 'post'
  };

  var _ref3 = getConfig('transport') || {},
      globalConfig = _ref3[type],
      _ref3$adapter = _ref3.adapter,
      globalAdapter = _ref3$adapter === void 0 ? defaultAxiosConfigAdapter : _ref3$adapter;

  var _dataSet$transport = dataSet.transport,
      config = _dataSet$transport[type],
      adapter = _dataSet$transport.adapter;

  if (globalConfig) {
    _extends(newConfig, generateConfig(globalConfig, dataSet, data, params, options));
  }

  if (config) {
    _extends(newConfig, generateConfig(config, dataSet, data, params, options));
  }

  if (newConfig.data && newConfig.method && newConfig.method.toLowerCase() === 'get') {
    newConfig.params = _objectSpread({}, newConfig.params, {}, newConfig.data);
  }

  return (adapter || globalAdapter)(newConfig, type) || newConfig;
} // 查询顶层父亲节点

export function findRootParent(children) {
  if (children.parent) {
    return findRootParent(children.parent);
  }

  return children;
}
export function prepareForSubmit(type, data, configs, dataSet) {
  if (data.length) {
    var newConfig = axiosConfigAdapter(type, dataSet, data);

    if (newConfig.url) {
      configs.push(newConfig);
    } else {
      return data;
    }
  }

  return [];
}
export function generateResponseData(item, dataKey) {
  if (item) {
    if (isArray(item)) {
      return item;
    }

    if (isObject(item)) {
      if (dataKey) {
        var result = ObjectChainValue.get(item, dataKey);

        if (result === undefined) {
          return [item];
        }

        if (isArray(result)) {
          return result;
        }

        if (isObject(result)) {
          return [result];
        }
      } else {
        return [item];
      }
    }
  }

  return [];
}
export function getRecordValue(data, cb, fieldName) {
  if (fieldName) {
    var field = this.getField(fieldName);

    if (field) {
      var bind = field.get('bind');

      if (bind) {
        fieldName = bind;
      }
    }

    var dataSet = this.dataSet;

    if (dataSet) {
      var checkField = dataSet.props.checkField;

      if (checkField && checkField === fieldName) {
        var trueValue = field ? field.get(BooleanValue.trueValue) : true;
        var falseValue = field ? field.get(BooleanValue.falseValue) : false;
        var children = this.children;

        if (children) {
          return children.every(function (child) {
            return cb(child, checkField) === trueValue;
          }) ? trueValue : falseValue;
        }
      }
    }

    return ObjectChainValue.get(data, fieldName);
  }
}

function tlsBind(props, name, lang, tlsKey) {
  var tls = props.record.get(tlsKey) || {};

  if (name in tls) {
    return "".concat(tlsKey, ".").concat(name, ".").concat(lang);
  }
}

export function processIntlField(name, fieldProps, callback, dataSet) {
  if (fieldProps.type === FieldType.intl) {
    var dynamicProps = fieldProps.dynamicProps;
    var tlsKey = getConfig('tlsKey');
    var supports = localeContext.supports;
    var languages = Object.keys(supports);
    languages.forEach(function (language) {
      return callback("".concat(tlsKey, ".").concat(name, ".").concat(language), {
        type: FieldType.string,
        label: "".concat(supports[language])
      });
    });

    var _ref4 = dataSet || {},
        _ref4$lang = _ref4.lang,
        lang = _ref4$lang === void 0 ? localeContext.locale.lang : _ref4$lang;

    var newDynamicProps = typeof dynamicProps === 'function' ? function (props) {
      return _objectSpread({}, dynamicProps(props), {
        bind: tlsBind(props, name, lang, tlsKey)
      });
    } : _objectSpread({}, dynamicProps, {
      bind: function bind(props) {
        return tlsBind(props, name, lang, tlsKey);
      }
    });
    return callback(name, _objectSpread({}, fieldProps, {
      dynamicProps: newDynamicProps
    }));
  }

  return callback(name, fieldProps);
}
export function findBindFieldBy(myField, fields, prop) {
  var value = myField.get(prop);
  var myName = myField.name;
  return _toConsumableArray(fields.values()).find(function (field) {
    var bind = field.get('bind');
    return bind && bind === "".concat(myName, ".").concat(value);
  });
}

function processNumberOptions(field, options) {
  var precision = field.get('precision');
  var numberGrouping = field.get('numberGrouping');

  if (isNumber(precision)) {
    options.minimumFractionDigits = precision;
    options.maximumFractionDigits = precision;
  }

  if (numberGrouping === false) {
    options.useGrouping = false;
  }

  return options;
}

export function processFieldValue(value, field, defaultLang, showValueIfNotFound) {
  var type = field.type;
  var formatterOptions = field.get('formatterOptions') || {};
  var numberFieldFormatterOptions = getConfig('numberFieldFormatterOptions') || {};

  if (type === FieldType.number) {
    var precisionInValue = getPrecision(value || 0);
    return formatNumber(value, formatterOptions.lang || numberFieldFormatterOptions.lang || defaultLang, processNumberOptions(field, _objectSpread({
      minimumFractionDigits: precisionInValue,
      maximumFractionDigits: precisionInValue
    }, numberFieldFormatterOptions.options, {}, formatterOptions.options)));
  }

  if (type === FieldType.currency) {
    return formatCurrency(value, formatterOptions.lang || defaultLang, processNumberOptions(field, _objectSpread({
      currency: field.get('currency')
    }, formatterOptions.options)));
  }

  return field.getText(value, showValueIfNotFound);
}
export function getLimit(limit, record) {
  if (isString(limit) && record.getField(limit)) {
    return record.get(limit);
  }

  return limit;
}
export function adapterDataToJSON(isSelected, noCascade) {
  if (isSelected) {
    if (noCascade) {
      return DataToJSON['selected-self'];
    }

    return DataToJSON.selected;
  }

  if (noCascade) {
    return DataToJSON['dirty-self'];
  }

  return undefined;
}
export function generateData(records) {
  var dirty = false;
  var data = records.reduce(function (list, record) {
    if (record.isRemoved) {
      dirty = true;
    } else {
      var d = record.toData();

      if (d.__dirty) {
        dirty = true;
      }

      delete d.__dirty;
      list.push(d);
    }

    return list;
  }, []);
  return {
    dirty: dirty,
    data: data
  };
}
export function generateJSONData(ds, records) {
  var dataToJSON = ds.dataToJSON;
  var data = [];
  records.forEach(function (record) {
    return generateRecordJSONData(data, record, dataToJSON);
  });
  return {
    dirty: data.length > 0,
    data: data
  };
}
export function isDirtyRecord(record) {
  return record.status !== RecordStatus.sync || record.dirty;
}
export function getSpliceRecord(records, inserts, fromRecord) {
  if (fromRecord) {
    if (inserts.includes(fromRecord)) {
      return getSpliceRecord(records, inserts, records[records.indexOf(fromRecord) + 1]);
    }

    return fromRecord;
  }
} // bugs in react native

export function fixAxiosConfig(config) {
  var method = config.method;

  if (method && method.toLowerCase() === 'get') {
    delete config.data;
  }

  return config;
}
var EMPTY_GROUP_KEY = '__empty_group__';
export function normalizeGroups(groups, records) {
  var optGroups = [];
  var restRecords = [];
  records.forEach(function (record) {
    var previousGroup;
    groups.every(function (key) {
      var label = record.get(key);

      if (label !== undefined) {
        if (!previousGroup) {
          previousGroup = optGroups.find(function (item) {
            return item.value === label;
          });

          if (!previousGroup) {
            previousGroup = {
              name: key,
              value: label,
              records: [],
              subGroups: []
            };
            optGroups.push(previousGroup);
          }
        } else {
          var _previousGroup = previousGroup,
              subGroups = _previousGroup.subGroups;
          previousGroup = subGroups.find(function (item) {
            return item.value === label;
          });

          if (!previousGroup) {
            previousGroup = {
              name: key,
              value: label,
              records: [],
              subGroups: []
            };
            subGroups.push(previousGroup);
          }
        }

        return true;
      }

      return false;
    });

    if (previousGroup) {
      var _previousGroup2 = previousGroup,
          groupRecords = _previousGroup2.records;
      groupRecords.push(record);
    } else {
      restRecords.push(record);
    }
  });

  if (restRecords.length) {
    optGroups.push({
      name: EMPTY_GROUP_KEY,
      value: undefined,
      records: restRecords,
      subGroups: []
    });
  }

  return optGroups;
}
/**
 *
 * @param data 导出需要导出的数据
 * @param excelname 导出表单的名字
 */

export function exportExcel(data, excelName) {
  var ws = XLSX.utils.json_to_sheet(data, {
    skipHeader: true
  });
  /* 新建空workbook，然后加入worksheet */

  var wb = XLSX.utils.book_new();
  /* 新建book */

  XLSX.utils.book_append_sheet(wb, ws);
  /* 生成xlsx文件(book,sheet数据,sheet命名) */

  XLSX.writeFile(wb, "".concat(excelName, ".xlsx"));
  /* 写文件(book,xlsx文件名称) */
}
//# sourceMappingURL=utils.js.map