@netgrif/components-core
Version:
Netgrif Application engine frontend core Angular library
284 lines • 42 kB
JavaScript
import { BehaviorSubject, of } from 'rxjs';
import { catchError, take, tap, map, distinctUntilChanged } from 'rxjs/operators';
export class ConfigurationService {
configuration;
_configurationResource;
_applicationConfiguration;
_dataFieldConfiguration;
APPLICATION_CONFIG;
_config$ = new BehaviorSubject(null);
config$ = this._config$.asObservable();
loaded$ = this.config$.pipe(map(cfg => !!cfg), distinctUntilChanged());
constructor(configuration, _configurationResource, _applicationConfiguration) {
this.configuration = configuration;
this._configurationResource = _configurationResource;
this._applicationConfiguration = _applicationConfiguration;
this.APPLICATION_CONFIG = _applicationConfiguration;
if (!this._applicationConfiguration?.resolve_configuration) {
this.initialize();
}
}
get snapshot() {
return this.configuration ? this.createConfigurationCopy() : null;
}
initialize() {
this.resolveEndpointURLs();
this._dataFieldConfiguration = this.getConfigurationSubtree(['services', 'dataFields']);
this._config$.next(this.createConfigurationCopy());
}
getAsync() {
return of(this.get());
}
/**
* Calls to this method should be avoided as creating a deep copy of the configuration has a large overhead
*
* @returns a deep copy of the entire configuration object
*/
get() {
return this.createConfigurationCopy();
}
/**
* Get view configuration from nae.json for view at given config path.
* @param viewConfigPath configuration path to the requested view. No leading backslash.
* @return requested configuration if it exists. `undefined` otherwise.
*/
getViewByPath(viewConfigPath) {
const viewPathSegments = viewConfigPath.split('/');
const configTreePathSegments = ['views'];
for (let i = 0; i < viewPathSegments.length; i++) {
if (i > 0) {
configTreePathSegments.push('children');
}
configTreePathSegments.push(viewPathSegments[i]);
}
return this.getConfigurationSubtree(configTreePathSegments);
}
/**
* Get view configuration from nae.json for view at given url.
* @param url to the requested view. Necessary backslash.
* @return requested configuration if it exists. `undefined` otherwise.
*/
getViewByUrl(url) {
const views = this.getViewsCopy();
if (!views) {
return undefined;
}
let map = new Map();
map = this.getChildren(views, map, '');
if (map.get(url) === undefined) {
for (const [key, value] of map) {
if (key?.includes('/**') && url?.includes(key.split('/**')[0]))
return value;
}
}
return map.get(url);
}
getChildren(views, map, prefix) {
Object.keys(views).forEach(view => {
if (!!views[view].routing.path) {
prefix = prefix.charAt(prefix.length - 1) === '/' ?
prefix.length > 1 ? prefix.substring(0, prefix.length - 2) : '' :
prefix;
const viewPath = views[view].routing.path.charAt(0) === '/' ?
views[view].routing.path.length > 1 ? views[view].routing.path.substring(1) : '' :
views[view].routing.path;
map.set(views[view].routing.match ?
prefix + '/' + viewPath + '/**' :
prefix + '/' + viewPath, views[view]);
}
if (views[view].children) {
this.getChildren(views[view].children, map, prefix + '/' + views[view].routing.path);
}
});
return map;
}
/**
* Get all URLs/paths of views with specified layout.
* @param layout Search views with this layout
* @returns Paths with prefixed '/' of all views with specified layout, empty array otherwise.
*/
getPathsByView(layout) {
const config = this.createConfigurationCopy();
const result = [];
if (!config.views) {
return result;
}
Object.values(config.views).forEach(view => {
result.push(...this.getView(layout, view).map(path => '/' + path));
});
return result;
}
getConfigurationSubtreeByPath(path) {
return this.getConfigurationSubtree(path.split('.'));
}
/**
* @param pathSegments the keys specifying the path trough the configuration that should be accessed
* @returns a deep copy of a specified subsection of the configuration object, or `undefined` if such subsection doesn't exist.
* Calling this method with an empty array as argument is equivalent to calling the [get()]{@link ConfigurationService#get} method.
*/
getConfigurationSubtree(pathSegments) {
let root = this.configuration;
for (const segment of pathSegments) {
if (root[segment] === undefined) {
return undefined;
}
root = root[segment];
}
return this.deepCopy(root);
}
/**
* @returns the appropriate template configuration for data fields, or `undefined` if such configuration is not present.
*/
getDatafieldConfiguration() {
if (this._dataFieldConfiguration === undefined) {
return undefined;
}
return { ...this._dataFieldConfiguration };
}
/**
* Resolves the URL addresses of backend endpoints based on the provided configuration.
*
* If the URLs begin with either `http://`, or `https://` the provided URL will be used.
*
* If not, then the URLs are considered to be relative to the location of the frontend application and it's URL will be used
* as the base path. `/api` is appended automatically.
*/
resolveEndpointURLs() {
if (this.configuration?.providers?.auth?.address === undefined) {
throw new Error(`'provider.auth.address' is a required property and must be present in the configuration!`);
}
this.configuration.providers.auth.address = this.resolveURL(this.configuration.providers.auth.address);
if (this.configuration?.providers?.resources === undefined) {
throw new Error(`'provider.resources' is a required property and must be present in the configuration!`);
}
if (Array.isArray(this.configuration.providers.resources)) {
this.configuration.providers.resources.forEach(resource => {
if (resource?.address === undefined) {
throw new Error(`Resources defined in 'provider.resources' must define an address property!`);
}
resource.address = this.resolveURL(resource.address);
});
}
else {
if (this.configuration?.providers?.resources?.address === undefined) {
throw new Error(`Resources defined in 'provider.resources' must define an address property!`);
}
this.configuration.providers.resources.address = this.resolveURL(this.configuration.providers.resources.address);
}
}
/**
* Resolves a single URL address.
*
* If the URL begins with either `http://`, or `https://` the provided URL will be used.
*
* If not, then the URL is considered to be relative to the location of the frontend application and it's URL will be used
* as the base path. `/api` is appended automatically.
*
* @param configURL value from the configuration file
* @returns the resolved URL
*/
resolveURL(configURL) {
if (configURL.startsWith('http://') || configURL.startsWith('https://')) {
return configURL;
}
else {
return location.origin + '/api' + configURL;
}
}
/**
* @returns the services configuration, or `undefined` if such configuration is not present.
*/
getServicesConfiguration() {
const subtree = this.getConfigurationSubtree(['services']);
return subtree !== undefined ? this.deepCopy(subtree) : undefined;
}
/**
* @returns the value stored in the [onLogoutRedirect]{@link Services#auth.onLogoutRedirect} attribute if defined.
* If not and the deprecated attribute [logoutRedirect]{@link Services#auth.logoutRedirect} is defined then its value is returned.
* Otherwise, `undefined` is returned.
*/
getOnLogoutPath() {
return this.configuration?.services?.auth?.onLogoutRedirect ?? this.configuration?.services?.auth?.logoutRedirect;
}
/**
* @returns the value stored in the [toLoginRedirect]{@link Services#auth.toLoginRedirect} attribute if defined.
* If not and the deprecated attribute [loginRedirect]{@link Services#auth.loginRedirect} is defined then its value is returned.
* Otherwise, `undefined` is returned.
*/
getToLoginPath() {
return this.configuration?.services?.auth?.toLoginRedirect ?? this.configuration?.services?.auth?.loginRedirect;
}
/**
* @returns the value stored in the [onLoginRedirect]{@link Services#auth.onLoginRedirect} attribute if defined.
* Otherwise, `undefined` is returned.
*/
getOnLoginPath() {
return this.configuration?.services?.auth?.onLoginRedirect;
}
getView(searched, view) {
const paths = [];
if (!!view.layout && view.layout.name === searched) {
paths.push(view.routing.path);
}
if (view.children && Object.keys(view.children).length !== 0) {
Object.values(view.children).forEach(child => {
paths.push(...this.getView(searched, child).map(path => view.routing.path + '/' + path));
});
}
return paths;
}
/**
* @param endpointKey the attribute name of the endpoint address in `nae.json`
* @returns the endpoint address or `undefined` if such endpoint is not defined in `nae.json`
*/
resolveProvidersEndpoint(endpointKey) {
const config = this.configuration;
if (!config
|| !config.providers
|| !config.providers.auth
|| !config.providers.auth.address
|| !config.providers.auth.endpoints
|| !config.providers.auth.endpoints[endpointKey]) {
throw new Error('Authentication provider address is not set!');
}
return config.providers.auth.address + config.providers.auth.endpoints[endpointKey];
}
/**
* Loads and initializes application configuration from the backend.
* If configuration resolution is disabled in APPLICATION_CONFIG, returns null Observable.
* Otherwise fetches public configuration via ConfigurationResourceService.
*
* @returns Observable<any> that emits null if resolution is disabled, otherwise emits the loaded configuration
* @fires initialize() Upon successful configuration load to setup endpoints and data field configurations
* @see ApplicationConfiguration
* @see NetgrifApplicationEngine
*/
loadConfiguration() {
if (!this.APPLICATION_CONFIG?.resolve_configuration) {
return of(void 0);
}
return this._configurationResource.getPublicApplicationConfiguration(this.APPLICATION_CONFIG).pipe(catchError((err) => {
if (err.status === 404) {
return of(null);
}
console.log(err.message);
return of(null);
}), tap((data) => {
if (!data?.properties) {
return;
}
this.configuration = data.properties;
this.initialize();
}), take(1), map(() => void 0));
}
createConfigurationCopy() {
return this.deepCopy(this.configuration);
}
getViewsCopy() {
return this.getConfigurationSubtree(['views']);
}
deepCopy(obj) {
return JSON.parse(JSON.stringify(obj));
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"configuration.service.js","sourceRoot":"","sources":["../../../../../projects/netgrif-components-core/src/lib/configuration/configuration.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {NetgrifApplicationEngine, Services, View, Views} from '../../commons/schema';\nimport {BehaviorSubject, Observable, of} from 'rxjs';\nimport {ApplicationConfiguration} from './application-configuration';\nimport {ConfigurationResourceService} from '../resources/engine-endpoint/configuration-resource.service';\nimport {catchError, take, tap, map, distinctUntilChanged} from 'rxjs/operators';\nimport {HttpErrorResponse} from '@angular/common/http';\n\n\nexport abstract class ConfigurationService {\n\n    private _dataFieldConfiguration: Services['dataFields'];\n\n    private readonly APPLICATION_CONFIG: ApplicationConfiguration;\n\n    private readonly _config$ = new BehaviorSubject<NetgrifApplicationEngine | null>(null);\n    public readonly config$: Observable<NetgrifApplicationEngine | null> = this._config$.asObservable();\n    public readonly loaded$: Observable<boolean> = this.config$.pipe(map(cfg => !!cfg), distinctUntilChanged());\n\n    protected constructor(protected configuration: NetgrifApplicationEngine,\n                          protected _configurationResource: ConfigurationResourceService,\n                          protected _applicationConfiguration: ApplicationConfiguration) {\n        this.APPLICATION_CONFIG = _applicationConfiguration;\n        if (!this._applicationConfiguration?.resolve_configuration) {\n            this.initialize();\n        }\n    }\n\n    public get snapshot(): NetgrifApplicationEngine | null {\n        return this.configuration ? (this.createConfigurationCopy() as NetgrifApplicationEngine) : null;\n    }\n\n    private initialize(): void {\n        this.resolveEndpointURLs();\n        this._dataFieldConfiguration = this.getConfigurationSubtree(['services', 'dataFields']);\n        this._config$.next(this.createConfigurationCopy() as NetgrifApplicationEngine);\n    }\n\n    public getAsync(): Observable<NetgrifApplicationEngine> {\n        return of(this.get());\n    }\n\n    /**\n     * Calls to this method should be avoided as creating a deep copy of the configuration has a large overhead\n     *\n     * @returns a deep copy of the entire configuration object\n     */\n    public get(): NetgrifApplicationEngine {\n        return this.createConfigurationCopy();\n    }\n\n    /**\n     * Get view configuration from nae.json for view at given config path.\n     * @param viewConfigPath configuration path to the requested view. No leading backslash.\n     * @return requested configuration if it exists. `undefined` otherwise.\n     */\n    public getViewByPath(viewConfigPath: string): View | undefined {\n        const viewPathSegments = viewConfigPath.split('/');\n        const configTreePathSegments = ['views'];\n        for (let i = 0; i < viewPathSegments.length; i++) {\n            if (i > 0) {\n                configTreePathSegments.push('children');\n            }\n            configTreePathSegments.push(viewPathSegments[i]);\n        }\n        return this.getConfigurationSubtree(configTreePathSegments);\n    }\n\n    /**\n     * Get view configuration from nae.json for view at given url.\n     * @param url to the requested view. Necessary backslash.\n     * @return requested configuration if it exists. `undefined` otherwise.\n     */\n    public getViewByUrl(url: string): View | undefined {\n        const views = this.getViewsCopy();\n        if (!views) {\n            return undefined;\n        }\n        let map: Map<string, View> = new Map();\n        map = this.getChildren(views, map, '');\n        if (map.get(url) === undefined) {\n            for (const [key, value] of map) {\n                if (key?.includes('/**') && url?.includes(key.split('/**')[0]))\n                    return value;\n            }\n        }\n        return map.get(url);\n    }\n\n    private getChildren(views: Views, map: Map<string, View>, prefix: string): Map<string, View> {\n        Object.keys(views).forEach(view => {\n            if (!!views[view].routing.path) {\n                prefix = prefix.charAt(prefix.length - 1) === '/' ?\n                    prefix.length > 1 ? prefix.substring(0, prefix.length - 2) : '' :\n                    prefix;\n                const viewPath = views[view].routing.path.charAt(0) === '/' ?\n                    views[view].routing.path.length > 1 ? views[view].routing.path.substring(1) : '' :\n                    views[view].routing.path;\n                map.set(\n                    views[view].routing.match ?\n                        prefix + '/' + viewPath + '/**' :\n                        prefix + '/' + viewPath,\n                    views[view]);\n            }\n            if (views[view].children) {\n                this.getChildren(views[view].children, map, prefix + '/' + views[view].routing.path);\n            }\n        });\n        return map;\n    }\n\n    /**\n     * Get all URLs/paths of views with specified layout.\n     * @param layout Search views with this layout\n     * @returns Paths with prefixed '/' of all views with specified layout, empty array otherwise.\n     */\n    public getPathsByView(layout: string): Array<string> {\n        const config = this.createConfigurationCopy() as NetgrifApplicationEngine;\n        const result = [];\n        if (!config.views) {\n            return result;\n        }\n        Object.values(config.views).forEach(view => {\n            result.push(...this.getView(layout, view).map(path => '/' + path));\n        });\n\n        return result;\n    }\n\n    public getConfigurationSubtreeByPath(path: string): any | undefined {\n        return this.getConfigurationSubtree(path.split('.'));\n    }\n\n    /**\n     * @param pathSegments the keys specifying the path trough the configuration that should be accessed\n     * @returns a deep copy of a specified subsection of the configuration object, or `undefined` if such subsection doesn't exist.\n     * Calling this method with an empty array as argument is equivalent to calling the [get()]{@link ConfigurationService#get} method.\n     */\n    public getConfigurationSubtree(pathSegments: Array<string>): any | undefined {\n        let root = this.configuration;\n        for (const segment of pathSegments) {\n            if (root[segment] === undefined) {\n                return undefined;\n            }\n            root = root[segment];\n        }\n        return this.deepCopy(root);\n    }\n\n    /**\n     * @returns the appropriate template configuration for data fields, or `undefined` if such configuration is not present.\n     */\n    public getDatafieldConfiguration(): Services['dataFields'] | undefined {\n        if (this._dataFieldConfiguration === undefined) {\n            return undefined;\n        }\n        return {...this._dataFieldConfiguration};\n    }\n\n    /**\n     * Resolves the URL addresses of backend endpoints based on the provided configuration.\n     *\n     * If the URLs begin with either `http://`, or `https://` the provided URL will be used.\n     *\n     * If not, then the URLs are considered to be relative to the location of the frontend application and it's URL will be used\n     * as the base path. `/api` is appended automatically.\n     */\n    protected resolveEndpointURLs() {\n        if (this.configuration?.providers?.auth?.address === undefined) {\n            throw new Error(`'provider.auth.address' is a required property and must be present in the configuration!`);\n        }\n        this.configuration.providers.auth.address = this.resolveURL(this.configuration.providers.auth.address);\n\n        if (this.configuration?.providers?.resources === undefined) {\n            throw new Error(`'provider.resources' is a required property and must be present in the configuration!`);\n        }\n        if (Array.isArray(this.configuration.providers.resources)) {\n            this.configuration.providers.resources.forEach(resource => {\n                if (resource?.address === undefined) {\n                    throw new Error(`Resources defined in 'provider.resources' must define an address property!`);\n                }\n                resource.address = this.resolveURL(resource.address);\n            });\n        } else {\n            if (this.configuration?.providers?.resources?.address === undefined) {\n                throw new Error(`Resources defined in 'provider.resources' must define an address property!`);\n            }\n            this.configuration.providers.resources.address = this.resolveURL(this.configuration.providers.resources.address);\n        }\n    }\n\n    /**\n     * Resolves a single URL address.\n     *\n     * If the URL begins with either `http://`, or `https://` the provided URL will be used.\n     *\n     * If not, then the URL is considered to be relative to the location of the frontend application and it's URL will be used\n     * as the base path. `/api` is appended automatically.\n     *\n     * @param configURL value from the configuration file\n     * @returns the resolved URL\n     */\n    protected resolveURL(configURL: string): string {\n        if (configURL.startsWith('http://') || configURL.startsWith('https://')) {\n            return configURL;\n        } else {\n            return location.origin + '/api' + configURL;\n        }\n    }\n\n    /**\n     * @returns the services configuration, or `undefined` if such configuration is not present.\n     */\n    public getServicesConfiguration(): Services | undefined {\n        const subtree = this.getConfigurationSubtree(['services']) as Services;\n        return subtree !== undefined ? this.deepCopy(subtree) as Services : undefined;\n    }\n\n    /**\n     * @returns the value stored in the [onLogoutRedirect]{@link Services#auth.onLogoutRedirect} attribute if defined.\n     * If not and the deprecated attribute [logoutRedirect]{@link Services#auth.logoutRedirect} is defined then its value is returned.\n     * Otherwise, `undefined` is returned.\n     */\n    public getOnLogoutPath(): string | undefined {\n        return this.configuration?.services?.auth?.onLogoutRedirect ?? this.configuration?.services?.auth?.logoutRedirect;\n    }\n\n    /**\n     * @returns the value stored in the [toLoginRedirect]{@link Services#auth.toLoginRedirect} attribute if defined.\n     * If not and the deprecated attribute [loginRedirect]{@link Services#auth.loginRedirect} is defined then its value is returned.\n     * Otherwise, `undefined` is returned.\n     */\n    public getToLoginPath(): string | undefined {\n        return this.configuration?.services?.auth?.toLoginRedirect ?? this.configuration?.services?.auth?.loginRedirect;\n    }\n\n    /**\n     * @returns the value stored in the [onLoginRedirect]{@link Services#auth.onLoginRedirect} attribute if defined.\n     * Otherwise, `undefined` is returned.\n     */\n    public getOnLoginPath(): string | undefined {\n        return this.configuration?.services?.auth?.onLoginRedirect;\n    }\n\n    private getView(searched: string, view: View): Array<string> {\n        const paths = [];\n        if (!!view.layout && view.layout.name === searched) {\n            paths.push(view.routing.path);\n        }\n        if (view.children && Object.keys(view.children).length !== 0) {\n            Object.values(view.children).forEach(child => {\n                paths.push(...this.getView(searched, child).map(path => view.routing.path + '/' + path));\n            });\n        }\n        return paths;\n    }\n\n    /**\n     * @param endpointKey the attribute name of the endpoint address in `nae.json`\n     * @returns the endpoint address or `undefined` if such endpoint is not defined in `nae.json`\n     */\n    public resolveProvidersEndpoint(endpointKey: string): string {\n        const config = this.configuration;\n        if (!config\n            || !config.providers\n            || !config.providers.auth\n            || !config.providers.auth.address\n            || !config.providers.auth.endpoints\n            || !config.providers.auth.endpoints[endpointKey]) {\n            throw new Error('Authentication provider address is not set!');\n        }\n        return config.providers.auth.address + config.providers.auth.endpoints[endpointKey];\n    }\n\n    /**\n     * Loads and initializes application configuration from the backend.\n     * If configuration resolution is disabled in APPLICATION_CONFIG, returns null Observable.\n     * Otherwise fetches public configuration via ConfigurationResourceService.\n     *\n     * @returns Observable<any> that emits null if resolution is disabled, otherwise emits the loaded configuration\n     * @fires initialize() Upon successful configuration load to setup endpoints and data field configurations\n     * @see ApplicationConfiguration\n     * @see NetgrifApplicationEngine\n     */\n    public loadConfiguration(): Observable<void> {\n        if (!this.APPLICATION_CONFIG?.resolve_configuration) {\n            return of(void 0);\n        }\n\n        return this._configurationResource.getPublicApplicationConfiguration(this.APPLICATION_CONFIG).pipe(\n            catchError((err: HttpErrorResponse) => {\n                if (err.status === 404) {\n                    return of(null);\n                }\n                console.log(err.message);\n                return of(null);\n            }),\n            tap((data: ApplicationConfiguration | null) => {\n                if (!data?.properties) {\n                    return;\n                }\n                this.configuration = data.properties as NetgrifApplicationEngine;\n                this.initialize();\n            }),\n            take(1),\n            map(() => void 0)\n        );\n    }\n\n    private createConfigurationCopy(): any {\n        return this.deepCopy(this.configuration);\n    }\n\n    private getViewsCopy(): Views {\n        return this.getConfigurationSubtree(['views']) as Views;\n    }\n\n    private deepCopy(obj: object): object {\n        return JSON.parse(JSON.stringify(obj));\n    }\n}\n"]}