loop-modules/utils/api-dispatcher.class.ts

Shared modules for the Loop product suite.

// angular
import { Http, Response } from '@angular/http';
// libs
import { Store } from '@ngrx/store';
import { Observable } from 'rxjs/Observable';
// app
import { ResponseBody } from './response-body.interface';
import { APIRequestOptions } from './api-request-options.interface';

export abstract class APIDispatcher {

    protected lastRequest: ResponseBody;

    loaded: boolean = false;
    fetchingNext: boolean = false;

    constructor(public http: Http, public store: Store<any>) { }

    /**
     * Wraps the http layer for GET requests
     * Injects Core API standards for filtering, sorting and pagination
     *
     * @param {string} url The relative API url
     * @param {number} [page=0] The page of the dataset to request
     * @param {number} [size=10] The maximum number of results to return
     * @param {APIRequestOptions} [options] The optional request options
     * @returns Observable of http get request
     */
    get(url: string, page: number = 0, size: number = 10, options: APIRequestOptions = {}): Observable<Response> {
        return this.http.get(url + '?' +
            this.getPageFragment(page) +
            this.getSizeFragment(size) +
            this.getOptionalFragments(options));
    }

    /**
     * Wraps the http layer for POST requests
     * Injects Core API standards used for fetching items by identities
     * Allows for filtering, sorting and pagination
     *
     * @param {string} url The relative API url
     * @param {*} requestBody The request body to send to the server
     * @param {number} [page=0] The page of the dataset to request
     * @param {number} [size=10] The maximum number of results to return
     * @param {APIRequestOptions} [options] The optional request options
     * @returns
     */
    post(url: string, requestBody: any, page: number = 0, size: number = 10, options: APIRequestOptions = {}): Observable<Response> {
        return this.http.post(url + '?' +
            this.getPageFragment(page) +
            this.getSizeFragment(size) +
            this.getOptionalFragments(options),
            requestBody);
    }

    handleError(error: any): any {
        let errMsg = (error.message) ? error.message : error.status ? `${error.status} - ${error.statusText}` : 'Server error';
        console.error(errMsg);
        return Observable.throw(errMsg);
    }


    /**
     * This clears the previous requests
     *
     * @memberOf APIDispatcher
     */
    clearRequest() {
        this.lastRequest = undefined;
    }

    // TODO - This will need to be abstract once services are up-to-date
    // getNextPage() {};

    /**
     * Determines if the paginated request has another page, based on the total number of pages vs. the currently requested content
     *
     * @readonly
     * @type {boolean}
     * @memberOf APIDispatcher
     */
    get hasNext(): boolean {
        if (this.lastRequest) {
            return (this.lastRequest.totalPages - 1) > this.lastRequest.currentPage;
        }
        return false;
    }

    /**
     * The get parameter fragment for page numbers
     *
     * @protected
     * @param {number} page
     * @returns {string}
     */
    protected getPageFragment(page: number): string {
        return 'page=' + page;
    }

    /**
     * The get parameter fragment for collection size
     *
     * @protected
     * @param {number} size
     * @returns {string}
     */
    protected getSizeFragment(size: number): string {
        return '&size=' + size;
    }

    /**
     * The get parameter fragments
     *
     * @protected
     * @param {APIRequestOptions} options
     * @returns {string}
     */
    protected getOptionalFragments(options: APIRequestOptions): string {
        return this.getSearchFragment(options.search) +
            this.getSortByFragment(options.sortBy) +
            this.getUnreadFragment(options.unread) +
            this.getSortDirFragment(options.sortDir) +
            this.getArchivedFragment(options.archived) +
            this.getIsReviewedFragment(options.reviewed) +
            this.getIsSubmittedFragment(options.submitted);
    }

    /**
     * The get parameter fragment for search term
     *
     * @protected
     * @param {string} search
     * @returns {string}
     */
    protected getSearchFragment(search: string): string {
        if (search) {
            return '&search=' + encodeURIComponent(search);
        }
        return '';
    }

    /**
     * The get parameter fragment for sort by
     *
     * @protected
     * @param {string} sortBy
     * @returns {string}
     */
    protected getSortByFragment(sortBy: string): string {
        if (sortBy) {
            return '&sortBy=' + sortBy;
        }
        return '';
    }

    /**
     * The get parameter fragment for sort direction
     *
     * @protected
     * @param {string} sortDir
     * @returns {string}
     */
    protected getSortDirFragment(sortDir: string): string {
        if (sortDir) {
            return '&sortDir=' + sortDir;
        }
        return '';
    }

    /**
     * The get parameter fragment for unread
     *
     * @protected
     * @param {string} unread
     * @returns {string}
     */
    protected getUnreadFragment(unread: string): string {
        if (unread) {
            return '&unread=' + unread;
        }
        return '';
    }

    /**
     * The get parameter fragment for unread
     *
     * @protected
     * @param {string} unread
     * @returns {string}
     */
    protected getArchivedFragment(archived: boolean): string {
        if (archived) {
            return '&isArchived=' + archived;
        }
        return '';
    }

    /**
     * The get parameter fragment for unread
     *
     * @protected
     * @param {string} unread
     * @returns {string}
     */
    protected getIsReviewedFragment(reviewed: boolean): string {
        if (reviewed !== undefined) {
            return '&reviewed=' + reviewed;
        }
        return '';
    }

    /**
     * The get parameter fragment for unread
     *
     * @protected
     * @param {string} unread
     * @returns {string}
     */
    protected getIsSubmittedFragment(submitted: boolean): string {
        if (submitted !== undefined) {
            return '&submitted=' + submitted;
        }
        return '';
    }
}