GoodDataFile: src/metadataExt.ts
// (C) 2020 GoodData Corporation
import { MetadataModule } from "./metadata";
import { XhrModule } from "./xhr";
import { UserModule } from "./user";
import cloneDeepWith from "lodash/cloneDeepWith";
import isEmpty from "lodash/isEmpty";
import compact from "lodash/compact";
import omit from "lodash/omit";
import {
IKPI,
IAnalyticalDashboardContent,
DashboardExport,
IVisualizationWidget,
IAnalyticalDashboard,
IObjectMeta,
} from "@gooddata/typings";
/**
* Modify how and what should be copied to the cloned dashboard
*/
export interface ICopyDashboardOptions {
/** copy new kpi and reference it in the cloned dashboard */
copyKpi?: boolean;
/** copy new visualization object and reference it in the cloned widget */
copyVisObj?: boolean;
/** optional, default value of name is "Copy of (current dashboard title)" */
name?: string;
/** optional, default value of summary is (current dashboard summary) */
summary?: string;
/** optional, if true, the isLocked flag will be cleared for the newly created dashboard, defaults to false */
clearLockedFlag?: boolean;
}
type UriTranslator = (oldUri: string) => string;
export function createTranslator(
kpiMap: Map<string, string>,
visWidgetMap: Map<string, string>,
): UriTranslator {
return (oldUri: string): string => {
const kpiMatch = kpiMap.get(oldUri);
const visWidgetMatch = visWidgetMap.get(oldUri);
if (kpiMatch) {
return kpiMatch;
} else if (visWidgetMatch) {
return visWidgetMatch;
} else {
return oldUri;
}
};
}
/**
* Updates content of the dashboard
*
* @param {string} dashboardUri uri of dashboard
* @param {UriTranslator} uriTranslator gets updated widgets and kpis uri
* @param {string} filterContext updated filter context uri
* @experimental
*/
export function updateContent(
analyticalDashboard: any,
uriTranslator: UriTranslator,
filterContext: string,
): IAnalyticalDashboardContent {
return cloneDeepWith(
{
...analyticalDashboard.content,
filterContext,
widgets: analyticalDashboard.content.widgets.map((uri: string) => {
return uriTranslator(uri);
}),
},
value => {
const uri = value.uri;
if (!uri) {
return;
}
return {
...value,
uri: uriTranslator(uri),
};
},
);
}
export class MetadataModuleExt {
private metadataModule: MetadataModule;
private userModule: UserModule;
private xhr: XhrModule;
constructor(xhr: XhrModule) {
this.xhr = xhr;
this.metadataModule = new MetadataModule(xhr);
this.userModule = new UserModule(xhr);
}
/**
* @param {string} projectId id of the project
* @param {string} dashboardUri uri of the dashboard
* @param {ICopyDashboardOptions} options object with options:
* - default {} dashboard is cloned with new kpi reference and visualization widget is cloned with new
* visualization object reference
* - copyKpi {boolean} choose whether dashboard is cloned with new Kpi reference
* - copyVisObj {boolean} choose whether visualization widget is cloned with new visualization object reference
* - name {string} optional - choose name, default value is "Copy of (old title of the dashboard)"
* @returns {string} uri of cloned dashboard
* @experimental
*/
public async saveDashboardAs(
projectId: string,
dashboardUri: string,
options: ICopyDashboardOptions,
): Promise<string> {
const objectsFromDashboard = await this.getObjectsFromDashboard(projectId, dashboardUri);
const dashboardDetails = await this.metadataModule.getObjectDetails(dashboardUri);
const { analyticalDashboard }: { analyticalDashboard: IAnalyticalDashboard } = dashboardDetails;
const allCreatedObjUris: string[] = [];
const visWidgetUris: string[] = [];
try {
const filterContext = await this.duplicateFilterContext(projectId, objectsFromDashboard, options);
allCreatedObjUris.push(filterContext);
const kpiMap = await this.duplicateOrKeepKpis(projectId, objectsFromDashboard, options);
if (this.shouldCopyKpi(options)) {
allCreatedObjUris.push(...Array.from(kpiMap.values()));
}
const visWidgetMap = await this.duplicateWidgets(projectId, objectsFromDashboard, options);
visWidgetUris.push(...Array.from(visWidgetMap.values()));
const translator = createTranslator(kpiMap, visWidgetMap);
const updatedContent = updateContent(analyticalDashboard, translator, filterContext);
const dashboardTitle = this.getDashboardName(analyticalDashboard.meta.title, options.name);
const dashboardSummary = this.getDashboardSummary(
analyticalDashboard.meta.summary,
options.summary,
);
const duplicateDashboard = {
...dashboardDetails,
analyticalDashboard: {
...dashboardDetails.analyticalDashboard,
content: this.getDashboardDetailObject(updatedContent, filterContext),
meta: {
...this.getSanitizedMeta(dashboardDetails.analyticalDashboard.meta, options),
title: dashboardTitle,
summary: dashboardSummary,
},
},
};
const duplicateDashboardUri: string = (
await this.metadataModule.createObject(projectId, duplicateDashboard)
).analyticalDashboard.meta.uri;
return duplicateDashboardUri;
} catch (err) {
if (this.shouldCopyVisObj(options)) {
await Promise.all(visWidgetUris.map(uri => this.cascadingDelete(projectId, uri)));
} else {
await Promise.all(visWidgetUris.map(uri => this.metadataModule.deleteObject(uri)));
}
await Promise.all(allCreatedObjUris.map(uri => this.cascadingDelete(projectId, uri)));
return dashboardUri;
}
}
/**
* Deletes dashboard and its objects
* (only the author of the dashboard can delete the dashboard and its objects)
*
* @method deleteAllObjects
* @param {string} projectId Project identifier
* @param {string} dashboardUri Uri of a dashboard to be deleted
* @experimental
*/
public async cascadingDelete(projectID: string, dashboardUri: string): Promise<any> {
const objects: any[] = await this.metadataModule.getObjectUsing(projectID, dashboardUri);
const currentUser: string = (await this.userModule.getAccountInfo()).profileUri;
const objectsToBeDeleted = objects
.filter((object: any) => object.author === currentUser)
.map((object: any) => {
return object.link;
});
return this.xhr.post(`/gdc/md/${projectID}/objects/delete`, {
body: {
delete: {
items: [dashboardUri].concat(objectsToBeDeleted),
mode: "cascade",
},
},
});
}
private getDashboardDetailObject(
updatedContent: IAnalyticalDashboardContent,
filterContext: string,
): IAnalyticalDashboardContent {
const { layout } = updatedContent;
return {
...updatedContent,
filterContext,
widgets: [...updatedContent.widgets],
...(isEmpty(layout) ? {} : { layout }),
};
}
private getDashboardName(originalName: string, newName?: string): string {
if (newName !== undefined) {
return newName;
}
return `Copy of ${originalName}`;
}
private getDashboardSummary(originalSummary?: string, newSummary?: string): string {
if (newSummary !== undefined) {
return newSummary;
} else if (originalSummary !== undefined) {
return originalSummary;
}
return "";
}
private async duplicateOrKeepKpis(
projectId: string,
objsFromDashboard: any[],
options: ICopyDashboardOptions,
): Promise<Map<string, string>> {
const uriMap: Map<string, string> = new Map();
if (this.shouldCopyKpi(options)) {
await Promise.all(
objsFromDashboard
.filter((obj: any) => this.unwrapObj(obj).meta.category === "kpi")
.map(async (kpiWidget: any) => {
const { kpi }: { kpi: IKPI } = kpiWidget;
const toSave = {
kpi: {
meta: this.getSanitizedMeta(kpi.meta as IObjectMeta, options),
content: { ...kpi.content },
},
};
const newUriKpiObj: string = (
await this.metadataModule.createObject(projectId, toSave)
).kpi.meta.uri;
uriMap.set(kpi.meta.uri as string, newUriKpiObj);
}),
);
}
return uriMap;
}
private async duplicateWidgets(
projectId: string,
objsFromDashboard: any[],
options: ICopyDashboardOptions,
): Promise<Map<string, string>> {
const uriMap: Map<string, string> = new Map();
await Promise.all(
objsFromDashboard
.filter((obj: any) => this.unwrapObj(obj).meta.category === "visualizationWidget")
.map(async (visWidget: any) => {
return this.createAndUpdateWidgets(projectId, visWidget, options, uriMap);
}),
);
return uriMap;
}
private async createAndUpdateWidgets(
projectId: string,
visWidget: any,
options: ICopyDashboardOptions,
uriMap: Map<string, string>,
): Promise<void> {
const { visualizationWidget } = visWidget;
if (this.shouldCopyVisObj(options)) {
const visObj = await this.metadataModule.getObjectDetails(
visualizationWidget.content.visualization,
);
const toSave = {
visualizationObject: {
meta: this.getSanitizedMeta(visObj.visualizationObject.meta, options),
content: { ...visObj.visualizationObject.content },
},
};
const newUriVisObj = (await this.metadataModule.createObject(projectId, toSave))
.visualizationObject.meta.uri;
const updatedVisWidget = {
...visWidget,
visualizationWidget: {
meta: this.getSanitizedMeta(visWidget.visualizationWidget.meta, options),
content: {
...visWidget.visualizationWidget.content,
visualization: newUriVisObj,
},
},
};
const visUri = (await this.metadataModule.createObject(projectId, updatedVisWidget))
.visualizationWidget.meta.uri;
uriMap.set(visualizationWidget.meta.uri, visUri);
} else {
const updatedVisWidget = {
...visWidget,
visualizationWidget: {
meta: this.getSanitizedMeta(visWidget.visualizationWidget.meta, options),
content: { ...visWidget.visualizationWidget.content },
},
};
const { visualizationWidget } = await this.metadataModule.createObject(
projectId,
updatedVisWidget,
);
uriMap.set(visWidget.visualizationWidget.meta.uri, visualizationWidget.meta.uri);
}
}
private async duplicateFilterContext(
projectId: string,
objsFromDashboard: any,
options: ICopyDashboardOptions,
): Promise<string> {
const originalFilterContext = objsFromDashboard.filter(
(obj: any) => this.unwrapObj(obj).meta.category === "filterContext",
)[0];
const toSave = {
filterContext: {
meta: this.getSanitizedMeta(originalFilterContext.filterContext.meta, options),
content: { ...originalFilterContext.filterContext.content },
},
};
const { filterContext } = await this.metadataModule.createObject(projectId, toSave);
return filterContext.meta.uri;
}
private getSanitizedMeta(originalMeta: IObjectMeta, options: ICopyDashboardOptions): IObjectMeta {
return omit(
originalMeta,
compact([
"identifier",
"uri",
"author",
"created",
"updated",
"contributor",
options && options.clearLockedFlag && "locked",
]),
) as IObjectMeta;
}
private async getObjectsFromDashboard(
projectId: string,
dashboardUri: string,
): Promise<Array<IKPI | DashboardExport.IFilterContext | IVisualizationWidget>> {
const uris = await this.getObjectsUrisInDashboard(projectId, dashboardUri);
return this.metadataModule.getObjects(projectId, uris);
}
private async getObjectsUrisInDashboard(projectId: string, dashboardUri: string): Promise<string[]> {
return (
await this.metadataModule.getObjectUsing(projectId, dashboardUri, {
types: ["kpi", "visualizationWidget", "filterContext"],
})
).map((obj: any) => {
return obj.link;
});
}
private unwrapObj(obj: any): any {
return obj[Object.keys(obj)[0]];
}
private shouldCopyVisObj(options: ICopyDashboardOptions): boolean {
return !!(options.copyVisObj || typeof options.copyVisObj === "undefined");
}
private shouldCopyKpi(options: ICopyDashboardOptions): boolean {
return !!(options.copyKpi || typeof options.copyKpi === "undefined");
}
}