private processData()

in src/converter/data/dataConverter.ts [229:332]
85 lines of code
24 McCabe index (conditional complexity)

    private processData(
        dataRepresentation: IDataRepresentation,
        columnGroupByRole: IColumnGroupByRole,
        settings: Settings,
        valuesColumn: powerbiVisualsApi.DataViewValueColumns,
    ): void {
        const dateColumnGroup: IColumnGroup = columnGroupByRole[dateColumn.name];
        const valueColumnGroup: IColumnGroup = columnGroupByRole[valueColumn.name];

        if (!dateColumnGroup
            || !dateColumnGroup.columns
            || !dateColumnGroup.columns.length
            || !valueColumnGroup
            || !valueColumnGroup.columns
            || !valueColumnGroup.columns.length
        ) {
            return;
        }

        settings.date.setColumnFormat(dateColumnGroup.columns[0].source.format);

        const tooltipColumnGroup: IColumnGroup = columnGroupByRole[tooltipColumn.name];

        const {
            createSelectionIdBuilder,
        } = this.constructorOptions;

        valueColumnGroup.columns.forEach((column: powerbiVisualsApi.DataViewValueColumn, columnIndex: number) => {
            const x: Date = <Date>(dateColumnGroup.values[0]);

            if (x instanceof Date && x !== undefined && x !== null) {
                if (!dataRepresentation.series[columnIndex]) {
                    const selectionId: powerbiVisualsApi.visuals.ISelectionId = createSelectionIdBuilder()
                        .withSeries(valuesColumn, column)
                        .withMeasure(column.source.queryName)
                        .createSelectionId();

                    const seriesSettings: SeriesSettings = this.prepareSeriesSettings(settings, column);
                    const series = this.initDataRepresentationSeries(
                        selectionId,
                        dataRepresentation.series.length,
                        column.source.displayName,
                        seriesSettings,
                    );

                    dataRepresentation.series.push(series);
                    dataRepresentation.sortedSeries.push(series);
                }

                const seriesItem: IDataRepresentationSeries = dataRepresentation.series[columnIndex];
                const y: number = this.parseValue(
                    valueColumnGroup.values[columnIndex],
                    seriesItem.settings.values.treatEmptyValuesAsZero,
                );

                const dataPoint: IDataRepresentationPoint = {
                    index: seriesItem.points.length,
                    x,
                    y,
                };

                dataRepresentation.latestDate = x;

                if (seriesItem.points.length > 1 && (seriesItem.points[seriesItem.points.length - 1].y !== dataPoint.y)) {
                    seriesItem.isLine = false;
                }

                seriesItem.points.push(dataPoint);

                if (seriesItem.settings.values.showLatterAvailableValue) {
                    if (!isNaN(dataPoint.y)) {
                        seriesItem.current = dataPoint;
                    }
                } else {
                    seriesItem.current = dataPoint;
                }

                seriesItem.x.min = this.getMin(seriesItem.x.min, x);
                seriesItem.x.max = this.getMax(seriesItem.x.max, x);
                this.setupYMinMax(y, seriesItem);
                const tooltip: string = tooltipColumnGroup && tooltipColumnGroup.values && tooltipColumnGroup.values[columnIndex] || undefined;
                dataRepresentation.series[columnIndex].tooltip = tooltip;
            }
        });

        const subtitleColumnGroup: IColumnGroup = columnGroupByRole[subtitleColumn.name];
        if (subtitleColumnGroup) {
            dataRepresentation.subtitle = subtitleColumnGroup.values[0];
        }

        const warningColumnGroup: IColumnGroup = columnGroupByRole[warningStateColumn.name];
        if (warningColumnGroup) {
            dataRepresentation.warningState = warningColumnGroup.values[0];
        }

        const changeStartDateColumnGroup: IColumnGroup = columnGroupByRole[changeStartDateColumn.name];
        if (changeStartDateColumnGroup) {
            const date: Date = changeStartDateColumnGroup
                && changeStartDateColumnGroup.values
                && changeStartDateColumnGroup.values[0];

            dataRepresentation.percentCalcDate = date instanceof Date ? date : dataRepresentation.percentCalcDate;
        }
    }