@vcd/sdk 0.13.0 → 15.0.0

package/esm2020/client/client/request.headers.interceptor.mjs

@@ -0,0 +1,91 @@
+import { Injectable } from '@angular/core';
+import { HttpResponse } from '@angular/common/http';
+import { map } from 'rxjs/operators';
+import { parseHeaderHateoasLinks } from '.';
+import { HTTP_HEADERS } from './constants';
+import * as i0 from "@angular/core";
+// tslint:disable:variable-name
+export class RequestHeadersInterceptor {
+    constructor() {
+        this._enabled = true;
+        this._version = '';
+        this._authenticationHeader = HTTP_HEADERS.Authorization;
+    }
+    set enabled(_enabled) {
+        this._enabled = _enabled;
+    }
+    set actAs(_actAs) {
+        this._actAs = _actAs;
+    }
+    get version() {
+        return this._version;
+    }
+    set version(_version) {
+        this._version = _version;
+    }
+    set authentication(_authentication) {
+        this._authentication = _authentication;
+        this._authenticationHeader = (this._authentication && this._authentication.length > 32) ?
+            HTTP_HEADERS.Authorization : HTTP_HEADERS.x_vcloud_authorization;
+    }
+    intercept(req, next) {
+        let headers = req.headers;
+        if (!headers.has('Accept')) {
+            headers = this.setAcceptHeader(headers);
+        }
+        if (!headers.has('Content-Type')) {
+            headers = this.setContentTypeHeader(headers, req.url);
+        }
+        if (this._authentication && !headers.has(HTTP_HEADERS.Authorization)) {
+            headers = headers.set(this._authenticationHeader, this._authentication);
+        }
+        /**
+         * Covers the case where the User set the ActAs token himself
+         */
+        if (!headers.has('X-VMWARE-VCLOUD-TENANT-CONTEXT') && this._actAs) {
+            headers = headers.set('X-VMWARE-VCLOUD-TENANT-CONTEXT', this._actAs);
+        }
+        const customReq = req.clone({
+            headers
+        });
+        return next.handle(customReq).pipe(map((res) => {
+            if (res instanceof HttpResponse) {
+                if (!res.body || !res.headers) {
+                    return res;
+                }
+                if (res.headers.has(HTTP_HEADERS.link)) {
+                    res.body.link = parseHeaderHateoasLinks(res.headers.get(HTTP_HEADERS.link));
+                }
+                if (res.headers.has(HTTP_HEADERS.Link)) {
+                    res.body.link = parseHeaderHateoasLinks(res.headers.get(HTTP_HEADERS.Link));
+                }
+                if (res.headers.has(HTTP_HEADERS.etag)) {
+                    res.body.etag = res.headers.get(HTTP_HEADERS.etag);
+                }
+            }
+            return res;
+        }));
+    }
+    setAcceptHeader(headers) {
+        const value = headers.get('_multisite');
+        headers = headers.delete('_multisite');
+        return headers.set('Accept', [
+            `application/*+json;version=${this._version}${value ? `;multisite=${value}` : ''}`,
+            `application/json;version=${this._version}${value ? `;multisite=${value}` : ''}`
+        ]);
+    }
+    setContentTypeHeader(headers, url) {
+        if (url.indexOf('cloudapi') > -1) {
+            return headers.set('Content-Type', 'application/json');
+        }
+        else {
+            return headers.set('Content-Type', 'application/*+json');
+        }
+    }
+}
+RequestHeadersInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.0", ngImport: i0, type: RequestHeadersInterceptor, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+RequestHeadersInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.0", ngImport: i0, type: RequestHeadersInterceptor });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.0", ngImport: i0, type: RequestHeadersInterceptor, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"request.headers.interceptor.js","sourceRoot":"","sources":["../../../../../../projects/vcd/sdk/src/client/client/request.headers.interceptor.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { HttpHandler, HttpInterceptor, HttpRequest, HttpEvent, HttpHeaders, HttpResponse } from '@angular/common/http';\nimport { Observable } from 'rxjs';\nimport { map } from 'rxjs/operators';\nimport { parseHeaderHateoasLinks } from '.';\nimport { HTTP_HEADERS } from './constants';\n\n// tslint:disable:variable-name\n@Injectable()\nexport class RequestHeadersInterceptor implements HttpInterceptor {\n    private _enabled = true;\n    set enabled(_enabled: boolean) {\n        this._enabled = _enabled;\n    }\n\n    private _actAs: string;\n    set actAs(_actAs: string) {\n        this._actAs = _actAs;\n    }\n\n    private _version = '';\n    get version(): string {\n        return this._version;\n    }\n    set version(_version: string) {\n        this._version = _version;\n    }\n\n    private _authenticationHeader: string = HTTP_HEADERS.Authorization;\n    private _authentication: string;\n    set authentication(_authentication: string) {\n        this._authentication = _authentication;\n        this._authenticationHeader = (this._authentication && this._authentication.length > 32) ?\n            HTTP_HEADERS.Authorization : HTTP_HEADERS.x_vcloud_authorization;\n    }\n\n    intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {\n        let headers = req.headers;\n\n        if (!headers.has('Accept')) {\n            headers = this.setAcceptHeader(headers);\n        }\n\n        if (!headers.has('Content-Type')) {\n            headers = this.setContentTypeHeader(headers, req.url);\n        }\n\n        if (this._authentication && !headers.has(HTTP_HEADERS.Authorization)) {\n            headers = headers.set(this._authenticationHeader, this._authentication);\n        }\n\n        /**\n         * Covers the case where the User set the ActAs token himself\n         */\n        if (!headers.has('X-VMWARE-VCLOUD-TENANT-CONTEXT') && this._actAs) {\n            headers = headers.set('X-VMWARE-VCLOUD-TENANT-CONTEXT', this._actAs);\n        }\n\n        const customReq: HttpRequest<any> = req.clone({\n            headers\n        });\n\n        return next.handle(customReq).pipe(\n            map((res: HttpEvent<any>) => {\n                if (res instanceof HttpResponse) {\n                    if (!res.body || !res.headers) {\n                        return res;\n                    }\n\n                    if (res.headers.has(HTTP_HEADERS.link)) {\n                        res.body.link = parseHeaderHateoasLinks(res.headers.get(HTTP_HEADERS.link));\n                    }\n\n                    if (res.headers.has(HTTP_HEADERS.Link)) {\n                        res.body.link = parseHeaderHateoasLinks(res.headers.get(HTTP_HEADERS.Link));\n                    }\n\n                    if (res.headers.has(HTTP_HEADERS.etag)) {\n                        res.body.etag = res.headers.get(HTTP_HEADERS.etag);\n                    }\n                }\n                return res;\n            })\n        );\n    }\n\n    private setAcceptHeader(headers: HttpHeaders): HttpHeaders {\n        const value = headers.get('_multisite');\n        headers = headers.delete('_multisite');\n\n        return headers.set(\n            'Accept', [\n                `application/*+json;version=${this._version}${value ? `;multisite=${value}` : ''}`,\n                `application/json;version=${this._version}${value ? `;multisite=${value}` : ''}`\n            ]\n        );\n    }\n\n    private setContentTypeHeader(headers: HttpHeaders, url: string): HttpHeaders {\n        if (url.indexOf('cloudapi') > -1) {\n            return headers.set('Content-Type', 'application/json');\n        } else {\n            return headers.set('Content-Type', 'application/*+json');\n        }\n    }\n}\n"]}

