@qrvey/utils 1.16.0-16 → 1.16.0-17

package/dist/charts/adapters/convertChartObjectFromV2toV1.d.ts

@@ -0,0 +1,2 @@
+import { ChartV2Model } from "../interfaces/IChartV2";
+export declare const convertChartObjectFromV2toV1: (v2Model: ChartV2Model, inPreviewMode?: boolean) => any;

package/dist/charts/adapters/convertChartObjectFromV2toV1.js

@@ -0,0 +1,63 @@
+import { CHART_TYPE } from "../../constants";
+import { isEmpty, objectCopy } from "../../general";
+import { hasReferenceLayer, hasSmallMultiple, hasTrendLayer, isChartMetric, isChartMinMax, isChartMultiserie, } from "../helpers/chartTypes";
+import { getChartLayerList } from "../helpers/getChartDimensions";
+import { getPanelBodyByChart } from "./getPanelBodyByChart";
+export const convertChartObjectFromV2toV1 = (v2Model, inPreviewMode = true) => {
+    if (!(v2Model === null || v2Model === void 0 ? void 0 : v2Model.stylesSettings) ||
+        ((isChartMetric(v2Model.type) || isChartMinMax(v2Model.type)) &&
+            isEmpty(v2Model.dimensions.values))) {
+        return;
+    }
+    const objCopy = objectCopy(v2Model);
+    const chart_ms = [
+        CHART_TYPE.BAR_CHART_MS,
+        CHART_TYPE.LINE_CHART_MS,
+        CHART_TYPE.SYMBOL_CHART_MS,
+        CHART_TYPE.AREA_CHART_MS,
+    ];
+    const chart_cb = [...chart_ms, CHART_TYPE.COMBO_CHART];
+    const chart_base = [
+        CHART_TYPE.BAR_CHART,
+        CHART_TYPE.LINE_CHART,
+        CHART_TYPE.SYMBOL_CHART,
+        CHART_TYPE.MINMAX_CHART,
+        CHART_TYPE.FUNNEL_CHART,
+        CHART_TYPE.AREA_CHART,
+    ];
+    const bar_type = objCopy.stylesSettings.bar_type;
+    objCopy.bar_width = objCopy.stylesSettings.bar_width;
+    objCopy.isMulti = isChartMultiserie(objCopy.type);
+    objCopy.isChartOptions = [...chart_base, ...chart_cb].includes(objCopy.type);
+    objCopy.isCombolayer = [
+        CHART_TYPE.COMBO_CHART,
+        CHART_TYPE.COMBINED_CHART,
+        CHART_TYPE.RADAR_CHART,
+    ].includes(objCopy.type);
+    objCopy.isReference = hasReferenceLayer(v2Model.dimensions.reference);
+    objCopy.isTrend =
+        objCopy.type !== CHART_TYPE.MINMAX_CHART &&
+            hasTrendLayer(v2Model.dimensions.trend);
+    const isBarMs = objCopy.isMulti && objCopy.type === CHART_TYPE.BAR_CHART_MS;
+    objCopy.is100 = isBarMs && bar_type === "h100";
+    objCopy.isCombo =
+        objCopy.isTrend ||
+            objCopy.isMulti ||
+            objCopy.isCombolayer ||
+            objCopy.isReference;
+    objCopy.isComboCalc = objCopy.isCombolayer;
+    objCopy.isStakedBar =
+        (isBarMs || objCopy.isCombo) &&
+            (objCopy.is100 || bar_type === "Stacked") &&
+            objCopy.type !== CHART_TYPE.BAR_CHART;
+    objCopy.isSmallMultiples =
+        [...chart_base, ...chart_cb].includes(objCopy.type) &&
+            objCopy.type !== CHART_TYPE.FUNNEL_CHART &&
+            hasSmallMultiple(v2Model.dimensions.smallmultiple);
+    const layerList = getChartLayerList(objCopy);
+    if (!layerList)
+        return;
+    const data = getPanelBodyByChart(objCopy.type, objCopy, layerList, inPreviewMode);
+    data.v2 = v2Model;
+    return data;
+};

package/dist/charts/adapters/getPanelBodyByChart.d.ts

@@ -0,0 +1,2 @@
+export declare const randomKey: () => string;
+export declare const getPanelBodyByChart: (chart: any, obj: any, layerList: any, inPreviewMode: any) => any;

package/dist/charts/adapters/getPanelBodyByChart.js

