private convertDataToPowerKPIFormat()

in src/visualComponent/dynamic/powerKPIComponent.ts [124:298]
143 lines of code
13 McCabe index (conditional complexity)

    private convertDataToPowerKPIFormat(options: ISparklineCellRenderOptions): IDataRepresentationPowerKPI {
        const {
            y,
            series,
            settings,
            metadata,
        } = options;

        const yAxis: IDataRepresentationAxis = {
            max: undefined,
            min: undefined,
        };

        const powerKPISettings: SettingsPowerKPI = settings.powerKPISettings;

        powerKPISettings.subtitle.titleText = series.name;

        powerKPISettings.dateValueKPI.displayUnits = series.settings.asOfDate.displayUnits;
        powerKPISettings.dateValueKPI.precision = series.settings.asOfDate.precision;

        powerKPISettings.actualValueKPI.displayUnits = series.settings.currentValue.displayUnits;
        powerKPISettings.actualValueKPI.precision = series.settings.currentValue.precision;

        powerKPISettings.kpiIndicatorValue.displayUnits = series.settings.kpiIndicatorValue.displayUnits;
        powerKPISettings.kpiIndicatorValue.precision = series.settings.kpiIndicatorValue.precision;

        if (!powerKPISettings.tooltipVariance.label) {
            powerKPISettings.tooltipVariance.label = settings.kpiIndicatorValue.label;
        }

        if (!powerKPISettings.secondTooltipVariance.label) {
            powerKPISettings.secondTooltipVariance.label = settings.secondKPIIndicatorValue.label;
        }

        series.settings.kpiIndicator.forEach((_, index: number, indexedName: string) => {
            powerKPISettings.kpiIndicator[indexedName] = series.settings.kpiIndicator[indexedName];
        });

        powerKPISettings.parseSettings(options.viewport, series.x.scale.type);

        const columnFormat: string = series.settings.asOfDate.columnFormat;

        powerKPISettings.dateValueKPI.setColumnFormat(columnFormat);
        powerKPISettings.tooltipLabel.setColumnFormat(columnFormat);

        if (series.settings.sparklineSettings.shouldUseCommonScale) {
            yAxis.min = y.min;
        } else if (NumericValueUtils.isValueFinite(powerKPISettings.yAxis.min)) {
            yAxis.min = powerKPISettings.yAxis.min;
        } else if (NumericValueUtils.isValueFinite(series.settings.sparklineSettings.yMin)) {
            yAxis.min = series.settings.sparklineSettings.yMin;
        }

        if (series.settings.sparklineSettings.shouldUseCommonScale) {
            yAxis.max = y.max;
        } else if (NumericValueUtils.isValueFinite(powerKPISettings.yAxis.max)) {
            yAxis.max = powerKPISettings.yAxis.max;
        } else if (NumericValueUtils.isValueFinite(series.settings.sparklineSettings.yMax)) {
            yAxis.max = series.settings.sparklineSettings.yMax;
        }

        const scaledYAxis: IDataRepresentationAxisPowerKPI = {
            format: series.settings.currentValue.getFormat(),
            max: undefined,
            min: undefined,
            scale: DataRepresentationScalePowerKPI.create(),
        };

        const pointFilter: DataRepresentationPointFilterPowerKPI = new DataRepresentationPointFilterPowerKPI();

        let maxThickness: number = 0;

        const powerKPISeries: IDataRepresentationSeriesPoweKPI[] = series.points
            .map((pointSet: IDataRepresentationPointSet, pointSetIndex: number) => {
                const gradientPoints: IDataRepresentationPointGradientColorPowerKPI[] = [];

                const points: IDataRepresentationPointPoweKPI[] = pointSet.points
                    .map((point: IDataRepresentationPoint, pointIndex: number) => {
                        const powerKpiPoint: IDataRepresentationPointPoweKPI = {
                            color: pointSet.colors[pointIndex] || pointSet.color,
                            kpiIndex: pointSet.kpiIndicatorIndexes[pointIndex],
                            x: point.axisValue as any,
                            y: point.value,
                        };

                        pointFilter.groupPointByColor(gradientPoints, powerKpiPoint, false);

                        return powerKpiPoint;
                    });

                const thickness: number = pointSet.thickness;

                maxThickness = Math.max(maxThickness, thickness);

                DataConverter.applyYArguments(yAxis, pointSet.min as number);
                DataConverter.applyYArguments(yAxis, pointSet.max as number);

                const seriesSettings: SeriesSettingsPowerKPI = SeriesSettingsPowerKPI.getDefault() as SeriesSettingsPowerKPI;

                seriesSettings.line.fillColor = pointSet.color;
                seriesSettings.line.lineStyle = pointSet.lineStyle;
                seriesSettings.line.thickness = thickness;

                return {
                    current: {
                        color: pointSet.color,
                        index: series.kpiIndicatorIndex,
                        kpiIndex: series.kpiIndicatorIndex,
                        x: series.axisValue,
                        y: series.currentValue,
                    },
                    domain: {
                        max: pointSet.max,
                        min: pointSet.min,
                    },
                    format: pointSet.settings.getFormat(),
                    gradientPoints,
                    hasSelection: false,
                    identity: pointSetIndex === 0
                        ? series.selectionId
                        : this.getSelectionId(`${pointSetIndex}`),
                    name: pointSet.name || pointSet.settings.label,
                    points,
                    settings: seriesSettings,

                    selected: false,
                    y: scaledYAxis,
                };
            });

        scaledYAxis.scale.domain([yAxis.min, yAxis.max], series.y.scale.type);
        scaledYAxis.min = yAxis.min as number;
        scaledYAxis.max = yAxis.max as number;

        const margin = powerKPISettings.dots.getMarginByThickness(
            maxThickness,
            {
                bottom: 0,
                left: 0,
                right: 0,
                top: 0,
            },
        );

        const powerKPIData: IDataRepresentationPowerKPI = {
            groups: [{
                series: powerKPISeries,
                y: scaledYAxis,
            }],
            margin,
            series: powerKPISeries,
            settings: powerKPISettings,
            sortedSeries: powerKPISeries,
            variance: [
                series.kpiIndicatorValue,
                series.secondKPIIndicatorValue,
            ],
            variances: series.varianceSet || [],
            viewport: options.viewport,
            x: {
                axisType: series.x.scale.type,
                format: series.settings.asOfDate.getFormat(),
                max: series.x.max as any,
                metadata,
                min: series.x.min as any,
                name: series.settings.asOfDate.label,
                scale: DataRepresentationScalePowerKPI
                    .create()
                    .domain(series.x.scale.getDomain(), series.x.scale.type),
                values: series.axisValues,
            },
        };

        return powerKPIData;
    }