dashboard/src/stores/Distribution.js

import { makeAutoObservable, runInAction, toJS } from 'mobx';
import * as req from '@haina/utils-request';
import { DATE_FORMAT, SMALL_DATETIME_FORMAT, HT_HOST } from './../config';
import moment from 'moment';
import { isEmpty, pick, sortBy, fixTo2Decimals, cloneDeep, unique } from '@haina/utils-commons';

const modelMapper = {
  'tourDays': { url: HT_HOST + '/service-Analyse2/GetTradeApartByTourDays', keySort: true, dynamicsX: false },
  'PML': { url: HT_HOST + '/service-Analyse2/GetTradeApartByPML', keySort: true, dynamicsX: false },
  'ConfirmDays': { url: HT_HOST + '/service-Analyse2/GetTradeApartByConfirmDays', keySort: true, dynamicsX: false },
  'ApplyDays': { url: HT_HOST + '/service-Analyse2/GetTradeApartByApplyDays', keySort: true, dynamicsX: false },
  'PersonNum': { url: HT_HOST + '/service-Analyse2/GetTradeApartByPersonNum', keySort: true, dynamicsX: false },
  'destination': { url: HT_HOST + '/service-Analyse2/GetTradeApartByDestination', keySort: false, dynamicsX: true, },
  'GlobalDestination': { url: HT_HOST + '/service-Analyse2/GetTradeApartByGlobalDestination', keySort: false, dynamicsX: true, },
  'destinationCountry': { url: HT_HOST + '/service-Analyse2/GetTradeApartByDestinationCountry', keySort: false, dynamicsX: true, },
  'guestCountry': { url: HT_HOST + '/service-Analyse2/GetTradeApartByGuestCountry', keySort: false, dynamicsX: true, },
};
class Distribution {
  constructor(appStore) {
    this.appStore = appStore;
    makeAutoObservable(this);
  }

  /**
   * 各个类型的分布
   */
  getApartData = async (param, getDiff = undefined) => {
    this.pageLoading = true;
    const mkey = this.curTab;
    this[mkey] = { loading: true, dataSource: [] };
    param.operator = param?.operator || -1;
    if (isEmpty(param.Date1) || isEmpty(param.Date2)) {
      return false;
    }
    // 环比的参数: 计算上一个时间段
    const [DateToQ1, DateToQ2] = [moment(param.Date1).subtract(moment(param.Date2).diff(param.Date1, 'days') + 1, 'days'), moment(param.Date1).subtract(1, 'days')];
    // 同比的参数: 去年同期
    const [DateToY1, DateToY2] = [moment(param.Date1).subtract(1, 'year'), moment(param.Date2).subtract(1, 'year')];
    const dynamicsX = getDiff ?? modelMapper[mkey].dynamicsX;
    if (getDiff === undefined) {
      param.DateToY1 = DateToY1.format(DATE_FORMAT);
      param.DateToY2 = DateToY2.format(SMALL_DATETIME_FORMAT);
      param.DateToQ1 = DateToQ1.format(DATE_FORMAT);
      param.DateToQ2 = DateToQ2.format(SMALL_DATETIME_FORMAT);
    }
    const json = dynamicsX === false ? await req.fetchJSON(modelMapper[mkey].url, param) : await this.getApartDataStep(param);
    if (json.errcode === 0) {
      const dataLength = json.result.length;
      const dataSource = calcDiff({ result: json.result, resultToY: json.resultToY, resultToQ: json.resultToQ }, modelMapper[mkey].keySort);
      runInAction(() => {
        this[mkey].loading = false;
        this[mkey].originData = json.result;
        this[mkey].dataSource = dataLength > 20 ? dataSource.slice(0,30) : dataSource;
        this.pageLoading = false;
      });
    }
    return this[mkey];
  };