package/esm2020/client/client/response.normalization.interceptor.mjs

@@ -0,0 +1,59 @@
+import { Injectable } from '@angular/core';
+import { HttpResponse } from '@angular/common/http';
+import { map } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+// tslint:disable:jsdoc-format
+/**
+ * An interceptor on the response chain that normalizes differences in
+ * JSON payloads between vCloud Director version 9.1 and versions
+ * greater than 9.1.
+ *
+ * In 9.1 (API version 30.0) the server serializes JSON and nests the payload in a value field:
+ * ```
+  {
+    "name" : "{http://www.vmware.com/vcloud/versions}SupportedVersions",
+    "declaredType" : "com.vmware.vcloud.api.rest.schema.versioning.SupportedVersionsType",
+    "scope" : "javax.xml.bind.JAXBElement$GlobalScope",
+    "value" : {
+      "versionInfo" : [],
+      "any" : [],
+      "otherAttributes" : {}
+    }
+  }
+  ```
+ *
+ * That same request in API versions 31.0 and above is represented as:
+ * ```
+  {
+    "versionInfo" : [],
+    "any" : [],
+    "otherAttributes" : {}
+  }
+  ```
+ * This interceptor should process responses before any other interceptors that rely
+ * on consistent API information.
+ */
+export class ResponseNormalizationInterceptor {
+    intercept(req, next) {
+        return next.handle(req).pipe(map(response => {
+            // While this condition seems awfully specific, the alternative option of examining the 'Content-Type'
+            // response header for 'version=30.0' proved to be an unreliable condition in at least one case;
+            // returning the same JSON payload as API versions >= 31.0.
+            if (response instanceof HttpResponse && response.body && response.body.value && response.body.declaredType && response.body.scope) {
+                const body = response.body.value;
+                if (response.body.declaredType === ResponseNormalizationInterceptor.QUERY_RESULT_TYPE) {
+                    body.record = body.record.map(record => record.value);
+                }
+                return response.clone({ body });
+            }
+            return response;
+        }));
+    }
+}
+ResponseNormalizationInterceptor.QUERY_RESULT_TYPE = 'com.vmware.vcloud.api.rest.schema_v1_5.QueryResultRecordsType';
+ResponseNormalizationInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.0", ngImport: i0, type: ResponseNormalizationInterceptor, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+ResponseNormalizationInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.0", ngImport: i0, type: ResponseNormalizationInterceptor });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.0", ngImport: i0, type: ResponseNormalizationInterceptor, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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