addio-admin-sdk 1.6.5

package/dist/lib/Product/index.js

@@ -0,0 +1,1325 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    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) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var Product_1 = require("../../Interfaces/Indexed/Product");
+var lodash_1 = require("lodash");
+var file_1 = require("../../utils/file");
+var context_1 = require("../../utils/context");
+var console_1 = require("../../utils/console");
+var currency_1 = require("../../utils/currency");
+var object_1 = require("../../utils/object");
+var services_1 = require("../../utils/services");
+var locale_1 = require("../../utils/locale");
+var algolia_1 = require("../../utils/algolia");
+var __1 = require("../..");
+var MarketplacePublication_1 = __importDefault(require("../MarketplacePublication"));
+var ProductAttribute_1 = __importDefault(require("../ProductAttribute"));
+var Product_2 = __importDefault(require("../Indexed/Product"));
+var Declination_1 = __importDefault(require("../Declination"));
+var Category_1 = __importDefault(require("../Category"));
+var Discount_1 = __importDefault(require("../Discount"));
+var moment_1 = __importDefault(require("moment"));
+var Brand_1 = __importDefault(require("../Brand"));
+var Space_1 = __importDefault(require("../Space"));
+var g2_1 = require("../../rules/GR/utils/g2");
+var baseService_1 = require("../baseService");
+var DatabaseService_1 = __importDefault(require("../../services/database/DatabaseService"));
+var Product = (function (_super) {
+    __extends(Product, _super);
+    function Product() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.data = function () { return _this._data; };
+        _this.toCSV = function () {
+            return __assign(__assign({}, _this.data()), { product_attributes: !!_this.data().product_attributes
+                    ? _this.data().product_attributes.map(function (pa) { return pa.attribute_id; })
+                    : undefined, declinations: !!_this.data().declinations
+                    ? _this.data().declinations.map(function (d) { return d.name; })
+                    : undefined, brand: !!_this.data().brand ? _this.data().brand.key : undefined, classes: !!_this.data().classes ? _this.data().classes.map(function (c) { return c.key; }) : undefined, category: !!_this.data().category ? _this.data().category.key : undefined });
+        };
+        _this.allRelationships = function () { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4, this.relationships(['brands'])];
+                    case 1: return [2, _c.sent()];
+                }
+            });
+        }); };
+        _this.getDefaultSupplier = function () {
+            var data = _this.data();
+            if (!!!data.suppliers)
+                return undefined;
+            var supplier = data.suppliers.filter(function (supplier) {
+                return supplier.supplier_order == 0;
+            })[0];
+            return supplier.supplier_id;
+        };
+        _this.relationships = function (relations) { return __awaiter(_this, void 0, void 0, function () {
+            var relationships, _getKeyFromRelationType, _i, relations_1, relation, relationReq, relationData;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        if (relations.length === 0)
+                            return [2, {}];
+                        relationships = {};
+                        _getKeyFromRelationType = function (_relation) {
+                            switch (_relation) {
+                                case 'brands':
+                                default:
+                                    return 'brand';
+                            }
+                        };
+                        _i = 0, relations_1 = relations;
+                        _c.label = 1;
+                    case 1:
+                        if (!(_i < relations_1.length)) return [3, 4];
+                        relation = relations_1[_i];
+                        if (!!relationships[relation])
+                            return [3, 3];
+                        if (!!!this._data[_getKeyFromRelationType(relation)])
+                            return [3, 3];
+                        return [4, DatabaseService_1.default.getDocument(DatabaseService_1.default.addToPath(DatabaseService_1.default.getPathParent(this._collection.path), relation), this._data[_getKeyFromRelationType(relation)].key)];
+                    case 2:
+                        relationReq = _c.sent();
+                        if (!relationReq.exists)
+                            return [3, 3];
+                        relationData = relationReq.data;
+                        if (!!!relationData)
+                            return [3, 3];
+                        relationships[_getKeyFromRelationType(relation)] = __assign(__assign({}, relationData), { id: relationReq.id });
+                        _c.label = 3;
+                    case 3:
+                        _i++;
+                        return [3, 1];
+                    case 4: return [2, relationships];
+                }
+            });
+        }); };
+        _this.save = function (partialProduct, options) { return __awaiter(_this, void 0, void 0, function () {
+            var beforeData, _c, id;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        beforeData = __assign({}, this._data);
+                        this._data = __assign(__assign({}, this._data), partialProduct);
+                        _c = this;
+                        return [4, this._updateDependancies(this._data, beforeData, !!options ? options.space : undefined)];
+                    case 1:
+                        _c._data = (_e.sent());
+                        this._data = __assign(__assign({}, this._data), { last_update_by: this._user });
+                        return [4, _super.prototype.save.call(this, this._data, undefined, true, true, true, beforeData)];
+                    case 2:
+                        id = _e.sent();
+                        if (!!id && !!!this._data.id && typeof id === 'string') {
+                            this._data = __assign(__assign({}, this._data), { id: id });
+                        }
+                        if (!!!options) {
+                            return [2, true];
+                        }
+                        return [2, id];
+                }
+            });
+        }); };
+        _this._updateDependancies = function (product, beforeData, space) { return __awaiter(_this, void 0, void 0, function () {
+            var productToUpdate, error_1;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        (0, console_1.workingMessage)('Updating images and stuff');
+                        productToUpdate = product;
+                        _c.label = 1;
+                    case 1:
+                        _c.trys.push([1, 10, , 11]);
+                        if (!!!!space) return [3, 3];
+                        return [4, Space_1.default.getCurrentSpaceWithRef(this._collection.path, this._user)];
+                    case 2:
+                        space = _c.sent();
+                        _c.label = 3;
+                    case 3: return [4, this._uploadDeclinationsImages(productToUpdate)];
+                    case 4:
+                        productToUpdate = _c.sent();
+                        return [4, this._updateSEOImage(productToUpdate)];
+                    case 5:
+                        productToUpdate = _c.sent();
+                        return [4, this._updatePanelDescriptionsImage(productToUpdate)];
+                    case 6:
+                        productToUpdate = _c.sent();
+                        return [4, this._updateDeclinationsDiscountRules(productToUpdate, beforeData)];
+                    case 7:
+                        productToUpdate = _c.sent();
+                        return [4, this._updateBarcode(productToUpdate, space)];
+                    case 8:
+                        productToUpdate = _c.sent();
+                        return [4, this._updateInventoryItem(productToUpdate, beforeData, space)];
+                    case 9:
+                        _c.sent();
+                        return [2, productToUpdate];
+                    case 10:
+                        error_1 = _c.sent();
+                        (0, console_1.errorMessage)("Error while updating dependancies: ".concat(error_1, " - ").concat(JSON.stringify(error_1)));
+                        return [2, product];
+                    case 11: return [2];
+                }
+            });
+        }); };
+        _this._updateSEOImage = function (product) { return __awaiter(_this, void 0, void 0, function () {
+            var _c, _e, _f, _g;
+            var _h, _j, _k;
+            return __generator(this, function (_l) {
+                switch (_l.label) {
+                    case 0:
+                        _c = [__assign({}, product)];
+                        _h = {};
+                        _e = [__assign({}, product.seo_info)];
+                        _j = {};
+                        if (!(!!product.seo_info &&
+                            !!product.seo_info.seoImage &&
+                            !!product.seo_info.seoImage.img_path &&
+                            typeof product.seo_info.seoImage.img_path === 'string')) return [3, 1];
+                        _f = product.seo_info.seoImage;
+                        return [3, 5];
+                    case 1:
+                        _k = {};
+                        if (!(!!product.seo_info && !!product.seo_info.seoImage && !!product.seo_info.seoImage.img_path)) return [3, 3];
+                        return [4, (0, file_1.uploadFileToPath)(product.seo_info.seoImage.img_path.file, (0, context_1.getPathTo)("products/".concat(product.slug), (0, context_1.getIdsBasedOnSpaceDocRef)(DatabaseService_1.default.getPathParent(this._collection.path))))];
+                    case 2:
+                        _g = _l.sent();
+                        return [3, 4];
+                    case 3:
+                        _g = '';
+                        _l.label = 4;
+                    case 4:
+                        _f = (_k.img_path = _g,
+                            _k);
+                        _l.label = 5;
+                    case 5: return [2, __assign.apply(void 0, _c.concat([(_h.seo_info = __assign.apply(void 0, _e.concat([(_j.seoImage = _f, _j)])), _h)]))];
+                }
+            });
+        }); };
+        _this._updatePanelDescriptionsImage = function (product) { return __awaiter(_this, void 0, void 0, function () {
+            var _c;
+            var _e;
+            var _this = this;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0:
+                        if (!!!product.panel_descriptions || !!!product.panel_descriptions.length)
+                            return [2, product];
+                        _c = [__assign({}, product)];
+                        _e = {};
+                        return [4, Promise.all(product.panel_descriptions.map(function (panel) { return __awaiter(_this, void 0, void 0, function () {
+                                var _c, _e, _f, _g;
+                                var _h, _j, _k, _l;
+                                return __generator(this, function (_m) {
+                                    switch (_m.label) {
+                                        case 0:
+                                            if (!!!panel.img)
+                                                return [2, panel];
+                                            if (typeof panel.img.img_path === 'string' && !panel.img.img_path.includes('base64'))
+                                                return [2, panel];
+                                            if (!(typeof panel.img.img_path === 'string')) return [3, 2];
+                                            _c = [__assign({}, panel)];
+                                            _h = {};
+                                            _e = [__assign({}, panel.img)];
+                                            _j = {};
+                                            return [4, (0, file_1.uploadStringToPath)(panel.img.img_path, (0, context_1.getPathTo)("products/".concat(product.slug, "/panels"), (0, context_1.getIdsBasedOnSpaceDocRef)(DatabaseService_1.default.getPathParent(this._collection.path))), (0, locale_1.getPrincipalWord)(panel.label_name), 'jpg')];
+                                        case 1: return [2, __assign.apply(void 0, _c.concat([(_h.img = __assign.apply(void 0, _e.concat([(_j.img_path = _m.sent(), _j)])), _h)]))];
+                                        case 2:
+                                            if (!!!panel.img.img_path.file) return [3, 4];
+                                            _f = [__assign({}, panel)];
+                                            _k = {};
+                                            _g = [__assign({}, panel.img)];
+                                            _l = {};
+                                            return [4, (0, file_1.uploadFileToPath)(panel.img.img_path.file, (0, context_1.getPathTo)("products/".concat(product.slug, "/panels"), (0, context_1.getIdsBasedOnSpaceDocRef)(DatabaseService_1.default.getPathParent(this._collection.path))))];
+                                        case 3: return [2, __assign.apply(void 0, _f.concat([(_k.img = __assign.apply(void 0, _g.concat([(_l.img_path = _m.sent(), _l)])), _k)]))];
+                                        case 4: return [2, __assign(__assign({}, panel), { img: undefined })];
+                                    }
+                                });
+                            }); }))];
+                    case 1: return [2, __assign.apply(void 0, _c.concat([(_e.panel_descriptions = _f.sent(), _e)]))];
+                }
+            });
+        }); };
+        _this._updateBarcode = function (product, space) { return __awaiter(_this, void 0, void 0, function () {
+            var _c, error_2;
+            var _e;
+            var _this = this;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0:
+                        _f.trys.push([0, 4, , 5]);
+                        if (!!!!space) return [3, 2];
+                        return [4, Space_1.default.getCurrentSpaceWithRef(this._collection.path, this._user)];
+                    case 1:
+                        space = _f.sent();
+                        _f.label = 2;
+                    case 2:
+                        if (!!!space.data().product_preferences.generate_barcode)
+                            return [2, product];
+                        _c = [__assign({}, product)];
+                        _e = {};
+                        return [4, Promise.all((product.declinations || []).map(function (_d) { return __awaiter(_this, void 0, void 0, function () {
+                                var upc;
+                                return __generator(this, function (_c) {
+                                    switch (_c.label) {
+                                        case 0:
+                                            if (!!_d.upc)
+                                                return [2, _d];
+                                            if (!!!space)
+                                                return [2, _d];
+                                            upc = space.data().product_preferences.barcode_next;
+                                            return [4, space.save({
+                                                    product_preferences: __assign(__assign({}, space.data().product_preferences), { barcode_next: "".concat((0, lodash_1.toNumber)(upc) + 1) })
+                                                })];
+                                        case 1:
+                                            _c.sent();
+                                            return [2, __assign(__assign({}, _d), { upc: upc })];
+                                    }
+                                });
+                            }); }))];
+                    case 3: return [2, __assign.apply(void 0, _c.concat([(_e.declinations = _f.sent(), _e)]))];
+                    case 4:
+                        error_2 = _f.sent();
+                        console.log(error_2);
+                        return [2, product];
+                    case 5: return [2];
+                }
+            });
+        }); };
+        _this._updateInventoryItem = function (product, beforeData, space) { return __awaiter(_this, void 0, void 0, function () {
+            var declis, allSameProductInventories, _i, allSameProductInventories_1, inventory, e_1, allSameProductInventoriesSamples, allSameProductInventoriesNotSamples, deletedSkusSamples, deletedSkusNotSamples, skusToDelete, e_2;
+            var _this = this;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        declis = product.declinations;
+                        if (!!!declis || !!!declis.length)
+                            return [2];
+                        if (!!!!space) return [3, 2];
+                        return [4, Space_1.default.getCurrentSpaceWithRef(this._collection.path, this._user)];
+                    case 1:
+                        space = _c.sent();
+                        _c.label = 2;
+                    case 2: return [4, space.inventoryItems.getAllFromSameProduct(!!product.slug ? product.slug : this.data().slug)];
+                    case 3:
+                        allSameProductInventories = _c.sent();
+                        if (!!!allSameProductInventories || !!!allSameProductInventories.length)
+                            return [2, true];
+                        if (!(!!beforeData && !!product.is_service && beforeData.is_service !== product.is_service)) return [3, 11];
+                        _c.label = 4;
+                    case 4:
+                        _c.trys.push([4, 9, , 10]);
+                        _i = 0, allSameProductInventories_1 = allSameProductInventories;
+                        _c.label = 5;
+                    case 5:
+                        if (!(_i < allSameProductInventories_1.length)) return [3, 8];
+                        inventory = allSameProductInventories_1[_i];
+                        return [4, inventory.delete()];
+                    case 6:
+                        _c.sent();
+                        _c.label = 7;
+                    case 7:
+                        _i++;
+                        return [3, 5];
+                    case 8: return [3, 10];
+                    case 9:
+                        e_1 = _c.sent();
+                        console.log('error on deleting inventories of now service product: ', e_1);
+                        return [3, 10];
+                    case 10: return [2, true];
+                    case 11:
+                        allSameProductInventoriesSamples = allSameProductInventories.filter(function (i) { return !!i.data().is_sample; });
+                        allSameProductInventoriesNotSamples = allSameProductInventories.filter(function (i) { return !!!i.data().is_sample; });
+                        deletedSkusSamples = allSameProductInventoriesSamples.filter(function (inventory) {
+                            var decliSku = inventory.data().decli_sku_associated_to_sample;
+                            var foundDecli = declis.find(function (d) { return d.sku === decliSku; });
+                            return !!!foundDecli || !foundDecli.is_sample;
+                        });
+                        deletedSkusNotSamples = allSameProductInventoriesNotSamples.filter(function (inventory) { return !!!declis.some(function (d) { return d.sku === inventory.data().sku; }) && !!!inventory.data().is_sample; });
+                        skusToDelete = __spreadArray(__spreadArray([], deletedSkusSamples, true), deletedSkusNotSamples, true);
+                        if (!!!skusToDelete.length)
+                            return [2, true];
+                        _c.label = 12;
+                    case 12:
+                        _c.trys.push([12, 14, , 15]);
+                        return [4, Promise.all(skusToDelete.map(function (inventory) { return __awaiter(_this, void 0, void 0, function () {
+                                return __generator(this, function (_c) {
+                                    switch (_c.label) {
+                                        case 0: return [4, inventory.delete()];
+                                        case 1:
+                                            _c.sent();
+                                            return [2];
+                                    }
+                                });
+                            }); }))];
+                    case 13:
+                        _c.sent();
+                        return [3, 15];
+                    case 14:
+                        e_2 = _c.sent();
+                        console.log('error on deleting inventories of deleted skus: ', e_2);
+                        return [3, 15];
+                    case 15: return [2, true];
+                }
+            });
+        }); };
+        _this._updateDeclinationsDiscountRules = function (product, beforeData) { return __awaiter(_this, void 0, void 0, function () {
+            var lastPushedTime, _c, _e;
+            var _f;
+            var _this = this;
+            return __generator(this, function (_g) {
+                switch (_g.label) {
+                    case 0:
+                        lastPushedTime = '';
+                        _c = [__assign({}, product)];
+                        _f = {};
+                        if (!!!product.declinations) return [3, 2];
+                        return [4, Promise.all(product.declinations.map(function (declination, index) { return __awaiter(_this, void 0, void 0, function () {
+                                var timestamp, idString, duplicateTime, currentDataDeclis, sameInCurrentData, discountsToDelete, _i, discountsToDelete_1, discount, discountObj, e_3, _c, _e;
+                                var _f;
+                                var _this = this;
+                                return __generator(this, function (_g) {
+                                    switch (_g.label) {
+                                        case 0:
+                                            timestamp = (0, moment_1.default)().toDate().getTime();
+                                            idString = String(timestamp) + '-' + String(index);
+                                            duplicateTime = idString === lastPushedTime;
+                                            lastPushedTime = String(timestamp) + '-' + String(index);
+                                            currentDataDeclis = !!beforeData.declinations ? beforeData.declinations : [];
+                                            sameInCurrentData = currentDataDeclis.find(function (d) { return !!d && d.sku === declination.sku; });
+                                            discountsToDelete = [];
+                                            if (!!sameInCurrentData) {
+                                                discountsToDelete = (sameInCurrentData.discount_rules || []).filter(function (d) {
+                                                    return !!d &&
+                                                        d.discountRule_type === 'tier-pricing' &&
+                                                        (!!!declination.discount_rules ||
+                                                            !!!declination.discount_rules.length ||
+                                                            !!!declination.discount_rules.some(function (_d) { return _d.id === d.id; }));
+                                                });
+                                            }
+                                            if (!!duplicateTime) {
+                                                idString =
+                                                    idString.split('-')[0] + '-' + String(index + product.declinations.length);
+                                            }
+                                            if (!(!!discountsToDelete &&
+                                                !!discountsToDelete.length &&
+                                                DatabaseService_1.default.getPathParent(this._collection.path) !== '/')) return [3, 6];
+                                            console.log('** Going to delete tier-pricing discount_rules no longer in declination **');
+                                            _i = 0, discountsToDelete_1 = discountsToDelete;
+                                            _g.label = 1;
+                                        case 1:
+                                            if (!(_i < discountsToDelete_1.length)) return [3, 6];
+                                            discount = discountsToDelete_1[_i];
+                                            _g.label = 2;
+                                        case 2:
+                                            _g.trys.push([2, 4, , 5]);
+                                            discountObj = new Discount_1.default(discount, {
+                                                path: DatabaseService_1.default.addToPath(DatabaseService_1.default.getPathParent(this._collection.path), 'discountRules')
+                                            }, this._user);
+                                            return [4, discountObj.delete()];
+                                        case 3:
+                                            _g.sent();
+                                            return [3, 5];
+                                        case 4:
+                                            e_3 = _g.sent();
+                                            console.log('error on deleting discount: ', e_3);
+                                            return [3, 5];
+                                        case 5:
+                                            _i++;
+                                            return [3, 1];
+                                        case 6:
+                                            _c = [__assign({}, declination)];
+                                            _f = { id: !!declination.id ? declination.id : idString };
+                                            if (!(!!declination.discount_rules && !!declination.discount_rules.length)) return [3, 8];
+                                            return [4, Promise.all((0, lodash_1.sortedUniqBy)(declination.discount_rules, function (dr) {
+                                                    var rule = !!dr.rules && dr.rules.find(function (r) { return r.field === 'quantity'; });
+                                                    if (!!!rule)
+                                                        return false;
+                                                    return rule.ruleDetails[0].value[0];
+                                                }).map(function (rule) { return __awaiter(_this, void 0, void 0, function () {
+                                                    var _rule, id;
+                                                    return __generator(this, function (_c) {
+                                                        switch (_c.label) {
+                                                            case 0:
+                                                                if (DatabaseService_1.default.getPathParent(this._collection.path) === '/')
+                                                                    return [2, rule];
+                                                                if (rule.discountRule_type !== 'tier-pricing')
+                                                                    return [2, rule];
+                                                                _rule = new Discount_1.default(rule, {
+                                                                    path: DatabaseService_1.default.addToPath(DatabaseService_1.default.getPathParent(this._collection.path), 'discountRules')
+                                                                }, this._user);
+                                                                return [4, _rule.save()];
+                                                            case 1:
+                                                                id = _c.sent();
+                                                                return [2, __assign(__assign({}, rule), (!!!rule.id && typeof id === 'string' && !!id ? { id: id } : {}))];
+                                                        }
+                                                    });
+                                                }); }))];
+                                        case 7:
+                                            _e = _g.sent();
+                                            return [3, 9];
+                                        case 8:
+                                            _e = [];
+                                            _g.label = 9;
+                                        case 9: return [2, __assign.apply(void 0, _c.concat([(_f.discount_rules = _e, _f)]))];
+                                    }
+                                });
+                            }); }))];
+                    case 1:
+                        _e = _g.sent();
+                        return [3, 3];
+                    case 2:
+                        _e = [];
+                        _g.label = 3;
+                    case 3: return [2, __assign.apply(void 0, _c.concat([(_f.declinations = _e, _f)]))];
+                }
+            });
+        }); };
+        _this._uploadDeclinationsImages = function (product) { return __awaiter(_this, void 0, void 0, function () {
+            var _c, _e, _f;
+            var _g;
+            var _this = this;
+            return __generator(this, function (_h) {
+                switch (_h.label) {
+                    case 0:
+                        _c = [__assign({}, product)];
+                        _g = {};
+                        if (!(!!!product.image_files || !!!product.image_files.length)) return [3, 1];
+                        _e = [];
+                        return [3, 3];
+                    case 1: return [4, Promise.all(product.image_files
+                            .filter(function (i) { return !!i && !!i.img_path; })
+                            .map(function (imageInfo) { return __awaiter(_this, void 0, void 0, function () {
+                            var _c, _e, img_path;
+                            var _f, _g;
+                            return __generator(this, function (_h) {
+                                switch (_h.label) {
+                                    case 0:
+                                        if (!(!!imageInfo.img_path.dataURL && !!!imageInfo.img_path.file)) return [3, 3];
+                                        if (!(typeof imageInfo.img_path.dataURL === 'string' &&
+                                            !!imageInfo.img_path.dataURL.includes('base64'))) return [3, 2];
+                                        _c = [__assign({}, imageInfo)];
+                                        _f = {};
+                                        return [4, (0, file_1.uploadStringToPath)(imageInfo.img_path.dataURL, (0, context_1.getPathTo)("products/".concat(product.slug), (0, context_1.getIdsBasedOnSpaceDocRef)(DatabaseService_1.default.getPathParent(this._collection.path))), (0, locale_1.getPrincipalWord)(product.name), imageInfo.img_path.dataURL.split(';')[0].split('/')[1])];
+                                    case 1: return [2, __assign.apply(void 0, _c.concat([(_f.img_path = _h.sent(), _f)]))];
+                                    case 2: return [2, __assign(__assign({}, imageInfo), { img_path: imageInfo.img_path.dataURL })];
+                                    case 3:
+                                        if (!(typeof imageInfo.img_path === 'string')) return [3, 6];
+                                        if (!!!imageInfo.img_path.includes('base64')) return [3, 5];
+                                        _e = [__assign({}, imageInfo)];
+                                        _g = {};
+                                        return [4, (0, file_1.uploadStringToPath)(imageInfo.img_path, (0, context_1.getPathTo)("products/".concat(product.slug), (0, context_1.getIdsBasedOnSpaceDocRef)(DatabaseService_1.default.getPathParent(this._collection.path))), (0, locale_1.getPrincipalWord)(product.name), imageInfo.img_path.split(';')[0].split('/')[1])];
+                                    case 4: return [2, __assign.apply(void 0, _e.concat([(_g.img_path = _h.sent(), _g)]))];
+                                    case 5: return [2, imageInfo];
+                                    case 6: return [4, (0, file_1.uploadFileToPath)(imageInfo.img_path.file, (0, context_1.getPathTo)("products/".concat(product.slug), (0, context_1.getIdsBasedOnSpaceDocRef)(DatabaseService_1.default.getPathParent(this._collection.path))))];
+                                    case 7:
+                                        img_path = _h.sent();
+                                        return [2, __assign(__assign({}, imageInfo), { img_path: img_path })];
+                                }
+                            });
+                        }); }))];
+                    case 2:
+                        _e = _h.sent();
+                        _h.label = 3;
+                    case 3:
+                        _g.image_files = _e;
+                        if (!(!!!product.declinations || !!!product.declinations.length)) return [3, 4];
+                        _f = [];
+                        return [3, 6];
+                    case 4: return [4, Promise.all(product.declinations.map(function (declination) { return __awaiter(_this, void 0, void 0, function () {
+                            var _c;
+                            var _e;
+                            var _this = this;
+                            return __generator(this, function (_f) {
+                                switch (_f.label) {
+                                    case 0:
+                                        if (!!!declination.image_files)
+                                            return [2, declination];
+                                        if (!!!declination.image_files.length)
+                                            return [2, declination];
+                                        if (!!!declination.image_files.find(function (imageInfo) { return !!imageInfo.img_path && !!imageInfo.img_path.file; }))
+                                            return [2, declination];
+                                        _c = [__assign({}, declination)];
+                                        _e = {};
+                                        return [4, Promise.all(declination.image_files
+                                                .filter(function (i) { return !!i && !!i.img_path; })
+                                                .map(function (imageInfo) { return __awaiter(_this, void 0, void 0, function () {
+                                                var _c, img_path;
+                                                var _e;
+                                                return __generator(this, function (_f) {
+                                                    switch (_f.label) {
+                                                        case 0:
+                                                            if (!(typeof imageInfo.img_path === 'string')) return [3, 3];
+                                                            if (!!!imageInfo.img_path.includes('base64')) return [3, 2];
+                                                            _c = [__assign({}, imageInfo)];
+                                                            _e = {};
+                                                            return [4, (0, file_1.uploadStringToPath)(imageInfo.img_path, (0, context_1.getPathTo)("brands/".concat(product.slug), (0, context_1.getIdsBasedOnSpaceDocRef)(DatabaseService_1.default.getPathParent(this._collection.path))), (0, locale_1.getPrincipalWord)(declination.name), imageInfo.img_path.split(';')[0].split('/')[1])];
+                                                        case 1: return [2, __assign.apply(void 0, _c.concat([(_e.img_path = _f.sent(), _e)]))];
+                                                        case 2: return [2, imageInfo];
+                                                        case 3: return [4, (0, file_1.uploadFileToPath)(imageInfo.img_path.file, (0, context_1.getPathTo)("products/".concat(product.slug), (0, context_1.getIdsBasedOnSpaceDocRef)(DatabaseService_1.default.getPathParent(this._collection.path))))];
+                                                        case 4:
+                                                            img_path = _f.sent();
+                                                            return [2, __assign(__assign({}, imageInfo), { img_path: img_path })];
+                                                    }
+                                                });
+                                            }); }))];
+                                    case 1: return [2, __assign.apply(void 0, _c.concat([(_e.image_files = _f.sent(), _e)]))];
+                                }
+                            });
+                        }); }))];
+                    case 5:
+                        _f = _h.sent();
+                        _h.label = 6;
+                    case 6: return [2, __assign.apply(void 0, _c.concat([(_g.declinations = _f, _g)]))];
+                }
+            });
+        }); };
+        _this._getAttributes = function () {
+            try {
+                if (!!!_this.data().product_attributes || !!!_this._data.id)
+                    return [];
+                return _this.data().product_attributes.map(function (d) {
+                    return new ProductAttribute_1.default(d, DatabaseService_1.default.addToPath(DatabaseService_1.default.addToPath(_this._collection.path, _this._data.id), 'attributes'), _this._user);
+                });
+            }
+            catch (err) {
+                throw new Error("Error while getting attributes: ".concat(err));
+            }
+        };
+        _this._addAttribute = function (productAttribute) { return __awaiter(_this, void 0, void 0, function () {
+            var pas, existingPA, _attributes;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        pas = !!this.data().product_attributes ? this.data().product_attributes : [];
+                        existingPA = pas.find(function (a) { return a.attribute_id === productAttribute.attribute_id; });
+                        if (!!!existingPA) return [3, 2];
+                        _attributes = pas.map(function (pa) {
+                            if (pa.id !== existingPA.id)
+                                return pa;
+                            return __assign(__assign({}, pa), productAttribute);
+                        });
+                        return [4, this.save({ product_attributes: _attributes })];
+                    case 1: return [2, _c.sent()];
+                    case 2: return [4, this.save({
+                            product_attributes: __spreadArray(__spreadArray([], pas, true), [productAttribute], false)
+                        })];
+                    case 3: return [2, _c.sent()];
+                }
+            });
+        }); };
+        _this._getCategory = function () { return __awaiter(_this, void 0, void 0, function () {
+            var categorySnap, err_1;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        if (!!!this._data.category)
+                            throw new Error("Product categoy is not yet defined");
+                        _c.label = 1;
+                    case 1:
+                        _c.trys.push([1, 3, , 4]);
+                        return [4, DatabaseService_1.default.getDocument(DatabaseService_1.default.addToPath(DatabaseService_1.default.getPathParent(this._collection.path), 'categories'), this._data.category)];
+                    case 2:
+                        categorySnap = _c.sent();
+                        if (!!!categorySnap)
+                            throw new Error("Inexisting category");
+                        if (!categorySnap.exists)
+                            throw new Error("Impossible to retreive the category");
+                        if (!!!categorySnap.data)
+                            throw new Error("Impossible te retreive the category data");
+                        return [2, new Category_1.default(__assign(__assign({}, categorySnap.data), { id: categorySnap.id }), {
+                                path: DatabaseService_1.default.addToPath(DatabaseService_1.default.getPathParent(this._collection.path), 'categories')
+                            }, this._user)];
+                    case 3:
+                        err_1 = _c.sent();
+                        throw new Error("Error while getting categories: ".concat(err_1));
+                    case 4: return [2];
+                }
+            });
+        }); };
+        _this._getBrand = function () { return __awaiter(_this, void 0, void 0, function () {
+            var brandSnap, err_2;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        if (!!!this._data.brand)
+                            return [2, undefined];
+                        _c.label = 1;
+                    case 1:
+                        _c.trys.push([1, 3, , 4]);
+                        return [4, DatabaseService_1.default.getDocument(DatabaseService_1.default.addToPath(DatabaseService_1.default.getPathParent(this._collection.path), 'brands'), this._data.brand)];
+                    case 2:
+                        brandSnap = _c.sent();
+                        if (!!!brandSnap)
+                            throw new Error("Inexisting brand");
+                        if (!brandSnap.exists)
+                            throw new Error("Impossible to retreive the brand");
+                        if (!!!brandSnap.data)
+                            throw new Error("Impossible te retreive the brand data");
+                        return [2, new Brand_1.default(__assign(__assign({}, brandSnap.data), { id: brandSnap.id }), {
+                                path: DatabaseService_1.default.addToPath(DatabaseService_1.default.getPathParent(this._collection.path), 'brands')
+                            }, this._user)];
+                    case 3:
+                        err_2 = _c.sent();
+                        throw new Error("Error while getting brands: ".concat(err_2));
+                    case 4: return [2];
+                }
+            });
+        }); };
+        _this._getDeclinations = function () {
+            if (!!!_this._data.id)
+                throw new Error("Product must be saved to create declinations.");
+            var declinationCollectionRef = DatabaseService_1.default.addToPath(DatabaseService_1.default.addToPath(_this._collection.path, _this._data.id), 'declinations');
+            if (!!!_this.data().declinations)
+                return [];
+            return _this.data().declinations.map(function (d) { return new Declination_1.default(d, declinationCollectionRef, _this._user); });
+        };
+        _this._addDeclination = function (declination) { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_c) {
+                if (!!!this._data.id)
+                    throw new Error("Product must be saved to create declinations.");
+                if (!!!this.data().declinations)
+                    return [2];
+                return [2, this.save({
+                        declinations: __spreadArray(__spreadArray([], this.data().declinations, true), [declination], false)
+                    })];
+            });
+        }); };
+        _this._saveIndex = function (category) { return __awaiter(_this, void 0, void 0, function () {
+            var brand, declinations, e_4, tree, _c, space, indexed, error_3;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        if (!!!this._data.id)
+                            throw new Error('Product must be saved first.');
+                        if (DatabaseService_1.default.getPathParent(this._collection.path) == '/')
+                            throw new Error('BD badly initialised. Products collection must have a parent.');
+                        brand = undefined;
+                        declinations = this.data().declinations;
+                        if (!!!declinations) {
+                            console.log("No declinations to update");
+                            return [2, true];
+                        }
+                        _e.label = 1;
+                    case 1:
+                        _e.trys.push([1, 15, , 16]);
+                        if (!(!!!category && !!!this.data().is_service)) return [3, 3];
+                        return [4, this.category.get()];
+                    case 2:
+                        category = _e.sent();
+                        if (!!!category)
+                            throw new Error("A category must be set");
+                        _e.label = 3;
+                    case 3:
+                        if (!!!this._data.brand) return [3, 7];
+                        _e.label = 4;
+                    case 4:
+                        _e.trys.push([4, 6, , 7]);
+                        return [4, this.brand.get()];
+                    case 5:
+                        brand = _e.sent();
+                        return [3, 7];
+                    case 6:
+                        e_4 = _e.sent();
+                        console.log('could not fetch brand with id ', this._data.brand, ': ', e_4.toString());
+                        return [3, 7];
+                    case 7:
+                        if (!!!category) return [3, 9];
+                        return [4, category.getParentTree()];
+                    case 8:
+                        _c = _e.sent();
+                        return [3, 10];
+                    case 9:
+                        _c = [];
+                        _e.label = 10;
+                    case 10:
+                        tree = _c;
+                        return [4, Space_1.default.getCurrentSpaceWithRef(this._collection.path, this._user)];
+                    case 11:
+                        space = _e.sent();
+                        return [4, space.initCurrencies()];
+                    case 12:
+                        _e.sent();
+                        return [4, (0, Product_1.populateIndexedProduct)(this.data(), tree, space, category, brand)];
+                    case 13:
+                        indexed = _e.sent();
+                        console.log('index is created');
+                        return [4, DatabaseService_1.default.saveDocument(DatabaseService_1.default.addToPath(DatabaseService_1.default.getPathParent(this._collection.path), 'indexes/products/public'), this._data.id, (0, moment_1.default)().unix(), (0, object_1.stripObjectForFirebase)(__assign(__assign({}, indexed), { declinations: indexed.declinations.map(function (declination) {
+                                    if (!!declination.promo_price || typeof declination.promo_price !== 'boolean')
+                                        return declination;
+                                    var promo_price = declination.promo_price, rest = __rest(declination, ["promo_price"]);
+                                    return __assign({}, rest);
+                                }) })), { merge: true })];
+                    case 14:
+                        _e.sent();
+                        return [2, true];
+                    case 15:
+                        error_3 = _e.sent();
+                        console.log("error while indexing", error_3.toString());
+                        console.trace("indexing error trace");
+                        throw error_3;
+                    case 16: return [2];
+                }
+            });
+        }); };
+        _this._getIndex = function () { return __awaiter(_this, void 0, void 0, function () {
+            var indexedProductsDocs;
+            var _this = this;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        if (!!!this._data.id)
+                            throw new Error("Product has never been saved");
+                        if (DatabaseService_1.default.getPathParent(this._collection.path) == '/')
+                            throw new Error("Can't access indexes collection");
+                        return [4, DatabaseService_1.default.getDocuments(DatabaseService_1.default.addToPath(DatabaseService_1.default.getPathParent(this._collection.path), 'indexes/products/public'), { query: [{ field: 'product_id', operator: '==', value: this._data.id }] })];
+                    case 1:
+                        indexedProductsDocs = _c.sent();
+                        return [4, Promise.all(indexedProductsDocs
+                                .filter(function (d) { return !!d.exists && !!d.data; })
+                                .map(function (doc) {
+                                return new Product_2.default(__assign(__assign({}, doc.data), { id: doc.id }), {
+                                    path: DatabaseService_1.default.addToPath(DatabaseService_1.default.getPathParent(_this._collection.path), 'indexes/products/public')
+                                }, _this._user);
+                            }))];
+                    case 2: return [2, _c.sent()];
+                }
+            });
+        }); };
+        _this._deleteIndex = function () { return __awaiter(_this, void 0, void 0, function () {
+            var error_4;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        if (DatabaseService_1.default.getPathParent(this._collection.path) == '/')
+                            throw new Error("Can't access parent collection");
+                        _c.label = 1;
+                    case 1:
+                        _c.trys.push([1, 3, , 4]);
+                        if (!!!this._data.id)
+                            throw new Error('No id for selected product');
+                        return [4, DatabaseService_1.default.deleteDocument(DatabaseService_1.default.addToPath(DatabaseService_1.default.getPathParent(this._collection.path), 'indexes/products/public'), this._data.id)];
+                    case 2:
+                        _c.sent();
+                        return [3, 4];
+                    case 3:
+                        error_4 = _c.sent();
+                        throw error_4;
+                    case 4: return [2];
+                }
+            });
+        }); };
+        _this.callPublicService = function (service, fromServer) {
+            if (fromServer === void 0) { fromServer = false; }
+            return __awaiter(_this, void 0, void 0, function () {
+                var requestHeader, url, method, quoteReq, details, error_5;
+                return __generator(this, function (_c) {
+                    switch (_c.label) {
+                        case 0:
+                            requestHeader = (0, services_1.productServiceUrl)(__assign({}, service.external_service_infos), service.external_service_name);
+                            if (!!!requestHeader)
+                                throw new Error("Can't access service provider. Please validate your external services configuration");
+                            url = requestHeader.url, method = requestHeader.type;
+                            _c.label = 1;
+                        case 1:
+                            _c.trys.push([1, 4, , 5]);
+                            return [4, fetch(!!fromServer ? "".concat(url, "&q=").concat(this.data().name[0].value) : '/api/services/cors', {
+                                    headers: { 'content-type': 'application/json' },
+                                    method: !!fromServer ? method : 'POST',
+                                    body: JSON.stringify({
+                                        props: { method: method, headers: { 'content-type': 'application/json' } },
+                                        url: "".concat(url, "&q=").concat(this.data().name[0].value)
+                                    })
+                                })];
+                        case 2:
+                            quoteReq = _c.sent();
+                            if (quoteReq.status.toString() !== '200')
+                                throw new Error("Error while getting service: ".concat(quoteReq.statusText));
+                            return [4, quoteReq.json()];
+                        case 3:
+                            details = _c.sent();
+                            return [2, { confirmed: true, details: details }];
+                        case 4:
+                            error_5 = _c.sent();
+                            (0, console_1.errorMessage)("Error while calling order service ".concat(error_5, " - ").concat(JSON.stringify(error_5)));
+                            return [2, { confirmed: false, error: error_5 }];
+                        case 5: return [2];
+                    }
+                });
+            });
+        };
+        _this._updateAllDeclinationsPrice = function (pricingMapFromExternalOrCustom, attributes, saveToDatabase, updateRegular, spaceToUse) {
+            if (saveToDatabase === void 0) { saveToDatabase = true; }
+            if (updateRegular === void 0) { updateRegular = true; }
+            return __awaiter(_this, void 0, void 0, function () {
+                var space, _c, spacePrice, declinations, declinationsWithAttributeLinkedToService, _loop_1, this_1, _i, declinationsWithAttributeLinkedToService_1, declinationToUpdate, state_1, error_6;
+                return __generator(this, function (_e) {
+                    switch (_e.label) {
+                        case 0:
+                            _e.trys.push([0, 9, , 10]);
+                            if (!!!spaceToUse) return [3, 1];
+                            _c = spaceToUse;
+                            return [3, 3];
+                        case 1: return [4, Space_1.default.getCurrentSpaceWithRef(this._collection.path, this._user)];
+                        case 2:
+                            _c = _e.sent();
+                            _e.label = 3;
+                        case 3:
+                            space = _c;
+                            spacePrice = this.adaptPriceChartingValues(pricingMapFromExternalOrCustom, space);
+                            declinations = this.data().declinations;
+                            if (!!!declinations)
+                                return [2, false];
+                            declinationsWithAttributeLinkedToService = declinations.filter(function (d) {
+                                return !!d.attributes.find(function (pa) {
+                                    var attr = attributes.find(function (_a) { return _a.id === pa.attribute_id; });
+                                    if (!!!attr)
+                                        return false;
+                                    if (!!!attr.is_service_related)
+                                        return false;
+                                    if (!!!attr.service_links_to_attribute)
+                                        return false;
+                                    return true;
+                                });
+                            });
+                            if (!!!declinationsWithAttributeLinkedToService.length)
+                                return [2, false];
+                            _loop_1 = function (declinationToUpdate) {
+                                var relationProductAttribute, relationAttribute, propsToLink, price, priceDetails, _declinations;
+                                return __generator(this, function (_f) {
+                                    switch (_f.label) {
+                                        case 0:
+                                            relationProductAttribute = declinationToUpdate.attributes.find(function (pa) {
+                                                var attr = attributes.find(function (_a) { return _a.id === pa.attribute_id; });
+                                                if (!!!attr)
+                                                    return false;
+                                                if (!!!attr.is_service_related)
+                                                    return false;
+                                                return true;
+                                            });
+                                            if (!!!relationProductAttribute)
+                                                return [2, "continue"];
+                                            relationAttribute = attributes.find(function (a) { return a.id === relationProductAttribute.attribute_id; });
+                                            if (!!!relationAttribute)
+                                                return [2, "continue"];
+                                            if (!!!relationAttribute.service_links_to_attribute)
+                                                return [2, "continue"];
+                                            propsToLink = relationAttribute.service_links_to_attribute.find(function (slta) {
+                                                return slta.value_slugs.find(function (vs) { return !!relationProductAttribute.values.find(function (value) { return value.slug === vs.slug; }); });
+                                            });
+                                            if (!!!propsToLink)
+                                                return [2, "continue"];
+                                            if (!!!spacePrice[propsToLink.service_field])
+                                                return [2, "continue"];
+                                            price = (0, lodash_1.toNumber)(spacePrice[propsToLink.service_field]) / 100;
+                                            priceDetails = propsToLink.value_slugs.find(function (vs) { return !!relationProductAttribute.values.find(function (value) { return value.slug === vs.slug; }); });
+                                            if (!!priceDetails) {
+                                                if (!!priceDetails.percent_variation) {
+                                                    price = price * (1 + priceDetails.percent_variation / 100);
+                                                }
+                                            }
+                                            _declinations = declinations.map(function (declination) {
+                                                if (declination.sku !== declinationToUpdate.sku)
+                                                    return declination;
+                                                return __assign(__assign({}, declination), { price: __assign(__assign(__assign({}, declination.price), { pdsf: { amount: (0, lodash_1.toNumber)(price) } }), (!!updateRegular
+                                                        ? {
+                                                            regular: {
+                                                                amount: (0, lodash_1.ceil)((0, lodash_1.toNumber)(price)) - 0.01 >= (0, lodash_1.toNumber)(declination.price.regular.amount)
+                                                                    ? (0, lodash_1.ceil)((0, lodash_1.toNumber)(price)) - 0.01
+                                                                    : (0, lodash_1.toNumber)(declination.price.regular.amount)
+                                                            }
+                                                        }
+                                                        : {})) });
+                                            });
+                                            if (!!!saveToDatabase)
+                                                return [2, { value: {
+                                                            declinations: _declinations,
+                                                            services: { price_charting: spacePrice }
+                                                        } }];
+                                            return [4, this_1.save({
+                                                    declinations: _declinations
+                                                }, { index: true })];
+                                        case 1:
+                                            _f.sent();
+                                            return [2];
+                                    }
+                                });
+                            };
+                            this_1 = this;
+                            _i = 0, declinationsWithAttributeLinkedToService_1 = declinationsWithAttributeLinkedToService;
+                            _e.label = 4;
+                        case 4:
+                            if (!(_i < declinationsWithAttributeLinkedToService_1.length)) return [3, 7];
+                            declinationToUpdate = declinationsWithAttributeLinkedToService_1[_i];
+                            return [5, _loop_1(declinationToUpdate)];
+                        case 5:
+                            state_1 = _e.sent();
+                            if (typeof state_1 === "object")
+                                return [2, state_1.value];
+                            _e.label = 6;
+                        case 6:
+                            _i++;
+                            return [3, 4];
+                        case 7: return [4, this.save({
+                                services: __assign(__assign({}, this.data().services), { price_charting: spacePrice })
+                            })];
+                        case 8:
+                            _e.sent();
+                            return [2, true];
+                        case 9:
+                            error_6 = _e.sent();
+                            if (process.env.NODE_ENV !== 'production')
+                                console.log(error_6);
+                            return [2, false];
+                        case 10: return [2];
+                    }
+                });
+            });
+        };
+        _this.adaptPriceChartingValues = function (pricingMap, space) {
+            var returnValue = {};
+            (0, lodash_1.forEach)(pricingMap, function (val, key) {
+                if (['loose-price', 'cib-price', 'loose-price', 'box-only-price', 'manual-only-price', 'new-price'].includes(key)) {
+                    returnValue[key] = (0, currency_1.calculateAmountByCurrency)(space, space.preferences.default.currency(), (0, lodash_1.toNumber)(val), 'USD');
+                    return;
+                }
+            });
+            return __assign(__assign({}, pricingMap), returnValue);
+        };
+        _this._updateAllDeclinationsPriceAsync = function (pricingMapFromExternalOrCustom) { return __awaiter(_this, void 0, void 0, function () {
+            var attributesRes, attributes, error_7;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        if (DatabaseService_1.default.getPathParent(this._collection.path) == '/')
+                            throw new Error("Can't fetch attributes");
+                        _c.label = 1;
+                    case 1:
+                        _c.trys.push([1, 4, , 5]);
+                        return [4, DatabaseService_1.default.getDocuments(DatabaseService_1.default.addToPath(DatabaseService_1.default.getPathParent(this._collection.path), 'attributes'))];
+                    case 2:
+                        attributesRes = _c.sent();
+                        attributes = attributesRes
+                            .filter(function (d) { return !!d.exists && !!d.data; })
+                            .map(function (d) { return (__assign(__assign({}, d.data), { id: d.id })); });
+                        return [4, this._updateAllDeclinationsPrice(pricingMapFromExternalOrCustom, attributes)];
+                    case 3: return [2, _c.sent()];
+                    case 4:
+                        error_7 = _c.sent();
+                        (0, console_1.errorMessage)("Error while fetching price and attributes");
+                        return [2, []];
+                    case 5: return [2];
+                }
+            });
+        }); };
+        _this._getMarketplacePublications = function (options) { return __awaiter(_this, void 0, void 0, function () {
+            var publications, error_8;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        if (DatabaseService_1.default.getPathParent(this._collection.path) == '/')
+                            throw new Error("Can't fetch marketplace publications");
+                        _c.label = 1;
+                    case 1:
+                        _c.trys.push([1, 3, , 4]);
+                        return [4, DatabaseService_1.default.getDocuments(DatabaseService_1.default.addToPath(DatabaseService_1.default.getPathParent(this._collection.path), 'marketplace_publications'), options)];
+                    case 2:
+                        publications = _c.sent();
+                        return [2, publications.map(function (d) { return (__assign(__assign({}, d.data), { id: d.id })); })];
+                    case 3:
+                        error_8 = _c.sent();
+                        (0, console_1.errorMessage)("Error while fetching marketplace publications");
+                        return [2, []];
+                    case 4: return [2];
+                }
+            });
+        }); };
+        _this._marketplacePublicationsListner = function (callback, options) {
+            if (DatabaseService_1.default.getPathParent(_this._collection.path) == '/')
+                throw new Error("Can't fetch marketplace publications");
+            try {
+                var call = DatabaseService_1.default.addToPath(DatabaseService_1.default.getPathParent(_this._collection.path), 'marketplace_publications');
+                return DatabaseService_1.default.registerListener(function (dataSnap) {
+                    if (!!!dataSnap.length)
+                        callback([]);
+                    (0, console_1.workingMessage)("Marketplace publications has been udpated. Refreshing...");
+                    callback(dataSnap.map(function (d) { return (__assign(__assign({}, d.data), { id: d.id })); }));
+                }, call, !!options ? options : { query: [{ field: 'parent_slug', operator: '==', value: _this._data.slug }] });
+            }
+            catch (error) {
+                (0, console_1.errorMessage)("Error while listening marketplace publications");
+                return '';
+            }
+        };
+        _this._createNewPublication = function (sku, marketplacePublication, space) { return __awaiter(_this, void 0, void 0, function () {
+            var productInvetory, error_9, newMarketplacePublication, error_10;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        if (DatabaseService_1.default.getPathParent(this._collection.path) == '/')
+                            throw new Error("Can't fetch marketplace publications");
+                        _c.label = 1;
+                    case 1:
+                        _c.trys.push([1, 3, , 4]);
+                        return [4, space.inventoryItems.getOne(sku)];
+                    case 2:
+                        productInvetory = _c.sent();
+                        if (!!!productInvetory || !!!productInvetory.web_inventory)
+                            throw new Error("Can't find inventory item with sku: ".concat(sku));
+                        if (!!!productInvetory.web_inventory.available)
+                            throw new Error("Inventory item with sku: ".concat(sku, " is not available"));
+                        if (marketplacePublication.quantity < 1)
+                            throw new Error("No quantity available");
+                        if ((0, lodash_1.toNumber)(productInvetory.web_inventory.available) < 1)
+                            throw new Error("No quantity available");
+                        if ((0, lodash_1.toNumber)(productInvetory.web_inventory.available) < marketplacePublication.quantity)
+                            throw new Error("Inventory item with sku: ".concat(sku, " is not available"));
+                        return [3, 4];
+                    case 3:
+                        error_9 = _c.sent();
+                        (0, console_1.errorMessage)("Error while fetching inventory item with sku: ".concat(sku));
+                        return [2, false];
+                    case 4:
+                        _c.trys.push([4, 6, , 7]);
+                        newMarketplacePublication = new MarketplacePublication_1.default(__assign(__assign({}, marketplacePublication), { sku: sku, parent_slug: this.data().slug, created_at: new Date(), created_by: this._user }), {
+                            path: DatabaseService_1.default.addToPath(DatabaseService_1.default.getPathParent(this._collection.path), 'marketplace_publications')
+                        }, this._user);
+                        return [4, newMarketplacePublication.save()];
+                    case 5: return [2, _c.sent()];
+                    case 6:
+                        error_10 = _c.sent();
+                        (0, console_1.errorMessage)("Error while creating marketplace publications");
+                        return [2, false];
+                    case 7: return [2];
+                }
+            });
+        }); };
+        _this._updateMarketplacePublication = function (sku, marketplacePublication) { return __awaiter(_this, void 0, void 0, function () {
+            var marketplacePublicationObj, error_11;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        if (DatabaseService_1.default.getPathParent(this._collection.path) == '/')
+                            throw new Error("Can't update marketplace publications");
+                        _c.label = 1;
+                    case 1:
+                        _c.trys.push([1, 4, , 5]);
+                        return [4, MarketplacePublication_1.default.getMarketplacePublicationObj(sku, DatabaseService_1.default.addToPath(DatabaseService_1.default.getPathParent(this._collection.path), 'marketplace_publications'), this._user)];
+                    case 2:
+                        marketplacePublicationObj = _c.sent();
+                        if (!!!marketplacePublicationObj)
+                            throw new Error("No marketplace publication found");
+                        return [4, marketplacePublicationObj.save(marketplacePublication)];
+                    case 3: return [2, _c.sent()];
+                    case 4:
+                        error_11 = _c.sent();
+                        (0, console_1.errorMessage)("Error while updating marketplace publications");
+                        return [2, false];
+                    case 5: return [2];
+                }
+            });
+        }); };
+        _this._removeMarketplacePublication = function (publicationId) { return __awaiter(_this, void 0, void 0, function () {
+            var marketplacePublicationObj, error_12;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        if (DatabaseService_1.default.getPathParent(this._collection.path) == '/')
+                            throw new Error("Can't remove marketplace publications");
+                        _c.label = 1;
+                    case 1:
+                        _c.trys.push([1, 4, , 5]);
+                        return [4, MarketplacePublication_1.default.getMarketplacePublicationObjById(publicationId, DatabaseService_1.default.addToPath(DatabaseService_1.default.getPathParent(this._collection.path), 'marketplace_publications'), this._user)];
+                    case 2:
+                        marketplacePublicationObj = _c.sent();
+                        if (!!!marketplacePublicationObj)
+                            throw new Error("No marketplace publication found");
+                        return [4, marketplacePublicationObj.delete()];
+                    case 3: return [2, _c.sent()];
+                    case 4:
+                        error_12 = _c.sent();
+                        (0, console_1.errorMessage)("Error while deleting marketplace publications");
+                        return [2, false];
+                    case 5: return [2];
+                }
+            });
+        }); };
+        _this.attributes = {
+            get: _this._getAttributes,
+            add: _this._addAttribute
+        };
+        _this.brand = {
+            get: _this._getBrand
+        };
+        _this.category = {
+            get: _this._getCategory
+        };
+        _this.publications = {
+            get: _this._getMarketplacePublications,
+            listen: _this._marketplacePublicationsListner,
+            update: _this._updateMarketplacePublication,
+            create: _this._createNewPublication,
+            remove: _this._removeMarketplacePublication
+        };
+        _this.declinations = {
+            get: _this._getDeclinations,
+            add: _this._addDeclination,
+            update: {
+                priceSync: _this._updateAllDeclinationsPrice,
+                priceAsync: _this._updateAllDeclinationsPriceAsync
+            }
+        };
+        _this.index = {
+            save: _this._saveIndex,
+            get: _this._getIndex,
+            delete: _this._deleteIndex
+        };
+        return _this;
+    }
+    var _b;
+    _b = Product;
+    Product.fetch = function (_c) {
+        var app = _c.app, api = _c.api, _e = _c.hpp, hpp = _e === void 0 ? 10 : _e, _f = _c.page, page = _f === void 0 ? 0 : _f, _g = _c.query, query = _g === void 0 ? '' : _g, _h = _c.filters, filters = _h === void 0 ? '' : _h, _j = _c.indice, indice = _j === void 0 ? 'products' : _j, _k = _c.f, f = _k === void 0 ? '' : _k, space = _c.space, _l = _c.useProspr, useProspr = _l === void 0 ? false : _l;
+        return __awaiter(void 0, void 0, void 0, function () {
+            var prosprSearch, prosprService, algolia, results, error_13;
+            return __generator(_b, function (_m) {
+                switch (_m.label) {
+                    case 0:
+                        _m.trys.push([0, 2, , 3]);
+                        prosprSearch = false;
+                        if (!!space) {
+                            prosprService = space
+                                .data()
+                                .external_services.find(function (es) { return es.external_service_name.toLowerCase().trim() === 'prosprsearch'; });
+                            prosprSearch = !!prosprService && prosprService.is_active;
+                        }
+                        algolia = (0, algolia_1.createClient)({
+                            app: app,
+                            indexId: "".concat(__1.isTestEnv ? 'test' : 'prod', "_").concat(indice),
+                            key: !!useProspr ? api : prosprSearch && !!space ? space.preferences.prosprsearch.app() : api,
+                            prospr: !!prosprSearch || !!useProspr
+                        });
+                        return [4, algolia.search(query, {
+                                hitsPerPage: hpp,
+                                facetFilters: filters,
+                                filters: f,
+                                page: page,
+                                facets: ['*']
+                            })];
+                    case 1:
+                        results = _m.sent();
+                        return [2, results];
+                    case 2:
+                        error_13 = _m.sent();
+                        (0, console_1.errorMessage)(error_13);
+                        throw error_13;
+                    case 3: return [2];
+                }
+            });
+        });
+    };
+    Product.checkExternalValuesForDecli = function (sku, space, org) { return __awaiter(void 0, void 0, void 0, function () {
+        var externalValues, serviceQuery;
+        return __generator(_b, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    if (!!!space)
+                        return [2];
+                    externalValues = undefined;
+                    serviceQuery = space.services({ field: 'external_service_name', value: 'G2' });
+                    if (!(!!serviceQuery && serviceQuery.length)) return [3, 2];
+                    return [4, (0, g2_1.getG2ProductExternalValues)(sku, serviceQuery[0], space, org)];
+                case 1:
+                    externalValues = _c.sent();
+                    _c.label = 2;
+                case 2: return [2, externalValues];
+            }
+        });
+    }); };
+    return Product;
+}(baseService_1.BaseServiceClass));
+exports.default = Product;
+//# sourceMappingURL=index.js.map