channelape-sdk/dist/locations/service/LocationsService.js

A client for interacting with ChannelApe's API

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Q = require("q");
const Version_1 = require("../../model/Version");
const Resource_1 = require("../../model/Resource");
const RestService_1 = require("../../service/RestService");
const GenerateApiError_1 = require("../../utils/GenerateApiError");
class LocationsService extends RestService_1.default {
    constructor(client) {
        super();
        this.client = client;
        this.EXPECTED_GET_OR_UPDATE_STATUS = 200;
        this.EXPECTED_CREATE_STATUS = 201;
    }
    create(locationCreationRequest) {
        const deferred = Q.defer();
        const requestUrl = `/${Version_1.default.V1}${Resource_1.default.LOCATIONS}`;
        const options = {
            data: locationCreationRequest
        };
        this.client.post(requestUrl, options, (error, response, body) => this.mapResponseToPromise(requestUrl, deferred, error, response, body, this.EXPECTED_CREATE_STATUS));
        return deferred.promise;
    }
    update(locationUpdateRequest) {
        const deferred = Q.defer();
        const requestUrl = `/${Version_1.default.V1}${Resource_1.default.LOCATIONS}/${locationUpdateRequest.id}`;
        const options = {
            data: locationUpdateRequest
        };
        this.client.put(requestUrl, options, (error, response, body) => {
            return this.mapResponseToPromise(requestUrl, deferred, error, response, body, this.EXPECTED_GET_OR_UPDATE_STATUS);
        });
        return deferred.promise;
    }
    updateSla(locationId, sla) {
        return new Promise((resolve) => {
            const requestUrl = `/${Version_1.default.V1}${Resource_1.default.LOCATIONS}/${locationId}/sla`;
            const options = {
                data: sla
            };
            this.client.put(requestUrl, options, (error, response, body) => {
                const requestResponse = {
                    error,
                    response,
                    body
                };
                resolve(this.mapLocationSLAResponse(requestUrl, requestResponse, this.EXPECTED_GET_OR_UPDATE_STATUS));
            });
        });
    }
    get(locationId) {
        const deferred = Q.defer();
        const requestUrl = `/${Version_1.default.V1}${Resource_1.default.LOCATIONS}/${locationId}`;
        this.client.get(requestUrl, {}, (error, response, body) => this.mapResponseToPromise(requestUrl, deferred, error, response, body, this.EXPECTED_GET_OR_UPDATE_STATUS));
        return deferred.promise;
    }
    getByBusinessId(businessId) {
        return new Promise((resolve) => {
            const requestUrl = `/${Version_1.default.V1}${Resource_1.default.LOCATIONS}?businessId=${businessId}`;
            this.client.get(requestUrl, {}, (error, response, body) => {
                const requestResponse = {
                    error,
                    response,
                    body
                };
                resolve(this.mapLocationsResponse(requestUrl, requestResponse, this.EXPECTED_GET_OR_UPDATE_STATUS));
            });
        });
    }
    getSla(locationId) {
        return new Promise((resolve) => {
            const requestUrl = `/${Version_1.default.V1}${Resource_1.default.LOCATIONS}/${locationId}/sla`;
            this.client.get(requestUrl, {}, (error, response, body) => {
                const requestResponse = {
                    error,
                    response,
                    body
                };
                resolve(this.mapLocationSLAResponse(requestUrl, requestResponse, this.EXPECTED_GET_OR_UPDATE_STATUS));
            });
        });
    }
    updateClosures(locationId, closedDates) {
        return new Promise((resolve) => {
            const requestUrl = `/${Version_1.default.V1}${Resource_1.default.LOCATIONS}/${locationId}/closures`;
            const options = {
                data: closedDates
            };
            this.client.put(requestUrl, options, (error, response, body) => {
                const requestResponse = {
                    error,
                    response,
                    body
                };
                resolve(this.mapLocationClosuresResponse(requestUrl, requestResponse, this.EXPECTED_GET_OR_UPDATE_STATUS));
            });
        });
    }
    getClosures(locationId) {
        return new Promise((resolve) => {
            const requestUrl = `/${Version_1.default.V1}${Resource_1.default.LOCATIONS}/${locationId}/closures`;
            this.client.get(requestUrl, {}, (error, response, body) => {
                const requestResponse = {
                    error,
                    response,
                    body
                };
                resolve(this.mapLocationClosuresResponse(requestUrl, requestResponse, this.EXPECTED_GET_OR_UPDATE_STATUS));
            });
        });
    }
    mapLocationsResponse(requestUrl, requestCallbackParams, expectedStatusCode) {
        return new Promise((resolve, reject) => {
            if (requestCallbackParams.error) {
                reject(requestCallbackParams.error);
            }
            else if (requestCallbackParams.response.status === expectedStatusCode) {
                const data = requestCallbackParams.body;
                resolve(data.locations.map(location => this.formatLocation(location)));
            }
            else {
                const channelApeErrorResponse = (0, GenerateApiError_1.default)(requestUrl, requestCallbackParams.response, requestCallbackParams.body, this.EXPECTED_GET_OR_UPDATE_STATUS);
                reject(channelApeErrorResponse);
            }
        });
    }
    mapLocationSLAResponse(requestUrl, requestCallbackParams, expectedStatusCode) {
        return new Promise((resolve, reject) => {
            if (requestCallbackParams.error) {
                reject(requestCallbackParams.error);
            }
            else if (requestCallbackParams.response.status === expectedStatusCode) {
                const data = requestCallbackParams.body;
                resolve(this.formatLocationSLA(data));
            }
            else {
                const channelApeErrorResponse = (0, GenerateApiError_1.default)(requestUrl, requestCallbackParams.response, requestCallbackParams.body, this.EXPECTED_GET_OR_UPDATE_STATUS);
                reject(channelApeErrorResponse);
            }
        });
    }
    mapLocationClosuresResponse(requestUrl, requestCallbackParams, expectedStatusCode) {
        return new Promise((resolve, reject) => {
            if (requestCallbackParams.error) {
                reject(requestCallbackParams.error);
            }
            else if (requestCallbackParams.response.status === expectedStatusCode) {
                const data = requestCallbackParams.body;
                resolve(data.closedDays.map(closedDay => this.formatLocationClosure(closedDay)));
            }
            else {
                const channelApeErrorResponse = (0, GenerateApiError_1.default)(requestUrl, requestCallbackParams.response, requestCallbackParams.body, this.EXPECTED_GET_OR_UPDATE_STATUS);
                reject(channelApeErrorResponse);
            }
        });
    }
    formatLocation(location) {
        location.createdAt = new Date(location.createdAt);
        location.updatedAt = new Date(location.updatedAt);
        return location;
    }
    formatLocationClosure(locationClosedDay) {
        locationClosedDay.createdAt = new Date(locationClosedDay.createdAt);
        locationClosedDay.updatedAt = new Date(locationClosedDay.updatedAt);
        return locationClosedDay;
    }
    formatLocationSLA(locationSla) {
        locationSla.createdAt = new Date(locationSla.createdAt);
        locationSla.updatedAt = new Date(locationSla.updatedAt);
        locationSla.operatingDays = locationSla.operatingDays.map(operatingDay => this.locationSLAOperatingDay(operatingDay));
        return locationSla;
    }
    locationSLAOperatingDay(locationSLAOperatingDay) {
        locationSLAOperatingDay.createdAt = new Date(locationSLAOperatingDay.createdAt);
        locationSLAOperatingDay.updatedAt = new Date(locationSLAOperatingDay.updatedAt);
        return locationSLAOperatingDay;
    }
}
exports.default = LocationsService;
//# sourceMappingURL=LocationsService.js.map