@progress/sitefinity-webservices-sdk 0.3.1 → 1.0.3

package/src/Requests/ExecutableRequest.ts

@@ -1,138 +1,111 @@
-import { RequestBase } from './Request';
+import { RequestBase, RequestOptionsBaseExtended } from './RequestBase';
 import { utils } from '../utils';
+import { HEADER_NAMES } from "../constants";
+import { SDKOptions, Token } from "../Sitefinity";
 
-var headerNames = require("../Headers").headerNames;
-var XMLHttpRequestDone = 4;
+const XMLHttpRequestDone = 4;
 
-function isFunction(func) {
-    return typeof func === 'function';
-}
-
-export class ExecutableRequest {
-    private request: RequestBase;
-    private handlers: any;
-    private token: any;
+export class ExecutableRequest extends RequestBase {
+    private token: Token;
     private enableUnlimitedChoices: boolean;
     private integrationMode: boolean;
 
-    constructor(options: any) {
-        this.request = options.request;
-        this.handlers = options.handlers;
-        this.token = options.token;
-        this.enableUnlimitedChoices = options.enableUnlimitedChoices;
-        this.integrationMode = options.integrationMode;
+    constructor(requestOptions: RequestOptionsBaseExtended, token: Token, sdkOptions: SDKOptions) {
+        super(requestOptions);
+        this.token = token;
+        this.successCb = this.successCb || sdkOptions.handlers?.successCb;
+        this.failureCb = this.failureCb || sdkOptions.handlers?.failureCb;
+        this.enableUnlimitedChoices = sdkOptions.enableUnlimitedChoices;
+        this.integrationMode = sdkOptions.integrationMode;
     }
 
     execute() {
-        this._execute();
-    }
-
-    _execute() {
-        var http = new XMLHttpRequest();
+        const http = new XMLHttpRequest();
 
         http.onreadystatechange = () => {
             if (http.readyState === XMLHttpRequestDone) {
                 if (http.status > 0) {
-                    var data = this.request._parseResponse(http);
+                    let data = this.parseResponse(http);
 
                     if (http.status >= 200 && http.status <= 206) {
 
-                        if (isFunction(this.request.successCb)) {
-                            this.request.successCb(data);
-                        }
-
-                        if (this.handlers && isFunction(this.handlers.successCb)) {
-                            this.handlers.successCb(data);
+                        if (utils.isFunction(this.successCb)) {
+                            this.successCb(data);
                         }
                     }
                     else if (http.status >= 400) {
                         // When the data is string, we save the string as message
                         // and convert the data to normal object with message property
                         if (utils.isString(data)) {
-                            var message = data;
                             data = {
-                                message: message
+                                message: data
                             };
                         }
 
                         data.status = http.status;
 
                         // in case of errors we would like there to be one handler for all of the errors
-                        if (isFunction(this.request.failureCb)) {
-                            this.request.failureCb(data);
-                        }
-
-                        if (this.handlers && isFunction(this.handlers.failureCb)) {
-                            this.handlers.failureCb(data);
+                        if (utils.isFunction(this.failureCb)) {
+                            this.failureCb(data);
                         }
                     }
                 }
             }
         };
 
-        if (isFunction(this.request.progressCb)) {
+        if (utils.isFunction(this.progressCb)) {
             if (http.upload) {
-                var that = this;
-                http.upload.onprogress = function (event) {
-                    that.request.progressCb(event);
+                http.upload.onprogress = (event) => {
+                    this.progressCb(event);
                 };
             }
         }
 
-        var method = this._getMethod();
-        var url = this._buildUrl();
+        const method = this.getMethod();
+        const url = this.buildUrl();
         http.open(method, url, true);
-        this.setHeaders(http, this._getHeaders());
+        this.setHeaders(http, this.getHeaders());
 
-        http.send(this._getBody());
+        http.send(utils.serializeToJSON(this.getBody()));
     }
 
-    setHeaders(http: any, headers: any) {
-        var headerKeys = Object.keys(headers);
-        for (var i = 0; i < headerKeys.length; i++) {
-            var currentHeaderName = headerKeys[i];
+    private setHeaders(http: XMLHttpRequest, headers: { [key: string]: string }) {
+        const headerKeys = Object.keys(headers);
+        for (let i = 0; i < headerKeys.length; i++) {
+            const currentHeaderName = headerKeys[i];
             http.setRequestHeader(currentHeaderName, headers[currentHeaderName]);
         }
 
         if (this.token) {
             if (typeof this.token === 'string') {
                 // for backward compatibility
-                http.setRequestHeader(headerNames.authorization, this.token);
+                http.setRequestHeader(HEADER_NAMES.authorization, this.token);
             } else {
-                http.setRequestHeader(headerNames.authorization, this.token.type + " " + this.token.value);
+                http.setRequestHeader(HEADER_NAMES.authorization, this.token.type + " " + this.token.value);
             }
         }
 
         if (this.enableUnlimitedChoices) {
-            http.setRequestHeader(headerNames.choicesBinaryRepresentation, true);
+            http.setRequestHeader(HEADER_NAMES.choicesBinaryRepresentation, "true");
         }
 
         if (this.integrationMode) {
-            http.setRequestHeader(headerNames.integrationMode, "true");
+            http.setRequestHeader(HEADER_NAMES.integrationMode, "true");
         }
 
         // for backward compatibility
-        http.setRequestHeader(headerNames.serviceRequest, "true");
-    }
-
-    _getBody() {
-        var body = utils.serializeToJSON(this.request._getBody());
-        return body;
-    }
-
-    _getMethod = function() {
-        return this.request._getMethod();
-    }
-
-    _getHeaders = function () {
-        return this.request._getHeaders();
+        http.setRequestHeader(HEADER_NAMES.serviceRequest, "true");
     }
+}
 
-    _getQueryString = function (urlOptions: any) {
-        return this.request._getQueryString(urlOptions);
-    }
+export interface ResponseHandlers {
+    /**
+    * The success handler.
+    */
+    successCb?: Function;
 
-    _buildUrl = function () {
-        return this.request._buildUrl();
-    }
+    /**
+    * The failure handler.
+    */
+    failureCb?: Function;
 }

package/src/Requests/Request.ts

@@ -1,339 +1,213 @@
-import { utils } from '../utils';
-
-var constants = require("../constants").default;
-var headerNames = require("../Headers").headerNames;
-var contentTypes = require("../ContentTypes").default;
-var httpMethods = require("../HttpMethods").default;
-
-export class RequestBase {
-    public successCb: (data: any) => void;
-    public failureCb: (data: any) => void;
-    public progressCb: any;
-    public key: string;
-    private action: string;
-    private _fallbackProperties: string[];
-    public urlOptions: any;
-
-    constructor(options: any) {
-        this.successCb = options.successCb;
-        this.failureCb = options.failureCb;
-        this.urlOptions = options.urlOptions;
-        this.progressCb = options.progressCb;
-        this.key = options.key;
-        this.action = options.action;
-        this._fallbackProperties = options.fallbackProperties;
-    }
-
-    _getBody() {
-        return undefined;
-    }
-
-    _getMethod() {
-        return null;
-    }
-
-    _getHeaders(): any {
-        var headers = {};
-        headers[headerNames.contentType] = contentTypes.json;
-        return headers;
-    }
-
-    _getQueryParameters(paramDictionary: any, urlOptions: any) {
-        if (urlOptions.ODataParams) {
-            var query = urlOptions.ODataParams.build();
-            if (utils.isString(query.$filter))
-                paramDictionary[constants.ODataParams.$filter] = query.$filter;
-            if (utils.isString(query.$select))
-                paramDictionary[constants.ODataParams.$select] = query.$select;
-            if (utils.isString(query.$expand))
-                paramDictionary[constants.ODataParams.$expand] = query.$expand;
-            if (utils.isString(query.$orderby))
-                paramDictionary[constants.ODataParams.$orderby] = query.$orderby;
-            if (utils.isNumber(query.$skip))
-                paramDictionary[constants.ODataParams.$skip] = query.$skip;
-            if (utils.isNumber(query.$top))
-                paramDictionary[constants.ODataParams.$top] = query.$top;
-            if (utils.isString(query.$search))
-                paramDictionary[constants.ODataParams.$search] = query.$search;
-
-            // inline count
-            if (utils.isBoolean(query.$count) && query.$count)
-                paramDictionary[constants.ODataParams.$count] = query.$count;
-        }
-
-        if (urlOptions.SFParams) {
-            var sfParams = urlOptions.SFParams;
-            if (sfParams.provider) {
-                paramDictionary[constants.SfParams.provider] = sfParams.provider;
-            }
-
-            if (sfParams.culture) {
-                paramDictionary[constants.SfParams.culture] = sfParams.culture;
-            }
-
-            if (sfParams.siteId) {
-                paramDictionary[constants.SfParams.siteId] = sfParams.siteId;
-            }
-        }
-
-        if (this._fallbackProperties) {
-            paramDictionary["sf_fallback_prop_names"] = this._fallbackProperties.join();
-        }
-
-        if (urlOptions.additionalQueryParams) {
-            for (const key in urlOptions.additionalQueryParams) {
-                if (urlOptions.additionalQueryParams.hasOwnProperty(key)) {
-                    paramDictionary[key] = urlOptions.additionalQueryParams[key];
-                }
-            }
-        }
-    }
-
-    _getQueryString(urlOptions: any) {
-        var paramDictionary = {};
-
-        this._getQueryParameters(paramDictionary, urlOptions);
-        var keys = Object.keys(paramDictionary);
-        if (keys.length == 0)
-            return null;
-
-        var queryString = "?";
-        for (var prop in paramDictionary) {
-            queryString += prop + "=" + paramDictionary[prop] + "&";
-        }
-
-        queryString = queryString.substring(0, queryString.length - 1);
-
-        return queryString;
-    }
-
-    _buildUrl() {
-        var url = this.urlOptions.baseUrl + (this.urlOptions.entitySet || "");
-        url += this.key ? ("(" + this.key + ")") : "";
-        if (this.action) {
-            url += url.endsWith("/") ? "" : "/";
-            url += this.action;
-        }
-
-        // including count here
-        // not the best solution as build() is called once more in getQueryString
-        // but not that big of an issue right now
-        if (this.urlOptions.ODataParams) {
-            var getCount = this.urlOptions.ODataParams.build().$count;
-
-            if (utils.isBoolean(getCount) && !getCount) {
-                url += "/$count";
-            }
-        }
-
-        return this._addQueryParameters(url);
-    }
-
-    _parseResponse(http: any) {
-        var data = utils.parseStringToJson(http.responseText);
-        if (data) {
-            if (http.status >= 400 && data.error) {
-                return data.error;
-            }
-
-            return data;
-        }
+import { HEADER_NAMES, HTTP_METHODS } from "../constants";
+import { SDKOptions, Token } from "../Sitefinity";
+import { utils } from '../utils';
+import { ExecutableRequest } from "./ExecutableRequest";
+import { RequestOptionsBaseExtended } from "./RequestBase";
 
-        return http.responseText;
+export class GetRequest extends ExecutableRequest {
+    constructor(requestOptions: RequestOptionsBaseExtended, token: Token, sdkOptions: SDKOptions) {
+        super(requestOptions, token, sdkOptions);
     }
 
-    _addQueryParameters(url: string) {
-        var queryString = this._getQueryString(this.urlOptions);
-
-        if (queryString) {
-            if (url.indexOf("?") > -1 && queryString[0] == "?") {
-                queryString = "&" + queryString.substring(1);
-            }
-
-            url += queryString;
-        }
-
-        return url;
+    getMethod(): string {
+        return HTTP_METHODS.get;
     }
 }
 
-export class GetRequest extends RequestBase {
-    constructor(options: any) {
-        super(options);
+export class GetByIdRequest extends ExecutableRequest {
+    constructor(requestOptions: RequestOptionsBaseExtended, token: Token, sdkOptions: SDKOptions) {
+        super(requestOptions, token, sdkOptions);
     }
 
-    _getMethod() {
-        return httpMethods.Get;
+    getMethod(): string {
+        return HTTP_METHODS.get;
     }
 }
 
-export class GetByIdRequest extends RequestBase {
-    constructor(options: any) {
-        super(options);
+export class DeleteRequest extends ExecutableRequest {
+    constructor(requestOptions: RequestOptionsBaseExtended, token: Token, sdkOptions: SDKOptions) {
+        super(requestOptions, token, sdkOptions);
     }
 
-    _getMethod() {
-        return httpMethods.Get;
+    getMethod(): string {
+        return HTTP_METHODS.delete;
     }
 }
 
-export class DeleteRequest extends RequestBase {
-    constructor(options: any) {
-        super(options);
-    }
-
-    _getMethod() {
-        return httpMethods.Delete;
-    }
-}
+export class UpdateRequest extends ExecutableRequest {
+    private data: object;
+    private saveTemp: boolean;
 
-export class UpdateRequest extends RequestBase {
-    private _data: any;
-    private _saveTemp: any;
-    constructor(options: any) {
-        super(options);
-        this._data = options.data;
-        this._saveTemp = options.saveTemp;
+    constructor(requestOptions: PutRequestOptionsExtended, token: Token, sdkOptions: SDKOptions) {
+        super(requestOptions, token, sdkOptions);
+        this.data = requestOptions.data;
+        this.saveTemp = requestOptions.saveTemp;
     }
 
-    _getMethod() {
-        return httpMethods.Patch;
+    getMethod(): string {
+        return HTTP_METHODS.patch;
     }
 
-    _getBody() {
-        var body = utils.convertDateFieldToISOString(this._data);
+    getBody(): object {
+        const body = utils.convertDateFieldToISOString(this.data);
         return body;
     }
 
-    _getHeaders() {
-        var headers = RequestBase.prototype._getHeaders.call(this);
-        if (this._saveTemp) {
-            headers[headerNames.operation] = "SaveTemp";
+    getHeaders(): { [key: string]: string } {
+        const headers = super.getHeaders();
+        if (this.saveTemp) {
+            headers[HEADER_NAMES.operation] = "SaveTemp";
         }
 
         return headers;
     }
 }
 
-export class CreateRequest extends RequestBase {
-    public _data: any;
-    constructor(options: any) {
-        super(options);
-        this._data = options.data;
+export class CreateRequest extends ExecutableRequest {
+    protected data: object;
+
+    constructor(requestOptions: PostRequestOptionsExtended, token: Token, sdkOptions: SDKOptions) {
+        super(requestOptions, token, sdkOptions);
+        this.data = requestOptions.data;
     }
 
-    _getMethod() {
-        return httpMethods.Post;
+    getMethod(): string {
+        return HTTP_METHODS.post;
     }
 
-    _getBody() {
-        var body = utils.convertDateFieldToISOString(this._data);
+    getBody(): object {
+        const body = utils.convertDateFieldToISOString(this.data);
         return body;
     }
 }
 
 export class GetRelatedRequest extends GetByIdRequest {
-    private navigationProperty: string;
-    constructor(options: any) {
-        super(options);
-        this.navigationProperty = options.navigationProperty;
+    private property: string;
+
+    constructor(requestOptions: RelatedRequestOptionsExtended, token: Token, sdkOptions: SDKOptions) {
+        super(requestOptions, token, sdkOptions);
+        this.property = requestOptions.property;
     }
 
-    _buildUrl() {
-        var url = this.urlOptions.baseUrl + this.urlOptions.entitySet + "(" + this.key + ")/" + this.navigationProperty;
-        return this._addQueryParameters(url);
+    buildUrl(): string {
+        const url = this.urlOptions.baseUrl + this.urlOptions.entitySet + "(" + this.key + ")/" + this.property;
+        return this.addQueryParameters(url);
     }
 }
 
 export class GetRelatedByIdRequest extends GetByIdRequest {
-    private navigationProperty: string;
-    private relatedKey: string;
-    constructor(options: any) {
-        super(options);
-        this.navigationProperty = options.navigationProperty;
-        this.relatedKey = options.relatedKey;
+    private property: string;
+    private relatedId: string;
+
+    constructor(requestOptions: RelatedByIdRequestOptionsExtended, token: Token, sdkOptions: SDKOptions) {
+        super(requestOptions, token, sdkOptions);
+        this.property = requestOptions.property;
+        this.relatedId = requestOptions.relatedId;
     }
 
-    _buildUrl() {
-        var url = this.urlOptions.baseUrl + this.urlOptions.entitySet + "(" + this.key + ")/" + this.navigationProperty + "(" + this.relatedKey + ")";
-        return this._addQueryParameters(url);
+    buildUrl(): string {
+        const url = this.urlOptions.baseUrl + this.urlOptions.entitySet + "(" + this.key + ")/" + this.property + "(" + this.relatedId + ")";
+        return this.addQueryParameters(url);
     }
 }
 
 export class DeleteRelatedRequest extends DeleteRequest {
-    private navigationProperty: string;
-    constructor(options: any) {
-        super(options);
-        this.navigationProperty = options.navigationProperty;
-    }
+    private property: string;
 
+    constructor(requestOptions: RelatedRequestOptionsExtended, token: Token, sdkOptions: SDKOptions) {
+        super(requestOptions, token, sdkOptions);
+        this.property = requestOptions.property;
+    }
 
-    _buildUrl() {
-        var url = this.urlOptions.baseUrl + this.urlOptions.entitySet + "(" + this.key + ")/" + this.navigationProperty + "/$ref"
-        return this._addQueryParameters(url);
+    buildUrl(): string {
+        const url = this.urlOptions.baseUrl + this.urlOptions.entitySet + "(" + this.key + ")/" + this.property + "/$ref"
+        return this.addQueryParameters(url);
     }
 }
 
 export class DeleteRelatedByIdRequest extends DeleteRequest {
-    private navigationProperty: string;
-    private relatedKey: string;
-    constructor(options: any) {
-        super(options);
-        this.navigationProperty = options.navigationProperty;
-        this.relatedKey = options.relatedKey
+    private property: string;
+    private relatedId: string;
+
+    constructor(requestOptions: RelatedByIdRequestOptionsExtended, token: Token, sdkOptions: SDKOptions) {
+        super(requestOptions, token, sdkOptions);
+        this.property = requestOptions.property;
+        this.relatedId = requestOptions.relatedId;
     }
 
-    _buildUrl() {
-        var url = this.urlOptions.baseUrl + this.urlOptions.entitySet + "(" + this.key + ")/" + this.navigationProperty + "(" + this.relatedKey + ")/$ref";
-        return this._addQueryParameters(url);
+    buildUrl(): string {
+        const url = this.urlOptions.baseUrl + this.urlOptions.entitySet + "(" + this.key + ")/" + this.property + "(" + this.relatedId + ")/$ref";
+        return this.addQueryParameters(url);
     }
 }
 
 export class CreateRelatedRequest extends CreateRequest {
-    private navigationProperty: string;
-    constructor(options: any) {
-        super(options);
-        this.navigationProperty = options.navigationProperty;
-        this.key = options.key;
+    private property: string;
+
+    constructor(requestOptions: RelatedRequestOptionsExtended, token: Token, sdkOptions: SDKOptions) {
+        super(requestOptions, token, sdkOptions);
+        this.property = requestOptions.property;
+        this.key = requestOptions.key;
     }
 
-    _buildUrl() {
-        var url = this.urlOptions.baseUrl + this.urlOptions.entitySet + "(" + this.key + ")/" + this.navigationProperty + "/$ref";
-        return this._addQueryParameters(url);
+    buildUrl(): string {
+        const url = this.urlOptions.baseUrl + this.urlOptions.entitySet + "(" + this.key + ")/" + this.property + "/$ref";
+        return this.addQueryParameters(url);
     }
 }
 
-
 export class UploadRequest extends CreateRequest {
-    private fileName: any;
-    private uploadProperties: any;
-    private contentType: any;
-
-    constructor(options: any) {
-        super(options);
-        this.fileName = options.fileName;
-        this.uploadProperties = options.uploadProperties;
-        this.contentType = options.contentType;
-    }
-
-    _getHeaders() {
-        var headers = super._getHeaders();
-        headers[headerNames.contentType] = this.contentType || "application/octet-stream";
-        headers[headerNames.fileName] = this.fileName;
-        headers[headerNames.properties] = this.uploadProperties;
-        headers[headerNames.contentEncoding] = "identity";
+    private fileName: string;
+    private uploadProperties: { [key: string]: string };
+    private contentType: string;
+
+    constructor(requestOptions: UploadRequestOptionsExtended, token: Token, sdkOptions: SDKOptions) {
+        super(requestOptions, token, sdkOptions);
+        this.fileName = requestOptions.fileName;
+        this.uploadProperties = requestOptions.uploadProperties;
+        this.contentType = requestOptions.contentType;
+    }
+
+    getHeaders(): { [key: string]: string } {
+        const headers = super.getHeaders();
+        headers[HEADER_NAMES.contentType] = this.contentType || "application/octet-stream";
+        headers[HEADER_NAMES.fileName] = this.fileName;
+        headers[HEADER_NAMES.properties] = JSON.stringify(this.uploadProperties);
+        headers[HEADER_NAMES.contentEncoding] = "identity";
         return headers;
     }
 
-    _getBody() {
-        return this._data;
+    getBody(): object {
+        return this.data;
     }
 
-    _getMethod() {
+    getMethod(): string {
         if (this.key) {
-            return httpMethods.Patch;
+            return HTTP_METHODS.patch;
         }
 
-        return httpMethods.Post;
+        return HTTP_METHODS.post;
     }
 }
+
+export interface PostRequestOptionsExtended extends RequestOptionsBaseExtended {
+    data?: object;
+}
+
+export interface PutRequestOptionsExtended extends PostRequestOptionsExtended {
+    saveTemp: boolean;
+}
+
+export interface RelatedRequestOptionsExtended extends PostRequestOptionsExtended {
+    property: string;
+}
+
+export interface RelatedByIdRequestOptionsExtended extends RelatedRequestOptionsExtended {
+    relatedId: string;
+}
+
+export interface UploadRequestOptionsExtended extends PostRequestOptionsExtended {
+    fileName: string;
+    contentType: string;
+    uploadProperties: { [key: string]: string };
+}