@zgfe/business-lib 1.1.66 → 1.1.67-beta.2

package/es/formulaTarget/components/formula/data.js

@@ -0,0 +1,40 @@
+export var formulaList = ['+', '-', '*', '/'];
+export var formulaList2 = [{
+  name: 'tianjia3',
+  value: '+'
+}, {
+  name: 'jian',
+  value: '-'
+}, {
+  name: 'qingchu',
+  value: '*'
+}, {
+  name: 'chu',
+  value: '/'
+}];
+export var formulaObj = {
+  '+': 'tianjia3',
+  '-': 'jian',
+  '*': 'qingchu',
+  '/': 'chu'
+};
+export var formulaDimensions = [{
+  type: 'number',
+  label: '人数'
+}, {
+  type: 'times',
+  label: '次数'
+}];
+export var resultFormatList = [{
+  label: '原始数据',
+  value: 'scale:5'
+}, {
+  label: '保留两位小数',
+  value: 'scale:2'
+}, {
+  label: '保留整数',
+  value: 'scale:0'
+}, {
+  label: '乘以100%',
+  value: 'percent:2'
+}];

package/es/formulaTarget/components/formula/demo.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => JSX.Element;
+export default _default;

package/es/formulaTarget/components/formula/demo.js

@@ -0,0 +1,76 @@
+import React from 'react';
+import FormulaContainer from '.';
+import { BizGlobalDataContext, convertAttributeData } from '../../..';
+import eventData from '../../../mock/event';
+import envData from '../../../mock/env';
+import userData from '../../../mock/user';
+import { OperateTypes } from '../../../attrConditions/types';
+var defaultValue = [{
+  filters: {
+    relation: 'and',
+    conditions: [{
+      attrId: 0,
+      propCategory: 'userProp',
+      type: 1,
+      operator: OperateTypes.Equal,
+      values: ['实名'],
+      dimensionSub: 'is_anonymous',
+      label: '实名/匿名',
+      attrName: 'is_anonymous',
+      category: 'fixed'
+    }]
+  },
+  analysisDimension: {
+    analysisIndex: 'number'
+  },
+  type: 'add',
+  alias: '新增用户',
+  eventGroupId: 0,
+  eventName: '新增用户',
+  eventId: -201,
+  isBuiltIn: true
+}, {
+  filters: {
+    relation: 'and',
+    conditions: [{
+      attrId: 30601363,
+      propCategory: 'eventProp',
+      type: 1,
+      operator: OperateTypes.Equal,
+      values: ['3.0'],
+      dimensionSub: 'event_attr',
+      label: '版本',
+      attrName: '版本'
+    }]
+  },
+  analysisDimension: {
+    analysisIndex: 'number'
+  },
+  type: 'event',
+  alias: '底部导航栏曝光',
+  eventGroupId: 0,
+  eventName: '底部导航栏曝光',
+  eventId: 24288499,
+  isBuiltIn: false
+}];
+export default (function () {
+  var store = convertAttributeData({
+    eventList: eventData,
+    userPropList: userData,
+    envPropList: envData
+  });
+  var onChange = function onChange(data, result) {
+    console.log('公式change:', data, result);
+  };
+  return /*#__PURE__*/React.createElement(BizGlobalDataContext.Provider, {
+    value: {
+      eventGroupList: store.eventGroupList,
+      userPropList: store.userPropList,
+      eventEnvList: store.envPropList
+    }
+  }, ' ', /*#__PURE__*/React.createElement(FormulaContainer, {
+    value: defaultValue,
+    formula: "$0/(30+$1)*2",
+    onChange: onChange
+  }));
+});

package/es/formulaTarget/components/formula/index.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import { FormulaContainerTypes } from './types';
+import './index.less';
+export declare const classPrefix = "formula-container";
+declare const FormulaContainer: React.ForwardRefExoticComponent<FormulaContainerTypes.Props & React.RefAttributes<any>>;
+export default FormulaContainer;

package/es/formulaTarget/components/formula/index.js

