@zgfe/modules-attribution 1.0.1-alpha.0

package/es/utils/transfer.js

@@ -0,0 +1,173 @@
+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) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+import moment from 'moment';
+import util from './util';
+export function transferEventSearchData(params) {
+  var userPropList = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  var eventGroupList = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+  var eventEnvList = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
+  var result = {
+    userGroup: params.user_group.split(','),
+    targets: [],
+    chartType: params.chartType
+  };
+  var timeData = params.time;
+  if (util.isString(timeData)) {
+    timeData = JSON.parse(timeData);
+  }
+  var time = timeData.dimension_date.split(',');
+  var unit = time[0];
+  var begin = timeData.begin_date;
+  var end = timeData.end_date;
+  if (time.includes('total') || begin.indexOf('-') < 0) {
+    result.time = {
+      unit: unit,
+      relative: [begin, end],
+      begin: moment().subtract(begin, unit).format('YYYY-MM-DD'),
+      end: moment().subtract(end, 'days').format('YYYY-MM-DD')
+    };
+  } else {
+    result.time = {
+      unit: unit,
+      begin: begin,
+      end: end
+    };
+  }
+  if (params.platform) {
+    var envData;
+    eventEnvList.forEach(function (env) {
+      if (env.name === 'platform') {
+        envData = env;
+      }
+    });
+    if (envData) {
+      var platforms = ['android', 'ios', 'js'];
+      result.globalFilters = {
+        relation: 'and',
+        conditions: [{
+          attrId: envData.id,
+          attrName: 'platform',
+          dimensionSub: 'platform',
+          label: envData.label,
+          category: envData.category,
+          type: envData.type,
+          operator: 'equal',
+          propCategory: 'envProp',
+          values: [platforms[params.platform - 1]]
+        }]
+      };
+    }
+  }
+  if (params.dimension_sub && params.event) {
+    var data = transferDimension(userPropList, eventGroupList, eventEnvList, params.dimension_sub, params.event, params.event_attr, params.user_attr);
+    if (data) {
+      result.globalDimensions = [data];
+    }
+  }
+  var targets = {
+    type: params.module,
+    alias: '',
+    eventGroupId: params.event_group_id || 0,
+    eventId: params.event || -100,
+    analysisDimension: {
+      analysisIndex: params.analysis_index,
+      analysisAttr: params.event_attr
+    }
+  };
+  if (params.filter_condition) {
+    var conditions = [];
+    var filterCondition = params.filter_condition;
+    if (util.isString(filterCondition)) {
+      filterCondition = JSON.parse(filterCondition);
+    }
+    var _filterCondition = filterCondition,
+      eventCondition = _filterCondition.eventCondition,
+      userCondition = _filterCondition.userCondition;
+    if (eventCondition && eventCondition.eventSingleConditions) {
+      eventCondition.eventSingleConditions.forEach(function (e) {
+        if (e.happenTime && e.happenTime.params.length) {
+          if (e.happenTime.params[0] === 'relative') {
+            result.time.relative = [e.happenTime.params[1], e.happenTime.params[2]];
+          }
+        }
+        if (e.eventName) {
+          targets.eventName = e.eventName;
+        }
+        if (e.attrConditions) {
+          conditions = conditions.concat(transferCondition(e.attrConditions));
+        }
+        if (e.environmentConditions) {
+          conditions = conditions.concat(transferCondition(e.environmentConditions));
+        }
+      });
+    }
+    if (userCondition && userCondition.userSingleConditions) {
+      conditions = conditions.concat(transferCondition(userCondition.userSingleConditions));
+    }
+    targets.filters = {
+      conditions: conditions,
+      relation: 'and'
+    };
+  }
+  result.targets = [targets];
+  return result;
+}
+function transferDimension(userPropList, eventGroupList, eventEnvList, dimensionSub, eventId, eventAttr, userAttr) {
+  var data;
+  if (eventAttr) {
+    eventGroupList.forEach(function (group) {
+      group.eventList.forEach(function (event) {
+        if (event.id === eventId) {
+          event.attrList.forEach(function (attr) {
+            if (attr.label === eventAttr && !data) {
+              data = {
+                attrId: attr.id,
+                attrName: attr.label,
+                propCategory: 'eventProp',
+                type: attr.type
+              };
+            }
+          });
+        }
+      });
+    });
+  } else if (userAttr) {
+    userPropList.forEach(function (user) {
+      if (user.name === userAttr) {
+        data = _objectSpread({
+          attrId: user.id,
+          attrName: user.name
+        }, user);
+      }
+    });
+  } else {
+    eventEnvList.forEach(function (env) {
+      if (env.name === dimensionSub) {
+        data = _objectSpread({
+          attrId: env.id,
+          attrName: env.name
+        }, env);
+      }
+    });
+  }
+  return data;
+}
+function transferCondition(conditions) {
+  var result = [];
+  conditions.forEach(function (attr) {
+    result.push({
+      subtype: attr.subtype,
+      attrId: attr.attrId,
+      attrName: attr.name,
+      label: attr.text,
+      type: attr.type,
+      propCategory: attr.isEventProp ? 'eventProp' : attr.isUserProp ? 'userProp' : 'envProp',
+      category: attr.category,
+      dimensionSub: attr.category,
+      operator: attr.operator,
+      values: attr.params
+    });
+  });
+  return result;
+}

