channelape-sdk/dist/actions/service/ActionsService.js

A client for interacting with ChannelApe's API

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Resource_1 = require("../../model/Resource");
const Subresource_1 = require("../model/Subresource");
const Version_1 = require("../../model/Version");
const GenerateApiError_1 = require("../../utils/GenerateApiError");
const Q = require("q");
const EXPECTED_STATUS_CODE = 200;
class ActionsService {
    constructor(client) {
        this.client = client;
    }
    get(actionIdOrRequest) {
        if (typeof actionIdOrRequest === 'string') {
            return this.getByActionId(actionIdOrRequest);
        }
        const deferred = Q.defer();
        const singlePage = false;
        this.getByRequest(actionIdOrRequest, [], deferred, singlePage);
        return deferred.promise;
    }
    getPage(actionRequest) {
        const deferred = Q.defer();
        const singlePage = true;
        this.getByRequest(actionRequest, [], deferred, singlePage);
        return deferred.promise;
    }
    getByActionId(actionId) {
        const deferred = Q.defer();
        const requestUrl = `/${Version_1.default.V1}${Resource_1.default.ACTIONS}/${actionId}`;
        this.client.get(requestUrl, {}, (error, response, body) => {
            this.mapActionPromise(requestUrl, deferred, error, response, body);
        });
        return deferred.promise;
    }
    getByRequest(actionsRequest, actions, deferred, singlePage) {
        const requestUrl = `/${Version_1.default.V1}${Resource_1.default.ACTIONS}`;
        const queryParams = actionsRequest;
        if (typeof actionsRequest.startDate !== 'undefined' && typeof actionsRequest.startDate !== 'string') {
            queryParams.startDate = actionsRequest.startDate.toISOString();
        }
        if (typeof actionsRequest.endDate !== 'undefined' && typeof actionsRequest.endDate !== 'string') {
            queryParams.endDate = actionsRequest.endDate.toISOString();
        }
        const options = {
            params: queryParams
        };
        this.client.get(requestUrl, options, (error, response, body) => {
            const requestCallbackParams = {
                error, response, body
            };
            this.mapActionsPromise(requestUrl, deferred, requestCallbackParams, actions, actionsRequest, singlePage);
        });
        return deferred.promise;
    }
    updateHealthCheck(actionId) {
        const requestUrl = `/${Version_1.default.V1}${Resource_1.default.ACTIONS}/${actionId}/${Subresource_1.default.HEALTH_CHECK}`;
        const deferred = Q.defer();
        this.client.put(requestUrl, {}, (error, response, body) => {
            this.mapActionPromise(requestUrl, deferred, error, response, body);
        });
        return deferred.promise;
    }
    complete(actionId) {
        const requestUrl = `/${Version_1.default.V1}${Resource_1.default.ACTIONS}/${actionId}/${Subresource_1.default.COMPLETE}`;
        const deferred = Q.defer();
        this.client.put(requestUrl, {}, (error, response, body) => {
            this.mapActionPromise(requestUrl, deferred, error, response, body);
        });
        return deferred.promise;
    }
    error(actionId) {
        const requestUrl = `/${Version_1.default.V1}${Resource_1.default.ACTIONS}/${actionId}/${Subresource_1.default.ERROR}`;
        const deferred = Q.defer();
        this.client.put(requestUrl, {}, (error, response, body) => {
            this.mapActionPromise(requestUrl, deferred, error, response, body);
        });
        return deferred.promise;
    }
    mapActionPromise(requestUrl, deferred, error, response, body) {
        if (error) {
            deferred.reject(error);
        }
        else if (response.status === EXPECTED_STATUS_CODE) {
            const action = this.formatAction(body);
            deferred.resolve(action);
        }
        else {
            const channelApeErrorResponse = (0, GenerateApiError_1.default)(requestUrl, response, body, EXPECTED_STATUS_CODE);
            deferred.reject(channelApeErrorResponse);
        }
    }
    mapActionsPromise(requestUrl, deferred, requestCallbackParams, actions, actionsRequest, singlePage) {
        if (requestCallbackParams.error) {
            deferred.reject(requestCallbackParams.error);
        }
        else if (requestCallbackParams.response.status === EXPECTED_STATUS_CODE) {
            const actionsFromThisCall = requestCallbackParams.body.actions.map(this.formatAction);
            const mergedActions = actions.concat(actionsFromThisCall);
            if (singlePage) {
                deferred.resolve({
                    actions: actionsFromThisCall,
                    pagination: requestCallbackParams.body.pagination
                });
            }
            else if (requestCallbackParams.body.pagination.lastPage) {
                deferred.resolve(mergedActions);
            }
            else {
                actionsRequest.lastKey = requestCallbackParams.body.pagination.lastKey;
                this.getByRequest(actionsRequest, mergedActions, deferred, singlePage);
            }
        }
        else {
            const channelApeErrorResponse = (0, GenerateApiError_1.default)(requestUrl, requestCallbackParams.response, requestCallbackParams.body, EXPECTED_STATUS_CODE);
            deferred.reject(channelApeErrorResponse);
        }
    }
    formatAction(actionBody) {
        const action = actionBody;
        action.lastHealthCheckTime = new Date(actionBody.lastHealthCheckTime);
        action.startTime = new Date(actionBody.startTime);
        if (action.endTime != null) {
            action.endTime = new Date(actionBody.endTime);
        }
        return action;
    }
}
exports.default = ActionsService;
//# sourceMappingURL=ActionsService.js.map