// (C) 2007-2020 GoodData Corporation
import invariant from "invariant";
import qs from "qs";
import range from "lodash/range";
import get from "lodash/get";
import { Execution, AFM } from "@gooddata/typings";
import { XhrModule, ApiResponseError } from "../xhr";
import { convertExecutionToJson } from "./execute-afm.convert";
export const DEFAULT_LIMIT = 1000;
/**
* This interface represents input for executeVisualization API endpoint.
*
* NOTE: all functionality related to executeVisualization is experimental and subject to possible breaking changes
* in the future; location and shape of this interface WILL change when the functionality is made GA.
*
* @private
* @internal
*/
export interface IVisualizationExecution {
visualizationExecution: {
reference: string;
resultSpec?: AFM.IResultSpec;
filters?: AFM.CompatibilityFilter[];
};
}
/**
* This interface represents error caused during second part of api execution (data fetching)
* and contains information about first execution part if that part was successful.
*/
export class ApiExecutionResponseError extends ApiResponseError {
constructor(error: ApiResponseError, public executionResponse: any) {
super(error.message, error.response, error.responseBody);
}
}
export class ExecuteAfmModule {
constructor(private xhr: XhrModule) {}
/**
* Execute AFM and fetch all data results
*
* @method executeAfm
* @param {String} projectId - GD project identifier
* @param {AFM.IExecution} execution - See https://github.com/gooddata/gooddata-typings/blob/v2.1.0/src/AFM.ts#L2
*
* @returns {Promise<Execution.IExecutionResponses>} Structure with `executionResponse` and `executionResult` -
* See https://github.com/gooddata/gooddata-typings/blob/v2.1.0/src/Execution.ts#L113
*/
public executeAfm(projectId: string, execution: AFM.IExecution): Promise<Execution.IExecutionResponses> {
validateNumOfDimensions(get(execution, "execution.resultSpec.dimensions").length);
return this.getExecutionResponse(projectId, execution).then(
(executionResponse: Execution.IExecutionResponse) => {
return this.getExecutionResult(executionResponse.links.executionResult)
.then((executionResult: Execution.IExecutionResult | null) => {
return { executionResponse, executionResult };
})
.catch(error => {
throw new ApiExecutionResponseError(error, executionResponse);
});
},
);
}
/**
* Execute AFM and return execution's response; the response describes dimensionality of the results and
* includes link to poll for the results.
*
* @method getExecutionResponse
* @param {string} projectId - GD project identifier
* @param {AFM.IExecution} execution - See https://github.com/gooddata/gooddata-typings/blob/v2.1.0/src/AFM.ts#L2
*
* @returns {Promise<Execution.IExecutionResponse>} Promise with `executionResponse`
* See https://github.com/gooddata/gooddata-typings/blob/v2.1.0/src/Execution.ts#L69
*/
public getExecutionResponse(
projectId: string,
execution: AFM.IExecution,
): Promise<Execution.IExecutionResponse> {
validateNumOfDimensions(get(execution, "execution.resultSpec.dimensions").length);
return this.xhr
.post(`/gdc/app/projects/${projectId}/executeAfm`, { body: convertExecutionToJson(execution) })
.then(apiResponse => apiResponse.getData())
.then(unwrapExecutionResponse);
}
/**
* Execute saved visualization and get all data.
*
* NOTE: all functionality related to executeVisualization is experimental and subject to possible breaking changes
* in the future; location and shape of this interface WILL change when the functionality is made GA.
*
* @param {string} projectId - GD project identifier
* @param {IVisualizationExecution} visExecution - execution payload
*
* @private
* @internal
*/
public _executeVisualization(
projectId: string,
visExecution: IVisualizationExecution,
): Promise<Execution.IExecutionResponses> {
// We have ONE-3961 as followup to take this out of experimental mode
return this._getVisExecutionResponse(projectId, visExecution).then(
(executionResponse: Execution.IExecutionResponse) => {
return this.getExecutionResult(executionResponse.links.executionResult).then(
(executionResult: Execution.IExecutionResult | null) => {
return { executionResponse, executionResult };
},
);
},
);
}
/**
*
* Execute visualization and return the response; the response describes dimensionality of the results and
* includes link to poll for the results.
*
* NOTE: all functionality related to executeVisualization is experimental and subject to possible breaking changes
* in the future; location and shape of this interface WILL change when the functionality is made GA.
*
* @param {string} projectId - GD project identifier
* @param {IVisualizationExecution} visExecution - execution payload
*
* @private
* @internal
*/
public _getVisExecutionResponse(
projectId: string,
visExecution: IVisualizationExecution,
): Promise<Execution.IExecutionResponse> {
// We have ONE-3961 as followup to take this out of experimental mode
const body = createExecuteVisualizationBody(visExecution);
return this.xhr
.post(`/gdc/app/projects/${projectId}/executeVisualization`, { body })
.then(apiResponse => apiResponse.getData())
.then(unwrapExecutionResponse);
}
//
// working with results
//
/**
* Get one page of Result from Execution (with requested limit and offset)
*
* @method getPartialExecutionResult
* @param {string} executionResultUri
* @param {number[]} limit - limit for each dimension
* @param {number[]} offset - offset for each dimension
*
* @returns {Promise<Execution.IExecutionResult | null>}
* Promise with `executionResult` or `null` (null means empty response - HTTP 204)
* See https://github.com/gooddata/gooddata-typings/blob/v2.1.0/src/Execution.ts#L88
*/
public getPartialExecutionResult(
executionResultUri: string,
limit: number[],
offset: number[],
): Promise<Execution.IExecutionResult | null> {
const executionResultUriQueryPart = getExecutionResultUriQueryPart(executionResultUri);
const numOfDimensions = Number(qs.parse(executionResultUriQueryPart).dimensions);
validateNumOfDimensions(numOfDimensions);
return this.getPage(executionResultUri, limit, offset);
}
/**
* Get whole ExecutionResult
*
* @method getExecutionResult
* @param {string} executionResultUri
*
* @returns {Promise<Execution.IExecutionResult | null>}
* Promise with `executionResult` or `null` (null means empty response - HTTP 204)
* See https://github.com/gooddata/gooddata-typings/blob/v2.1.0/src/Execution.ts#L88
*/
public getExecutionResult(executionResultUri: string): Promise<Execution.IExecutionResult | null> {
const executionResultUriQueryPart = getExecutionResultUriQueryPart(executionResultUri);
const numOfDimensions = Number(qs.parse(executionResultUriQueryPart).dimensions);
validateNumOfDimensions(numOfDimensions);
const limit = Array(numOfDimensions).fill(DEFAULT_LIMIT);
const offset = Array(numOfDimensions).fill(0);
return this.getAllPages(executionResultUri, limit, offset);
}
private getPage(
executionResultUri: string,
limit: number[],
offset: number[],
): Promise<Execution.IExecutionResult | null> {
return this.fetchExecutionResult(executionResultUri, limit, offset).then(
(executionResultWrapper: Execution.IExecutionResultWrapper | null) => {
return executionResultWrapper ? unwrapExecutionResult(executionResultWrapper) : null;
},
);
}
private getAllPages(
executionResultUri: string,
limit: number[],
offset: number[],
prevExecutionResult?: Execution.IExecutionResult,
): Promise<Execution.IExecutionResult | null> {
return this.fetchExecutionResult(executionResultUri, limit, offset).then(
(executionResultWrapper: Execution.IExecutionResultWrapper | null) => {
if (!executionResultWrapper) {
return null;
}
const executionResult = unwrapExecutionResult(executionResultWrapper);
const newExecutionResult = prevExecutionResult
? mergePage(prevExecutionResult, executionResult)
: executionResult;
const { offset, total } = executionResult.paging;
const nextOffset = getNextOffset(limit, offset, total);
const nextLimit = getNextLimit(limit, nextOffset, total);
return nextPageExists(nextOffset, total)
? this.getAllPages(executionResultUri, nextLimit, nextOffset, newExecutionResult)
: newExecutionResult;
},
);
}
private fetchExecutionResult(
executionResultUri: string,
limit: number[],
offset: number[],
): Promise<Execution.IExecutionResultWrapper | null> {
const uri = replaceLimitAndOffsetInUri(executionResultUri, limit, offset);
return this.xhr
.get(uri)
.then(apiResponse => (apiResponse.response.status === 204 ? null : apiResponse.getData()));
}
}
function getExecutionResultUriQueryPart(executionResultUri: string): string {
return executionResultUri.split(/\?(.+)/)[1];
}
function unwrapExecutionResponse(
executionResponseWrapper: Execution.IExecutionResponseWrapper,
): Execution.IExecutionResponse {
return executionResponseWrapper.executionResponse;
}
function unwrapExecutionResult(
executionResultWrapper: Execution.IExecutionResultWrapper,
): Execution.IExecutionResult {
return executionResultWrapper.executionResult;
}
function validateNumOfDimensions(numOfDimensions: number): void {
invariant(
numOfDimensions === 1 || numOfDimensions === 2,
`${numOfDimensions} dimensions are not allowed. Only 1 or 2 dimensions are supported.`,
);
}
function createExecuteVisualizationBody(visExecution: IVisualizationExecution): string {
const { reference, resultSpec, filters } = visExecution.visualizationExecution;
const resultSpecProp = resultSpec ? { resultSpec } : undefined;
const filtersProp = filters ? { filters } : undefined;
return JSON.stringify({
visualizationExecution: {
reference,
...resultSpecProp,
...filtersProp,
},
});
}
export function replaceLimitAndOffsetInUri(oldUri: string, limit: number[], offset: number[]): string {
const [uriPart, queryPart] = oldUri.split(/\?(.+)/);
const query = {
...qs.parse(queryPart),
limit: limit.join(","),
offset: offset.join(","),
};
return uriPart + qs.stringify(query, { addQueryPrefix: true });
}
export function getNextOffset(limit: number[], offset: number[], total: number[]): number[] {
const numOfDimensions = total.length;
const defaultNextRowsOffset = offset[0] + limit[0];
if (numOfDimensions === 1) {
return [defaultNextRowsOffset];
}
const defaultNextColumnsOffset = offset[1] + limit[1];
const nextColumnsExist = offset[1] + limit[1] < total[1];
const nextRowsOffset = nextColumnsExist
? offset[0] // stay in the same rows
: defaultNextRowsOffset; // go to the next rows
const nextColumnsOffset = nextColumnsExist
? defaultNextColumnsOffset // next columns for the same rows
: 0; // start in the beginning of the next rows
return [nextRowsOffset, nextColumnsOffset];
}
export function getNextLimit(limit: number[], nextOffset: number[], total: number[]): number[] {
const numOfDimensions = total.length;
validateNumOfDimensions(numOfDimensions);
const getSingleNextLimit = (limit: number, nextOffset: number, total: number): number =>
nextOffset + limit > total ? total - nextOffset : limit;
// prevent set up lower limit than possible for 2nd dimension in the beginning of the next rows
if (
numOfDimensions === 2 &&
nextOffset[1] === 0 && // beginning of the next rows
limit[0] < total[1] // limit from 1st dimension should be used in 2nd dimension
) {
return [getSingleNextLimit(limit[0], nextOffset[0], total[0]), limit[0]];
}
return range(numOfDimensions).map((i: number) => getSingleNextLimit(limit[i], nextOffset[i], total[i]));
}
export function nextPageExists(nextOffset: number[], total: number[]): boolean {
// expression "return nextLimit[0] > 0" also returns correct result
return nextOffset[0] < total[0];
}
function mergeHeaderItemsForEachAttribute(
dimension: number,
headerItems: Execution.IResultHeaderItem[][][] | undefined,
result: Execution.IExecutionResult,
) {
if (headerItems && result.headerItems) {
for (let attrIdx = 0; attrIdx < headerItems[dimension].length; attrIdx += 1) {
result.headerItems[dimension][attrIdx].push(...headerItems[dimension][attrIdx]);
}
}
}
// works only for one or two dimensions
export function mergePage(
prevExecutionResult: Execution.IExecutionResult,
executionResult: Execution.IExecutionResult,
): Execution.IExecutionResult {
const result = prevExecutionResult;
const { headerItems, data, paging } = executionResult;
const mergeHeaderItems = (dimension: number) => {
// for 1 dimension we already have the headers from first page
const otherDimension = dimension === 0 ? 1 : 0;
const isEdge = paging.offset[otherDimension] === 0;
if (isEdge) {
mergeHeaderItemsForEachAttribute(dimension, headerItems, result);
}
};
// merge data
const rowOffset = paging.offset[0];
if (result.data[rowOffset]) {
// appending columns to existing rows
for (let i = 0; i < data.length; i += 1) {
const columns = data[i] as Execution.DataValue[];
const resultData = result.data[i + rowOffset] as Execution.DataValue[];
resultData.push(...columns);
}
} else {
// appending new rows
const resultData = result.data as Execution.DataValue[];
const currentPageData = data as Execution.DataValue[];
resultData.push(...currentPageData);
}
// merge headerItems
if (paging.offset.length > 1) {
mergeHeaderItems(0);
mergeHeaderItems(1);
} else {
mergeHeaderItemsForEachAttribute(0, headerItems, result);
}
// update page count
if (paging.offset.length === 1) {
result.paging.count = [get(result, "headerItems[0][0]", []).length];
}
if (paging.offset.length === 2) {
result.paging.count = [
get(result, "headerItems[0][0]", []).length,
get(result, "headerItems[1][0]", []).length,
];
}
return result;
}
GoodData