  getApartDataStep = async (param) => {
    const mkey = this.curTab;
    this[mkey] = { loading: true, dataSource: [] };
    const xParam = cloneDeep(param);
    delete xParam.DateToY1;
    delete xParam.DateToY2;
    delete xParam.DateToQ1;
    delete xParam.DateToQ2;
    const { result, ...jsonY } = await req.fetchJSON(modelMapper[mkey].url, { ...xParam });
    const { result: resultToY } = await req.fetchJSON(modelMapper[mkey].url, { ...xParam, Date1: param.DateToY1, Date2: param.DateToY2 });
    const { result: resultToQ } = await req.fetchJSON(modelMapper[mkey].url, { ...xParam, Date1: param.DateToQ1, Date2: param.DateToQ2 });
    return { ...jsonY, result, resultToY, resultToQ };
  };

  /**
   * 明细
   */
  getDetailData = async (param) => {
    this.detailData.loading = true;
    const json = await req.fetchJSON(HT_HOST + '/service-Analyse2/GetTradeApartDetail', param);
    if (json.errcode === 0) {
      runInAction(() => {
        this.detailData.loading = false;
        this.detailData.dataSource = json.result;
        const daysData = json.result.filter((ele) => ele.confirmDays).map((row) => pick(row, ['o_id', 'tourdays', 'applyDays', 'personNum', 'country', 'startDate']));
        this.scatterDays = daysData;
      });
    }
    return json.result;
  };

  resetData = () => {
    // this.detailData = { loading: false, dataSource: [] };
    // this.scatterDays = [];

    this.tourDays = { loading: false, dataSource: [] };
    this.PML = { loading: false, dataSource: [] };
    this.ConfirmDays = { loading: false, dataSource: [] };
    this.ApplyDays = { loading: false, dataSource: [] };
    this.PersonNum = { loading: false, dataSource: [] };
    this.destination = { loading: false, dataSource: [] };
    this.GlobalDestination = { loading: false, dataSource: [] };
    this.destinationCountry = { loading: false, dataSource: [] };
    this.guestCountry = { loading: false, dataSource: [] };
  };

  curTab = 'tourDays';
  setCurTab(v) {
    this.curTab = v;
  }

  setFormDates(param) {
    // 环比的参数: 计算上一个时间段
    const [DateToQ1, DateToQ2] = [moment(param.Date1).subtract(moment(param.Date2).diff(param.Date1, 'days') + 1, 'days'), moment(param.Date1).subtract(1, 'days')];
    // 同比的参数: 去年同期
    const [DateToY1, DateToY2] = [moment(param.Date1).subtract(1, 'year'), moment(param.Date2).subtract(1, 'year')];
    this.dateStringY = `${DateToY1.format(DATE_FORMAT)}~${DateToY2.format(DATE_FORMAT)}`;
    this.dateStringQ = `${DateToQ1.format(DATE_FORMAT)}~${DateToQ2.format(DATE_FORMAT)}`;
  }

  pageLoading = false;
  dateStringY = '';
  dateStringQ = '';

  detailData = { loading: false, dataSource: [] };
  scatterDays = [];

  tourDays = { loading: false, dataSource: [] };
  PML = { loading: false, dataSource: [] };
  ConfirmDays = { loading: false, dataSource: [] };
  ApplyDays = { loading: false, dataSource: [] };
  PersonNum = { loading: false, dataSource: [] };
  destination = { loading: false, dataSource: [] };
  GlobalDestination = { loading: false, dataSource: [] };
  destinationCountry = { loading: false, dataSource: [] };
  guestCountry = { loading: false, dataSource: [] };
}

/**
 * 计算 同比, 环比
 */
