@progress/sitefinity-webservices-sdk 0.3.0 → 1.0.2

package/src/Requests/RequestBase.ts

@@ -0,0 +1,161 @@
+import { CONTENT_TYPES, HEADER_NAMES, ODATA_PARAMS, SF_PARAMS } from "../constants";
+import { RequestOptionsBase } from "../Data";
+import { Query } from "../Query";
+import { TypeOptions } from "../Sitefinity";
+import { utils } from '../utils';
+
+export class RequestBase {
+    public successCb: Function;
+    public failureCb: Function;
+    public progressCb: Function;
+    public key: string | number;
+    public urlOptions: TypeOptions;
+    protected query: Query;
+    private action: string;
+    private fallbackProperties: string[];
+
+    constructor(options: RequestOptionsBaseExtended) {
+        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;
+        this.query = options.query;
+    }
+
+    getQueryString(urlOptions: TypeOptions, query: Query): string {
+        const paramDictionary: { [key: string]: string } = {};
+
+        this.getQueryParameters(paramDictionary, urlOptions, query);
+        const keys = Object.keys(paramDictionary);
+        if (keys.length == 0)
+            return null;
+
+        let queryString = "?";
+        for (const prop in paramDictionary) {
+            queryString += prop + "=" + paramDictionary[prop] + "&";
+        }
+
+        queryString = queryString.substring(0, queryString.length - 1);
+
+        return queryString;
+    }
+
+    getBody(): object {
+        return undefined;
+    }
+
+    getMethod(): string {
+        return null;
+    }
+
+    getHeaders(): { [key: string]: string } {
+        const headers = {};
+        headers[HEADER_NAMES.contentType] = CONTENT_TYPES.json;
+        return headers;
+    }
+
+    buildUrl(): string {
+        let 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.query) {
+            const getCount = this.query.build().$count;
+
+            if (utils.isBoolean(getCount) && !getCount) {
+                url += "/$count";
+            }
+        }
+
+        return this.addQueryParameters(url);
+    }
+
+    protected parseResponse(http: XMLHttpRequest): string | any {
+        const data = utils.parseStringToJson(http.responseText);
+        if (data) {
+            if (http.status >= 400 && data.error) {
+                return data.error;
+            }
+
+            return data;
+        }
+
+        return http.responseText;
+    }
+
+    protected addQueryParameters(url: string): string {
+        let queryString = this.getQueryString(this.urlOptions, this.query);
+
+        if (queryString) {
+            if (url.indexOf("?") > -1 && queryString[0] == "?") {
+                queryString = "&" + queryString.substring(1);
+            }
+
+            url += queryString;
+        }
+
+        return url;
+    }
+
+    private getQueryParameters(paramDictionary: { [key: string]: string }, urlOptions: TypeOptions, query: Query) {
+        if (query) {
+            const builtQuery = query.build();
+            if (utils.isString(builtQuery.$filter))
+                paramDictionary[ODATA_PARAMS.$filter] = builtQuery.$filter;
+            if (utils.isString(builtQuery.$select))
+                paramDictionary[ODATA_PARAMS.$select] = builtQuery.$select;
+            if (utils.isString(builtQuery.$expand))
+                paramDictionary[ODATA_PARAMS.$expand] = builtQuery.$expand;
+            if (utils.isString(builtQuery.$orderby))
+                paramDictionary[ODATA_PARAMS.$orderby] = builtQuery.$orderby;
+            if (utils.isNumber(builtQuery.$skip))
+                paramDictionary[ODATA_PARAMS.$skip] = builtQuery.$skip;
+            if (utils.isNumber(builtQuery.$top))
+                paramDictionary[ODATA_PARAMS.$top] = builtQuery.$top;
+            if (utils.isString(builtQuery.$search))
+                paramDictionary[ODATA_PARAMS.$search] = builtQuery.$search;
+
+            // inline count
+            if (utils.isBoolean(builtQuery.$count) && builtQuery.$count)
+                paramDictionary[ODATA_PARAMS.$count] = builtQuery.$count;
+        }
+
+        if (urlOptions.provider) {
+            paramDictionary[SF_PARAMS.provider] = urlOptions.provider;
+        }
+
+        if (urlOptions.culture) {
+            paramDictionary[SF_PARAMS.culture] = urlOptions.culture;
+        }
+
+        if (urlOptions.siteId) {
+            paramDictionary[SF_PARAMS.siteId] = urlOptions.siteId;
+        }
+
+        if (this.fallbackProperties) {
+            paramDictionary[SF_PARAMS.fallbackParams] = this.fallbackProperties.join();
+        }
+
+        if (urlOptions.additionalQueryParams) {
+            for (const key in urlOptions.additionalQueryParams) {
+                if (urlOptions.additionalQueryParams.hasOwnProperty(key)) {
+                    paramDictionary[key] = urlOptions.additionalQueryParams[key];
+                }
+            }
+        }
+    }
+}
+
+export interface RequestOptionsBaseExtended extends RequestOptionsBase {
+    progressCb?: Function;
+    urlOptions: TypeOptions;
+}

