channelape-sdk/dist/variants/service/VariantsService.js

A client for interacting with ChannelApe's API

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Q = require("q");
const Resource_1 = require("../../model/Resource");
const Version_1 = require("../../model/Version");
const GenerateApiError_1 = require("../../utils/GenerateApiError");
const EXPECTED_GET_STATUS = 200;
const PARSE_INT_RADIX = 10;
class VariantsService {
    constructor(client) {
        this.client = client;
    }
    get(variantRequest) {
        const deferred = Q.defer();
        if (variantRequest.inventoryItemValue) {
            this.getVariantByRequest(variantRequest, deferred);
        }
        else {
            this.getVariantsByRequest(variantRequest, [], deferred);
        }
        return deferred.promise;
    }
    search(variantSearchRequest) {
        const deferred = Q.defer();
        const getSinglePage = false;
        this.getVariantSearchResultsByRequest(variantSearchRequest, [], deferred, getSinglePage);
        return deferred.promise;
    }
    getPage(variantsSearchRequestByProductFilterId) {
        const deferred = Q.defer();
        const getSinglePage = true;
        this.getVariantSearchResultsByProductFilterId(variantsSearchRequestByProductFilterId, [], deferred, getSinglePage);
        return deferred.promise;
    }
    getVariantSearchResultsByRequest(variantSearchRequest, variantSearchDetails, deferred, getSinglePage) {
        let requestUrl = `${Version_1.default.V1}${Resource_1.default.PRODUCTS}${Resource_1.default.VARIANTS}`;
        if (variantSearchRequest.vendor) {
            requestUrl += Resource_1.default.VENDORS;
        }
        if (variantSearchRequest.sku) {
            requestUrl += Resource_1.default.SKUS;
        }
        if (variantSearchRequest.upc) {
            requestUrl += Resource_1.default.UPCS;
        }
        if (variantSearchRequest.tag) {
            requestUrl += Resource_1.default.TAGS;
        }
        const options = {
            params: variantSearchRequest
        };
        this.client.get(requestUrl, options, (error, response, body) => {
            const requestResponse = {
                error,
                response,
                body
            };
            this.mapVariantsSearchPromise(requestUrl, deferred, requestResponse, variantSearchDetails, variantSearchRequest, EXPECTED_GET_STATUS, getSinglePage);
        });
        return deferred.promise;
    }
    getVariantSearchResultsByProductFilterId(variantSearchRequest, variantSearchDetails, deferred, getSinglePage) {
        const requestUrl = `${Version_1.default.V1}${Resource_1.default.PRODUCTS}${Resource_1.default.VARIANTS}`;
        const options = {
            params: variantSearchRequest
        };
        this.client.get(requestUrl, options, (error, response, body) => {
            const requestResponse = {
                error,
                response,
                body
            };
            this.mapVariantsSearchPromise(requestUrl, deferred, requestResponse, variantSearchDetails, variantSearchRequest, EXPECTED_GET_STATUS, getSinglePage);
        });
        return deferred.promise;
    }
    getVariantByRequest(variantRequest, deferred) {
        const requestUrl = `/${Version_1.default.V1}${Resource_1.default.PRODUCTS}/${variantRequest.productId}${Resource_1.default.VARIANTS}/` +
            `${encodeURIComponent(variantRequest.inventoryItemValue)}`;
        const options = {};
        this.client.get(requestUrl, options, (error, response, body) => {
            const requestResponse = {
                error,
                response,
                body
            };
            this.mapVariantPromise(requestUrl, deferred, requestResponse, EXPECTED_GET_STATUS);
        });
    }
    getVariantsByRequest(variantsRequest, variants, deferred) {
        const requestUrl = `/${Version_1.default.V1}${Resource_1.default.PRODUCTS}/${variantsRequest.productId}${Resource_1.default.VARIANTS}`;
        const options = {};
        this.client.get(requestUrl, options, (error, response, body) => {
            const requestResponse = {
                error,
                response,
                body
            };
            this.mapVariantsPromise(requestUrl, deferred, requestResponse, variants, EXPECTED_GET_STATUS);
        });
    }
    mapVariantPromise(requestUrl, deferred, requestResponse, expectedStatusCode) {
        if (requestResponse.error) {
            deferred.reject(requestResponse.error);
        }
        else if (requestResponse.response.status === expectedStatusCode) {
            const variant = this.formatVariant(requestResponse.body);
            deferred.resolve(variant);
        }
        else {
            const channelApeErrorResponse = (0, GenerateApiError_1.default)(requestUrl, requestResponse.response, requestResponse.body, EXPECTED_GET_STATUS);
            deferred.reject(channelApeErrorResponse);
        }
    }
    mapVariantsPromise(requestUrl, deferred, requestCallbackParams, variants, expectedStatusCode) {
        if (requestCallbackParams.error) {
            deferred.reject(requestCallbackParams.error);
        }
        else if (requestCallbackParams.response.status === expectedStatusCode) {
            const data = requestCallbackParams.body;
            const mergedVariants = variants.concat(data.variants.map(v => this.formatVariant(v)));
            deferred.resolve(mergedVariants);
        }
        else {
            const channelApeErrorResponse = (0, GenerateApiError_1.default)(requestUrl, requestCallbackParams.response, requestCallbackParams.body, EXPECTED_GET_STATUS);
            deferred.reject(channelApeErrorResponse);
        }
    }
    mapVariantsSearchPromise(requestUrl, deferred, requestCallbackParams, variantDetails, variantsRequest, expectedStatusCode, getSinglePage) {
        if (requestCallbackParams.error) {
            deferred.reject(requestCallbackParams.error);
        }
        else if (requestCallbackParams.response.status === expectedStatusCode) {
            const data = requestCallbackParams.body;
            const variantSearchResults = data.variantSearchResults.map(vs => this.formatVariantSearchDetails(vs));
            const mergedVariantDetails = variantDetails.concat(variantSearchResults);
            if (getSinglePage) {
                const variantSearchDetailsToReturn = variantsRequest.exactMatch
                    ? this.filterOutNonExactMatches(mergedVariantDetails, variantsRequest) : mergedVariantDetails;
                deferred.resolve({
                    variantSearchResults: variantSearchDetailsToReturn,
                    pagination: data.pagination
                });
            }
            else if (data.pagination.lastPage) {
                const variantSearchDetailsToReturn = variantsRequest.exactMatch
                    ? this.filterOutNonExactMatches(mergedVariantDetails, variantsRequest) : mergedVariantDetails;
                deferred.resolve(variantSearchDetailsToReturn);
            }
            else {
                const newVariantsRequest = Object.assign(Object.assign({}, variantsRequest), { lastKey: data.pagination.lastKey });
                this.getVariantSearchResultsByRequest(newVariantsRequest, mergedVariantDetails, deferred, getSinglePage);
            }
        }
        else {
            const channelApeErrorResponse = (0, GenerateApiError_1.default)(requestUrl, requestCallbackParams.response, requestCallbackParams.body, EXPECTED_GET_STATUS);
            deferred.reject(channelApeErrorResponse);
        }
    }
    filterOutNonExactMatches(variantSearchDetails, variantSearchRequest) {
        return variantSearchDetails.filter((searchResult) => {
            if (variantSearchRequest.sku && searchResult.sku.toLowerCase() !== variantSearchRequest.sku.toLowerCase()) {
                return false;
            }
            if (variantSearchRequest.upc &&
                searchResult.upc.toLowerCase() !== variantSearchRequest.upc.toLowerCase()) {
                return false;
            }
            return true;
        });
    }
    formatVariant(variant) {
        return {
            additionalFields: variant.additionalFields,
            alphabeticCurrencyCode: variant.alphabeticCurrencyCode,
            categories: variant.categories,
            condition: variant.condition,
            createdAt: new Date(variant.createdAt),
            description: variant.description,
            errors: variant.errors,
            grams: parseInt(variant.grams, PARSE_INT_RADIX),
            images: variant.images,
            inventoryItemValue: variant.inventoryItemValue,
            options: variant.options,
            productId: variant.productId,
            quantity: variant.quantity,
            retailPrice: parseFloat(variant.retailPrice),
            sku: variant.sku ? variant.sku : '',
            upc: variant.upc ? variant.upc : '',
            tags: variant.tags,
            title: variant.title,
            updatedAt: new Date(variant.updatedAt),
            vendor: variant.vendor,
            wholesalePrice: parseFloat(variant.wholesalePrice)
        };
    }
    formatVariantSearchDetails(variantSearchDetails) {
        return {
            businessId: variantSearchDetails.businessId,
            condition: variantSearchDetails.condition,
            currencyCode: variantSearchDetails.currencyCode,
            grams: parseInt(variantSearchDetails.grams, PARSE_INT_RADIX),
            inventoryItemValue: variantSearchDetails.inventoryItemValue,
            primaryCategory: variantSearchDetails.primaryCategory,
            productId: variantSearchDetails.productId,
            quantity: variantSearchDetails.quantity,
            retailPrice: parseFloat(variantSearchDetails.retailPrice),
            sku: variantSearchDetails.sku,
            tags: variantSearchDetails.tags,
            title: variantSearchDetails.title,
            upc: variantSearchDetails.upc,
            vendor: variantSearchDetails.vendor,
            wholesalePrice: parseFloat(variantSearchDetails.wholesalePrice)
        };
    }
}
exports.default = VariantsService;
//# sourceMappingURL=VariantsService.js.map