@@ -0,0 +1,289 @@
+import { CHART_TYPE } from "../../constants";
+import { _get, objectCopy, pick } from "../../general";
+import { timePeriod, timePeriodCustomRange } from "../constants/TIME_PERIOD";
+import { parseCalculation } from "../helpers/chartTypes";
+import { parseGlobalSettingByType, parseStyleSettingByType, } from "../helpers/styleSettingsByChartType";
+const parsePropertyComplexData = (column) => {
+    return _get(column, "property.value", null);
+};
+export const randomKey = () => {
+    return (Date.now() + Math.random() * 1e17).toString(36);
+};
+const setTotalAggregateInPreview = (totalAggregate, _inPreviewMode) => {
+    if (!totalAggregate)
+        return;
+    return totalAggregate;
+};
+const columnKey = (id, type, prop = "", index = 0) => {
+    const fixedProp = prop !== null ? prop["value"] || prop || "" : "";
+    const idx = index === void 0 ? "" : `|${index}`;
+    return `${id}|${type}|${fixedProp}${idx}`;
+};
+const parseSortOrder = (chartType, column) => {
+    const sortDirection = column.sortOrder || typeof column.sorting !== "string"
+        ? _get(column, "sorting.order")
+        : column.sorting;
+    if (chartType === CHART_TYPE.CROSSTAB_CHART) {
+        const isDategroupSortOpt = typeof sortDirection === "string" && column.dateGroup;
+        return Object.assign(Object.assign({}, (typeof column.sorting !== "string" ? column.sorting : {})), { order: isDategroupSortOpt
+                ? {
+                    [column.dateGroup.text]: sortDirection || "asc",
+                }
+                : sortDirection });
+    }
+    const isDategroupSortOpt = column.dateGroup && typeof sortDirection !== "string";
+    return Object.assign(Object.assign({}, (typeof column.sorting !== "string" ? column.sorting : {})), { order: isDategroupSortOpt
+            ? sortDirection &&
+                _get(column, `sorting.order.${column.dateGroup.text}`)
+            : sortDirection });
+};
+const getTableConfig = (chart, inPreviewMode, isTrendChart = false) => {
+    const fields = {
+        groupsList: [],
+        columnsList: [],
+    };
+    const params = [
+        { objKey: "categories", fieldKey: "groupsList", type: "group" },
+        { objKey: "values", fieldKey: "columnsList", type: "column" },
+    ];
+    let count = 0;
+    params.forEach((param) => {
+        var _a;
+        if ((_a = chart.dimensions[param.objKey]) === null || _a === void 0 ? void 0 : _a.length) {
+            fields[param.fieldKey] = chart.dimensions[param.objKey].map((item) => {
+                const column = {
+                    data: Object.assign(Object.assign({}, item), { property: parsePropertyComplexData(item) }),
+                    index: new Date().getTime() + randomKey(),
+                    type: param.type,
+                    label: item.label || item.text,
+                    visualization: item.visualization || "Values",
+                    aggregate: setTotalAggregateInPreview(item.totalAggregate, inPreviewMode),
+                    calculation: chart.dimensions["categories"].length
+                        ? parseCalculation(item, chart)
+                        : null,
+                    dataField: columnKey(item.id, item.type, item.property, count + 1),
+                    qrveyid: item.qrveyid,
+                    dateGroup: item.dateGroup,
+                    sorting: parseSortOrder(chart.type, item),
+                    sortIndex: item.sortIndex,
+                    width: item.width,
+                    groupAggregate: undefined,
+                };
+                if (item.aggregate)
+                    column.groupAggregate = Object.assign({}, item.aggregate);
+                count += 1;
+                return column;
+            });
+        }
+    });
+    if (isTrendChart)
+        return { fields };
+    const isGrouped = fields.groupsList && !!fields.groupsList.length;
+    return {
+        fields,
+        isGrouped,
+        conditions: chart.conditions,
+        visualization: parseStyleSettingByType(CHART_TYPE.TABLE_CHART, Object.assign(Object.assign({}, chart), { isGrouped })),
+        totals: chart.dimensions.tableTotals,
+        isMultipleSorted: chart.isMultipleSorted,
+        trendsChart: chart.trendsCharts || [],
+    };
+};
+const getCrosstabConfig = (opts) => {
+    const fields = {};
+    const params = [
+        { objKey: "pivots", fieldKey: "columnsList", type: "column" },
+        { objKey: "categories", fieldKey: "rowsList", type: "row" },
+        { objKey: "values", fieldKey: "valuesList", type: "data" },
+    ];
+    params.forEach((param) => {
+        var _a;
+        const dimension = param.objKey === "values" && !((_a = opts.dimensions[param.objKey]) === null || _a === void 0 ? void 0 : _a.length)
+            ? [opts.dimensions.categories[0] || opts.dimensions.pivots[0]]
+            : opts.dimensions[param.objKey];
+        fields[param.fieldKey] = dimension.map((item) => {
+            const column = {
+                data: Object.assign(Object.assign({}, item), { property: parsePropertyComplexData(item) }),
+                index: new Date().getTime() + randomKey(),
+                type: param.type,
+                qrveyid: item.qrveyid,
+                label: item.label || item.text,
+                sorting: parseSortOrder(opts.type, item),
+                dateGroup: undefined,
+                aggregate: undefined,
+            };
+            if (item.dateGroup) {
+                column.dateGroup = item.dateGroup;
+            }
+            if (item.aggregate && param.type === "data") {
+                column.aggregate = Object.assign({}, item.aggregate);
+            }
+            return column;
+        });
+    });
+    const rowGrandTotals = ["SHOW", "ROWSONLY"].includes(opts.globalSettings.crosstab_totals.option);
+    const columnGrandTotals = ["SHOW", "COLUMNSONLY"].includes(opts.globalSettings.crosstab_totals.option);
+    return {
+        fields,
+        visualization: parseStyleSettingByType(CHART_TYPE.CROSSTAB_CHART, opts),
+        config: {
+            showBorders: false,
+            width: 442,
+            height: 361,
+            fieldChooser: { enabled: false },
+            fieldPanel: {
+                visible: opts.globalSettings.crosstab_labels.value,
+                showFilterFields: false,
+                allowFieldDragging: false,
+                showColumnFields: true,
+                showRowFields: true,
+                showDataFields: false,
+                texts: { columnFieldArea: "", rowFieldArea: "" },
+            },
+            rowHeaderLayout: "tree",
+            showRowGrandTotals: opts.globalSettings.crosstab_totals.value && rowGrandTotals,
+            showColumnGrandTotals: opts.globalSettings.crosstab_totals.value && columnGrandTotals,
+            showRowTotals: opts.globalSettings.crosstab_subtotals,
+            showColumnTotals: opts.globalSettings.crosstab_subtotals,
+            allowSorting: opts.globalSettings.crosstab_labels.options.sorting,
+            allowSortingBySummary: false,
+        },
+    };
+};
+const getGeoMapConfig = (opts) => {
+    const fields = {};
+    const params = [
+        { objKey: "categories", fieldKey: "categories", type: "column" },
+        { objKey: "values", fieldKey: "values", type: "column" },
+    ];
+    params.forEach((param) => {
+        var _a;
+        if ((_a = opts.dimensions[param.objKey]) === null || _a === void 0 ? void 0 : _a.length) {
+            fields[param.fieldKey] = opts.dimensions[param.objKey].map((item) => {
+                const column = {
+                    data: Object.assign(Object.assign({}, item), { property: parsePropertyComplexData(item) }),
+                    index: new Date().getTime() + randomKey(),
+                    type: param.type,
+                    qrveyid: item.qrveyid,
+                    aggregate: undefined,
+                };
+                if (item.aggregate && param.type === "data") {
+                    column.aggregate = Object.assign({}, item.aggregate);
+                }
+                return column;
+            });
+        }
+    });
+    return {
+        fields,
+    };
+};
+const getMetricConfigData = (chart, obj) => {
+    const { values, thresholds, comparison } = objectCopy(obj.dimensions);
+    let data = {
+        value: Object.assign(Object.assign({}, values[0]), { property: parsePropertyComplexData(values[0]) }),
+        dataSet: {},
+        valueAggregate: values[0] && values[0].aggregate,
+        dateColumn: undefined,
+        timePeriod: undefined,
+        comparison: undefined,
+        timePeriodCustomRange: undefined,
+        timePeriodDate: undefined,
+        timePeriodEndDate: undefined,
+        comparisonCustomRange: undefined,
+        comparisonDate: undefined,
+        comparisonEndDate: undefined,
+    };
+    if (comparison[0]) {
+        const dateColumn = Object.assign({}, comparison[0]);
+        const config = dateColumn.comparison;
+        delete dateColumn.comparison;
+        data = Object.assign(Object.assign({}, data), { dateColumn, timePeriod: timePeriod.find((tp) => tp.label === config.time_period.value), comparison: timePeriod.find((tp) => tp.label === config.time_comparison.value) });
+        if (config.time_period.value === "CUSTOM_RANGE" /* CUSTOM_RANGE */) {
+            data = Object.assign(Object.assign({}, data), { timePeriodCustomRange: timePeriodCustomRange.find((tpc) => tpc.label === config.time_period.range), timePeriodDate: config.time_period.start, timePeriodEndDate: config.time_period.end });
+        }
+        if (config.time_comparison.value === "CUSTOM_RANGE" /* CUSTOM_RANGE */) {
+            data = Object.assign(Object.assign({}, data), { comparisonCustomRange: timePeriodCustomRange.find((tpc) => tpc.label === config.time_comparison.range), comparisonDate: config.time_comparison.start, comparisonEndDate: config.time_comparison.end });
+        }
+    }
+    return {
+        appid: obj.appid,
+        type: { label: chart },
+        thresholdsList: thresholds.map((thr) => ({
+            label: thr.custom_label || thr.label,
+            color: thr.color,
+            operator: { label: thr.operator },
+            value: thr.value,
+            initValue: thr.value,
+            endValue: thr.max_value,
+            type: thr === null || thr === void 0 ? void 0 : thr.type,
+            column: thr === null || thr === void 0 ? void 0 : thr.column,
+            aggregate: thr === null || thr === void 0 ? void 0 : thr.aggregate,
+            endColumn: thr === null || thr === void 0 ? void 0 : thr.endColumn,
+            endAggregate: thr === null || thr === void 0 ? void 0 : thr.endAggregate,
+        })),
+        data,
+        individualSettings: parseStyleSettingByType(chart, obj),
+        dataset: data.dataSet,
+    };
+};
+export const getPanelBodyByChart = (chart, obj, layerList, inPreviewMode) => {
+    let panelBody = Object.assign(Object.assign({}, pick(obj, [
+        "title",
+        "name",
+        "metricid",
+        "chartid",
+        "type",
+        "position",
+        "createDate",
+        "modifyDate",
+        "dataSet",
+        "isOldChart",
+        "isMulti",
+        "bar_width",
+        "isComboCalc",
+    ])), { globalSettings: parseGlobalSettingByType(obj.type, obj), preFilters: obj.preFilters || [], defaultFilters: obj.defaultFilters || {}, oldInternalFilters: obj.oldInternalFilters, dateGroup: _get(layerList[0], "dateGroup"), 
+        // retro-compatibility
+        timeGroup: _get(layerList[0], "timeGroup"), layerList });
+    panelBody.name = obj.name || obj.title;
+    panelBody.dataset = obj.dataset;
+    switch (chart) {
+        case CHART_TYPE.BOXWHISKER_CHART:
+            panelBody.globalSettings.sortX = {
+                type: "Label",
+                order: "Asc",
+            };
+            break;
+        case CHART_TYPE.CROSSTAB_CHART:
+            panelBody = Object.assign(Object.assign({}, panelBody), { chart: getCrosstabConfig(obj) });
+            break;
+        case CHART_TYPE.EXPANDABLE_TABLE_CHART:
+        case CHART_TYPE.TABLE_CHART: {
+            const isSimpleTable = !obj.dimensions["categories"].length;
+            const attrMax = isSimpleTable
+                ? "globalSettings.max_rows.value"
+                : "globalSettings.max_groups.value";
+            const maxRecords = _get(obj, attrMax);
+            panelBody = Object.assign(Object.assign({}, panelBody), { globalSettings: Object.assign(Object.assign({}, panelBody.globalSettings), { maxRecords }), chart: getTableConfig(obj, inPreviewMode) });
+            break;
+        }
+        case CHART_TYPE.INDICATOR_METRIC:
+        case CHART_TYPE.DIAL_METRIC:
+        case CHART_TYPE.BULLET_METRIC: {
+            const { comparison } = objectCopy(obj.dimensions);
+            panelBody = Object.assign(Object.assign(Object.assign({}, panelBody), { globalSettings: Object.assign(Object.assign({}, panelBody.globalSettings), { 
+                    // TODO: Rebase this implementation to refactor
+                    comparisonType: _get(comparison[0], "comparison.type", "CHANGE") }) }), getMetricConfigData(chart, obj));
+            break;
+        }
+        case CHART_TYPE.GEO_CHART_DOT:
+        case CHART_TYPE.GEO_CHART_BUBBLE:
+        case CHART_TYPE.GEO_CHART_CHOROPLETH:
+            panelBody = Object.assign(Object.assign({}, panelBody), { isSmallMultiples: obj.isSmallMultiples, chart: getGeoMapConfig(obj) });
+            break;
+        default:
+            panelBody = Object.assign(Object.assign({}, panelBody), { isChartOptions: true, isCombolayer: obj.isCombolayer, isReference: obj.isReference, isMulti: obj.isMulti, isCombo: obj.isCombo, isSmallMultiples: obj.isSmallMultiples, isTrend: obj.isTrend, is100: obj.is100, isStakedBar: obj.isStakedBar, isSplit: false });
+            break;
+    }
+    return panelBody;
+};

package/dist/charts/adapters/index.d.ts

@@ -2,3 +2,5 @@ export * from "./endpointDataValidators";
 export * from "./endpointDataGet";
 export * from "./endpointData";
 export * from "./RequestAdapterMetric";
+export * from "./convertChartObjectFromV2toV1";
+export * from "./getPanelBodyByChart";

package/dist/charts/adapters/index.js

@@ -2,3 +2,5 @@ export * from "./endpointDataValidators";
 export * from "./endpointDataGet";
 export * from "./endpointData";
 export * from "./RequestAdapterMetric";
+export * from "./convertChartObjectFromV2toV1";
+export * from "./getPanelBodyByChart";