@knora/core
Version:
Knora ui module: core
249 lines • 31.9 kB
JavaScript
import * as tslib_1 from "tslib";
import { HttpClient, HttpErrorResponse, HttpHeaders, HttpParams, HttpResponse } from '@angular/common/http';
import { Inject, Injectable } from '@angular/core';
import { KnoraApiConfig } from '@knora/api';
import { from } from 'rxjs';
import { throwError } from 'rxjs/internal/observable/throwError';
import { catchError, map } from 'rxjs/operators';
import { KnoraApiConfigToken } from '../core.module';
import { ApiServiceError } from '../declarations/api-service-error';
import { ApiServiceResult } from '../declarations/api-service-result';
import { KnoraConstants } from '../declarations/api/knora-constants';
import * as i0 from "@angular/core";
import * as i1 from "@angular/common/http";
import * as i2 from "../core.module";
var jsonld = require('jsonld');
var semver = require('semver');
var ApiService = /** @class */ (function () {
function ApiService(http, knoraApiConfig) {
this.http = http;
this.knoraApiConfig = knoraApiConfig;
// if is loading, set it true;
// it can be used in components
// for progress loader element
this.loading = false;
}
/**
* @deprecated since v9.5.0
*
* GET
*
* @param {string} path the URL for the GET request.
* @param {HttpParams} params the parameters for the GET request.
* @returns Observable of any
*/
ApiService.prototype.httpGet = function (path, params) {
var _this = this;
this.loading = true;
var headers = this.setHeaders();
return this.http.get(this.knoraApiConfig.apiUrl + path, { headers: headers, observe: 'response', params: params }).pipe(map(function (response) {
_this.loading = false;
var result = new ApiServiceResult();
result.header = { 'server': response.headers.get('Server') };
_this.compareVersion(response.headers.get('Server'));
result.status = response.status;
result.statusText = response.statusText;
result.url = path;
result.body = response.body;
return result;
}), catchError(function (error) {
_this.loading = false;
return _this.handleRequestError(error);
}));
};
/**
* @deprecated since v9.5.0
*
* Processes JSON-LD returned by Knora.
* Expands Iris and creates an empty context object.
*
* @param {ApiServiceResult} resourceResponse
*/
ApiService.prototype.processJSONLD = function (resourceResponse) {
var resPromises = jsonld.promises;
// compact JSON-LD using an empty context: expands all Iris
var resPromise = resPromises.compact(resourceResponse.body, {});
// convert promise to Observable and return it
// https://www.learnrxjs.io/operators/creation/frompromise.html
return from(resPromise);
};
/**
* @deprecated since v9.5.0
*
* POST
*
* @param {string} path
* @param {any} body
* @returns Observable of any
*/
ApiService.prototype.httpPost = function (path, body) {
var _this = this;
this.loading = true;
var headers = this.setHeaders();
return this.http.post(this.knoraApiConfig.apiUrl + path, body, { headers: headers, observe: 'response' }).pipe(map(function (response) {
_this.loading = false;
var result = new ApiServiceResult();
result.header = { 'server': response.headers.get('Server') };
_this.compareVersion(result.header.server);
result.status = response.status;
result.statusText = response.statusText;
result.url = path;
result.body = response.body;
return result;
}), catchError(function (error) {
_this.loading = false;
// console.error(error);
return _this.handleRequestError(error);
}));
};
/**
* @deprecated since v9.5.0
*
* PUT
*
* @param {string} path
* @param {any} body
* @returns Observable of any
*/
ApiService.prototype.httpPut = function (path, body) {
var _this = this;
this.loading = true;
var headers = this.setHeaders();
return this.http.put(this.knoraApiConfig.apiUrl + path, body, { headers: headers, observe: 'response' }).pipe(map(function (response) {
_this.loading = false;
// console.log(response);
var result = new ApiServiceResult();
result.header = { 'server': response.headers.get('Server') };
_this.compareVersion(result.header.server);
result.status = response.status;
result.statusText = response.statusText;
result.url = path;
result.body = response.body;
return result;
}), catchError(function (error) {
_this.loading = false;
// console.error(error);
return _this.handleRequestError(error);
}));
};
/**
* @deprecated since v9.5.0
*
* DELETE
*
* @param {string} path
* @returns Observable of any
*/
ApiService.prototype.httpDelete = function (path) {
var _this = this;
this.loading = true;
var headers = this.setHeaders();
return this.http.delete(this.knoraApiConfig.apiUrl + path, { headers: headers, observe: 'response' }).pipe(map(function (response) {
_this.loading = false;
// console.log(response);
var result = new ApiServiceResult();
result.header = { 'server': response.headers.get('Server') };
_this.compareVersion(result.header.server);
result.status = response.status;
result.statusText = response.statusText;
result.url = path;
result.body = response.body;
return result;
}), catchError(function (error) {
_this.loading = false;
// console.error(error);
return _this.handleRequestError(error);
}));
};
/**
* handle request error in case of server error
*
* @param {HttpErrorResponse} error
* @returns Observable of ApiServiceError
*/
ApiService.prototype.handleRequestError = function (error) {
// console.error(error);
var serviceError = new ApiServiceError();
serviceError.header = { 'server': error.headers.get('Server') };
serviceError.status = error.status;
serviceError.statusText = error.statusText;
serviceError.errorInfo = error.message;
serviceError.url = error.url;
return throwError(serviceError);
};
/**
* handle json error in case of type error in json response (json2typescript)
*
* @param {any} error
* @returns Observable of ApiServiceError
*/
ApiService.prototype.handleJsonError = function (error) {
if (error instanceof ApiServiceError)
return throwError(error);
var serviceError = new ApiServiceError();
serviceError.header = { 'server': error.headers.get('Server') };
serviceError.status = -1;
serviceError.statusText = 'Invalid JSON';
serviceError.errorInfo = error;
serviceError.url = '';
return throwError(serviceError);
};
/**
* @deprecated since v9.5.0
*
* @param {string} server
*/
ApiService.prototype.compareVersion = function (server) {
// expected knora api version
var expected = KnoraConstants.KnoraVersion;
// existing knora api version
if (server) {
var versions = server.split(' ');
var existing = versions[0].split('/')[1];
// compare the two versions: expected vs existing
if (semver.diff(existing, expected) === 'major') {
console.warn('The version of the @knora/core module works with Knora v' + expected + ', but you are using it with Knora v' + existing);
}
}
else {
// console.warn('No server information from headers response');
}
};
/**
* Set headers to authorise http requests
*
* This method was replaced by interceptor. But since the implementation
* of new knora-api-js-lib services the interceptor is redundant.
* As long we not all services are replaced by knora-api-js-lib
* we have to use this setHeaders "hack" for the two services left.
*
* @returns HttpHeaders
*/
ApiService.prototype.setHeaders = function () {
var session = JSON.parse(localStorage.getItem('session'));
if (session && session !== null) {
return new HttpHeaders({
'Authorization': "Bearer " + session.user.jwt
});
}
else {
return new HttpHeaders();
}
};
ApiService.ctorParameters = function () { return [
{ type: HttpClient },
{ type: KnoraApiConfig, decorators: [{ type: Inject, args: [KnoraApiConfigToken,] }] }
]; };
ApiService.ngInjectableDef = i0.ɵɵdefineInjectable({ factory: function ApiService_Factory() { return new ApiService(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(i2.KnoraApiConfigToken)); }, token: ApiService, providedIn: "root" });
ApiService = tslib_1.__decorate([
Injectable({
providedIn: 'root',
}),
tslib_1.__param(1, Inject(KnoraApiConfigToken)),
tslib_1.__metadata("design:paramtypes", [HttpClient,
KnoraApiConfig])
], ApiService);
return ApiService;
}());
export { ApiService };
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api.service.js","sourceRoot":"ng://@knora/core/","sources":["lib/services/api.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient, HttpErrorResponse, HttpHeaders, HttpParams, HttpResponse } from '@angular/common/http';\nimport { Inject, Injectable } from '@angular/core';\nimport { KnoraApiConfig } from '@knora/api';\nimport { from } from 'rxjs';\nimport { Observable } from 'rxjs/internal/Observable';\nimport { throwError } from 'rxjs/internal/observable/throwError';\nimport { catchError, map } from 'rxjs/operators';\n\nimport { KnoraApiConfigToken } from '../core.module';\nimport { ApiServiceError } from '../declarations/api-service-error';\nimport { ApiServiceResult } from '../declarations/api-service-result';\nimport { KnoraConstants } from '../declarations/api/knora-constants';\nimport { Session } from '../session.service';\n\ndeclare let require: any; // http://stackoverflow.com/questions/34730010/angular2-5-minute-install-bug-require-is-not-defined\nconst jsonld = require('jsonld');\n\nconst semver = require('semver');\n\n@Injectable({\n    providedIn: 'root',\n})\nexport abstract class ApiService {\n\n    // if is loading, set it true;\n    // it can be used in components\n    // for progress loader element\n    loading = false;\n\n    knoraApiUrl: string;\n\n    protected constructor(\n        public http: HttpClient,\n        @Inject(KnoraApiConfigToken) private knoraApiConfig: KnoraApiConfig\n    ) { }\n\n    /**\n     * @deprecated since v9.5.0\n     *\n     * GET\n     *\n     * @param {string} path the URL for the GET request.\n     * @param {HttpParams} params the parameters for the GET request.\n     * @returns Observable of any\n     */\n    httpGet(path: string, params?: HttpParams): Observable<any> {\n\n        this.loading = true;\n\n        const headers = this.setHeaders();\n\n        return this.http.get(this.knoraApiConfig.apiUrl + path, { headers: headers, observe: 'response', params: params }).pipe(\n            map((response: HttpResponse<any>): ApiServiceResult => {\n                this.loading = false;\n\n                const result = new ApiServiceResult();\n                result.header = { 'server': response.headers.get('Server') };\n                this.compareVersion(response.headers.get('Server'));\n                result.status = response.status;\n                result.statusText = response.statusText;\n                result.url = path;\n                result.body = response.body;\n\n                return result;\n            }),\n            catchError((error: HttpErrorResponse) => {\n                this.loading = false;\n\n                return this.handleRequestError(error);\n            })\n        );\n\n    }\n\n    /**\n     * @deprecated since v9.5.0\n     *\n     * Processes JSON-LD returned by Knora.\n     * Expands Iris and creates an empty context object.\n     *\n     * @param {ApiServiceResult} resourceResponse\n     */\n    protected processJSONLD(resourceResponse: ApiServiceResult): Observable<any> {\n\n        const resPromises = jsonld.promises;\n\n\n        // compact JSON-LD using an empty context: expands all Iris\n        const resPromise = resPromises.compact(resourceResponse.body, {});\n\n        // convert promise to Observable and return it\n        // https://www.learnrxjs.io/operators/creation/frompromise.html\n        return from(resPromise);\n\n    }\n\n    /**\n     * @deprecated since v9.5.0\n     *\n     * POST\n     *\n     * @param {string} path\n     * @param {any} body\n     * @returns Observable of any\n     */\n    httpPost(path: string, body?: any): Observable<any> {\n\n        this.loading = true;\n\n        const headers = this.setHeaders();\n\n        return this.http.post(this.knoraApiConfig.apiUrl + path, body, { headers: headers, observe: 'response' }).pipe(\n            map((response: HttpResponse<any>): ApiServiceResult => {\n                this.loading = false;\n\n                const result = new ApiServiceResult();\n                result.header = { 'server': response.headers.get('Server') };\n                this.compareVersion(result.header.server);\n                result.status = response.status;\n                result.statusText = response.statusText;\n                result.url = path;\n                result.body = response.body;\n                return result;\n            }),\n            catchError((error: HttpErrorResponse) => {\n                this.loading = false;\n\n                // console.error(error);\n\n                return this.handleRequestError(error);\n            })\n        );\n\n    }\n\n    /**\n     * @deprecated since v9.5.0\n     *\n     * PUT\n     *\n     * @param {string} path\n     * @param {any} body\n     * @returns Observable of any\n     */\n    httpPut(path: string, body?: any): Observable<any> {\n\n        this.loading = true;\n\n        const headers = this.setHeaders();\n\n        return this.http.put(this.knoraApiConfig.apiUrl + path, body, { headers: headers, observe: 'response' }).pipe(\n            map((response: HttpResponse<any>): ApiServiceResult => {\n                this.loading = false;\n\n                // console.log(response);\n\n                const result = new ApiServiceResult();\n                result.header = { 'server': response.headers.get('Server') };\n                this.compareVersion(result.header.server);\n                result.status = response.status;\n                result.statusText = response.statusText;\n                result.url = path;\n                result.body = response.body;\n                return result;\n\n            }),\n            catchError((error: HttpErrorResponse) => {\n                this.loading = false;\n\n                // console.error(error);\n\n                return this.handleRequestError(error);\n            })\n        );\n    }\n\n    /**\n     * @deprecated since v9.5.0\n     *\n     * DELETE\n     *\n     * @param {string} path\n     * @returns Observable of any\n     */\n    httpDelete(path: string): Observable<any> {\n\n        this.loading = true;\n\n        const headers = this.setHeaders();\n\n        return this.http.delete(this.knoraApiConfig.apiUrl + path, { headers: headers, observe: 'response' }).pipe(\n            map((response: HttpResponse<any>): ApiServiceResult => {\n                this.loading = false;\n\n                // console.log(response);\n\n                const result = new ApiServiceResult();\n                result.header = { 'server': response.headers.get('Server') };\n                this.compareVersion(result.header.server);\n                result.status = response.status;\n                result.statusText = response.statusText;\n                result.url = path;\n                result.body = response.body;\n                return result;\n\n            }),\n            catchError((error: HttpErrorResponse) => {\n                this.loading = false;\n\n                // console.error(error);\n\n                return this.handleRequestError(error);\n            })\n        );\n    }\n\n\n    /**\n     * handle request error in case of server error\n     *\n     * @param {HttpErrorResponse} error\n     * @returns Observable of ApiServiceError\n     */\n    protected handleRequestError(error: HttpErrorResponse): Observable<ApiServiceError> {\n        // console.error(error);\n        const serviceError = new ApiServiceError();\n        serviceError.header = { 'server': error.headers.get('Server') };\n        serviceError.status = error.status;\n        serviceError.statusText = error.statusText;\n        serviceError.errorInfo = error.message;\n        serviceError.url = error.url;\n        return throwError(serviceError);\n    }\n\n    /**\n     * handle json error in case of type error in json response (json2typescript)\n     *\n     * @param {any} error\n     * @returns Observable of ApiServiceError\n     */\n    protected handleJsonError(error: any): Observable<ApiServiceError> {\n\n        if (error instanceof ApiServiceError) return throwError(error);\n\n        const serviceError = new ApiServiceError();\n        serviceError.header = { 'server': error.headers.get('Server') };\n        serviceError.status = -1;\n        serviceError.statusText = 'Invalid JSON';\n        serviceError.errorInfo = error;\n        serviceError.url = '';\n        return throwError(serviceError);\n\n    }\n    /**\n     * @deprecated since v9.5.0\n     *\n     * @param  {string} server\n     */\n    protected compareVersion(server: string): void {\n\n        // expected knora api version\n        const expected: string = KnoraConstants.KnoraVersion;\n\n        // existing knora api version\n        if (server) {\n            const versions: string[] = server.split(' ');\n            const existing: string = versions[0].split('/')[1];\n\n            // compare the two versions: expected vs existing\n            if (semver.diff(existing, expected) === 'major') {\n                console.warn('The version of the @knora/core module works with Knora v' + expected + ', but you are using it with Knora v' + existing);\n            }\n        } else {\n            // console.warn('No server information from headers response');\n        }\n    }\n\n    /**\n     * Set headers to authorise http requests\n     *\n     * This method was replaced by interceptor. But since the implementation\n     * of new knora-api-js-lib services the interceptor is redundant.\n     * As long we not all services are replaced by knora-api-js-lib\n     * we have to use this setHeaders \"hack\" for the two services left.\n     *\n     * @returns HttpHeaders\n     */\n    protected setHeaders(): HttpHeaders {\n        const session: Session = JSON.parse(localStorage.getItem('session'));\n\n        if (session && session !== null) {\n            return new HttpHeaders({\n                'Authorization': `Bearer ${session.user.jwt}`\n            });\n        } else {\n            return new HttpHeaders();\n        }\n    }\n}\n"]}