@@ -0,0 +1,132 @@
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _iterableToArrayLimit(arr, i) { var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"]; if (null != _i) { var _s, _e, _x, _r, _arr = [], _n = !0, _d = !1; try { if (_x = (_i = _i.call(arr)).next, 0 === i) { if (Object(_i) !== _i) return; _n = !1; } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0); } catch (err) { _d = !0, _e = err; } finally { try { if (!_n && null != _i.return && (_r = _i.return(), Object(_r) !== _r)) return; } finally { if (_d) throw _e; } } return _arr; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+import React, { useEffect, useImperativeHandle, useState } from 'react';
+import { formatTarget, getBrackets, targetsFormat } from './util';
+import './index.less';
+import FormulaSymbol from '../symbol';
+import FormulaItem from '../formulaItem';
+import _ from 'lodash';
+import { BizSelect, IconFont, util } from '../../..';
+import { formulaList, resultFormatList } from './data';
+export var classPrefix = 'formula-container';
+var FormulaContainer = /*#__PURE__*/React.forwardRef(function (props, ref) {
+  var _useState = useState([]),
+    _useState2 = _slicedToArray(_useState, 2),
+    targetList = _useState2[0],
+    setTargetList = _useState2[1];
+  var _useState3 = useState([null, null]),
+    _useState4 = _slicedToArray(_useState3, 2),
+    brackets = _useState4[0],
+    setBrackets = _useState4[1];
+  var _useState5 = useState(resultFormatList[0]),
+    _useState6 = _slicedToArray(_useState5, 2),
+    resultFormat = _useState6[0],
+    setResultFormat = _useState6[1];
+  useEffect(function () {
+    init();
+  }, []);
+  useEffect(function () {
+    setBrackets(getBrackets(targetList));
+    var item = formatTarget(targetList);
+    props.onChange && props.onChange(item.formulaList, item.formula, resultFormat.value);
+  }, [targetList, resultFormat]);
+  useImperativeHandle(ref, function () {
+    return {
+      reset: init
+    };
+  });
+  var init = function init() {
+    setResultFormat(function () {
+      return props.resultFormat ? resultFormatList.filter(function (item) {
+        return item.value === props.resultFormat;
+      })[0] : resultFormatList[0];
+    });
+    setTargetList(targetsFormat(props.formula, props.value));
+  };
+  var _onChange = function onChange(index, data) {
+    setTargetList(function (list) {
+      var newList = _.cloneDeep(list);
+      newList[index].value = _.cloneDeep(data);
+      return newList;
+    });
+  };
+  var onAdd = function onAdd() {
+    setTargetList(function (list) {
+      var newList = _.cloneDeep(list);
+      if (list.length) {
+        newList.push({
+          id: util.guid(),
+          type: 'symbol',
+          value: formulaList[2]
+        });
+      }
+      newList.push({
+        id: util.guid(),
+        type: 'item',
+        value: null
+      });
+      return newList;
+    });
+  };
+  var _onDelete = function onDelete(id) {
+    setTargetList(function (list) {
+      var newList = _.cloneDeep(list);
+      newList.forEach(function (item, i) {
+        if (item.id === id) {
+          newList.splice(i, 1);
+          if (i > 0) {
+            newList.splice(i - 1, 1);
+          } else {
+            newList.splice(i, 1);
+          }
+        }
+      });
+      return newList;
+    });
+  };
+  var onChangeFormat = function onChangeFormat(data) {
+    setResultFormat(data);
+  };
+  return /*#__PURE__*/React.createElement("div", {
+    className: classPrefix
+  }, targetList.map(function (target, index) {
+    if (target.type === 'symbol') {
+      return /*#__PURE__*/React.createElement(FormulaSymbol, {
+        key: target.id,
+        value: target.value,
+        onChange: function onChange(data) {
+          return _onChange(index, data);
+        }
+      });
+    }
+    return /*#__PURE__*/React.createElement(FormulaItem, {
+      key: target.id,
+      id: target.id,
+      index: index,
+      value: target.value,
+      brackets: brackets,
+      onChange: function onChange(data) {
+        return _onChange(index, data);
+      },
+      onDelete: function onDelete() {
+        return _onDelete(target.id);
+      }
+    });
+  }), targetList.length < 9 ? /*#__PURE__*/React.createElement(IconFont, {
+    type: "tianjia",
+    className: "".concat(classPrefix, "-add"),
+    onClick: onAdd
+  }) : null, /*#__PURE__*/React.createElement("div", {
+    className: "".concat(classPrefix, "-format")
+  }, /*#__PURE__*/React.createElement("span", null, "\u8BA1\u7B97\u7ED3\u679C"), /*#__PURE__*/React.createElement(BizSelect, {
+    value: resultFormat,
+    options: resultFormatList,
+    keyField: 'value',
+    onChange: onChangeFormat
+  })));
+});
+export default FormulaContainer;

package/es/formulaTarget/components/formula/index.less

@@ -0,0 +1,68 @@
+@import '../../../assets/styles/inner.less';
+
+.formula-container {
+  display: flex;
+  align-items: center;
+  &-target {
+    display: flex;
+    &:hover {
+      .formula-container-option:not(.active) {
+        display: flex;
+        color: #b9ceff;
+      }
+    }
+    &-handle {
+      min-width: 88px;
+      &-icon {
+        margin-left: 4px;
+        color: @text-color-middle;
+      }
+      &-name {
+        margin-left: 4px;
+      }
+    }
+  }
+
+  &-format {
+    display: flex;
+    align-items: center;
+    margin-left: 40px;
+    & > span {
+      margin-right: 12px;
+    }
+
+    .biz-select-handle {
+      min-width: 136px;
+    }
+  }
+  &-add {
+    margin-left: 8px;
+    color: @primary-color;
+    font-size: 18px !important;
+    cursor: pointer;
+  }
+  &-option {
+    display: flex;
+    align-items: center;
+    color: transparent;
+    cursor: pointer;
+    &.active {
+      display: flex;
+      color: #354354;
+    }
+    &.disabled {
+      cursor: not-allowed;
+    }
+
+    &:first-child {
+      margin-right: 4px;
+    }
+    &:last-child {
+      margin-left: 4px;
+    }
+  }
+
+  &-symbol {
+    margin: 0 12px;
+  }
+}

package/es/formulaTarget/components/formula/types.d.ts

@@ -0,0 +1,24 @@
+import { TargetConditionTypes } from '../../..';
+export declare namespace FormulaContainerTypes {
+    interface Props {
+        value?: TargetConditionTypes.Value[];
+        formula?: string;
+        resultFormat?: string;
+        onChange?: (formulaList: TargetConditionTypes.Value[], formula: string, result?: string) => void;
+    }
+    type Value = null | string | TargetConditionTypes.Value;
+    interface FormulaItemValue {
+        id: string;
+        type: 'item' | 'symbol';
+        value: null | string | Item;
+    }
+    interface Item {
+        left: boolean;
+        right: boolean;
+        condition?: Value;
+    }
+    interface Bracket {
+        id: string;
+        index: number;
+    }
+}

package/es/formulaTarget/components/formula/types.js

@@ -0,0 +1 @@
+export {};

package/es/formulaTarget/components/formula/util.d.ts

@@ -0,0 +1,28 @@
+import { AttrConditionTypes, TargetConditionTypes } from '../../..';
+import { EventGroup } from '../../../attributeSelector/types';
+import { FormulaContainerTypes } from './types';
+import { BizFormulaTargetTypes } from '../../types';
+export declare const newItem: FormulaContainerTypes.FormulaItemValue;
+export declare const newSymbol: FormulaContainerTypes.FormulaItemValue;
+export declare const targetsFormat: (targetFormula?: string, targets?: TargetConditionTypes.Value[]) => FormulaContainerTypes.FormulaItemValue[];
+export declare const formatTarget: (targetList: FormulaContainerTypes.FormulaItemValue[]) => {
+    formula: string;
+    formulaList: TargetConditionTypes.Value[];
+};
+export declare const getBrackets: (formula: FormulaContainerTypes.FormulaItemValue[]) => any[];
+export declare const dimensionLabel: (condition: any) => any;
+export declare const isDisable: (id: string, currentIndex: number, brackets: any[], type: string) => boolean;
+export declare const validator: (type: string, condition?: TargetConditionTypes.Value | string | null) => {
+    isOk: boolean;
+    msg: string;
+};
+export declare const getDimension: (data: TargetConditionTypes.DimensionValue, eId?: number, eventGroupList?: EventGroup[]) => string;
+export declare const judgeHaveFilter: (filter?: AttrConditionTypes.GroupValue) => boolean;
+export declare const getFilters: (filters?: AttrConditionTypes.GroupValue) => {
+    conditions: AttrConditionTypes.ItemValue[];
+    relation?: "and" | "or" | undefined;
+} | undefined;
+export declare const validatorFormula: (params: BizFormulaTargetTypes.Value) => {
+    isOk: boolean;
+    msg: string;
+};

package/es/formulaTarget/components/formula/util.js

@@ -0,0 +1,245 @@
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+import _ from 'lodash';
+import { normalOptions } from '../../../targetConditionGroup/data/operates';
+import { util } from '../../../utils';
+import { formulaDimensions, formulaList } from './data';
+export var newItem = {
+  id: util.guid(),
+  type: 'item',
+  value: null
+};
+export var newSymbol = {
+  id: util.guid(),
+  type: 'symbol',
+  value: formulaList[2]
+};
+export var targetsFormat = function targetsFormat(targetFormula, targets) {
+  if (!targetFormula || !(targets === null || targets === void 0 ? void 0 : targets.length)) return [{
+    id: util.guid(),
+    type: 'item',
+    value: null
+  }];
+  var symbolReg = new RegExp("[".concat(formulaList.join('\\'), "]"), 'g');
+  var symbolList = targetFormula === null || targetFormula === void 0 ? void 0 : targetFormula.match(symbolReg);
+  var formulaItems = [];
+  targetFormula.split(symbolReg).forEach(function (formula, i) {
+    var item = {
+      id: util.guid(),
+      type: 'item',
+      value: {
+        left: /\(/.test(formula),
+        right: /\)/.test(formula),
+        condition: null
+      }
+    };
+    if (/\$/.test(formula)) {
+      var num = formula.match(/\d+/);
+      item.value.condition = num ? targets[Number(num[0])] : null;
+    } else {
+      item.value.condition = formula.replace(/\(|\)/g, '');
+    }
+    formulaItems.push(item);
+    if (symbolList && symbolList[i]) {
+      formulaItems.push({
+        id: util.guid(),
+        type: 'symbol',
+        value: symbolList[i]
+      });
+    }
+  });
+  return formulaItems;
+};
+export var formatTarget = function formatTarget(targetList) {
+  var formulaList = [];
+  var formula = '';
+  var i = 0;
+  targetList.forEach(function (item) {
+    if (!item.value) {
+      formula += item.value;
+      return;
+    }
+    if (item.type === 'item') {
+      var _data$condition;
+      var data = _.cloneDeep(item.value);
+      var code = "$".concat(i);
+      if ((_data$condition = data.condition) === null || _data$condition === void 0 ? void 0 : _data$condition.eventId) {
+        formulaList.push(data.condition);
+        i++;
+      } else {
+        code = data.condition;
+      }
+      formula += "".concat(data.left ? '(' : '').concat(code).concat(data.right ? ')' : '');
+    } else if (item.type === 'symbol') {
+      formula += item.value;
+    }
+  });
+  return {
+    formula: formula,
+    formulaList: formulaList
+  };
+};
+export var getBrackets = function getBrackets(formula) {
+  var brackets = new Array(2);
+  formula.forEach(function (item, i) {
+    var flag1 = item.value && item.value.left;
+    var flag2 = item.value && item.value.right;
+    if (flag1) {
+      brackets[0] = {
+        id: item.id,
+        index: i
+      };
+    }
+    if (flag2) {
+      brackets[1] = {
+        id: item.id,
+        index: i
+      };
+    }
+  });
+  return brackets;
+};
+export var dimensionLabel = function dimensionLabel(condition) {
+  if (util.isString(condition)) return '';
+  if (condition && ['add', 'pv', 'active'].includes(condition.type)) return '';
+  if (condition && condition.dimension) {
+    if (/:sum$/.test(condition.dimension)) {
+      return condition.dimension.replace(/:sum$/, ':总和');
+    }
+    var dimension = formulaDimensions.find(function (item) {
+      return item.type === condition.dimension;
+    });
+    if (dimension) return dimension.label;
+  }
+  return '';
+};
+export var isDisable = function isDisable(id, currentIndex, brackets, type) {
+  var disable = false;
+  var index = type === 'left' ? 0 : 1;
+  var flag = type === 'left' ? brackets[1] && brackets[1].index < currentIndex : brackets[0] && brackets[0].index > currentIndex;
+  if (brackets[index] && brackets[index].id !== id || flag) {
+    disable = true;
+  }
+  return disable;
+};
+export var validator = function validator(type, condition) {
+  var isOk = true;
+  var msg = '';
+  if (type === 'constant') {
+    if (condition !== '0' && !condition) {
+      isOk = false;
+      msg = '常数不可为空';
+    } else {
+      isOk = !/[^0-9.]/g.test(condition);
+      if (Number(condition) === 0) {
+        isOk = false;
+        msg = '常数不可为0';
+      } else if (!isOk) {
+        isOk = false;
+        msg = '常数中只能输入大于0的数字';
+      }
+    }
+  } else {
+    var _condition$filters;
+    if (condition && (condition === null || condition === void 0 ? void 0 : condition.filters) && (condition === null || condition === void 0 ? void 0 : (_condition$filters = condition.filters) === null || _condition$filters === void 0 ? void 0 : _condition$filters.conditions)) {
+      var _condition$filters2;
+      condition === null || condition === void 0 ? void 0 : (_condition$filters2 = condition.filters) === null || _condition$filters2 === void 0 ? void 0 : _condition$filters2.conditions.forEach(function (item) {
+        if (!isOk) return;
+        if (item.propCategory === 'eventProp' && !item.attrId || item.propCategory !== 'eventProp' && !item.attrName) {
+          isOk = false;
+          msg = '属性不可为空';
+        } else if (!item.values || !item.values.length) {
+          if (item.operator !== 'is null' && item.operator !== 'is not null') {
+            isOk = false;
+            msg = '属性值不能为空';
+          }
+        }
+      });
+    }
+  }
+  return {
+    isOk: isOk,
+    msg: msg
+  };
+};
+export var getDimension = function getDimension(data, eId, eventGroupList) {
+  var name = '';
+  normalOptions.forEach(function (item) {
+    if (item.value === data.analysisIndex) {
+      name = item.label;
+    }
+  });
+  if (data.analysisAttr) {
+    eventGroupList === null || eventGroupList === void 0 ? void 0 : eventGroupList.forEach(function (group) {
+      group.eventList.forEach(function (event) {
+        if (event.id === eId) {
+          event.attrList.forEach(function (attr) {
+            if (String(attr.id) === data.analysisAttr) {
+              name += attr.alias || attr.label;
+            }
+          });
+          return;
+        }
+      });
+    });
+  }
+  return name;
+};
+export var judgeHaveFilter = function judgeHaveFilter(filter) {
+  var flag = false;
+  filter === null || filter === void 0 ? void 0 : filter.conditions.forEach(function (item) {
+    if (item.attrId) {
+      if (item.values && item.values.length || ['is null', 'is not null'].includes(item.operator)) {
+        flag = true;
+        return;
+      }
+    }
+  });
+  return flag;
+};
+export var getFilters = function getFilters(filters) {
+  if (!filters) return;
+  var conditions = filters.conditions;
+  if (conditions && conditions.length) {
+    conditions = conditions.filter(function (item) {
+      return item.attrId && (item.values && item.values.length || ['is null', 'is not null'].includes(item.operator));
+    });
+  }
+  return _objectSpread(_objectSpread({}, filters), {}, {
+    conditions: conditions
+  });
+};
+export var validatorFormula = function validatorFormula(params) {
+  var isOk = true;
+  var msg = '';
+  var formula = params.formula;
+  var customCondition = params.customCondition || [];
+  var reg = RegExp(/null|undefined/);
+  if (!customCondition.length || !formula || !/\$/.test(formula)) {
+    isOk = false;
+    msg = '公式不合法，请添加整体指标或事件指标';
+  } else if (/\(|\)/.test(formula) && !/\(\S*?\)/.test(formula) || formula.match(reg)) {
+    isOk = false;
+    msg = '公式不合法';
+  }
+  if (isOk) {
+    customCondition.forEach(function (condition) {
+      if (!isOk) return;
+      var type = condition.type || 'constant';
+      var validatorData = validator(type, condition);
+      if (!validatorData.isOk) {
+        isOk = false;
+        msg = '公式不合法';
+        return;
+      }
+    });
+  }
+  return {
+    isOk: isOk,
+    msg: msg
+  };
+};

package/es/formulaTarget/components/formulaItem/data.d.ts

@@ -0,0 +1,2 @@
+import { FormulaContainerTypes } from '../formula/types';
+export declare const itemDefaultData: FormulaContainerTypes.Item;

package/es/formulaTarget/components/formulaItem/data.js

@@ -0,0 +1,4 @@
+export var itemDefaultData = {
+  left: false,
+  right: false
+};

package/es/formulaTarget/components/formulaItem/index.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { FormulaItemProps } from './types';
+declare const FormulaItem: React.FC<FormulaItemProps>;
+export default FormulaItem;