package/es/utils/util.d.ts

@@ -0,0 +1,32 @@
+declare let util: {
+    dayTime: number;
+    type(obj: any): string;
+    isObject(obj: any): boolean;
+    isArray(obj: any): boolean;
+    isString(obj: any): boolean;
+    isNumber(obj: any): boolean;
+    isDate(obj: any): boolean;
+    isFunction(obj: any): boolean;
+    isEqual(a?: {}, b?: {}): boolean;
+    equal(a: any, b: any): boolean;
+    random(min: number, max: number): number;
+    guid(): string;
+    mergeObject(defaults: {
+        [x: string]: any;
+    }, option: {
+        [x: string]: any;
+    }): {
+        [x: string]: any;
+    };
+    toThousands(num: number): string;
+    toDoubleNumber(num: number): string;
+    dateFormat(date?: any, formatter?: string): string;
+    timeFormat(date: any, formatter: string | undefined, autoShort: any): string | undefined;
+    strMiddleSplit(str: string, config?: {
+        maxLength: number;
+        beginLength: number;
+        endLength: number;
+        replaceStr: string;
+    }): string;
+};
+export default util;

package/es/utils/util.js

@@ -0,0 +1,139 @@
+var util = {
+  dayTime: 24 * 60 * 60 * 1000,
+  type: function type(obj) {
+    return Object.prototype.toString.call(obj);
+  },
+  isObject: function isObject(obj) {
+    return this.type(obj) === '[object Object]';
+  },
+  isArray: function isArray(obj) {
+    return this.type(obj) === '[object Array]';
+  },
+  isString: function isString(obj) {
+    return this.type(obj) === '[object String]';
+  },
+  isNumber: function isNumber(obj) {
+    return this.type(obj) === '[object Number]';
+  },
+  isDate: function isDate(obj) {
+    return this.type(obj) === '[object Date]';
+  },
+  isFunction: function isFunction(obj) {
+    return this.type(obj) === '[object Function]';
+  },
+  isEqual: function isEqual() {
+    var a = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    var b = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    return JSON.stringify(a) === JSON.stringify(b);
+  },
+  equal: function equal(a, b) {
+    return JSON.stringify(a) === JSON.stringify(b);
+  },
+  random: function random(min, max) {
+    return Math.round(Math.random() * (max - min)) + min;
+  },
+  guid: function guid() {
+    function s4() {
+      return Math.floor((1 + Math.random()) * 0x10000).toString(16).substring(1);
+    }
+    return s4() + s4() + '-' + s4() + '-' + s4() + '-' + s4() + '-' + s4() + s4() + s4();
+  },
+  mergeObject: function mergeObject(defaults, option) {
+    defaults = defaults || {};
+    option = option || {};
+    for (var prop in defaults) {
+      if (this.isObject(defaults[prop])) {
+        option[prop] = option[prop] ? option[prop] : {};
+        this.mergeObject(defaults[prop], option[prop]);
+      } else if (this.isArray(defaults[prop])) {
+        if (!option[prop] || !option[prop].length) {
+          option[prop] = defaults[prop];
+        } else {
+          var i = 0;
+          var optLenght = option[prop].length;
+          var defaultLength = defaults[prop].length;
+          for (i; i < optLenght && i < defaultLength; i++) {
+            option[prop][i] = this.mergeObject(defaults[prop][i], option[prop][i]);
+          }
+        }
+      } else {
+        option[prop] = option[prop] === null || option[prop] === undefined ? defaults[prop] : option[prop];
+      }
+    }
+    return option;
+  },
+  toThousands: function toThousands(num) {
+    var source = String(num).split('.');
+    source[0] = source[0].replace(new RegExp('(\\d)(?=(\\d{3})+$)', 'ig'), '$1,');
+    return source.join('.');
+  },
+  toDoubleNumber: function toDoubleNumber(num) {
+    var num2 = num.toString();
+    return num > 9 ? num2 : '0' + num2;
+  },
+  dateFormat: function dateFormat() {
+    var date = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : new Date();
+    var formatter = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'yyyy-mm-dd';
+    return formatter.replace('yyyy', date.getFullYear()).replace('mm', this.toDoubleNumber(date.getMonth() + 1)).replace('dd', this.toDoubleNumber(date.getDate()));
+  },
+  timeFormat: function timeFormat() {
+    var date = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : new Date();
+    var formatter = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'hh:mm:ss';
+    var autoShort = arguments.length > 2 ? arguments[2] : undefined;
+    if (this.isDate(date)) {
+      return formatter.replace('hh', this.toDoubleNumber(date.getHours())).replace('mm', this.toDoubleNumber(date.getMinutes())).replace('ss', this.toDoubleNumber(date.getSeconds()));
+    } else if (this.isNumber(date)) {
+      var s = parseInt(date / 1000 + '');
+      var m = parseInt(s / 60 + '');
+      var h = parseInt(m / 60 + '');
+      s = s - m * 60;
+      m = m - h * 60;
+      if (!h && autoShort) {
+        formatter = formatter.replace(/hh\S*?mm/, 'mm');
+        if (!m) {
+          formatter = formatter.replace(/mm\S*?ss/, 'ss');
+          return formatter.replace('ss', s + '');
+        }
+      }
+      return formatter.replace('hh', this.toDoubleNumber(h)).replace('mm', this.toDoubleNumber(m)).replace('ss', this.toDoubleNumber(s));
+    }
+  },
+  strMiddleSplit: function strMiddleSplit(str) {
+    var config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
+      maxLength: 20,
+      beginLength: 8,
+      endLength: 8,
+      replaceStr: '...'
+    };
+    str += '';
+    var reg = {
+      fullCharReg: /[^\x00-\xff]/,
+      fullCharsReg: /[^\x00-\xff]/g,
+      anyChars: /[\S\s]{1}/g
+    };
+    var fullCharLength = (str.match(reg.fullCharsReg) || []).length;
+    var fullLength = str.length + fullCharLength;
+    var beginArr = [];
+    var beginLength = 0;
+    var endArr = [];
+    var endLength = 0;
+    if (fullLength > config.maxLength) {
+      var strArr = str.match(reg.anyChars) || [];
+      strArr.forEach(function (char) {
+        if (beginLength >= config.beginLength) return;
+        var len = reg.fullCharReg.test(char) ? 2 : 1;
+        beginLength += len;
+        beginArr.push(char);
+      });
+      strArr.reverse().forEach(function (char) {
+        if (endLength >= config.endLength) return;
+        var len = reg.fullCharReg.test(char) ? 2 : 1;
+        endLength += len;
+        endArr.push(char);
+      });
+      return beginArr.join('') + config.replaceStr + endArr.reverse().join('');
+    }
+    return str;
+  }
+};
+export default util;

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@zgfe/modules-attribution",
+  "version": "1.0.1-alpha.0",
+  "module": "es/index.js",
+  "typings": "es/index.d.ts",
+  "files": [
+    "es"
+  ],
+  "scripts": {
+    "build": "father-build",
+    "deploy": "npm run docs:build && npm run docs:deploy",
+    "docs:build": "dumi build",
+    "docs:deploy": "gh-pages -d docs-dist",
+    "prepublishOnly": "npm run build",
+    "prettier": "prettier --write \"**/*.{js,jsx,tsx,ts,less,md,json}\"",
+    "pub": "lerna publish",
+    "start": "dumi dev",
+    "test": "umi-test",
+    "test:coverage": "umi-test --coverage"
+  },
+  "lint-staged": {
+    "*.{js,jsx,less,md,json}": [
+      "prettier --write"
+    ],
+    "*.ts?(x)": [
+      "prettier --parser=typescript --write"
+    ]
+  },
+  "dependencies": {
+    "caniuse-lite": "^1.0.30001491",
+    "nanoid": "^4.0.2"
+  },
+  "devDependencies": {
+    "@testing-library/jest-dom": "^5.15.1",
+    "@testing-library/react": "^12.1.2",
+    "@types/jest": "^27.0.3",
+    "@types/lodash": "^4.14.191",
+    "@umijs/fabric": "^2.8.1",
+    "@umijs/test": "^3.0.5",
+    "@zgfe/business-lib": "1.1.41-attribution.2",
+    "antd": "^4.22.6",
+    "dumi": "^1.1.0",
+    "echarts": "^5.3.2",
+    "echarts-for-react": "^3.0.2",
+    "father-build": "^1.17.2",
+    "gh-pages": "^3.0.0",
+    "lerna": "^4.0.0",
+    "lint-staged": "^10.0.7",
+    "prettier": "^2.2.1",
+    "react": "^16.12.0 || ^17.0.0",
+    "yorkie": "^2.0.0"
+  },
+  "gitHead": "de967bd9bb00ff055a992f8b2f21e656554b239c"
+}