GoodDataFile: src/project.ts
// (C) 2007-2020 GoodData Corporation
import { getIn, handlePolling, getAllPagesByOffsetLimit } from "./util";
import { ITimezone, IColor, IColorPalette, IFeatureFlags } from "./interfaces";
import { IStyleSettingsResponse, IFeatureFlagsResponse } from "./apiResponsesInterfaces";
import { XhrModule, ApiResponse } from "./xhr";
const DEFAULT_PALETTE = [
{ r: 0x2b, g: 0x6b, b: 0xae },
{ r: 0x69, g: 0xaa, b: 0x51 },
{ r: 0xee, g: 0xb1, b: 0x4c },
{ r: 0xd5, g: 0x3c, b: 0x38 },
{ r: 0x89, g: 0x4d, b: 0x94 },
{ r: 0x73, g: 0x73, b: 0x73 },
{ r: 0x44, g: 0xa9, b: 0xbe },
{ r: 0x96, g: 0xbd, b: 0x5f },
{ r: 0xfd, g: 0x93, b: 0x69 },
{ r: 0xe1, g: 0x5d, b: 0x86 },
{ r: 0x7c, g: 0x6f, b: 0xad },
{ r: 0xa5, g: 0xa5, b: 0xa5 },
{ r: 0x7a, g: 0xa6, b: 0xd5 },
{ r: 0x82, g: 0xd0, b: 0x8d },
{ r: 0xff, g: 0xd2, b: 0x89 },
{ r: 0xf1, g: 0x84, b: 0x80 },
{ r: 0xbf, g: 0x90, b: 0xc6 },
{ r: 0xbf, g: 0xbf, b: 0xbf },
];
const isProjectCreated = (project: any) => {
// TODO
const projectState = project.content.state;
return projectState === "ENABLED" || projectState === "DELETED";
};
export interface IProjectConfigSettingItem {
settingItem: {
key: string;
links: {
self: string;
};
source: string;
value: string;
};
}
export interface IProjectConfigResponse {
settings: {
items: IProjectConfigSettingItem[];
};
}
// Parses string values to boolean, number and string
export const parseSettingItemValue = (value: string): boolean | number | string => {
if (value === "true") {
return true;
}
if (value === "false") {
return false;
}
const nr = Number(value);
if (nr.toString() === value) {
return nr;
}
return value;
};
/**
* Functions for working with projects
*
* @class project
* @module project
*/
export class ProjectModule {
constructor(private xhr: XhrModule) {}
/**
* Get current project id
*
* @method getCurrentProjectId
* @return {String} current project identifier
*/
public getCurrentProjectId() {
return this.xhr
.get("/gdc/app/account/bootstrap")
.then(r => r.getData())
.then(this.getCurrentProjectIdInBootstrap);
}
/**
* Return current project id in bootstrap
* @method getCurrentProjectIdInBootstrap
* @param bootstrapData - data was got from bootstrap resource
*/
public getCurrentProjectIdInBootstrap(bootstrapData: any): string | null {
const currentProject = bootstrapData.bootstrapResource.current.project;
// handle situation in which current project is missing (e.g. new user)
if (!currentProject) {
return null;
}
return bootstrapData.bootstrapResource.current.project.links.self.split("/").pop();
}
/**
* Fetches projects available for the user represented by the given profileId
*
* @method getProjects
* @param {String} profileId - User profile identifier
* @return {Array} An Array of projects
*/
public getProjects(profileId: string) {
return getAllPagesByOffsetLimit(
this.xhr,
`/gdc/account/profile/${profileId}/projects`,
"projects",
).then((result: any) => result.map((p: any) => p.project));
}
/**
* Fetches all datasets for the given project
*
* @method getDatasets
* @param {String} projectId - GD project identifier
* @return {Array} An array of objects containing datasets metadata
*/
public getDatasets(projectId: string) {
return this.xhr
.get(`/gdc/md/${projectId}/query/datasets`)
.then(r => r.getData())
.then(getIn("query.entries"));
}
/**
* Fetches a chart color palette for a project represented by the given
* projectId parameter.
*
* @method getColorPalette
* @param {String} projectId - A project identifier
* @return {Array} An array of objects with r, g, b fields representing a project's
* color palette
*/
public getColorPalette(projectId: string) {
return this.xhr
.get(`/gdc/projects/${projectId}/styleSettings`)
.then(r => r.getData())
.then(
(result: any) => {
return result.styleSettings.chartPalette.map((c: any) => {
return {
r: c.fill.r,
g: c.fill.g,
b: c.fill.b,
};
});
},
err => {
if (err.status === 200) {
return DEFAULT_PALETTE;
}
throw new Error(err.statusText);
},
);
}
/**
* Fetches a chart color palette for a project represented by the given
* projectId parameter.
*
* @method getColorPaletteWithGuids
* @param {String} projectId - A project identifier
* @return {Array} An array of objects representing a project's
* color palette with color guid or undefined
*/
public getColorPaletteWithGuids(projectId: string): Promise<IColorPalette | undefined> {
return this.xhr
.get(`/gdc/projects/${projectId}/styleSettings`)
.then((apiResponse: ApiResponse) => {
return apiResponse.getData();
})
.then((result: IStyleSettingsResponse) => {
if (result && result.styleSettings) {
return result.styleSettings.chartPalette;
} else {
return undefined;
}
});
}
/**
* Sets given colors as a color palette for a given project.
*
* @method setColorPalette
* @param {String} projectId - GD project identifier
* @param {Array} colors - An array of colors that we want to use within the project.
* Each color should be an object with r, g, b fields. // TODO really object?
*/
public setColorPalette(projectId: string, colors: IColor[]): Promise<ApiResponse> {
return this.xhr.put(`/gdc/projects/${projectId}/styleSettings`, {
body: {
styleSettings: {
chartPalette: colors.map((fill, idx: number) => {
return { fill, guid: `guid${idx}` };
}),
},
},
});
}
/**
* Gets current timezone and its offset. Example output:
*
* {
* id: 'Europe/Prague',
* displayName: 'Central European Time',
* currentOffsetMs: 3600000
* }
*
* @method getTimezone
* @param {String} projectId - GD project identifier
*/
public getTimezone(projectId: string): Promise<ITimezone> {
const bootstrapUrl = `/gdc/app/account/bootstrap?projectId=${projectId}`;
return this.xhr
.get(bootstrapUrl)
.then(r => r.getData())
.then((result: any) => {
return result.bootstrapResource.current.timezone;
});
}
public setTimezone(projectId: string, timezone: ITimezone) {
const timezoneServiceUrl = `/gdc/md/${projectId}/service/timezone`;
const data = {
service: { timezone },
};
return this.xhr
.post(timezoneServiceUrl, {
body: data,
})
.then(r => r.getData());
}
/**
* Create project
* Note: returns a promise which is resolved when the project creation is finished
*
* @experimental
* @method createProject
* @param {String} title
* @param {String} authorizationToken
* @param {Object} options for project creation (summary, projectTemplate, ...)
* @return {Object} created project object
*/
public createProject(title: string, authorizationToken: string, options: any = {}) {
const {
summary,
projectTemplate,
driver = "Pg",
environment = "TESTING",
guidedNavigation = 1,
} = options;
return this.xhr
.post("/gdc/projects", {
body: JSON.stringify({
project: {
content: {
guidedNavigation,
driver,
authorizationToken,
environment,
},
meta: {
title,
summary,
projectTemplate,
},
},
}),
})
.then(r => r.getData())
.then((project: any) =>
handlePolling(
this.xhr.get.bind(this.xhr),
project.uri,
(response: any) => {
// TODO project response
return isProjectCreated(response.project);
},
options,
),
);
}
/**
* Delete project
*
* @method deleteProject
* @param {String} projectId
*/
public deleteProject(projectId: string) {
return this.xhr.del(`/gdc/projects/${projectId}`);
}
/**
* Gets aggregated feature flags for given project and current user
*
* @method getFeatureFlags
* @param {String} projectId - A project identifier
* @return {IFeatureFlags} Hash table of feature flags and theirs values where feature flag is as key
*/
public getFeatureFlags(projectId: string): Promise<IFeatureFlags> {
return this.xhr
.get(`/gdc/app/projects/${projectId}/featureFlags`)
.then((apiResponse: ApiResponse) => {
return apiResponse.getData();
})
.then((result: IFeatureFlagsResponse) => {
if (result && result.featureFlags) {
return result.featureFlags;
}
return {};
});
}
/**
* Gets project config including project specific feature flags
*
* @param {String} projectId - A project identifier
* @return {IProjectConfigSettingItem[]} An array of project config setting items
*/
public getConfig(projectId: string): Promise<IProjectConfigSettingItem[]> {
return this.xhr
.get(`/gdc/app/projects/${projectId}/config`)
.then((apiResponse: ApiResponse) => {
const projectConfig = apiResponse.getData();
return projectConfig;
})
.then((result: IProjectConfigResponse) => {
if (result && result.settings && result.settings.items) {
return result.settings.items;
}
return [];
});
}
/**
* Gets project specific feature flags
*
* @param {String} projectId - A project identifier
* @param {String} source - optional filter settingItems with specific source
* @return {IFeatureFlags} Hash table of feature flags and theirs values where feature flag is as key
*/
public getProjectFeatureFlags(projectId: string, source?: string): Promise<IFeatureFlags> {
return this.getConfig(projectId).then((settingItems: IProjectConfigSettingItem[]) => {
const filteredSettingItems = source
? settingItems.filter(settingItem => settingItem.settingItem.source === source)
: settingItems;
const featureFlags: IFeatureFlags = {};
filteredSettingItems.forEach(settingItem => {
featureFlags[settingItem.settingItem.key] = parseSettingItemValue(
settingItem.settingItem.value,
);
});
return featureFlags;
});
}
}