const calcDiff = ({ result, resultToY, resultToQ }, keySort) => {
  const initialDataWithAllKeys = unique([].concat(result, resultToY, resultToQ).map((ele) => `${ele.key}@${ele.label}`))
    .reduce((r, v) => {
      const [key, label] = String(v).split('@');
      r.push({ key: Number(key), label, SumML: 0, ConfirmOrder: 0, SumOrder: 0, SumMLPercent: 0, ConfirmOrderPercent: 0, SumOrderPercent: 0 });
      return r;
    }, [])
    .sort(keySort ? sortBy('key') : undefined);
  const initialMapped = initialDataWithAllKeys.reduce((r, v) => ({ ...r, [v.key]: v }), {});
  const resultMapped = result.reduce((r, v) => ({ ...r, [v.key]: v }), cloneDeep(initialMapped));
  const resultToYMapped = resultToY.reduce((r, v) => ({ ...r, [v.key]: v }), cloneDeep(initialMapped));
  const resultToQMapped = resultToQ.reduce((r, v) => ({ ...r, [v.key]: v }), cloneDeep(initialMapped));
  const afterCalc = initialDataWithAllKeys.map((row) => {
    const diff = {
      SumMLY: resultToYMapped?.[row.key]?.SumML || 0,
      SumMLToY: resultToYMapped?.[row.key]?.SumML ? fixTo2Decimals(((resultMapped[row.key].SumML - resultToYMapped[row.key].SumML) / resultToYMapped[row.key].SumML) * 100) : 0,
      SumMLQ: resultToQMapped?.[row.key]?.SumML || 0,
      SumMLToQ: resultToQMapped?.[row.key]?.SumML ? fixTo2Decimals(((resultMapped[row.key].SumML - resultToQMapped[row.key].SumML) / resultToQMapped[row.key].SumML) * 100) : 0,
      SumMLDiffY: resultMapped[row.key].SumML - resultToYMapped[row.key].SumML,
      SumMLDiffQ: resultMapped[row.key].SumML - resultToQMapped[row.key].SumML,

      ConfirmOrderY: resultToYMapped?.[row.key]?.ConfirmOrder || 0,
      ConfirmOrderToY: resultToYMapped?.[row.key]?.ConfirmOrder
        ? fixTo2Decimals(((resultMapped[row.key].ConfirmOrder - resultToYMapped[row.key].ConfirmOrder) / resultToYMapped[row.key].ConfirmOrder) * 100)
        : 0,
      ConfirmOrderQ: resultToQMapped?.[row.key]?.ConfirmOrder || 0,
      ConfirmOrderToQ: resultToQMapped?.[row.key]?.ConfirmOrder
        ? fixTo2Decimals(((resultMapped[row.key].ConfirmOrder - resultToQMapped[row.key].ConfirmOrder) / resultToQMapped[row.key].ConfirmOrder) * 100)
        : 0,
      ConfirmOrderDiffY: resultMapped[row.key].ConfirmOrder - resultToYMapped[row.key].ConfirmOrder,
      ConfirmOrderDiffQ: resultMapped[row.key].ConfirmOrder - resultToQMapped[row.key].ConfirmOrder,

      SumOrderY: resultToYMapped?.[row.key]?.SumOrder || 0,
      SumOrderToY: resultToYMapped?.[row.key]?.SumOrder
        ? fixTo2Decimals(((resultMapped[row.key].SumOrder - resultToYMapped[row.key].SumOrder) / resultToYMapped[row.key].SumOrder) * 100)
        : 0,
      SumOrderQ: resultToQMapped?.[row.key]?.SumOrder || 0,
      SumOrderToQ: resultToQMapped?.[row.key]?.SumOrder
        ? fixTo2Decimals(((resultMapped[row.key].SumOrder - resultToQMapped[row.key].SumOrder) / resultToQMapped[row.key].SumOrder) * 100)
        : 0,
      SumOrderDiffY: resultMapped[row.key].SumOrder - resultToYMapped[row.key].SumOrder,
      SumOrderDiffQ: resultMapped[row.key].SumOrder - resultToQMapped[row.key].SumOrder,
    };
    return { ...resultMapped[row.key], ...diff, resultToY: resultToYMapped[row.key], resultToQ: resultToQMapped[row.key] };
  });
  // console.log(afterCalc, '==================');
  return afterCalc;
};

export default Distribution;