@gooddata/gooddata-js/src/DataLayer/converters/toAfmResultSpec.ts

GoodData JavaScript SDK

// (C) 2007-2020 GoodData Corporation
import compact from "lodash/compact";
import flatMap from "lodash/flatMap";
import get from "lodash/get";
import { AFM, VisualizationObject } from "@gooddata/typings";
import { convertVisualizationObjectExtendedFilter } from "./FilterConverter";
import MeasureConverter from "./MeasureConverter";
import { LOCATION, TOOLTIP_TEXT } from "../../DataLayer/constants/buckets";
import { IVisualizationProperties } from "./model/VisualizationObject";

function convertAttribute(
    attribute: VisualizationObject.IVisualizationAttribute,
    idx: number,
): AFM.IAttribute {
    const alias = attribute.visualizationAttribute.alias;
    const aliasProp = alias ? { alias } : {};
    return {
        displayForm: attribute.visualizationAttribute.displayForm,
        localIdentifier: attribute.visualizationAttribute.localIdentifier || `a${idx + 1}`,
        ...aliasProp,
    };
}

function convertAFM(visualizationObject: VisualizationObject.IVisualizationObjectContent): AFM.IAfm {
    const textualAttributes: AFM.IAttribute[] = getAttributes(visualizationObject.buckets).map(
        convertAttribute,
    );
    const geoAttribute = getGeoAttributeForTooltip(visualizationObject);
    const attributes = geoAttribute ? [...textualAttributes, geoAttribute] : textualAttributes;

    const attrProp = attributes.length ? { attributes } : {};

    const measures: AFM.IMeasure[] = getMeasures(visualizationObject.buckets).map(
        MeasureConverter.convertMeasure,
    );
    const measuresProp = measures.length ? { measures } : {};

    const filters: AFM.CompatibilityFilter[] = visualizationObject.filters
        ? compact(visualizationObject.filters.map(convertVisualizationObjectExtendedFilter))
        : [];
    const filtersProp = filters.length ? { filters } : {};

    const nativeTotals = convertNativeTotals(visualizationObject);
    const nativeTotalsProp = nativeTotals.length ? { nativeTotals } : {};

    return {
        ...measuresProp,
        ...attrProp,
        ...filtersProp,
        ...nativeTotalsProp,
    };
}

function getMeasures(buckets: VisualizationObject.IBucket[]): VisualizationObject.IMeasure[] {
    return buckets.reduce((result: VisualizationObject.IMeasure[], bucket: VisualizationObject.IBucket) => {
        const measureItems: VisualizationObject.IMeasure[] = bucket.items.filter(
            VisualizationObject.isMeasure,
        );

        return result.concat(measureItems);
    }, []);
}

function getNativeTotalAttributeIdentifiers(
    bucket: VisualizationObject.IBucket,
    total: VisualizationObject.IVisualizationTotal,
): string[] {
    const attributes = bucket.items.filter(VisualizationObject.isAttribute);

    const totalAttributeIndex = attributes.findIndex(
        attribute => attribute.visualizationAttribute.localIdentifier === total.attributeIdentifier,
    );

    return attributes
        .slice(0, totalAttributeIndex)
        .map(attribute => attribute.visualizationAttribute.localIdentifier);
}

function convertNativeTotals(
    visObj: VisualizationObject.IVisualizationObjectContent,
): AFM.INativeTotalItem[] {
    const nativeTotalsPerBucket = visObj.buckets.map(bucket => {
        const totals = bucket.totals || [];
        const nativeTotals = totals.filter(total => total.type === "nat");

        return nativeTotals.map(total => ({
            measureIdentifier: total.measureIdentifier,
            attributeIdentifiers: getNativeTotalAttributeIdentifiers(bucket, total),
        }));
    });

    return flatMap(nativeTotalsPerBucket);
}

function getAttributes(
    buckets: VisualizationObject.IBucket[],
): VisualizationObject.IVisualizationAttribute[] {
    return buckets.reduce(
        (result: VisualizationObject.IVisualizationAttribute[], bucket: VisualizationObject.IBucket) => {
            const items: VisualizationObject.IVisualizationAttribute[] = bucket.items.filter(
                VisualizationObject.isAttribute,
            );

            return result.concat(items);
        },
        [],
    );
}

function parsePropertyItem(item: string): IVisualizationProperties {
    try {
        return JSON.parse(item);
    } catch (e) {
        return {};
    }
}

function buildTooltipBucketItem(tooltipText: string, alias: string): AFM.IAttribute {
    const tooltipAlias = alias ? { alias } : {};
    return {
        localIdentifier: TOOLTIP_TEXT,
        displayForm: {
            uri: tooltipText,
        },
        ...tooltipAlias,
    };
}

function getGeoAttributeForTooltip(
    visualizationObject: VisualizationObject.IVisualizationObjectContent,
): AFM.IAttribute | null {
    const properties: IVisualizationProperties = parsePropertyItem(visualizationObject.properties || "");
    const tooltipText: string = get(properties, "controls.tooltipText", "");
    if (tooltipText) {
        // copy alias of Geo attribute to alias of tooltipText attribute
        const locationAlias: string = visualizationObject.buckets.reduce(
            (locationAlias: string, bucket: VisualizationObject.IBucket): string => {
                if (!locationAlias && bucket.localIdentifier === LOCATION) {
                    return get(bucket, "items[0].visualizationAttribute.alias");
                }
                return locationAlias;
            },
            "",
        );
        return buildTooltipBucketItem(tooltipText, locationAlias);
    }

    return null;
}

function convertSorting(visObj: VisualizationObject.IVisualizationObjectContent): AFM.SortItem[] {
    if (visObj.properties) {
        let properties = {};
        try {
            properties = JSON.parse(visObj.properties);
        } catch {
            // tslint:disable-next-line:no-console
            console.error("Properties contains invalid JSON string.");
        }

        const sorts: AFM.SortItem[] = get(properties, "sortItems", []);
        return sorts ? sorts : [];
    }

    return [];
}

function convertResultSpec(visObj: VisualizationObject.IVisualizationObjectContent): AFM.IResultSpec {
    const sorts = convertSorting(visObj);
    // Workaround because we can handle only 1 sort item for now
    const sortsProp = sorts.length ? { sorts: sorts.slice(0, 1) } : {};

    return {
        ...sortsProp,
    };
}

export interface IConvertedAFM {
    afm: AFM.IAfm;
    resultSpec: AFM.IResultSpec;
}

/**
 * Converts visualizationObject to afm and resultSpec
 *
 * @method toAfmResultSpec
 * @param {VisualizationObject.IVisualizationObjectContent} visObj
 * @returns {IConvertedAFM}
 */
export function toAfmResultSpec(visObj: VisualizationObject.IVisualizationObjectContent): IConvertedAFM {
    const afm = convertAFM(visObj);
    return {
        afm,
        resultSpec: convertResultSpec(visObj),
    };
}