channelape-sdk/dist/orders/service/OrdersService.js

A client for interacting with ChannelApe's API

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Resource_1 = require("../../model/Resource");
const Version_1 = require("../../model/Version");
const GenerateApiError_1 = require("../../utils/GenerateApiError");
const Q = require("q");
const EXPECTED_GET_STATUS = 200;
const EXPECTED_UPDATE_STATUS = 202;
class OrdersService {
    constructor(client) {
        this.client = client;
    }
    get(orderIdOrRequest) {
        if (typeof orderIdOrRequest === 'string') {
            return this.getByOrderId(orderIdOrRequest);
        }
        const deferred = Q.defer();
        const getSinglePage = false;
        this.getOrdersByRequest(orderIdOrRequest, [], deferred, getSinglePage);
        return deferred.promise;
    }
    getPage(orderRequest) {
        const deferred = Q.defer();
        const getSinglePage = true;
        this.getOrdersByRequest(orderRequest, [], deferred, getSinglePage);
        return deferred.promise;
    }
    update(order) {
        const deferred = Q.defer();
        const requestUrl = `${Version_1.default.V1}${Resource_1.default.ORDERS}/${order.id}`;
        const options = {
            body: order
        };
        this.client.put(requestUrl, options, (error, response, body) => {
            this.mapOrderPromise(requestUrl, deferred, error, response, body, EXPECTED_UPDATE_STATUS);
        });
        return deferred.promise;
    }
    getByOrderId(orderId) {
        const deferred = Q.defer();
        const requestUrl = `/${Version_1.default.V1}${Resource_1.default.ORDERS}/${orderId}`;
        this.client.get(requestUrl, (error, response, body) => {
            this.mapOrderPromise(requestUrl, deferred, error, response, body, EXPECTED_GET_STATUS);
        });
        return deferred.promise;
    }
    getOrdersByRequest(ordersRequest, orders, deferred, getSinglePage) {
        const requestUrl = `/${Version_1.default.V1}${Resource_1.default.ORDERS}`;
        const ordersQueryParams = ordersRequest;
        if (ordersQueryParams.startDate != null && typeof ordersQueryParams.startDate !== 'string') {
            ordersQueryParams.startDate = ordersQueryParams.startDate.toISOString();
        }
        if (ordersQueryParams.endDate != null && typeof ordersQueryParams.endDate !== 'string') {
            ordersQueryParams.endDate = ordersQueryParams.endDate.toISOString();
        }
        const options = {
            qs: ordersQueryParams
        };
        this.client.get(requestUrl, options, (error, response, body) => {
            const requestResponse = {
                error,
                response,
                body
            };
            this.mapOrdersPromise(requestUrl, deferred, requestResponse, orders, ordersRequest, EXPECTED_GET_STATUS, getSinglePage);
        });
    }
    mapOrderPromise(requestUrl, deferred, error, response, body, expectedStatusCode) {
        if (error) {
            deferred.reject(error);
        }
        else if (response.statusCode === expectedStatusCode) {
            const order = this.formatOrder(body);
            deferred.resolve(order);
        }
        else {
            const channelApeErrorResponse = GenerateApiError_1.default(requestUrl, response, body, EXPECTED_UPDATE_STATUS);
            deferred.reject(channelApeErrorResponse);
        }
    }
    mapOrdersPromise(requestUrl, deferred, requestCallbackParams, orders, ordersRequest, expectedStatusCode, getSinglePage) {
        if (requestCallbackParams.error) {
            deferred.reject(requestCallbackParams.error);
        }
        else if (requestCallbackParams.response.statusCode === expectedStatusCode) {
            const data = requestCallbackParams.body;
            const mergedOrders = orders.concat(data.orders);
            if (getSinglePage) {
                deferred.resolve({
                    orders: mergedOrders.map(o => this.formatOrder(o)),
                    pagination: data.pagination
                });
            }
            else if (data.pagination.lastPage) {
                const ordersToReturn = mergedOrders.map(o => this.formatOrder(o));
                deferred.resolve(ordersToReturn);
            }
            else {
                const newOrdersRequest = Object.assign({}, ordersRequest, { lastKey: data.pagination.lastKey });
                this.getOrdersByRequest(newOrdersRequest, mergedOrders, deferred, getSinglePage);
            }
        }
        else {
            const channelApeErrorResponse = GenerateApiError_1.default(requestUrl, requestCallbackParams.response, requestCallbackParams.body, EXPECTED_UPDATE_STATUS);
            deferred.reject(channelApeErrorResponse);
        }
    }
    formatOrder(order) {
        order.purchasedAt = new Date(order.purchasedAt);
        if (order.canceledAt != null) {
            order.canceledAt = new Date(order.canceledAt);
        }
        order.updatedAt = new Date(order.updatedAt);
        order.createdAt = new Date(order.createdAt);
        order.status = order.status;
        order.totalPrice = Number(order.totalPrice);
        order.subtotalPrice = Number(order.subtotalPrice);
        order.totalShippingPrice = Number(order.totalShippingPrice);
        if (typeof order.totalShippingTax !== 'undefined') {
            order.totalShippingTax = Number(order.totalShippingTax);
        }
        order.totalTax = Number(order.totalTax);
        order.totalGrams = Number(order.totalGrams);
        order.lineItems = order.lineItems.map(this.formatLineItem);
        order.fulfillments = order.fulfillments.map((f) => this.formatFulfillment(f));
        return order;
    }
    formatFulfillment(fulfillment) {
        fulfillment.lineItems = fulfillment.lineItems.map(this.formatLineItem);
        return fulfillment;
    }
    formatLineItem(lineItem) {
        lineItem.grams = Number(lineItem.grams);
        lineItem.price = Number(lineItem.price);
        return lineItem;
    }
}
exports.default = OrdersService;
//# sourceMappingURL=OrdersService.js.map