addio-admin-sdk 1.6.5

package/dist/lib/CMS/Reader/index.js

@@ -0,0 +1,1174 @@
+"use strict";
+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 __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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 __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 enums_1 = require("../../../constants/enums");
+var math_1 = require("../../../utils/math");
+var moment_1 = __importStar(require("moment"));
+var data_1 = require("../../../utils/data");
+var errors_1 = require("../../../constants/errors");
+var firestore_1 = require("firebase/firestore");
+var toNumber_1 = __importDefault(require("lodash/toNumber"));
+var Category_1 = __importDefault(require("../../../lib/Category"));
+var flatten_1 = __importDefault(require("lodash/flatten"));
+var sumBy_1 = __importDefault(require("lodash/sumBy"));
+var enums_2 = require("../../../Interfaces/Quote/QuoteCMS/enums");
+var string_1 = require("../../../utils/string");
+var CMSReader = (function () {
+    function CMSReader(appData, options) {
+        if (appData === void 0) { appData = []; }
+        var _this = this;
+        this._getProductConvertionRatio = function (sku, unitSlug) {
+            if (!!!unitSlug)
+                return 1;
+            var products = _this._data.find(function (q) { return q.dataType == enums_1.QuotePartDataTypeEnum.ALL_PRODUCTS; });
+            if (!!!products)
+                return 1;
+            var productsData = products.data.map(function (d) { return d.data(); });
+            for (var _i = 0, productsData_1 = productsData; _i < productsData_1.length; _i++) {
+                var p = productsData_1[_i];
+                for (var _a = 0, _b = p.declinations || []; _a < _b.length; _a++) {
+                    var d = _b[_a];
+                    if (d.sku === sku) {
+                        for (var _c = 0, _d = d.other_units || []; _c < _d.length; _c++) {
+                            var u = _d[_c];
+                            if (u.unit_slug === unitSlug) {
+                                return u.fitting_unit || 1;
+                            }
+                        }
+                    }
+                }
+            }
+            return 1;
+        };
+        this._customGetTotal = function (fieldValue, fieldValueData) {
+            var value = fieldValueData.getTotal();
+            var ttl = value;
+            var taxes = fieldValueData.getTaxes();
+            if (!!taxes) {
+                for (var _i = 0, _a = taxes.taxes; _i < _a.length; _i++) {
+                    var t = _a[_i];
+                    ttl += value * t.value;
+                }
+            }
+            return +ttl.toFixed(2);
+        };
+        this._customGetSubTotal = function (fieldValue, fieldValueData) {
+            var value = fieldValueData.getTotal();
+            return +value.toFixed(2);
+        };
+        this._customGetEstimatedPalette = function (fieldValue, fieldValueData) {
+            var data = fieldValueData.data();
+            var products = _this._data.find(function (d) { return d.dataType == enums_1.QuotePartDataTypeEnum.ALL_PRODUCTS; });
+            if (!!!products)
+                return 0;
+            var ttl = 0;
+            for (var _i = 0, _a = data.items; _i < _a.length; _i++) {
+                var item = _a[_i];
+                var rate = _this._getProductConvertionRatio(item.sku, 'palette');
+                ttl += item.qty / rate;
+            }
+            if (!!!data.estimated_skid_count) {
+                data = __assign(__assign({}, data), { estimated_skid_count: +ttl.toFixed(1) });
+                fieldValueData.save(data);
+            }
+            return +ttl.toFixed(1);
+        };
+        this._customGetTPS = function (fieldValue, fieldValueData) {
+            var value = fieldValueData.getTotal();
+            var ttl = 0;
+            var taxes = fieldValueData.getTaxes();
+            if (!!taxes) {
+                for (var _i = 0, _a = taxes.taxes; _i < _a.length; _i++) {
+                    var t = _a[_i];
+                    if (t.label_fr == 'TPS')
+                        ttl = value * t.value;
+                }
+            }
+            return +ttl.toFixed(2);
+        };
+        this._customGetTVQ = function (fieldValue, fieldValueData) {
+            var value = fieldValueData.getTotal();
+            var ttl = 0;
+            var taxes = fieldValueData.getTaxes();
+            if (!!taxes) {
+                for (var _i = 0, _a = taxes.taxes; _i < _a.length; _i++) {
+                    var t = _a[_i];
+                    if (t.label_fr == 'TVQ')
+                        ttl = value * t.value;
+                }
+            }
+            return +ttl.toFixed(2);
+        };
+        this._customFunctionHandler = [
+            {
+                cmd: 'getTotal',
+                fnc: this._customGetTotal
+            },
+            {
+                cmd: 'getSubTotal',
+                fnc: this._customGetSubTotal
+            },
+            {
+                cmd: 'getEstimatedPalette',
+                fnc: this._customGetEstimatedPalette
+            },
+            {
+                cmd: 'getTPS',
+                fnc: this._customGetTPS
+            },
+            {
+                cmd: 'getTVQ',
+                fnc: this._customGetTVQ
+            }
+        ];
+        this._isConditionRespected = function (condition, options) {
+            if (!!!condition.condition_props)
+                return false;
+            switch (condition.condition_operator) {
+                case '!=':
+                    if (condition.condition_props.type === 'datetime')
+                        throw new Error(errors_1.ErrorEnum.A0000NIMP);
+                    return _this.renderFieldValue(condition.condition_props, options) != condition.condition_value;
+                case '<':
+                    if (condition.condition_props.type === 'datetime')
+                        throw new Error(errors_1.ErrorEnum.A0000NIMP);
+                    return (0, toNumber_1.default)(_this.renderFieldValue(condition.condition_props, options)) < (0, toNumber_1.default)(condition.condition_value);
+                case '<=':
+                    if (condition.condition_props.type === 'datetime')
+                        throw new Error(errors_1.ErrorEnum.A0000NIMP);
+                    return ((0, toNumber_1.default)(_this.renderFieldValue(condition.condition_props, options)) <= (0, toNumber_1.default)(condition.condition_value));
+                case '>':
+                    if (condition.condition_props.type === 'datetime')
+                        throw new Error(errors_1.ErrorEnum.A0000NIMP);
+                    return (0, toNumber_1.default)(_this.renderFieldValue(condition.condition_props, options)) > (0, toNumber_1.default)(condition.condition_value);
+                case '>=':
+                    if (condition.condition_props.type === 'datetime')
+                        throw new Error(errors_1.ErrorEnum.A0000NIMP);
+                    return ((0, toNumber_1.default)(_this.renderFieldValue(condition.condition_props, options)) >= (0, toNumber_1.default)(condition.condition_value));
+                case '==':
+                    if (condition.condition_props.type === 'datetime')
+                        throw new Error(errors_1.ErrorEnum.A0000NIMP);
+                    return ((0, toNumber_1.default)(_this.renderFieldValue(condition.condition_props, options)) ==
+                        (condition.condition_props.type === 'boolean'
+                            ? condition.condition_value || false
+                            : condition.condition_value));
+                case 'direct-child-of-category':
+                    var itemCategory = _this.renderFieldValue(condition.condition_props, __assign({}, options));
+                    var parentCategory = condition.condition_value;
+                    if (parentCategory === itemCategory)
+                        return true;
+                    var categories = (_this.data.find(function (c) { return c.dataType === enums_1.QuotePartDataTypeEnum.ALL_CATEGORY; }) || { data: [] }).data;
+                    return Category_1.default.categoryIdIsDirectChildOf(itemCategory, parentCategory || '', categories || []);
+                case 'contains':
+                case 'not-in':
+                default:
+                    throw new Error(errors_1.ErrorEnum.A0000NIMP);
+            }
+        };
+        this._selectDataFromFieldValueUseProps = function (fieldValue, key, options) {
+            var dataType = fieldValue[key];
+            if (dataType === undefined)
+                throw new Error(errors_1.ErrorEnum['A00001-1']);
+            var data = _this._getDataFromDataType(dataType, __assign({}, options));
+            if (fieldValue.object_path !== undefined && key === 'path_use')
+                data = _this._goDownInObjWithPath(data, fieldValue.object_path);
+            if (!!!options || !!!options.filter)
+                return data;
+            return _this._filterSectionData(fieldValue, data, options);
+        };
+        this._filterSectionData = function (fieldValue, completeData, options) {
+            if (!!!options || options.index === undefined)
+                return completeData;
+            if (_this.section === undefined)
+                return completeData;
+            if (_this.sectionData === undefined)
+                return completeData;
+            var filtersToApply = (0, flatten_1.default)((_this.section.fields || []).filter(function (f) { return (f.values || []).some(function (v) { return v.will_filter; }); }).map(function (f) { return f.values; })).map(function (fieldValue, index) {
+                return {
+                    key: _this._removeDataTypeFromKey(fieldValue.key, _this.section.data_map_on),
+                    value: _this.renderFieldValue(__assign(__assign({}, fieldValue), { index: index }))
+                };
+            });
+            var filteredData = _this.sectionData.filter(function (d) {
+                return filtersToApply.every(function (filter) { return filter.value === undefined || d[filter.key] === filter.value; });
+            });
+            return completeData.filter(function (cData) {
+                var leftValue = fieldValue.path_key !== undefined && cData[fieldValue.path_key];
+                return filteredData.some(function (fData) {
+                    return fData[_this._removeDataTypeFromKey(fieldValue.key, _this.section.data_map_on)] === leftValue;
+                });
+            });
+        };
+        this._getDataFromDataType = function (dataType, options) {
+            if (dataType === enums_1.QuotePartDataTypeEnum.CURRENT_QUOTE_PRODUCTS) {
+                var quoteKey = 'items';
+                var quote = _this._getDataFromDataType(enums_1.QuotePartDataTypeEnum.CURRENT_QUOTE, options);
+                if ((0, data_1.isBaseClass)(quote) && !!quote.data)
+                    return quote.data()[quoteKey];
+                return quote[quoteKey];
+            }
+            var data = _this.data.find(function (d) { return d.dataType === dataType; });
+            if (data === undefined)
+                throw new Error(errors_1.ErrorEnum['A00002']);
+            if (data.data === undefined)
+                throw new Error(errors_1.ErrorEnum['A00002']);
+            if (!!options && !!!options.keepClass) {
+                if (Array.isArray(data.data))
+                    return data.data.map(function (d) { return ((0, data_1.isBaseClass)(d) && !!d.data ? d.data() : d); });
+                return (0, data_1.isBaseClass)(data.data) && !!data.data.data ? data.data.data() : data.data;
+            }
+            return data.data;
+        };
+        this._getIfSectionHasFilteringFieldValue = function () {
+            return !!_this.section && (_this.section.fields || []).some(function (f) { return (f.values || []).some(function (v) { return !!v.will_filter; }); });
+        };
+        this._removeDataTypeFromKey = function (key, dataType) {
+            if (dataType === undefined)
+                return key;
+            return key.replace(new RegExp("".concat(dataType, "."), 'ig'), '');
+        };
+        this._createDataTypeForCustomFieldWithOptions = function (fieldValueKey, append) {
+            return "".concat(fieldValueKey, "-").concat(append);
+        };
+        this._addCustomDataToData = function (dataType, data) {
+            _this.data = __spreadArray(__spreadArray([], _this.data, true), [
+                {
+                    dataType: dataType,
+                    data: data
+                }
+            ], false);
+        };
+        this._constructCustomFieldAndSendIt = function (fieldValue, options) {
+            if (!!!options || !!!options.field)
+                throw new Error(errors_1.ErrorEnum['A00001-3']);
+            var fieldType = options.field.fieldType;
+            switch (fieldType) {
+                case enums_1.FieldTypeEnum.CHECKBOX_COLOR:
+                    var key = 'custom-colors';
+                    _this._addCustomDataToData(_this._createDataTypeForCustomFieldWithOptions(fieldValue.key, key), options.field[key]);
+                    return _this.renderFieldValue(__assign(__assign({}, fieldValue), { path_key: "custom-slug@red", path_use: _this._createDataTypeForCustomFieldWithOptions(fieldValue.key, key), type: 'select', givenValue: 'red', object: [
+                            {
+                                key: 'value',
+                                field: 'custom-slug'
+                            },
+                            {
+                                key: 'label',
+                                field: 'custom-title'
+                            }
+                        ] }), __assign(__assign({}, options), { field: undefined }));
+                case enums_1.FieldTypeEnum.CHECKBOXES:
+                    var keyBool = 'custom-bool';
+                    _this._addCustomDataToData(keyBool, options.field[keyBool]);
+                    return _this.renderFieldValue(__assign(__assign({}, fieldValue), { path_key: "custom-slug@bool", path_use: keyBool, type: 'boolean', givenValue: false, object: [
+                            {
+                                key: 'value',
+                                field: 'custom-slug'
+                            },
+                            {
+                                key: 'label',
+                                field: 'custom-title'
+                            }
+                        ] }), __assign(__assign({}, options), { field: undefined }));
+                default:
+                    throw new Error(errors_1.ErrorEnum.A0000NIMP);
+            }
+        };
+        this._goDownInObjWithPath = function (obj, path) {
+            if (path.includes('.') && !path.includes('@')) {
+                var _a = path.split('.'), first = _a[0], rest = _a.slice(1);
+                return _this._goDownInObjWithPath(obj[first], rest.join('.'));
+            }
+            if (path.indexOf('@') < path.indexOf('.') || (!path.includes('.') && path.includes('@'))) {
+                var _b = path.split('@'), key_1 = _b[0], rest = _b.slice(1);
+                var _c = rest.join('@').split('.'), value_1 = _c[0], restPath = _c.slice(1);
+                return _this._goDownInObjWithPath(obj.find(function (o) { return o[key_1] === value_1; }), restPath.join('.'));
+            }
+            return obj[path];
+        };
+        this._goDownOperation = function (finalOperation, fieldValue, operation, options) {
+            if (fieldValue.operation !== undefined && fieldValue.operate_by !== undefined)
+                if (operation !== undefined && operation === 'length') {
+                    if (fieldValue.operation === '*') {
+                        return _this.getValue(finalOperation, fieldValue, options);
+                    }
+                    throw new Error(errors_1.ErrorEnum.A0000NIMP);
+                }
+            return undefined;
+        };
+        this._getDefaultValueFuncType = function (value) {
+            var _a = value.split('&func:'), rest = _a[1];
+            var _b = rest.split('@'), stringType = _b[0], restOfString = _b.slice(1);
+            switch (stringType) {
+                case 'quote_settings_preference':
+                    return enums_1.DefaultValueFunctionType.QUOTE_SETTINGS_PREFERENCE;
+                default:
+                    throw new Error((0, errors_1.ErrorCustom)(stringType)['D00001-1-CUS']);
+            }
+        };
+        this._constructFieldValueBasedOnFunctionValueAndPreferences = function (fieldValue) {
+            var value = !!fieldValue.value && fieldValue.value.includes('@')
+                ? (fieldValue.value.split('@')[1] || '').split('.')[0]
+                : fieldValue.value;
+            return {
+                key: "client_choice.attribute_id@".concat(value, ".attribute_value"),
+                label: 'Préférences client',
+                type: 'string',
+                use: enums_1.QuotePartDataTypeEnum.CURRENT_QUOTE,
+                path_use: enums_1.QuotePartDataTypeEnum.QUOTE_PREFERENCES,
+                order: 0
+            };
+        };
+        this.constructPartialBasedOnKey = function (value, obj, field) {
+            var _a, _b, _c;
+            try {
+                if (Array.isArray(obj)) {
+                    if (field.index !== undefined) {
+                        return obj
+                            .filter(function (o) { return !!o; })
+                            .map(function (o, oIndex) {
+                            if (oIndex !== field.index)
+                                return o;
+                            return _this.constructPartialBasedOnKey(value, o, __assign(__assign({}, field), { index: undefined }));
+                        });
+                    }
+                }
+                var baseKey = field.key;
+                if (baseKey.includes('@'))
+                    if (!baseKey.includes('.') || baseKey.indexOf('@') < baseKey.indexOf('.')) {
+                        var _d = baseKey.split('@'), key_2 = _d[0], restAndValue = _d.slice(1);
+                        var _e = restAndValue.join('.').split('.'), keyValue_1 = _e[0], rest_1 = _e.slice(1);
+                        if (!Array.isArray(obj))
+                            return obj;
+                        var objExists = obj.some(function (o) {
+                            return o[key_2] === keyValue_1;
+                        });
+                        console.log('keyv', keyValue_1, objExists, field);
+                        if (!objExists) {
+                            return __spreadArray(__spreadArray([], obj, true), [
+                                _this.constructPartialBasedOnKey(value, __assign(__assign({}, field.default), (_a = {}, _a[key_2] = keyValue_1, _a)), __assign(__assign({}, field), { key: rest_1.join('.') }))
+                            ], false);
+                        }
+                        return obj.map(function (o) {
+                            if (o[key_2] === keyValue_1)
+                                return _this.constructPartialBasedOnKey(value, o, __assign(__assign({}, field), { key: rest_1.join('.') }));
+                            return o;
+                        });
+                    }
+                if (!baseKey.includes('.')) {
+                    if (baseKey.includes('%')) {
+                        var _f = baseKey.split('%'), props = _f[0], op = _f.slice(1);
+                        var fittingUnit = _this._getProductConvertionRatio(obj.sku, op[0]);
+                        obj[props] = +(value * fittingUnit).toFixed(3);
+                        return obj;
+                    }
+                    if (baseKey === undefined)
+                        return obj;
+                    obj[baseKey] = value;
+                    return obj;
+                }
+                var _g = baseKey.split('.'), first = _g[0], rest = _g.slice(1);
+                if (obj[first] === undefined) {
+                    obj = __assign(__assign({}, obj), (_b = {}, _b[first] = field.type === 'select' ? [] : field.type === 'obj' ? {} : field.type === 'number' ? 0 : '', _b));
+                }
+                return __assign(__assign({}, obj), (_c = {}, _c[first] = _this.constructPartialBasedOnKey(value, obj[first], __assign(__assign({}, field), { key: rest.join('.') })), _c));
+            }
+            catch (error) {
+                if (process.env.NODE_ENV !== 'production')
+                    console.log(error);
+                return 'Non déterminé';
+            }
+        };
+        this._findBestProductMatch = function (baseCatID, categories, products, preferences, privee, haveSku) {
+            var getParentCat = function (catId) {
+                var cat = categories.find(function (c) { return c.id == catId; });
+                if (!!!cat)
+                    return '';
+                if (!!cat.parent)
+                    return getParentCat(cat.parent);
+                return catId;
+            };
+            var firstInCat = undefined;
+            var bestmatch = undefined;
+            var _loop_1 = function (p) {
+                if (!!p.category && getParentCat(p.category) == baseCatID) {
+                    if (!!!firstInCat)
+                        firstInCat = p;
+                    if (!!p.product_attributes && !!p.product_attributes.length) {
+                        var match_1 = 0;
+                        p.product_attributes.map(function (a) {
+                            if (preferences.some(function (pref) { return pref.attribute_id == a.attribute_id; }))
+                                match_1++;
+                        });
+                        if (match_1 > 0 && !!p.declinations) {
+                            match_1 = 0;
+                            var _loop_2 = function (decli) {
+                                var good = 0;
+                                p.product_attributes.map(function (a) {
+                                    var pref = preferences.find(function (pr) { return pr.attribute_id == a.attribute_id; });
+                                    var decliAttrib = decli.attributes.find(function (attr) { return attr.attribute_id == a.attribute_id; });
+                                    if (!!!pref || !!!decliAttrib) {
+                                    }
+                                    else if (!!decliAttrib.values &&
+                                        !!decliAttrib.values.length &&
+                                        decliAttrib.values[0].slug == pref.value)
+                                        good++;
+                                });
+                                if (typeof privee !== 'undefined') {
+                                    if (privee !==
+                                        decli.attributes.some(function (a) {
+                                            if (!!a.values && !!a.values.length && a.values[0].slug === 'privee')
+                                                return true;
+                                            return false;
+                                        })) {
+                                        good = -5;
+                                    }
+                                }
+                                if (good > 0) {
+                                    if (!!!bestmatch || bestmatch.attributes.length < decli.attributes.length)
+                                        bestmatch = __assign(__assign({}, decli), { category: p.category, parent_slug: p.slug });
+                                }
+                            };
+                            for (var _a = 0, _b = p.declinations; _a < _b.length; _a++) {
+                                var decli = _b[_a];
+                                _loop_2(decli);
+                            }
+                        }
+                    }
+                }
+            };
+            for (var _i = 0, products_1 = products; _i < products_1.length; _i++) {
+                var p = products_1[_i];
+                _loop_1(p);
+            }
+            if (!!bestmatch)
+                return bestmatch;
+            if (!!haveSku)
+                return undefined;
+            return !!firstInCat && !!firstInCat.declinations
+                ? __assign(__assign({}, firstInCat.declinations[0]), { category: firstInCat.category, parent_slug: firstInCat.slug }) : undefined;
+        };
+        this.computeItemsForBB = function (data, template) {
+            var categories = _this._getDataFromDataType(enums_1.QuotePartDataTypeEnum.ALL_CATEGORY).map(function (c) {
+                return c.data();
+            });
+            var products = _this._getDataFromDataType(enums_1.QuotePartDataTypeEnum.ALL_PRODUCTS).map(function (p) { return p.data(); });
+            var prodGrp = _this._getDataFromDataType(enums_1.QuotePartDataTypeEnum.ALL_PRODUCT_GROUPS).map(function (p) {
+                return p.data();
+            });
+            var prefClient = data.client_choice;
+            var getParentCat = function (catId) {
+                var cat = categories.find(function (c) { return c.id == catId; });
+                if (!!!cat)
+                    return undefined;
+                if (!!cat.parent)
+                    return getParentCat(cat.parent);
+                return cat;
+            };
+            var portePrivee = 0;
+            var porteTtl = 0;
+            var extraProduct = [];
+            var addToExtraPart = function (sku, qty) {
+                var idx = extraProduct.findIndex(function (p) { return p.sku == sku; });
+                if (idx > -1)
+                    extraProduct[idx].qty += qty;
+                else
+                    extraProduct.push({ sku: sku, qty: qty });
+            };
+            data.items.map(function (i) {
+                var thisCat = getParentCat(i.category_id);
+                if (!!thisCat && thisCat.slug == 'portes') {
+                    if (!!i.privee) {
+                        portePrivee += i.qty;
+                    }
+                    porteTtl += i.qty;
+                    prodGrp.map(function (pg) {
+                        if (pg.parts.some(function (s) { return s.sku == i.sku; }))
+                            pg.parts.map(function (pgp) {
+                                if (pgp.sku != i.sku) {
+                                    console.log(i);
+                                    addToExtraPart(pgp.sku, pgp.qty * i.qty);
+                                }
+                            });
+                    });
+                }
+            });
+            var setPoigneeQty = function (privee, qty) {
+                var poigneeIndex = data.items.findIndex(function (i) {
+                    var thisCat = getParentCat(i.category_id);
+                    if (!!thisCat && thisCat.slug == 'poignees') {
+                        return !!i.attributes && i.attributes.some(function (a) { return a.value == 'privee'; }) == privee;
+                    }
+                });
+                if (poigneeIndex == -1) {
+                    var thisCat = categories.find(function (c) { return c.slug == 'poignees'; });
+                    if (!!thisCat) {
+                        var match = _this._findBestProductMatch(thisCat.id, categories, products, (prefClient || []).map(function (q) { return ({ attribute_id: q.attribute_id, value: q.attribute_value }); }), privee);
+                        if (!!match)
+                            data.items.push({
+                                category_id: match.category,
+                                order: data.items.length,
+                                qty: qty,
+                                unit_price: match.price.regular.amount,
+                                status: enums_2.ProductProductionStateEnum.ATTENTE,
+                                attributes: match.attributes.map(function (a) {
+                                    return ({
+                                        attribute_id: a.attribute_id,
+                                        value: !!a.values && !!a.values.length ? a.values[0].slug : undefined
+                                    });
+                                }),
+                                parent_slug: match.parent_slug,
+                                sku: match.sku
+                            });
+                    }
+                }
+                else {
+                    data.items[poigneeIndex] = __assign(__assign({}, data.items[poigneeIndex]), { qty: qty });
+                }
+            };
+            var compute = false;
+            if (!!template) {
+                ;
+                (template.tabs || []).map(function (t) {
+                    ;
+                    (t.sections || []).map(function (s) {
+                        if (s.data_render_type == enums_1.QuoteSectionRenderTypeEnum.BOARD) {
+                            if (!!s.fields &&
+                                s.fields.some(function (f) {
+                                    return !!f.is_usable &&
+                                        !!f.values.length &&
+                                        f.values[0].key == 'autoAdd' &&
+                                        _this.renderFieldValue(f.values[0], { section: s });
+                                })) {
+                                var scondCat = _this._getSectionCategory(s.conditions_to_be_rendered || []);
+                                if (!!scondCat) {
+                                    var cat = getParentCat(scondCat);
+                                    if (!!cat && cat.slug == 'poignees')
+                                        compute = true;
+                                }
+                            }
+                        }
+                    });
+                });
+            }
+            if (compute) {
+                setPoigneeQty(true, portePrivee);
+                setPoigneeQty(false, porteTtl - portePrivee);
+            }
+            for (var i = 0; i < data.items.length; i++) {
+                var thisCat = getParentCat(data.items[i].category_id);
+                if (!!!thisCat)
+                    continue;
+                var privee = undefined;
+                if (thisCat.slug === 'portes')
+                    privee = !!data.items[i].privee;
+                if (thisCat.slug === 'poignees')
+                    privee = (data.items[i].attributes || []).some(function (a) { return a.value == 'privee'; });
+                var match = _this._findBestProductMatch(thisCat.id, categories, products, data.items[i].attributes || [], privee, true);
+                if (!!!match)
+                    continue;
+                data.items[i].sku = match.sku;
+            }
+            extraProduct.map(function (ep) {
+                var idx = data.items.findIndex(function (i) { return i.sku == ep.sku; });
+                if (idx > -1)
+                    data.items[idx] = __assign(__assign({}, data.items[idx]), { qty: ep.qty });
+                else {
+                    var productToAdd = products.find(function (p) { return !!p.declinations && !!p.declinations.some(function (d) { return d.sku == ep.sku; }); });
+                    if (!!!productToAdd)
+                        return;
+                    var decliToAdd = (productToAdd.declinations || []).find(function (d) { return d.sku == ep.sku; });
+                    if (!!!decliToAdd)
+                        return;
+                    data.items.push({
+                        category_id: productToAdd.category,
+                        order: data.items.length,
+                        qty: ep.qty,
+                        unit_price: decliToAdd.price.regular.amount,
+                        status: enums_2.ProductProductionStateEnum.ATTENTE,
+                        attributes: decliToAdd.attributes.map(function (a) {
+                            return ({
+                                attribute_id: a.attribute_id,
+                                value: !!a.values && !!a.values.length ? a.values[0].slug : undefined
+                            });
+                        }),
+                        parent_slug: productToAdd.slug,
+                        sku: decliToAdd.sku
+                    });
+                }
+            });
+            return data;
+        };
+        this._getSectionCategory = function (conds) {
+            var cond = conds.find(function (c) { return c.condition_props && c.condition_props.type == 'category'; });
+            if (!!!cond)
+                return undefined;
+            return cond.condition_value;
+        };
+        this._fetchAttributesNeeded = function (fields) {
+            var attribs = [];
+            (fields || []).map(function (f) {
+                console.log(f);
+                f.values.map(function (v) {
+                    if (v.type == 'select') {
+                        attribs.push({
+                            attribute_id: (v.key.split('@')[1] || '').split('.')[0],
+                            value: _this.hasDefaultValue(v) ? _this.getDefaultValue(v) : ''
+                        });
+                    }
+                });
+            });
+            return attribs;
+        };
+        this.removeLine = function (_me, idx, template) { return __awaiter(_this, void 0, void 0, function () {
+            var re, dataObj, data;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (typeof idx === 'undefined')
+                            return [2];
+                        if (!!!this._confirm) return [3, 2];
+                        return [4, this._confirm('Voulez-vous vraiment effacer cette ligne ?')];
+                    case 1:
+                        re = _a.sent();
+                        if (!!!re)
+                            return [2];
+                        _a.label = 2;
+                    case 2:
+                        dataObj = this._getDataFromDataType(enums_1.QuotePartDataTypeEnum.CURRENT_QUOTE, {
+                            keepClass: true
+                        });
+                        data = dataObj.data();
+                        return [4, dataObj.save(this.computeItemsForBB(__assign(__assign({}, data), { items: data.items.filter(function (f, i) { return i !== idx; }) }), template))];
+                    case 3:
+                        _a.sent();
+                        return [2];
+                }
+            });
+        }); };
+        this.cloneItem = function (_me, idx, template) { return __awaiter(_this, void 0, void 0, function () {
+            var dataObj, data;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (typeof idx === 'undefined')
+                            return [2];
+                        dataObj = this._getDataFromDataType(enums_1.QuotePartDataTypeEnum.CURRENT_QUOTE, {
+                            keepClass: true
+                        });
+                        data = dataObj.data();
+                        return [4, dataObj.save(this.computeItemsForBB(__assign(__assign({}, data), { items: __spreadArray(__spreadArray([], data.items, true), [__assign(__assign({}, data.items[idx]), { order: data.items.length })], false) }), template))];
+                    case 1:
+                        _a.sent();
+                        return [2];
+                }
+            });
+        }); };
+        this.addNewLine = function (section, template) { return __awaiter(_this, void 0, void 0, function () {
+            var condCat, dataObj, categories, products, data, attribs, bestSku, newItem, newData;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!!!section.conditions_to_be_rendered)
+                            return [2];
+                        condCat = this._getSectionCategory(section.conditions_to_be_rendered);
+                        if (!!!condCat)
+                            return [2];
+                        dataObj = this._getDataFromDataType(enums_1.QuotePartDataTypeEnum.CURRENT_QUOTE, {
+                            keepClass: true
+                        });
+                        categories = this._getDataFromDataType(enums_1.QuotePartDataTypeEnum.ALL_CATEGORY);
+                        products = this._getDataFromDataType(enums_1.QuotePartDataTypeEnum.ALL_PRODUCTS);
+                        data = dataObj.data();
+                        attribs = this._fetchAttributesNeeded(section.fields || []);
+                        bestSku = this._findBestProductMatch(condCat, categories.map(function (c) { return c.data(); }), products.map(function (p) { return p.data(); }), attribs);
+                        newItem = [];
+                        if (!!!bestSku)
+                            return [2];
+                        newItem.push({
+                            category_id: bestSku.category,
+                            order: data.items.length,
+                            qty: 1,
+                            unit_price: bestSku.price.regular.amount,
+                            status: enums_2.ProductProductionStateEnum.ATTENTE,
+                            attributes: attribs,
+                            parent_slug: bestSku.parent_slug,
+                            sku: bestSku.sku
+                        });
+                        newData = this.computeItemsForBB(__assign(__assign({}, data), { items: __spreadArray(__spreadArray([], data.items, true), newItem, true) }), template);
+                        return [4, dataObj.save(newData)];
+                    case 1:
+                        _a.sent();
+                        return [2];
+                }
+            });
+        }); };
+        this._data = appData;
+        if (!!options) {
+            if (!!options.confirmDlg)
+                this._confirm = options.confirmDlg;
+        }
+    }
+    Object.defineProperty(CMSReader.prototype, "data", {
+        get: function () {
+            return this._data;
+        },
+        set: function (data) {
+            this._data = data;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(CMSReader.prototype, "section", {
+        get: function () {
+            return this._section;
+        },
+        set: function (section) {
+            this._section = section;
+            if (!!section) {
+                if (section.data_map_on !== undefined)
+                    this._sectionData = this._getDataFromDataType(section.data_map_on);
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(CMSReader.prototype, "sectionData", {
+        get: function () {
+            return this._sectionData;
+        },
+        set: function (sectionData) {
+            this._sectionData = sectionData;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    CMSReader.prototype.renderFieldValue = function (fieldValue, options) {
+        var _a, _b, _c;
+        var _this = this;
+        if (Array.isArray(fieldValue))
+            fieldValue = fieldValue[0];
+        if (fieldValue.custom_field !== undefined)
+            return this.renderFieldValue(fieldValue.custom_field, options);
+        if (fieldValue.givenValue !== undefined && fieldValue.type !== 'select')
+            return fieldValue.givenValue;
+        if (fieldValue.type === 'operator')
+            return fieldValue.operation;
+        if (!!options && !!options.field && !!options.field.is_computed) {
+            if (fieldValue.type === 'number')
+                return (0, toNumber_1.default)(fieldValue.value);
+            throw new Error(errors_1.ErrorEnum.A0000NIMP);
+        }
+        if (this.data === undefined && !!!options)
+            throw new Error(errors_1.ErrorEnum['A00001-B']);
+        if (this.data === undefined && !!options && options.divingData === undefined)
+            throw new Error(errors_1.ErrorEnum['A00001-C']);
+        if (!!options && options.section !== undefined)
+            this.section = options.section;
+        var keyForPath = !!options && !!options.forOptions ? 'path_key' : 'key';
+        if (fieldValue[keyForPath] === undefined)
+            throw new Error(keyForPath === 'key' ? errors_1.ErrorEnum['A00001-1'] : errors_1.ErrorEnum['A00001-1B']);
+        var fieldValueData = !!options && options.divingData !== undefined
+            ? options.divingData
+            : this._selectDataFromFieldValueUseProps(fieldValue, keyForPath === 'key' ? 'use' : 'path_use', {
+                keepClass: fieldValue.type === 'function' || fieldValue.type === 'action'
+            });
+        var propsKey = fieldValue[keyForPath].split(')')[fieldValue[keyForPath].split(')').length - 1];
+        switch (fieldValue.type) {
+            case 'function':
+                var override = this._customFunctionHandler.find(function (o) { return o.cmd === fieldValue.key; });
+                if (!!override)
+                    return override.fnc(fieldValue, fieldValueData);
+                return eval("fieldValueData.".concat(fieldValue.key, "()"));
+            case 'action': {
+                switch (fieldValue.key) {
+                    case enums_1.PredefinedActionEnum.PRINT.toString():
+                        return fieldValueData.printQuote;
+                    case enums_1.PredefinedActionEnum.EMAIL_SEND.toString():
+                        return fieldValueData.sendQuoteToClient;
+                    case enums_1.PredefinedActionEnum.CREATE_UPDATE_ROUTE.toString():
+                        return fieldValueData.addOrUpdateDispatch;
+                    case enums_1.PredefinedActionEnum.REMOVE_FROM_ROUTE.toString():
+                        return fieldValueData.removeFromDispatch;
+                    case enums_1.PredefinedActionEnum.STATUS_ANNULEE.toString():
+                    case enums_1.PredefinedActionEnum.STATUS_APPROBATION.toString():
+                    case enums_1.PredefinedActionEnum.STATUS_APPROUVEE_CLIENT.toString():
+                    case enums_1.PredefinedActionEnum.STATUS_APPROUVEE_PAR_LE_GESTIONNAIRE.toString():
+                    case enums_1.PredefinedActionEnum.STATUS_BO.toString():
+                    case enums_1.PredefinedActionEnum.STATUS_COMPTABILISE.toString():
+                    case enums_1.PredefinedActionEnum.STATUS_EN_ATTENTE.toString():
+                    case enums_1.PredefinedActionEnum.STATUS_EN_COURS.toString():
+                    case enums_1.PredefinedActionEnum.STATUS_EN_LIVRAISON.toString():
+                    case enums_1.PredefinedActionEnum.STATUS_LIVREE.toString():
+                    case enums_1.PredefinedActionEnum.STATUS_PRODUCTION.toString():
+                    case enums_1.PredefinedActionEnum.STATUS_REFUSEE_PAR_LE_CLIENT.toString():
+                    case enums_1.PredefinedActionEnum.STATUS_REFUSEE_PAR_LE_GESTIONNAIRE.toString():
+                    case enums_1.PredefinedActionEnum.STATUS_TERMINEE.toString():
+                        return function () { return __awaiter(_this, void 0, void 0, function () {
+                            var statusField, classObj, partialObjForUpdate;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        statusField = { key: 'status', label: 'status', type: 'number', use: 8 };
+                                        classObj = this.getClass(statusField);
+                                        partialObjForUpdate = classObj.data();
+                                        this.constructPartialBasedOnKey((0, toNumber_1.default)(fieldValue.key) - 10, classObj.data(), statusField);
+                                        return [4, classObj.save(partialObjForUpdate)];
+                                    case 1:
+                                        _a.sent();
+                                        return [2];
+                                }
+                            });
+                        }); };
+                    case 'addItemLine':
+                        return this.addNewLine;
+                    case 'cloneItem':
+                        return function (me, template) {
+                            me.cloneItem(me, fieldValue.index, template);
+                        };
+                    case 'removeLine':
+                        return function (me, template) {
+                            me.removeLine(me, fieldValue.index, template);
+                        };
+                    case 'autoAdd': {
+                        if (!!!this.section)
+                            return false;
+                        var statusField = { key: 'autoAdd', label: 'autoAdd', type: 'obj', use: 8 };
+                        var classObj = this.getClass(statusField);
+                        var partialObjForUpdate = classObj.data();
+                        if (!!options && options.toggle) {
+                            if (!!!partialObjForUpdate.autoAdd) {
+                                partialObjForUpdate.autoAdd = (_a = {}, _a[(0, string_1.string_to_slug)(this.section.label)] = true, _a);
+                            }
+                            var val = !!partialObjForUpdate.autoAdd[(0, string_1.string_to_slug)(this.section.label)];
+                            partialObjForUpdate.autoAdd[(0, string_1.string_to_slug)(this.section.label)] = !val;
+                            classObj.save(partialObjForUpdate);
+                        }
+                        if (!!!partialObjForUpdate.autoAdd ||
+                            typeof partialObjForUpdate.autoAdd[(0, string_1.string_to_slug)(this.section.label)] == 'undefined')
+                            return true;
+                        return !!partialObjForUpdate.autoAdd[(0, string_1.string_to_slug)(this.section.label)];
+                    }
+                }
+            }
+            default:
+        }
+        if (propsKey.includes('@'))
+            if (!propsKey.includes('.') || (propsKey.indexOf('@') < propsKey.indexOf('.') && Array.isArray(fieldValueData))) {
+                var _d = propsKey.split('@'), key_3 = _d[0], restAndValue = _d.slice(1);
+                var _e = restAndValue.join('.').split('.'), value_2 = _e[0], rest_2 = _e.slice(1);
+                var objFound = fieldValueData.find(function (o) {
+                    if (!!o && !Array.isArray(o) && (0, data_1.isBaseClass)(o))
+                        o = o.data();
+                    if (value_2.includes('{') && value_2.includes('}')) {
+                        if (value_2.includes('givenValue'))
+                            return o[key_3] === fieldValue.givenValue;
+                    }
+                    return o[key_3] === value_2;
+                });
+                if (!!!rest_2 || !!!rest_2.length) {
+                    return this.getValue(fieldValueData, fieldValue, options);
+                }
+                return this.renderFieldValue(__assign(__assign({}, fieldValue), (_b = {}, _b[keyForPath] = rest_2.join('.'), _b)), __assign(__assign({}, options), { divingData: objFound }));
+            }
+        if (Array.isArray(fieldValueData) && fieldValue.index !== undefined)
+            return this.renderFieldValue(fieldValue, __assign(__assign({}, options), { divingData: fieldValueData[fieldValue.index] }));
+        if (!propsKey.includes('.')) {
+            if (propsKey.includes('->') || (!!options && options.field !== undefined && options.field.alters !== undefined)) {
+                var _f = propsKey.split('->'), props = _f[0], op = _f.slice(1);
+                if (!!options && options.field !== undefined && options.field.alters !== undefined) {
+                    var alters_1 = options.field.alters || [];
+                    var value = (fieldValueData[props] || []).filter(function (v) {
+                        var respect = _this.respectAllGivenConditions(alters_1
+                            .filter(function (a) { return a.altering_type === 'array'; })
+                            .map(function (a) {
+                            var _a;
+                            var condition_props = a.condition_props;
+                            if (condition_props === undefined)
+                                return a;
+                            if (condition_props.key === undefined)
+                                return a;
+                            if (typeof condition_props.key !== 'string')
+                                return a;
+                            return __assign(__assign({}, a), { condition_props: __assign(__assign({}, condition_props), (_a = {}, _a[keyForPath] = condition_props.key.split('.')[condition_props.key.split('.').length - 1], _a)) });
+                        }), { divingData: v, noNeedToDiveInData: false });
+                        return respect;
+                    });
+                    var operation = this._goDownOperation((0, sumBy_1.default)(value, function (v) {
+                        var operated_by = (fieldValue.operate_by || '').split('%');
+                        var mul = _this._getProductConvertionRatio(v.sku, operated_by[1]);
+                        return v[operated_by[0]] / mul;
+                    }), fieldValue, op[0], options);
+                    if (operation !== undefined)
+                        return operation;
+                    if (op === undefined || !!!op.length)
+                        return value;
+                    return this.getValue(value[op], fieldValue, options);
+                }
+                if (propsKey.includes('->')) {
+                    var operation = this._goDownOperation((0, sumBy_1.default)(fieldValueData[props], function (v) {
+                        var operated_by = (fieldValue.operate_by || '').split('%');
+                        var mul = _this._getProductConvertionRatio(v.sku, operated_by[1]);
+                        return v[operated_by[0]] / mul;
+                    }), fieldValue, op[0], options);
+                    if (operation !== undefined)
+                        return operation;
+                    return this.getValue(fieldValueData[props][op], fieldValue, options);
+                }
+            }
+            if (propsKey.includes('%')) {
+                var _g = propsKey.split('%'), props = _g[0], op = _g.slice(1);
+                var fittingUnit = this._getProductConvertionRatio(fieldValueData.sku, op[0]);
+                return +(this.getValue(fieldValueData[props], fieldValue, options) / fittingUnit).toFixed(3);
+            }
+            if (Array.isArray(fieldValueData) && fieldValue.index === undefined)
+                throw new Error(errors_1.ErrorEnum['A00003-3']);
+            return this.getValue(fieldValueData[propsKey], fieldValue, options);
+        }
+        var _h = propsKey.split('.'), first = _h[0], rest = _h.slice(1);
+        return this.renderFieldValue(__assign(__assign({}, fieldValue), (_c = {}, _c[keyForPath] = rest.join('.'), _c)), __assign(__assign({}, options), { divingData: fieldValueData[first] }));
+    };
+    CMSReader.prototype.renderField = function (field, options) {
+        var _this = this;
+        if (!!field.is_text)
+            return field.text;
+        var fields = field.values.map(function (fieldvalue) {
+            if (fieldvalue.type == 'boolean')
+                return !!_this.renderFieldValue(fieldvalue, __assign(__assign({}, options), { field: field }));
+            return _this.renderFieldValue(fieldvalue, __assign(__assign({}, options), { field: field }));
+        });
+        if (field.values.some(function (v) { return v.type === 'operator'; }))
+            return [(0, math_1.prioritizeAndResolve)(fields)];
+        if (Array.isArray(fields) && Array.isArray(fields[0]))
+            return (0, flatten_1.default)(fields);
+        return fields;
+    };
+    CMSReader.prototype.renderFieldValueOptions = function (fieldValue, options) {
+        if (fieldValue.path_key === undefined)
+            throw new Error(errors_1.ErrorEnum['A00003-1']);
+        if (fieldValue.path_use === undefined)
+            throw new Error(errors_1.ErrorEnum['A00003-2']);
+        if (!!options && options.section)
+            this.section = options.section;
+        var fieldValueData = this._selectDataFromFieldValueUseProps(fieldValue, 'path_use', __assign({ keepClass: !!options && !!options.keepClass, filter: this._getIfSectionHasFilteringFieldValue() }, options));
+        var object = fieldValue.object;
+        if (object === undefined)
+            return fieldValueData;
+        return fieldValueData.map(function (d) {
+            var newObj = {};
+            for (var _i = 0, object_1 = object; _i < object_1.length; _i++) {
+                var line = object_1[_i];
+                newObj[line.key] = d[line.field];
+            }
+            return newObj;
+        });
+    };
+    CMSReader.prototype.getValue = function (fieldValueData, fieldValue, options) {
+        if (fieldValueData === undefined)
+            return undefined;
+        var _a = options || { parseValue: false, stringify: false }, parseValue = _a.parseValue, stringify = _a.stringify;
+        if (fieldValueData instanceof firestore_1.Timestamp)
+            return !!stringify ? (0, moment_1.default)(fieldValueData.toDate()).format('LLLL') : fieldValueData.toDate();
+        if (!!!parseValue && !!!stringify)
+            return fieldValueData;
+        if ((0, moment_1.isDate)(fieldValueData))
+            return !!stringify ? (0, moment_1.default)(fieldValueData).format('LLLL') : fieldValueData;
+        if (typeof fieldValueData === 'string')
+            if (fieldValue.type === 'select')
+                return { value: fieldValueData, field: fieldValue };
+        return fieldValueData;
+    };
+    CMSReader.prototype.respectAllGivenConditions = function (conditions, options) {
+        if (!!!conditions)
+            return true;
+        if (!!!conditions.length)
+            return true;
+        for (var _i = 0, conditions_1 = conditions; _i < conditions_1.length; _i++) {
+            var condition = conditions_1[_i];
+            if (!this._isConditionRespected(condition, options))
+                return false;
+        }
+        return true;
+    };
+    CMSReader.prototype.fieldRespectConditionToBe = function (field, toBe, options) {
+        var fieldCondition = field[toBe === 'displayed' ? 'conditions_to_be_rendered' : 'conditions_to_be_editable'];
+        if (fieldCondition === undefined)
+            return true;
+        return this.respectAllGivenConditions(fieldCondition, options);
+    };
+    CMSReader.prototype.renderSectionAsRows = function (section, options) {
+        var _this = this;
+        var fields = section.fields;
+        var dataMapOn = section.data_map_on;
+        if (dataMapOn === undefined)
+            return [];
+        if (fields === undefined)
+            return [];
+        var currentSectionData = this._getDataFromDataType(dataMapOn);
+        if (!!!currentSectionData)
+            return [];
+        if (!Array.isArray(currentSectionData))
+            return [];
+        var rows = [];
+        currentSectionData.map(function (currentLine, currentLineIndex) {
+            if (!_this.respectAllGivenConditions((section.conditions_to_be_rendered || []).map(function (condition) { return (__assign(__assign({}, condition), { condition_props: !!condition.condition_props
+                    ? __assign(__assign({}, (condition.condition_props || {})), { key: CMSReader.remotePartFromKeyString((condition.condition_props.key || ''), CMSReader.getDataMapOnKey(dataMapOn) || '') }) : undefined })); }), { divingData: currentLine }))
+                return;
+            var row = {};
+            for (var _i = 0, fields_1 = fields; _i < fields_1.length; _i++) {
+                var field = fields_1[_i];
+                var fieldValue = field.values[0];
+                if (fieldValue === undefined)
+                    continue;
+                var value = _this.renderFieldValue(__assign(__assign({}, fieldValue), { index: currentLineIndex, key: CMSReader.remotePartFromKeyString(fieldValue.key, CMSReader.getDataMapOnKey(dataMapOn) || '') }), { divingData: currentLine });
+                row[CMSReader.remotePartFromKeyString(fieldValue.key, CMSReader.getDataMapOnKey(dataMapOn) || '')] =
+                    value;
+                row['id'] = currentLineIndex;
+            }
+            rows.push(row);
+        });
+        return rows;
+    };
+    CMSReader.prototype.getClass = function (fieldValue) {
+        var objFromData = this.data.find(function (d) { return d.dataType === fieldValue.use; });
+        if (!!!objFromData)
+            throw new Error(errors_1.ErrorEnum['C00001-3']);
+        if (Array.isArray(objFromData.data))
+            throw new Error(errors_1.ErrorEnum['C00001-4']);
+        if (!(0, data_1.isBaseClass)(objFromData.data))
+            throw new Error(errors_1.ErrorEnum['A00002-C']);
+        return objFromData.data;
+    };
+    CMSReader.prototype.hasDefaultValue = function (fieldValue) {
+        if (fieldValue.value !== undefined)
+            return true;
+        return false;
+    };
+    CMSReader.prototype.getDefaultValue = function (fieldValue) {
+        if (!this.hasDefaultValue(fieldValue))
+            throw new Error(errors_1.ErrorEnum.D00001);
+        if (!this.defaultValueIsAFunction(fieldValue))
+            return fieldValue.value;
+        return this.execDefaultValueFunction(fieldValue);
+    };
+    CMSReader.prototype.defaultValueIsAFunction = function (fieldValue) {
+        if (!this.hasDefaultValue(fieldValue))
+            throw new Error(errors_1.ErrorEnum.D00001);
+        return (fieldValue.value || '').includes('&func:');
+    };
+    CMSReader.prototype.execDefaultValueFunction = function (fieldValue) {
+        if (!this.hasDefaultValue(fieldValue))
+            throw new Error(errors_1.ErrorEnum.D00001);
+        var funcType = this._getDefaultValueFuncType(fieldValue.value);
+        switch (funcType) {
+            case enums_1.DefaultValueFunctionType.QUOTE_SETTINGS_PREFERENCE:
+                var builtFieldValue = this._constructFieldValueBasedOnFunctionValueAndPreferences(fieldValue);
+                var fieldValueResult = this.renderFieldValue(builtFieldValue);
+                return fieldValueResult;
+            default:
+                throw new Error((0, errors_1.ErrorCustom)(funcType)['D00001-1-CUS']);
+        }
+    };
+    CMSReader.getFieldValues = function (field) {
+        if (!!field.multiple_values)
+            return field.values;
+        return field.values[0];
+    };
+    CMSReader.getDataMapOnKey = function (dataMapOn) {
+        switch (dataMapOn) {
+            case enums_1.QuotePartDataTypeEnum.CURRENT_QUOTE_PRODUCTS:
+                return 'items';
+            default:
+                return undefined;
+        }
+    };
+    CMSReader.getLastPropOfKeyString = function (key) {
+        return key.split('.')[key.split('.').length - 1];
+    };
+    CMSReader.remotePartFromKeyString = function (key, partToRemove) {
+        return key.replace(new RegExp("".concat(partToRemove, "."), 'ig'), '');
+    };
+    return CMSReader;
+}());
+exports.default = CMSReader;
+//# sourceMappingURL=index.js.map