package/src/Requests/RequestFactory.ts

@@ -1,85 +1,67 @@
-import { GetRequest, GetByIdRequest, CreateRequest, UpdateRequest, DeleteRequest, GetRelatedRequest, GetRelatedByIdRequest, DeleteRelatedRequest, DeleteRelatedByIdRequest, CreateRelatedRequest, UploadRequest } from "./Request";
-import { ExecutableRequest } from './ExecutableRequest';
-
-var BatchRequest = require('./BatchRequest');
+import { GetRequest, GetByIdRequest, CreateRequest, UpdateRequest, DeleteRequest, GetRelatedRequest, GetRelatedByIdRequest, DeleteRelatedRequest, DeleteRelatedByIdRequest, CreateRelatedRequest, UploadRequest, PostRequestOptionsExtended, PutRequestOptionsExtended, RelatedRequestOptionsExtended, RelatedByIdRequestOptionsExtended, UploadRequestOptionsExtended } from "./Request";
+import { SDKOptions, Token } from "../Sitefinity";
+import { BatchRequest, BatchRequestOptionsExtended } from "./BatchRequest";
+import { RequestOptionsBaseExtended } from "./RequestBase";
 
 export class RequestFactory {
-    public token: any;
-    private handlers: any;
-    private enableUnlimitedChoices: boolean;
-    private integrationMode: boolean;
-
-    constructor(options: any) {
-        this.token = null;
-        this.handlers = options.handlers;
-        this.enableUnlimitedChoices = options.enableUnlimitedChoices;
-        this.integrationMode = options.integrationMode;
-    }
+    public token: Token;
+    private options: SDKOptions;
 
-    get(parameters: any) {
-        return this.createExecutor(new GetRequest(parameters));
+    constructor(options: SDKOptions) {
+        this.options = options;
     }
 
-    getSingle(parameters: any) {
-        return this.createExecutor(new GetByIdRequest(parameters));
+    get(parameters: RequestOptionsBaseExtended) {
+        return new GetRequest(parameters, this.token, this.options);
     }
 
-    create(parameters: any) {
-        return this.createExecutor(new CreateRequest(parameters));
+    getSingle(parameters: RequestOptionsBaseExtended) {
+        return new GetByIdRequest(parameters, this.token, this.options);
     }
 
-    update(parameters: any) {
-        return this.createExecutor(new UpdateRequest(parameters));
+    create(parameters: PostRequestOptionsExtended) {
+        return new CreateRequest(parameters, this.token, this.options);
     }
 
-    destroy(parameters: any) {
-        return this.createExecutor(new DeleteRequest(parameters));
+    update(parameters: PutRequestOptionsExtended) {
+        return new UpdateRequest(parameters, this.token, this.options);
     }
 
-    getProperty(parameters: any) {
-        return this.createExecutor(new GetRelatedRequest(parameters));
+    destroy(parameters: RequestOptionsBaseExtended) {
+        return new DeleteRequest(parameters, this.token, this.options);
     }
 
-    getRelated(parameters: any) {
-        return this.createExecutor(new GetRelatedRequest(parameters));
+    getProperty(parameters: RelatedRequestOptionsExtended) {
+        return new GetRelatedRequest(parameters, this.token, this.options);
     }
 
-    getRelatedById(parameters: any) {
-        return this.createExecutor(new GetRelatedByIdRequest(parameters));
+    getRelated(parameters: RelatedRequestOptionsExtended) {
+        return new GetRelatedRequest(parameters, this.token, this.options);
     }
 
-    destroyRelated(parameters: any) {
-        return this.createExecutor(new DeleteRelatedRequest(parameters));
+    getRelatedById(parameters: RelatedByIdRequestOptionsExtended) {
+        return new GetRelatedByIdRequest(parameters, this.token, this.options);
     }
 
-    destroyRelatedById(parameters: any) {
-        return this.createExecutor(new DeleteRelatedByIdRequest(parameters));
+    destroyRelated(parameters: RelatedRequestOptionsExtended) {
+        return new DeleteRelatedRequest(parameters, this.token, this.options);
     }
 
-    createRelated(parameters: any) {
-        return this.createExecutor(new CreateRelatedRequest(parameters));
+    destroyRelatedById(parameters: RelatedByIdRequestOptionsExtended) {
+        return new DeleteRelatedByIdRequest(parameters, this.token, this.options);
     }
 
-    batch(parameters) {
-        parameters._factory = this;
-        return new BatchRequest(parameters);
+    createRelated(parameters: RelatedRequestOptionsExtended) {
+        return new CreateRelatedRequest(parameters, this.token, this.options);
     }
 
-    upload(parameters: any) {
-        return this.createExecutor(new UploadRequest(parameters));
+    upload(parameters: UploadRequestOptionsExtended) {
+        return new UploadRequest(parameters, this.token, this.options);
     }
 
-    createExecutor(request: any) {
-        var executor = new ExecutableRequest({
-            request: request,
-            handlers: this.handlers || {},
-            token: this.token,
-            enableUnlimitedChoices: this.enableUnlimitedChoices,
-            integrationMode: this.integrationMode
-        });
-
-        // TODO
-        (executor as any).navigationProperty = request.navigationProperty;
-        return executor;
+    batch(parameters: RequestOptionsBaseExtended) {
+        const batchParams = parameters as BatchRequestOptionsExtended;
+        batchParams.factory = this;
+        return new BatchRequest(batchParams, this.token, this.options);
     }
 }

package/src/Requests/request.spec.ts

@@ -0,0 +1,108 @@
+import { Query } from "../Query";
+import { Sitefinity } from "../Sitefinity";
+
+describe("SDK basic tests", () => {
+    const baseUrl = "http://www.mysite.com/api/default/"
+    let sitefinity: Sitefinity;
+    let query: Query;
+
+    beforeEach(function() {
+        jasmine.Ajax.install();
+    });
+
+    afterEach(function() {
+        jasmine.Ajax.uninstall();
+    });
+
+    beforeAll(() => {
+        sitefinity = new Sitefinity({
+            baseUrl
+        });
+
+        query = new Sitefinity.Query();
+    });
+
+    it("query assert", () => {
+        const testQuery = (query.where().and().endsWith("Title", "Record").done() as any).or().startsWith('Title', 'asd').done().done();
+        const resultingQuery = testQuery.build();
+        expect(resultingQuery.$filter).toEqual("(endswith(Title, 'Record')) and (startswith(Title, 'asd'))");
+    });
+
+    it("complex query assert", () => {
+        const testQuery = query.where().not().endsWith("Record", "Title").done().and().not().eq('Content', 'test').done().done().done();
+        const resultingQuery = testQuery.build();
+        expect(resultingQuery.$filter).toEqual("(not endswith(Record, 'Title')) and ((not (Content eq 'test')))");
+    });
+
+    it("query count assert", () => {
+        const data = sitefinity.data({
+            entitySet: "newsitems"
+        });
+
+        data.get({query: query.count(false)});
+
+        let request = jasmine.Ajax.requests.mostRecent();
+        expect(request.url).toBe('http://www.mysite.com/api/default/newsitems/$count');
+
+        data.get({query: query.count(true)});
+
+        request = jasmine.Ajax.requests.mostRecent();
+        expect(request.url).toBe('http://www.mysite.com/api/default/newsitems?$count=true');
+    });
+
+    it("request assert", () => {
+        sitefinity.data({
+            entitySet: "newsitems",
+            provider: "newsProvider",
+            culture: "en-US"
+        }).get({query: null});
+
+        const request = jasmine.Ajax.requests.mostRecent();
+        expect(request.url).toBe('http://www.mysite.com/api/default/newsitems?sf_provider=newsProvider&sf_culture=en-US');
+        expect(request.method).toBe('GET');
+        expect(request.data()).toEqual({});
+    });
+
+    it("batch assert", async () => {
+        const batch = sitefinity.batch();
+        const getQuery = query.where().eq('Title', 'newTitleN11').done();
+
+        batch.get({
+            entitySet: "newsitems",
+            query: getQuery
+        });
+
+        const transaction = batch.beginTransaction();
+
+        transaction.create({
+            entitySet: "newsitems",
+            data: { title: "Test" }
+        });
+
+        batch.endTransaction(transaction);
+        (batch as any).execute();
+
+        const request = jasmine.Ajax.requests.mostRecent();
+        expect(request.url).toBe('http://www.mysite.com/api/default/$batch');
+        expect(request.method).toBe('POST');
+
+        await readBlobAsText(request.params).then((result) => {
+            expect(result).toContain("{\"title\":\"Test\"}");
+        });
+    });
+
+    function readBlobAsText(blob: Blob): Promise<string> {
+        return new Promise((resolve, reject) => {
+            const reader = new FileReader();
+
+            reader.onload = () => {
+                resolve(<string>reader.result);
+            };
+
+            reader.onerror = () => {
+                reject();
+            };
+            reader.readAsText(blob);
+        });
+    }
+});