@apihawk/billia-sdk/lib/services/billia-sdk-affiliate.js

The ApiHawk Billia SDK

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
const qs = require("qs");
const billia_sdk_service_base_1 = require("../lib/billia-sdk-service-base");
const to_rest_resource_1 = require("./common/to-rest-resource");
class BilliaSDKAffiliate extends billia_sdk_service_base_1.BilliaSDKServiceBase {
    /**
     * Get affiliate status
     * @param {IApihawkSession} session
     * @returns {Promise<IAffiliateEntity>}
     */
    getStatus(session) {
        return __awaiter(this, void 0, void 0, function* () {
            const affiliate = yield this.api.call({
                url: '/affiliate',
                method: 'GET',
                session,
                headers: {
                    'Accept-Response': 'Advanced'
                }
            });
            return affiliate._embedded.affiliate[0];
        });
    }
    /**
     * Get affiliate commissions
     * @param {IApihawkSession} session
     * @param query
     * @returns {Promise<IRestPaginatedResource<IAffiliateCommissionEntity>>}
     */
    getAffiliateCommission(session, query = {}) {
        return __awaiter(this, void 0, void 0, function* () {
            const q = query || {};
            const filterData = {};
            if (q.sort_by && q.sort_order) {
                switch (q.sort_by) {
                    case 'status':
                        filterData.order = [{ field: 'status', sort: q.sort_order }];
                        break;
                    case 'amount':
                        filterData.order = [{ field: 'amount', sort: q.sort_order }];
                        break;
                    case 'date':
                        filterData.order = [{ field: 'date', sort: q.sort_order }];
                        break;
                }
            }
            filterData.page = q.page || 1;
            filterData.page_size = q.page_size || 25;
            const commission = yield this.api.call({
                url: '/affiliate-commission',
                method: 'GET',
                query: filterData,
                session,
                headers: {
                    'Accept-Response': 'Advanced'
                }
            });
            return to_rest_resource_1.toRestResource(commission, 'affiliate_commission');
        });
    }
    /**
     * Get affiliate multi-tier level
     * @param {IApihawkSession} session
     * @param query
     * @returns {Promise<IRestPaginatedResource<IAffiliateMultiTierLevelEntity>>}
     */
    getAffiliateMultiTierLevel(session, query = {}) {
        return __awaiter(this, void 0, void 0, function* () {
            const filter = {
                page: query.page || 1,
                page_size: query.page_size || 25,
                where: []
            };
            if (query.type) {
                filter.where.push({
                    field: 'affiliate_type',
                    where: 'and',
                    type: 'equalTo',
                    value: query.type
                });
            }
            if (query.level) {
                filter.where.push({
                    field: 'level',
                    where: 'and',
                    type: 'equalTo',
                    value: query.level
                });
            }
            if (query.productIds) {
                filter.where.push({
                    field: 'product_id',
                    where: 'and',
                    type: 'in',
                    values: query.productIds
                });
            }
            const multiTierLevel = yield this.api.call({
                url: `/billing/affiliate/multi_tier_level?${qs.stringify(filter)}`,
                method: 'GET',
                session,
                headers: {
                    'Accept-Response': 'Advanced'
                }
            });
            return to_rest_resource_1.toRestResource(multiTierLevel, 'affiliate_multi_tier_level');
        });
    }
    /**
     * Sign up for affiliate program
     * @param {IApihawkSession} session
     * @param {number} userId
     * @returns {Promise<IAffiliateEntity>}
     */
    signUp(session, userId) {
        return __awaiter(this, void 0, void 0, function* () {
            return this.api.call({
                url: '/affiliate',
                method: 'POST',
                body: {
                    user_id: userId
                },
                session
            });
        });
    }
    /**
     * Get promocode
     * @param {IApihawkSession} session
     * @param {string} promocode
     * @returns {Promise<IDiscountPromocodeEntity>}
     */
    getPromocode(session, promocode) {
        return __awaiter(this, void 0, void 0, function* () {
            if (!promocode) {
                throw new Error('Error getting promocode.');
            }
            const promocodeResponse = yield this.api.call({
                url: `/discount/promocode/${encodeURIComponent(promocode)}`,
                method: 'GET',
                session
            });
            const promocodeProducts = yield this.getPromocodeProducts(session, [
                promocode
            ]);
            promocodeResponse.promocode_products = promocodeProducts.items;
            return promocodeResponse;
        });
    }
    /**
     * Get affiliate promocodes
     * @param {IApihawkSession} session
     * @param query
     * @returns {Promise<IRestPaginatedResource<IDiscountPromocodeEntity>>}
     */
    getAffiliatePromocodes(session, query = {}) {
        return __awaiter(this, void 0, void 0, function* () {
            if (!query.affiliate_id) {
                throw new Error('Error getting affiliate promocodes.');
            }
            const filter = {
                page: query.page || 1,
                page_size: query.page_size || 25,
                where: [
                    {
                        field: 'affiliate_id',
                        where: 'and',
                        type: 'equalTo',
                        value: query.affiliate_id
                    }
                ]
            };
            const promocodes = yield this.api.call({
                url: `/discount/promocode?${qs.stringify(filter)}`,
                method: 'GET',
                session
            });
            if (!promocodes._embedded.promocode_discount.length) {
                return to_rest_resource_1.toRestResource(promocodes, 'promocode_discount');
            }
            const promocodeProducts = yield this.getPromocodeProducts(session, promocodes._embedded.promocode_discount.map((p) => p.name), query.affiliate_type, query.affiliate_level);
            promocodes._embedded.promocode_discount.forEach((promocode) => {
                if (!promocode.promocode_products) {
                    promocode.promocode_products = [];
                }
                promocodeProducts.items.forEach((promocodeProduct) => {
                    if (promocode.name === promocodeProduct.code_name) {
                        // @ts-ignore
                        promocode.promocode_products.push(promocodeProduct);
                    }
                });
            });
            return to_rest_resource_1.toRestResource(promocodes, 'promocode_discount');
        });
    }
    /**
     * Create promocode
     * @param {IApihawkSession} session
     * @param {IDiscountPromocodeEntity} data
     * @param {any[]} products
     * @returns {Promise<IDiscountPromocodeEntity>}
     */
    createPromocode(session, data, products) {
        return __awaiter(this, void 0, void 0, function* () {
            const validationError = this.validate(data, ['affiliate', 'promocode']);
            if (validationError) {
                throw validationError;
            }
            const promocode = yield this.api.call({
                url: '/discount/promocode',
                method: 'POST',
                body: data,
                session
            });
            if (products && products.length) {
                const discounts = yield this.createDiscounts(session, products, data.name);
            }
            return promocode;
        });
    }
    /**
     * Update promocode
     * @param {IApihawkSession} session
     * @param {IDiscountPromocodeEntity} data
     * @param {any[]} products
     * @param {any[]} productsToRemove
     * @returns {Promise<IDiscountPromocodeEntity>}
     */
    updatePromocode(session, data, products, productsToRemove) {
        return __awaiter(this, void 0, void 0, function* () {
            const validationError = this.validate(data, ['affiliate', 'promocode']);
            if (validationError) {
                throw validationError;
            }
            const promocode = yield this.api.call({
                url: `/discount/promocode/${encodeURIComponent(data.name)}`,
                method: 'PATCH',
                body: {
                    limit: data.limit,
                    start_date: data.start_date,
                    end_date: data.end_date
                },
                session
            });
            if (products && products.length) {
                const createDiscountsResponse = yield this.createDiscounts(session, products, data.name);
            }
            if (productsToRemove && productsToRemove.length) {
                const deleteDiscountsResponse = yield this.deleteDiscounts(session, productsToRemove);
            }
            return promocode;
        });
    }
    /**
     * Create discounts for the provided products with promocode and amount
     * @param {IApihawkSession} session
     * @param {any[]} products
     * @param {string} promocode
     * @returns {Promise<IDiscountProductEntity[]>}
     */
    createDiscounts(session, products, promocode) {
        return __awaiter(this, void 0, void 0, function* () {
            const promises = [];
            products.forEach((product) => {
                if (!product.id) {
                    promises.push(new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
                        const discountProduct = yield this.api.call({
                            url: '/discount/product',
                            method: 'POST',
                            body: {
                                product_id: product.product_id,
                                type: 'percent',
                                discount: product.discount,
                                hook: 'promocode',
                                item_type: 'new',
                                min_quantity: 1,
                                max_quantity: 36
                            },
                            session
                        });
                        if (promocode) {
                            const promocodeProduct = yield this.api.call({
                                url: '/discount/promocode/products',
                                method: 'POST',
                                body: {
                                    discount_id: discountProduct.id,
                                    code_name: promocode,
                                    product_id: product.product_id
                                },
                                session
                            });
                        }
                        resolve(discountProduct);
                    })));
                }
            });
            const result = yield Promise.all(promises);
            return result;
        });
    }
    /**
     * Remove discounts
     * @param {IApihawkSession} session
     * @param {any[]} data
     * @returns {Promise<IDiscountProductEntity[]>}
     */
    deleteDiscounts(session, data) {
        return __awaiter(this, void 0, void 0, function* () {
            const promises = [];
            data.forEach((item) => {
                promises.push(new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
                    const discountProduct = yield this.api.call({
                        url: `/discount/promocode/products/${item.promocode_product_id}`,
                        method: 'DELETE',
                        session
                    });
                    resolve(discountProduct);
                })));
            });
            const result = yield Promise.all(promises);
            return result;
        });
    }
    /**
     * Update discount amount
     * @param {IApihawkSession} session
     * @param data
     * @returns {Promise<IDiscountProductEntity>}
     */
    updateDiscountProduct(session, data) {
        return __awaiter(this, void 0, void 0, function* () {
            const discountProduct = yield this.api.call({
                url: `/discount/product/${data.discount_id}`,
                method: 'PATCH',
                body: {
                    discount: data.discount
                },
                session
            });
            return discountProduct;
        });
    }
    /**
     * Get promocode products
     * @param {IApihawkSession} session
     * @param {string[]} promocodes
     * @param affiliateType
     * @param affiliateLevel
     * @returns {Promise<IRestPaginatedResource<IDiscountPromocodeProductsEntity>>}
     */
    getPromocodeProducts(session, promocodes = [], affiliateType, affiliateLevel) {
        return __awaiter(this, void 0, void 0, function* () {
            const filter = {
                page: 1,
                page_size: -1,
                where: [
                    {
                        field: 'code_name',
                        where: 'and',
                        type: 'in',
                        values: promocodes
                    }
                ]
            };
            const promocodeProducts = yield this.api.call({
                url: `/discount/promocode/products?${qs.stringify(filter)}`,
                method: 'GET',
                session
            });
            if (!promocodeProducts._embedded.promocode_products.length) {
                return to_rest_resource_1.toRestResource(promocodeProducts, 'promocode_products');
            }
            const catalogProductIds = [
                ...new Set(promocodeProducts._embedded.promocode_products.map((promocodeProduct) => +promocodeProduct.product_id))
            ];
            const catalogProducts = yield this.getCatalogProducts(session, catalogProductIds);
            const promocodeDiscountIds = [
                ...new Set(promocodeProducts._embedded.promocode_products.map((promocodeProduct) => promocodeProduct.discount_id))
            ];
            const promocodeDiscounts = yield this.getPromocodeDiscounts(session, promocodeDiscountIds);
            const multiTierLevels = yield this.getAffiliateMultiTierLevel(session, {
                page: 1,
                page_size: -1,
                type: affiliateType,
                level: affiliateLevel,
                productIds: [0, ...catalogProductIds]
            });
            let defaultMultiTierLevel;
            multiTierLevels.items.forEach((multiTierLevel) => {
                if (multiTierLevel.product_id === 0) {
                    defaultMultiTierLevel = multiTierLevel;
                }
            });
            promocodeProducts._embedded.promocode_products.forEach((pp) => {
                catalogProducts._embedded.catalog_product.forEach((cp) => {
                    if (+pp.product_id === +cp.product_id) {
                        pp.product = cp;
                    }
                });
                promocodeDiscounts._embedded.product_discount.forEach((pd) => {
                    if (+pp.discount_id === +pd.id) {
                        pp.discount = pd;
                    }
                });
                multiTierLevels.items.forEach((multiTierLevel) => {
                    if (!pp.multiTierLevel) {
                        pp.multiTierLevel = defaultMultiTierLevel;
                    }
                    if (+pp.product_id === +multiTierLevel.product_id) {
                        pp.multiTierLevel = multiTierLevel;
                    }
                });
            });
            return to_rest_resource_1.toRestResource(promocodeProducts, 'promocode_products');
        });
    }
    /**
     * Get catalog products fitered by product_id
     * @param {IApihawkSession} session
     * @param {Array<string | number>} productIds
     * @returns {Promise<IZendRestPaginatedResource<ICatalogProduct>>}
     */
    getCatalogProducts(session, productIds = []) {
        return __awaiter(this, void 0, void 0, function* () {
            const filter = {
                page: 1,
                page_size: -1,
                where: [
                    {
                        field: 'product_id',
                        where: 'and',
                        type: 'in',
                        values: productIds
                    }
                ]
            };
            return this.api.call({
                url: `/billing/product?${qs.stringify(filter)}`,
                method: 'GET',
                headers: {
                    'Accept-Response': 'Advanced'
                },
                session
            });
        });
    }
    /**
     * Get promocode discounts filtered by discount_id
     * @param {IApihawkSession} session
     * @param {Array<string | number>} discountIds
     * @returns {Promise<any>}
     */
    getPromocodeDiscounts(session, discountIds = []) {
        return __awaiter(this, void 0, void 0, function* () {
            const filter = {
                page: 1,
                page_size: -1,
                where: [
                    {
                        field: 'id',
                        where: 'and',
                        type: 'in',
                        values: discountIds
                    }
                ]
            };
            return this.api.call({
                url: `/discount/product?${qs.stringify(filter)}`,
                method: 'GET',
                session
            });
        });
    }
}
exports.BilliaSDKAffiliate = BilliaSDKAffiliate;