@colijnit/configurator 260.1.2 → 261.1.1

package/esm2015/lib/builder.js

@@ -0,0 +1,795 @@
+import { __awaiter } from "tslib";
+import * as THREE from 'three';
+import { BehaviorSubject } from 'rxjs';
+import { Injectable } from '@angular/core';
+import { DecoNode } from '@colijnit/configuratorapi/build/model/deco-node';
+import { Selection } from '@colijnit/configuratorapi/build/model/selection';
+import { DecoNodeType } from '@colijnit/configuratorapi/build/enum/deco-node-type.enum';
+import { DecoNodeKind } from '@colijnit/configuratorapi/build/enum/deco-node-kind.enum';
+import { Article } from '@colijnit/configuratorapi/build/model/article';
+import { NodeType } from '@colijnit/configuratorapi/build/enum/node-type.enum';
+import { BusinessObjectFactory } from '@colijnit/ioneconnector/build/service/business-object-factory';
+import { ThreedUtils } from './utils/threed.utils';
+import { VariationHelper } from './core/helper/variation-helper';
+import { SwitchBuildFurnitureService } from './services/switch-build-furniture.service';
+import { SwitchLoadFurnitureService } from './services/switch-load-furniture.service';
+import { ConfiguratorService } from './services/configurator.service';
+import { ConfiguratorConnectorService } from './services/configurator-connector.service';
+import { ConfigurationResultObject } from './model/configuration-result-object';
+import { ImageUtils } from './utils/image.utils';
+import { SceneUtils } from './utils/scene-utils';
+import { ObjectUtils } from './utils/object.utils';
+import { ServiceLocator } from './services/locator.service';
+import * as i0 from "@angular/core";
+export class Builder {
+    constructor() {
+        this.selectionsReceived = new BehaviorSubject([]);
+        this.articleLoaded = new BehaviorSubject(undefined);
+        this.decosReceived = new BehaviorSubject([]);
+        this.answersReceived = new BehaviorSubject([]);
+        this.modelLoaded = new BehaviorSubject(null);
+        this._selections = [];
+        this._answers = [];
+        this._decos = [];
+        this._placedAdjustables = [];
+        this._placedAddables = [];
+        this._adjustables = [];
+        this._addables = [];
+        this._imageCache = new Map();
+        this._articleCache = new Map();
+        this._configuratorService = ServiceLocator.injector.get(ConfiguratorService);
+        this._buildFurnitureService = ServiceLocator.injector.get(SwitchBuildFurnitureService);
+        this._loadFurnitureService = ServiceLocator.injector.get(SwitchLoadFurnitureService);
+        this._configuratorConnectorService = ServiceLocator.injector.get(ConfiguratorConnectorService);
+    }
+    set debug(value) {
+        if (value) {
+            this._debug = value;
+            if (this._variationHelper) {
+                this._variationHelper.debug = this._debug;
+            }
+        }
+    }
+    get debug() {
+        return this._debug;
+    }
+    initNewBuild(scene, options, sku, instanceId, goodId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (options) {
+                yield this._configuratorService.initConnector(options, true);
+            }
+            this._buildFurnitureService.currentActiveService.scene = scene;
+            if (sku) {
+                try {
+                    const furnitureData = new ConfigurationResultObject();
+                    furnitureData.sku = sku;
+                    furnitureData.instanceId = instanceId;
+                    const resultObject = yield this._loadFurnitureService.currentActiveService.loadFurniture(furnitureData, false, true, false, false, false, false);
+                    return resultObject.object;
+                }
+                catch (error) {
+                    console.error('Error loading furniture configuration:', error);
+                }
+            }
+        });
+    }
+    buildWithData(options, selections, decos, assetUrl, cdnUrl, schema) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+                if (!this._scene) {
+                    reject('no scene provided!');
+                }
+                try {
+                    this._log('start build', true);
+                    yield this._downloadAsset(assetUrl, cdnUrl, schema, selections && selections.length > 1 && decos && decos.length > 0);
+                    try {
+                        if (this._source) {
+                            try {
+                                if (selections && selections.length > 1 && decos && decos.length > 0) {
+                                    this._reset();
+                                    // Set the scene.
+                                    this._buildFurnitureService.currentActiveService.scene = this._scene;
+                                    const result = new ConfigurationResultObject();
+                                    this._configuratorConnectorService.selections = selections;
+                                    this._configuratorConnectorService.decoNodes = decos;
+                                    // this._linkSelectionsAndDecos();
+                                    this._buildFurnitureService.currentActiveService.linkSelectionsAndDecos();
+                                    // this._prepareTheSelections();
+                                    this._buildFurnitureService.currentActiveService.prepareTheSelections();
+                                    // this._preloadMaterials();
+                                    this._buildFurnitureService.currentActiveService.preloadMaterials(options.schema);
+                                    // const build = await this._build();
+                                    const build = yield this._buildFurnitureService.currentActiveService.build(result);
+                                    resolve(build.object);
+                                }
+                                else {
+                                    resolve(this._source); // just return the source for simplicity
+                                }
+                            }
+                            catch (e) {
+                                reject(e.message);
+                            }
+                            {
+                            }
+                        }
+                        else {
+                            if (assetUrl) {
+                                reject(`Error downloading source: ${assetUrl}`);
+                            }
+                            else {
+                                reject('No 3D source provided!');
+                            }
+                        }
+                    }
+                    finally {
+                        this._cleanUp();
+                        this._log('finish build', true);
+                    }
+                }
+                catch (e) {
+                    reject(e);
+                }
+            }));
+        });
+    }
+    init(scene, options) {
+        this._boFactory = new BusinessObjectFactory();
+        this._threedUtils = new ThreedUtils();
+        this._variationHelper = new VariationHelper();
+        this._variationHelper.debug = this._debug;
+        if (!scene) {
+            throw 'No scene object provided!';
+        }
+        this._configuratorService = new ConfiguratorService();
+        // this._imageCacheService = new ImageCacheService();
+        if (options) {
+            this._configuratorService.initApi(options);
+        }
+        this._scene = scene;
+    }
+    buildModel(sku, instanceId, goodId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this._scene) {
+                return;
+            }
+            try {
+                yield this._setInstanceId(sku, instanceId, goodId);
+                yield this._prepareConfiguration(this._sku, this._goodId);
+                if (this._source) {
+                    yield this._configuratorService.setInstanceToConfigure(this._instanceId);
+                    const promises = [];
+                    this._reset();
+                    promises.push(this.getQuestionAndAnswers());
+                    promises.push(this._getSelections(this._instanceId));
+                    promises.push(this._getDecos());
+                    yield Promise.all(promises);
+                    if (this._answers.length > 0) {
+                        return;
+                    }
+                    this._linkSelectionsAndDecos();
+                    this._prepareTheSelections();
+                    this._preloadMaterials();
+                    const build = yield this._build();
+                    return build;
+                }
+                else {
+                    throw 'GLB source not found!';
+                }
+            }
+            catch (e) {
+                throw e;
+            }
+        });
+    }
+    buildModelFromData(selections, decos, assetUrl, cdnUrl, schema) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+                if (!this._scene) {
+                    reject('no scene provided!');
+                }
+                try {
+                    this._log('start build', true);
+                    yield this._downloadAsset(assetUrl, cdnUrl, schema, selections && selections.length > 1 && decos && decos.length > 0);
+                    try {
+                        if (this._source) {
+                            try {
+                                if (selections && selections.length > 1 && decos && decos.length > 0) {
+                                    this._reset();
+                                    this._selections = selections;
+                                    this._decos = decos;
+                                    this._linkSelectionsAndDecos();
+                                    this._prepareTheSelections();
+                                    this._preloadMaterials();
+                                    const build = yield this._build();
+                                    resolve(build);
+                                }
+                                else {
+                                    resolve(this._source); // just return the source for simplicity
+                                }
+                            }
+                            catch (e) {
+                                reject(e.message);
+                            }
+                            {
+                            }
+                        }
+                        else {
+                            if (assetUrl) {
+                                reject(`Error downloading source: ${assetUrl}`);
+                            }
+                            else {
+                                reject('No 3D source provided!');
+                            }
+                        }
+                    }
+                    finally {
+                        this._cleanUp();
+                        this._log('finish build', true);
+                    }
+                }
+                catch (e) {
+                    reject(e);
+                }
+            }));
+        });
+    }
+    initNodeInstance(goodId) {
+        return this._configuratorService.initNodeInstance(goodId, false);
+    }
+    destroy() {
+        this._threedUtils.clearCache();
+        this._variationHelper.clearCache();
+    }
+    selectSelection(selection) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._configuratorService.selectSelection(selection, false);
+            yield this.getQuestionAndAnswers();
+        });
+    }
+    getQuestionAndAnswers(publicationCode) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const questionsAndAnswers = yield this._configuratorService.getQuestionAndAnswers(false, publicationCode);
+            this._answers = questionsAndAnswers && questionsAndAnswers.answers ? questionsAndAnswers.answers : [];
+            this.answersReceived.next(this._answers);
+        });
+    }
+    selectAnswer(answer) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._configuratorService.selectAnswer(answer, false);
+            yield this.getQuestionAndAnswers();
+            if (this._answers && this._answers.length === 0) {
+                this._build();
+            }
+        });
+    }
+    getImageForSelectionOrAnswer(object) {
+        const includeMimeType = true, thumb = true;
+        return new Promise((resolve, reject) => {
+            if (object && object.nodeId) {
+                if (!this._imageCache.has(object.nodeId)) {
+                    return this._configuratorService.getSingleImage(object.nodeId, 4, includeMimeType, thumb, true)
+                        .then((responseData) => {
+                        const base64 = this._handleResponseData(includeMimeType, thumb, responseData);
+                        this._imageCache.set(object.nodeId, base64);
+                        resolve(base64);
+                    }).catch(() => {
+                        reject();
+                    });
+                }
+                else {
+                    resolve(this._imageCache.get(object.nodeId));
+                }
+            }
+            else {
+                reject();
+            }
+        });
+    }
+    _cleanUp() {
+        this._sku = undefined;
+        this._goodId = undefined;
+        this._instanceId = undefined;
+        this._variationHelper.clearCache();
+    }
+    _handleResponseData(includeMimetype, thumb, responseData) {
+        if (responseData && responseData.resultObject) {
+            if (responseData.resultObject.filePath !== null && responseData.resultObject.filePath !== '') {
+                return ImageUtils.getFixedImageFilepathUrl(responseData.resultObject.filePath);
+            }
+            else {
+                if (includeMimetype) {
+                    return ImageUtils.getDocBodyWithMimeTypeDefinition(responseData.resultObject.fileName, thumb ? responseData.resultObject.thumbnailBody : responseData.resultObject.documentBody);
+                }
+                else {
+                    return thumb ? responseData.resultObject.thumbnailBody : responseData.resultObject.documentBody;
+                }
+            }
+        }
+        else {
+            return '';
+        }
+    }
+    _preloadMaterials() {
+        if (this._decos && this._decos.length) {
+            const materials = [...new Set(this._decos
+                    .filter(d => (d.gameObjectName || d.materialUrl) && d.type === DecoNodeType.Variation)
+                    .map(d => d))];
+            this._variationHelper.preloadVariations(materials);
+        }
+    }
+    _setInstanceId(sku, instanceId, goodId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!instanceId && !this._instanceId) {
+                if (!goodId) {
+                    goodId = yield this._getGoodIdFromSku(sku);
+                }
+                this._goodId = goodId;
+                const result = yield this.initNodeInstance(this._goodId);
+                if (result && result.resultObject) {
+                    this._instanceId = result.resultObject;
+                }
+                else {
+                    throw 'Failed to initialize node instance';
+                }
+            }
+            else if (!this._instanceId) {
+                this._instanceId = instanceId;
+            }
+            if (!this._sku) {
+                this._sku = sku;
+            }
+        });
+    }
+    _prepareConfiguration(sku, goodId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const article = yield this._getArticle(sku, goodId);
+            if (article && article.assetUrl) {
+                if (article.contentDeliveryUrl) {
+                    this._variationHelper.assetPath =
+                        article.contentDeliveryUrl +
+                            (article.contentDeliveryUrl.endsWith('/') ? '' : '/') +
+                            (article.distSchema ? article.distSchema : 'UP_DBA');
+                }
+                yield this._downloadAsset(article.assetUrl, article.contentDeliveryUrl, article.distSchema);
+            }
+        });
+    }
+    _downloadAsset(assetUrl, cdnUrl, schema, setVisibleFalse = true) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._source = yield this._threedUtils.download3DSource(assetUrl, setVisibleFalse)
+                .catch((error) => {
+                throw error;
+            });
+            if (cdnUrl) {
+                this._variationHelper.assetPath =
+                    cdnUrl +
+                        (cdnUrl.endsWith('/') ? '' : '/') +
+                        (schema ? schema : 'UP_DBA');
+            }
+        });
+    }
+    _build() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const adjustables = this._getAdjustables();
+            if (adjustables && adjustables.length === 0 && this._selections && this._selections.length > 0) { // check if article has a gameObject
+                if (this._selections[0].nodeType === NodeType.Article && this._selections[0].gameObject) {
+                    adjustables.push(this._selections[0]);
+                }
+            }
+            if (adjustables && adjustables.length > 0) {
+                const obj = new THREE.Object3D();
+                obj.visible = false; // no need to render visualy
+                this._scene.add(obj);
+                let connected = false;
+                this._log('build main model');
+                for (let i = 0, len = adjustables.length; i < len; i++) {
+                    const adjustable = this._createAdjustable(obj, adjustables[i]);
+                    if (adjustable) {
+                        for (let ii = this._placedAdjustables.length - 1; ii >= 0; ii--) {
+                            if (SceneUtils.TrySelectorConnection(this._scene, obj, this._placedAdjustables[ii], adjustable, i === 1)) {
+                                this._placedAdjustables[ii].visible = true;
+                                adjustable.visible = true;
+                                connected = true;
+                                break;
+                            }
+                            connected = false;
+                        }
+                    }
+                    if (!connected && this._placedAdjustables.length > 1) {
+                        console.warn('No connection found for: ', adjustable.name);
+                    }
+                }
+                this._log('place addables');
+                this._placeAddables(obj);
+                this._log('update pivot');
+                this._updatePivot(obj);
+                this._log('load variations');
+                yield this._loadVariations(obj);
+                // this._variationHelper.clearCache();
+                this._log('remove from scene');
+                this._scene.remove(obj);
+                ObjectUtils.DisposeObject(this._source);
+                // this._cleanUp();
+                this._log('ready!');
+                this.modelLoaded.next(obj);
+                return obj;
+            }
+            else {
+                throw 'No adjustables found!';
+                // this._building = false;
+                // if (this.selections.length < 2) {
+                //     this._errorService.addError(this.activeInstance, {message: 'NO_SELECTIONS_OR_DECOS', description: 'NO_SELECTIONS_OR_DECOS_INFO'});
+                //     this.buildFinished.next({instanceId: this.activeInstance, resultType: ResultType.NoSelections});
+                // } else if (this.decos.size === 0) {
+                //     this._errorService.addError(this.activeInstance, {message: 'NO_SELECTIONS_OR_DECOS', description: 'NO_SELECTIONS_OR_DECOS_INFO'});
+                //     this.buildFinished.next({instanceId: this.activeInstance, resultType: ResultType.NoDecoNodes});
+                // } else {
+                //     this._errorService.addError(this.activeInstance, {message: 'NO_ADJUSTABLES', description: 'NO_ADJUSTABLES_INFO'});
+                //     this.buildFinished.next({instanceId: this.activeInstance, resultType: ResultType.NoAdjustables});
+                // }
+            }
+        });
+    }
+    _prepareTheSelections() {
+        if (!this._selections || !this._selections.length) {
+            return;
+        }
+        const selections = this._selections.slice();
+        const selectionOfArticle = selections.find(s => s.nodeType === NodeType.Article);
+        const adjustableSelections = selections.filter(s => s.addAdjust === '2');
+        const isArticleWithMaterial = adjustableSelections.length === 0 &&
+            selectionOfArticle.gameObject &&
+            selectionOfArticle.gameObject.length > 0;
+        // get generic variations
+        const globalVariations = this._selections
+            .filter(s => (s.generic || adjustableSelections.length === 1) && s.decoNode.variation && !s.decoNode.type)
+            .map((value, index, array) => {
+            // find selection of variation
+            const sel = this._selections.find(s => s.artNodeIdDeco === value.decoNode.variation.parentId);
+            if (sel) {
+                value.decoNode.variation.supplierArticleNr = sel.supplierArticleNr;
+            }
+            value.decoNode.variation.materialId = this._getMaterialIdFromParent(value.node);
+            return value.decoNode.variation;
+        });
+        // commented out for the moment
+        // globalVariations.forEach(g => {
+        //   const parentIdx = selections.findIndex(s => s.decoNode && s.decoNode.id === g.parentId);
+        //   if (parentIdx) { // remove parent selection
+        //     selections.splice(parentIdx, 1);
+        //   }
+        //   const idx = selections.findIndex(s => s.decoNode && s.decoNode.id === g.id);
+        //   if (idx) { // move generic variations to top
+        //     const selection = selections[idx];
+        //     selections.splice(idx, 1);
+        //     selections.unshift(selection);
+        //   }
+        // });
+        // const usedVariations: FurniturePartVariation[] = [];
+        let globalVariationsRewrite = true;
+        const len = selections.length;
+        let lastAdded;
+        let lastAdjustable;
+        let newPart = false;
+        let previousPresLevel = -1;
+        let positioning;
+        let optionText;
+        for (let i = 0; i < len; i++) {
+            const selection = selections[i];
+            if (selection.presentationLevel === 1) {
+                positioning = selection.hdecoPositioning;
+                optionText = selection.question;
+            }
+            if (selection.presentationLevel > previousPresLevel) {
+                selection.hdecoPositioning = selection.hdecoPositioning || positioning;
+            }
+            if (selection.decoNode) {
+                if (selection.decoNode.type === DecoNodeType.Variation) {
+                    const decoNode = selection.decoNode;
+                    decoNode.optionText = optionText;
+                    // find selection of variation and set materialId in case of multimaterial
+                    decoNode.materialId = this._getMaterialIdFromParent(decoNode.nodeId);
+                    if (lastAdded) {
+                        if (newPart) {
+                            if (decoNode.materialId) {
+                                lastAdded.variations.push(decoNode);
+                            }
+                            else {
+                                lastAdded.variations = [decoNode];
+                            }
+                        }
+                        else {
+                            lastAdded.variations.push(decoNode);
+                        }
+                        newPart = false;
+                    }
+                    else {
+                        if (globalVariationsRewrite) {
+                            globalVariations.length = 0;
+                            globalVariationsRewrite = false;
+                        }
+                        if (!globalVariations.find(v => v.id === decoNode.id)) {
+                            globalVariations.push(decoNode);
+                        }
+                    }
+                    // const variation: FurniturePartVariation = new FurniturePartVariation();
+                    // variation.BrandId = selection.decoNode.brandId;
+                    // variation.Description = selection.decoNode.gameObjectName;
+                    // variation.MaterialId = (selection.decoNode as any).materialId;
+                    // variation.SupplierArticleNr = (selection.decoNode as any).supplierArticleNr;
+                    // usedVariations.push(variation);
+                }
+                else if ((selection.decoNode.type === DecoNodeType.Part &&
+                    typeof selection.decoNode.gameObjectName === 'string' &&
+                    selection.decoNode.gameObjectName.length) || (isArticleWithMaterial)) {
+                    if (selection.decoNode.kind === DecoNodeKind.Adjustable || (isArticleWithMaterial)) {
+                        selection.variations = globalVariations;
+                        this._adjustables.push(selection);
+                        if (!lastAdded || (lastAdded.nodeId !== selection.nodeId || lastAdded.node !== selection.node)) {
+                            newPart = true;
+                        }
+                        lastAdded = selection;
+                        lastAdjustable = selection;
+                    }
+                    else if (selection.decoNode.kind === DecoNodeKind.Addable) {
+                        selection.variations = lastAdjustable ? lastAdjustable.variations : globalVariations;
+                        if (lastAdjustable) {
+                            lastAdjustable.addables.push(selection);
+                        }
+                        this._addables.push(selection);
+                        if (!lastAdded || (lastAdded.nodeId !== selection.nodeId || lastAdded.node !== selection.node)) {
+                            newPart = true;
+                        }
+                        lastAdded = selection;
+                    }
+                }
+            }
+            previousPresLevel = selection.presentationLevel;
+        }
+        // this._upsertFurniture(this.activeInstance,
+        //   {Variations: usedVariations});
+    }
+    /**
+     * Returns the materialId of the parent up the tree until presentionlevel 1 is reached
+     * @param id
+     * @private
+     */
+    _getMaterialIdFromParent(id) {
+        if (this._selections) {
+            const idx = this._selections.findIndex(s => s.node === id);
+            let currentLevel = 999;
+            if (idx > -1) {
+                for (let i = idx; i > 0; i--) {
+                    const selection = this._selections[i];
+                    if (selection.presentationLevel >= currentLevel) {
+                        break;
+                    }
+                    currentLevel = selection.presentationLevel;
+                    if (selection.hdecoGameObject) {
+                        return selection.hdecoGameObject;
+                    }
+                }
+            }
+        }
+        return undefined;
+    }
+    _createAdjustable(parent, adj) {
+        let obj = this._source ? this._source.getObjectByName(adj.decoNode.gameObjectName || adj.gameObject) : null;
+        if (!obj) {
+            // in case of glb files, the importer removes dots from names
+            const name = adj.decoNode.gameObjectName.replace(/[.]/g, '');
+            obj = this._source ? this._source.getObjectByName(name) : null;
+            if (!obj) {
+                console.warn(`No object with name ${adj.decoNode.gameObjectName} found!`);
+                return null;
+            }
+        }
+        let adjustable = obj.clone();
+        adjustable.name = this._createUniqueName(parent, obj);
+        adjustable.userData.selection = adj;
+        adjustable.position.set(0, 0, 0);
+        adjustable.traverse(c => {
+            c.visible = !c.name.toLowerCase().startsWith('c_');
+        });
+        parent.add(adjustable);
+        // the object being added to the customFloorGroup is being recreated so we loose the reference
+        // therefor we need to retrieve the created object again
+        adjustable = parent.getObjectByName(adjustable.name);
+        this._placedAdjustables.push(adjustable);
+        return adjustable;
+    }
+    _createAddable(parent, add, part2, part1) {
+        const obj = this._source.getObjectByName(add.decoNode.gameObjectName);
+        if (!obj) {
+            return null;
+        }
+        // const selection: Selection = this._getSelectionFromId(adj.artNodeIdDeco);
+        const addable = obj.clone();
+        addable.name = this._createUniqueName(parent, obj);
+        addable.userData.selection = add;
+        addable.position.set(0, 0, 0);
+        addable.visible = true;
+        if (part1 && part2) {
+            parent.add(addable);
+            this._placedAddables.push(addable);
+            return addable;
+        }
+        return addable;
+    }
+    _placeAddables(parent) {
+        const len = this._placedAdjustables.length;
+        for (let i = 0; i < len; i++) {
+            if (this._placedAdjustables[i].userData.hasOwnProperty('selection') && this._placedAdjustables[i].userData.selection) {
+                const adjustableSelection = this._placedAdjustables[i].userData.selection;
+                if (adjustableSelection) {
+                    const lena = adjustableSelection.addables.length;
+                    let conAddable;
+                    for (let ia = 0; ia < lena; ia++) {
+                        SceneUtils.TrySelectorConnection(this._scene, parent, this._placedAdjustables[i], adjustableSelection.addables[ia], false, (add, part2, part1) => this._createAddable(parent, add, part2, part1));
+                        if (conAddable) {
+                            SceneUtils.TrySelectorConnection(this._scene, parent, conAddable, adjustableSelection.addables[ia], false, (add, part2, part1) => this._createAddable(parent, add, part2, part1));
+                        }
+                        conAddable = this._placedAddables[this._placedAddables.length - 1];
+                    }
+                }
+            }
+        }
+    }
+    _createUniqueName(parent, obj) {
+        let iteration = 0;
+        let name = obj.name;
+        let existingObj = parent.getObjectByName(name);
+        while (existingObj) {
+            iteration++;
+            name = obj.name + (iteration !== 0 ? ('_' + iteration) : '');
+            existingObj = parent.getObjectByName(name);
+        }
+        return name;
+    }
+    _getGoodIdFromSku(sku) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this._configuratorService.getGoodIdFromSku(sku, false);
+            if (response && response.validationResult && response.validationResult.success && response.resultObject) {
+                return response.resultObject;
+            }
+        });
+    }
+    _getArticle(sku, goodId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._articleCache.has(sku)) {
+                this.articleLoaded.next(this._articleCache.get(sku));
+                return this._articleCache.get(sku);
+            }
+            if (!goodId) {
+                goodId = yield this._getGoodIdFromSku(sku)
+                    .catch((error) => {
+                    throw `Article with sku ${sku} not found!`;
+                });
+            }
+            let article;
+            const articleResponse = yield this._configuratorService.getArticleQuickSel(goodId, false);
+            if (articleResponse && articleResponse.validationResult && articleResponse.validationResult.success && articleResponse.resultObject) {
+                if (articleResponse.resultObject.hasOwnProperty('oArticle')) {
+                    const obj = Array.isArray(articleResponse.resultObject['oArticle']) ? articleResponse.resultObject['oArticle'][0] : articleResponse.resultObject['oArticle'];
+                    article = this._boFactory.makeWithRawBackendData(Article, obj);
+                }
+                else {
+                    article = this._boFactory.makeWithRawBackendData(Article, articleResponse.resultObject);
+                }
+            }
+            this._articleCache.set(sku, article);
+            this.articleLoaded.next(article);
+            return article;
+        });
+    }
+    _getSelections(instanceId, publicationCode) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._selections = [];
+            const selectionResponse = yield this._configuratorService.getSelections(false, publicationCode);
+            if (selectionResponse && selectionResponse.resultObjects && selectionResponse.resultObjects.length > 0) {
+                this._selections = this._boFactory.makeBOArrayFromRawBackendDataArray(Selection, selectionResponse.resultObjects);
+                this._selections.forEach(s => s.instanceId = instanceId);
+                // const filtered: Selection[] = this._selections.filter(s => s.nodeType !== NodeType.Article && s.presentationLevel === 1);
+                this.selectionsReceived.next(this._selections);
+            }
+            else {
+                throw 'No selections found!';
+            }
+        });
+    }
+    _getDecos() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._decos = [];
+            const decosResponse = yield this._configuratorService.getDecos(false);
+            if (decosResponse && decosResponse.resultObjects && decosResponse.resultObjects.length > 0) {
+                this._decos = this._boFactory.makeBOArrayFromRawBackendDataArray(DecoNode, decosResponse.resultObjects);
+                this.decosReceived.next(this._decos);
+            }
+            else {
+                throw 'No deconodes found!';
+            }
+        });
+    }
+    _linkSelectionsAndDecos() {
+        if (!this._selections || !this._selections.length) {
+            return;
+        }
+        const len = this._selections.length;
+        for (let i = 0; i < len; i++) {
+            // const id: string = this.selections[i].artNodeIdDeco;
+            let deco = this._decos.find(d => d.nodeId === this._selections[i].node);
+            if (!deco) {
+                deco = new DecoNode();
+            }
+            if (deco.type !== DecoNodeType.Variation) {
+                const variation = this._getVariations().find(v => v.parentId === this._selections[i].artNodeIdDeco);
+                if (variation) {
+                    deco.variation = variation;
+                }
+            }
+            this._selections[i].decoNode = deco;
+        }
+    }
+    _getVariations() {
+        if (this._decos && this._decos.length) {
+            return this._decos.filter((deco) => {
+                return deco.type === DecoNodeType.Variation;
+            });
+        }
+        return [];
+    }
+    _loadVariations(obj) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._log('load variation for parts');
+            yield this._variationHelper.loadPart(obj, this._adjustables, true);
+            this._log('load variation for adjustables');
+            yield this._variationHelper.loadVariation(obj, this._adjustables, true);
+            this._log('load variation for addables');
+            yield this._variationHelper.loadVariation(obj, this._addables, true);
+            this._log('load variation clear cache');
+            this._variationHelper.clearCache();
+            this._log('load variations done');
+        });
+    }
+    _getAdjustables() {
+        if (!this._selections || !this._selections.length) {
+            return [];
+        }
+        return this._selections.filter(s => {
+            const node = s.decoNode;
+            return node && node.gameObjectName && node.type === DecoNodeType.Part && node.kind === DecoNodeKind.Adjustable;
+        });
+    }
+    _updatePivot(obj) {
+        const boundingBox = new THREE.Box3().setFromObject(obj);
+        const bbCenterPivot = new THREE.Vector3();
+        boundingBox.getCenter(bbCenterPivot);
+        const delta = new THREE.Vector3().sub(bbCenterPivot).setY(Math.abs(Math.min(boundingBox.min.y, 0)));
+        obj.children.forEach((child) => {
+            child.position.add(delta);
+        });
+        obj.updateWorldMatrix(false, true);
+    }
+    _reset() {
+        this._placedAddables.length = 0;
+        this._placedAdjustables.length = 0;
+        this._adjustables.length = 0;
+        this._addables.length = 0;
+        // this._prepareTheSelections();
+    }
+    _log(message, force = false) {
+        if (this.debug) {
+            this.debug(message);
+            console.log(new Date(), message);
+        }
+    }
+}
+Builder.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: Builder, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+Builder.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: Builder, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: Builder, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"builder.js","sourceRoot":"","sources":["../../../../projects/configurator/src/lib/builder.ts"],"names":[],"mappings":"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","sourcesContent":["import * as THREE from 'three';\r\nimport {Scene} from 'three';\r\nimport {BehaviorSubject} from 'rxjs';\r\nimport {Injectable} from '@angular/core';\r\nimport {DecoNode} from '@colijnit/configuratorapi/build/model/deco-node';\r\nimport {Selection} from '@colijnit/configuratorapi/build/model/selection';\r\nimport {DecoNodeType} from '@colijnit/configuratorapi/build/enum/deco-node-type.enum';\r\nimport {DecoNodeKind} from '@colijnit/configuratorapi/build/enum/deco-node-kind.enum';\r\nimport {Article} from '@colijnit/configuratorapi/build/model/article';\r\nimport {Answer} from '@colijnit/configuratorapi/build/model/answer';\r\nimport {QuestionAndAnswers} from '@colijnit/configuratorapi/build/model/question-and-answers';\r\nimport {NodeType} from '@colijnit/configuratorapi/build/enum/node-type.enum';\r\nimport {BusinessObjectFactory} from '@colijnit/ioneconnector/build/service/business-object-factory';\r\nimport {Options} from '@colijnit/ioneconnector/build/model/options';\r\nimport {DataServiceResponseData} from '@colijnit/ioneconnector/build/model/data-service-response-data';\r\nimport {ThreedUtils} from './utils/threed.utils';\r\nimport {VariationHelper} from './core/helper/variation-helper';\r\nimport {SwitchBuildFurnitureService} from './services/switch-build-furniture.service';\r\nimport {SwitchLoadFurnitureService} from './services/switch-load-furniture.service';\r\nimport {ConfiguratorService} from './services/configurator.service';\r\nimport {ConfiguratorConnectorService} from './services/configurator-connector.service';\r\nimport {ConfigurationResultObject} from './model/configuration-result-object';\r\nimport {ImageUtils} from './utils/image.utils';\r\nimport {SceneUtils} from './utils/scene-utils';\r\nimport {ObjectUtils} from './utils/object.utils';\r\nimport {ServiceLocator} from './services/locator.service';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class Builder {\r\n\r\n  public selectionsReceived: BehaviorSubject<Selection[]> = new BehaviorSubject<Selection[]>([]);\r\n  public articleLoaded: BehaviorSubject<Article> = new BehaviorSubject<Article>(undefined);\r\n  public decosReceived: BehaviorSubject<DecoNode[]> = new BehaviorSubject<DecoNode[]>([]);\r\n  public answersReceived: BehaviorSubject<Answer[]> = new BehaviorSubject<Answer[]>([]);\r\n  public modelLoaded: BehaviorSubject<THREE.Object3D> = new BehaviorSubject<THREE.Object3D>(null);\r\n\r\n  public set debug(value: Function) {\r\n    if (value) {\r\n      this._debug = value;\r\n      if (this._variationHelper) {\r\n        this._variationHelper.debug = this._debug;\r\n      }\r\n    }\r\n  }\r\n\r\n  public get debug(): Function {\r\n    return this._debug;\r\n  }\r\n\r\n  private _scene: THREE.Scene;\r\n  private _instanceId: string;\r\n  private _sku: string;\r\n  private _goodId: number;\r\n  private _selections: Selection[] = [];\r\n  private _answers: Answer[] = [];\r\n  private _decos: DecoNode[] = [];\r\n  private _placedAdjustables: any[] = [];\r\n  private _placedAddables: any[] = [];\r\n  private _adjustables: any[] = [];\r\n  private _addables: any[] = [];\r\n\r\n  private _debug: Function;\r\n\r\n  private _imageCache: Map<number, string> = new Map();\r\n\r\n  private _boFactory: BusinessObjectFactory;\r\n  private _source: THREE.Object3D;\r\n  private _threedUtils: ThreedUtils;\r\n  private _variationHelper: VariationHelper;\r\n  private _articleCache: Map<string, Article> = new Map();\r\n\r\n  private _configuratorService: ConfiguratorService;\r\n  private _buildFurnitureService: SwitchBuildFurnitureService;\r\n  private _loadFurnitureService: SwitchLoadFurnitureService;\r\n  private _configuratorConnectorService: ConfiguratorConnectorService;\r\n\r\n  constructor() {\r\n    this._configuratorService = ServiceLocator.injector.get(ConfiguratorService);\r\n    this._buildFurnitureService = ServiceLocator.injector.get(SwitchBuildFurnitureService);\r\n    this._loadFurnitureService = ServiceLocator.injector.get(SwitchLoadFurnitureService);\r\n    this._configuratorConnectorService = ServiceLocator.injector.get(ConfiguratorConnectorService);\r\n  }\r\n\r\n  public async initNewBuild(\r\n    scene: Scene,\r\n    options?: Options,\r\n    sku?: string,\r\n    instanceId?: string,\r\n    goodId?: number\r\n  ): Promise<THREE.Object3D> {\r\n    if (options) {\r\n      await this._configuratorService.initConnector(options, true);\r\n    }\r\n    this._buildFurnitureService.currentActiveService.scene = scene;\r\n    if (sku) {\r\n      try {\r\n\r\n        const furnitureData: ConfigurationResultObject = new ConfigurationResultObject();\r\n        furnitureData.sku = sku;\r\n        furnitureData.instanceId = instanceId;\r\n\r\n        const resultObject: ConfigurationResultObject =\r\n          await this._loadFurnitureService.currentActiveService.loadFurniture(\r\n            furnitureData,\r\n            false,\r\n            true,\r\n            false,\r\n            false,\r\n            false,\r\n            false\r\n          );\r\n        return resultObject.object;\r\n      } catch (error) {\r\n        console.error('Error loading furniture configuration:', error);\r\n      }\r\n    }\r\n  }\r\n\r\n  public async buildWithData(\r\n    options?: Options,\r\n    selections?: Selection[],\r\n    decos?: DecoNode[],\r\n    assetUrl?: string,\r\n    cdnUrl?: string,\r\n    schema?: string\r\n  ): Promise<THREE.Object3D> {\r\n\r\n    return new Promise(async (resolve: Function, reject: Function) => {\r\n      if (!this._scene) {\r\n        reject('no scene provided!');\r\n      }\r\n      try {\r\n        this._log('start build', true);\r\n        await this._downloadAsset(assetUrl, cdnUrl, schema, selections && selections.length > 1 && decos && decos.length > 0);\r\n        try {\r\n          if (this._source) {\r\n            try {\r\n              if (selections && selections.length > 1 && decos && decos.length > 0) {\r\n                this._reset();\r\n                // Set the scene.\r\n                this._buildFurnitureService.currentActiveService.scene = this._scene;\r\n                const result: ConfigurationResultObject = new ConfigurationResultObject();\r\n                this._configuratorConnectorService.selections = selections;\r\n                this._configuratorConnectorService.decoNodes = decos;\r\n                // this._linkSelectionsAndDecos();\r\n                this._buildFurnitureService.currentActiveService.linkSelectionsAndDecos();\r\n                // this._prepareTheSelections();\r\n                this._buildFurnitureService.currentActiveService.prepareTheSelections();\r\n                // this._preloadMaterials();\r\n                this._buildFurnitureService.currentActiveService.preloadMaterials(options.schema);\r\n                // const build = await this._build();\r\n                const build: ConfigurationResultObject = await this._buildFurnitureService.currentActiveService.build(result);\r\n\r\n                resolve(build.object);\r\n              } else {\r\n                resolve(this._source); // just return the source for simplicity\r\n              }\r\n            } catch (e) {\r\n              reject(e.message);\r\n            }\r\n            {\r\n            }\r\n          } else {\r\n            if (assetUrl) {\r\n              reject(`Error downloading source: ${assetUrl}`);\r\n            } else {\r\n              reject('No 3D source provided!');\r\n            }\r\n          }\r\n        } finally {\r\n          this._cleanUp();\r\n          this._log('finish build', true);\r\n        }\r\n      } catch (e) {\r\n        reject(e);\r\n      }\r\n    });\r\n  }\r\n\r\n  public init(scene: Scene, options?: Options) {\r\n    this._boFactory = new BusinessObjectFactory();\r\n    this._threedUtils = new ThreedUtils();\r\n    this._variationHelper = new VariationHelper();\r\n    this._variationHelper.debug = this._debug;\r\n\r\n    if (!scene) {\r\n      throw 'No scene object provided!';\r\n    }\r\n    this._configuratorService = new ConfiguratorService();\r\n    // this._imageCacheService = new ImageCacheService();\r\n    if (options) {\r\n      this._configuratorService.initApi(options);\r\n    }\r\n    this._scene = scene;\r\n  }\r\n\r\n  public async buildModel(sku?: string, instanceId?: string, goodId?: number): Promise<THREE.Object3D> {\r\n    if (!this._scene) {\r\n      return;\r\n    }\r\n    try {\r\n      await this._setInstanceId(sku, instanceId, goodId);\r\n      await this._prepareConfiguration(this._sku, this._goodId);\r\n      if (this._source) {\r\n        await this._configuratorService.setInstanceToConfigure(this._instanceId);\r\n        const promises: Promise<any>[] = [];\r\n        this._reset();\r\n        promises.push(this.getQuestionAndAnswers());\r\n        promises.push(this._getSelections(this._instanceId));\r\n        promises.push(this._getDecos());\r\n        await Promise.all(promises);\r\n        if (this._answers.length > 0) {\r\n          return;\r\n        }\r\n        this._linkSelectionsAndDecos();\r\n        this._prepareTheSelections();\r\n        this._preloadMaterials();\r\n        const build = await this._build();\r\n        return build;\r\n      } else {\r\n        throw 'GLB source not found!';\r\n      }\r\n    } catch (e) {\r\n      throw e;\r\n    }\r\n  }\r\n\r\n  public async buildModelFromData(selections: Selection[], decos: DecoNode[], assetUrl: string, cdnUrl: string, schema: string): Promise<THREE.Object3D> {\r\n    return new Promise(async (resolve: Function, reject: Function) => {\r\n      if (!this._scene) {\r\n        reject('no scene provided!');\r\n      }\r\n      try {\r\n        this._log('start build', true);\r\n        await this._downloadAsset(assetUrl, cdnUrl, schema, selections && selections.length > 1 && decos && decos.length > 0);\r\n        try {\r\n          if (this._source) {\r\n            try {\r\n              if (selections && selections.length > 1 && decos && decos.length > 0) {\r\n                this._reset();\r\n                this._selections = selections;\r\n                this._decos = decos;\r\n                this._linkSelectionsAndDecos();\r\n                this._prepareTheSelections();\r\n                this._preloadMaterials();\r\n                const build = await this._build();\r\n                resolve(build);\r\n              } else {\r\n                resolve(this._source); // just return the source for simplicity\r\n              }\r\n            } catch (e) {\r\n              reject(e.message);\r\n            }\r\n            {\r\n            }\r\n          } else {\r\n            if (assetUrl) {\r\n              reject(`Error downloading source: ${assetUrl}`);\r\n            } else {\r\n              reject('No 3D source provided!');\r\n            }\r\n          }\r\n        } finally {\r\n          this._cleanUp();\r\n          this._log('finish build', true);\r\n        }\r\n      } catch (e) {\r\n        reject(e);\r\n      }\r\n    });\r\n  }\r\n\r\n  public initNodeInstance(goodId: number): Promise<any> {\r\n    return this._configuratorService.initNodeInstance(goodId, false);\r\n  }\r\n\r\n  public destroy(): void {\r\n    this._threedUtils.clearCache();\r\n    this._variationHelper.clearCache();\r\n  }\r\n\r\n  public async selectSelection(selection: Selection): Promise<void> {\r\n    await this._configuratorService.selectSelection(selection, false);\r\n    await this.getQuestionAndAnswers();\r\n  }\r\n\r\n  public async getQuestionAndAnswers(publicationCode?: number): Promise<void> {\r\n    const questionsAndAnswers: QuestionAndAnswers = await this._configuratorService.getQuestionAndAnswers(false, publicationCode);\r\n    this._answers = questionsAndAnswers && questionsAndAnswers.answers ? questionsAndAnswers.answers : [];\r\n    this.answersReceived.next(this._answers);\r\n  }\r\n\r\n  public async selectAnswer(answer: Answer): Promise<void> {\r\n    await this._configuratorService.selectAnswer(answer, false);\r\n    await this.getQuestionAndAnswers();\r\n    if (this._answers && this._answers.length === 0) {\r\n      this._build();\r\n    }\r\n  }\r\n\r\n  public getImageForSelectionOrAnswer(object: Selection | Answer): Promise<string> {\r\n    const includeMimeType: boolean = true, thumb: boolean = true;\r\n    return new Promise((resolve: Function, reject: Function) => {\r\n      if (object && object.nodeId) {\r\n        if (!this._imageCache.has(object.nodeId)) {\r\n          return this._configuratorService.getSingleImage(object.nodeId, 4, includeMimeType, thumb, true)\r\n            .then((responseData: DataServiceResponseData) => {\r\n              const base64: string = this._handleResponseData(includeMimeType, thumb, responseData);\r\n              this._imageCache.set(object.nodeId, base64);\r\n              resolve(base64);\r\n            }).catch(() => {\r\n              reject();\r\n            });\r\n        } else {\r\n          resolve(this._imageCache.get(object.nodeId));\r\n        }\r\n      } else {\r\n        reject();\r\n      }\r\n    });\r\n  }\r\n\r\n  public _cleanUp(): void {\r\n    this._sku = undefined;\r\n    this._goodId = undefined;\r\n    this._instanceId = undefined;\r\n    this._variationHelper.clearCache();\r\n  }\r\n\r\n  private _handleResponseData(includeMimetype: boolean, thumb: boolean, responseData: DataServiceResponseData): string {\r\n    if (responseData && responseData.resultObject) {\r\n      if (responseData.resultObject.filePath !== null && responseData.resultObject.filePath !== '') {\r\n        return ImageUtils.getFixedImageFilepathUrl(responseData.resultObject.filePath);\r\n      } else {\r\n        if (includeMimetype) {\r\n          return ImageUtils.getDocBodyWithMimeTypeDefinition(responseData.resultObject.fileName,\r\n            thumb ? responseData.resultObject.thumbnailBody : responseData.resultObject.documentBody);\r\n        } else {\r\n          return thumb ? responseData.resultObject.thumbnailBody : responseData.resultObject.documentBody;\r\n        }\r\n      }\r\n    } else {\r\n      return '';\r\n    }\r\n  }\r\n\r\n  private _preloadMaterials(): void {\r\n    if (this._decos && this._decos.length) {\r\n      const materials: DecoNode[] = [...new Set(\r\n        this._decos\r\n          .filter(d => (d.gameObjectName || d.materialUrl) && d.type === DecoNodeType.Variation)\r\n          .map(d => d)\r\n      )];\r\n      this._variationHelper.preloadVariations(materials);\r\n    }\r\n  }\r\n\r\n  private async _setInstanceId(sku: string, instanceId?: string, goodId?: number): Promise<void> {\r\n    if (!instanceId && !this._instanceId) {\r\n      if (!goodId) {\r\n        goodId = await this._getGoodIdFromSku(sku);\r\n      }\r\n      this._goodId = goodId;\r\n      const result: DataServiceResponseData = await this.initNodeInstance(this._goodId);\r\n      if (result && result.resultObject) {\r\n        this._instanceId = result.resultObject;\r\n      } else {\r\n        throw 'Failed to initialize node instance';\r\n      }\r\n    } else if (!this._instanceId) {\r\n      this._instanceId = instanceId;\r\n    }\r\n    if (!this._sku) {\r\n      this._sku = sku;\r\n    }\r\n  }\r\n\r\n  private async _prepareConfiguration(sku: string, goodId?: number): Promise<void> {\r\n    const article: Article = await this._getArticle(sku, goodId);\r\n    if (article && article.assetUrl) {\r\n      if (article.contentDeliveryUrl) {\r\n        this._variationHelper.assetPath =\r\n          article.contentDeliveryUrl +\r\n          (article.contentDeliveryUrl.endsWith('/') ? '' : '/') +\r\n          (article.distSchema ? article.distSchema : 'UP_DBA');\r\n      }\r\n      await this._downloadAsset(article.assetUrl, article.contentDeliveryUrl, article.distSchema);\r\n    }\r\n  }\r\n\r\n  private async _downloadAsset(assetUrl: string, cdnUrl: string, schema: string, setVisibleFalse: boolean = true): Promise<void> {\r\n    this._source = await this._threedUtils.download3DSource(assetUrl, setVisibleFalse)\r\n      .catch((error) => {\r\n        throw error;\r\n      });\r\n    if (cdnUrl) {\r\n      this._variationHelper.assetPath =\r\n        cdnUrl +\r\n        (cdnUrl.endsWith('/') ? '' : '/') +\r\n        (schema ? schema : 'UP_DBA');\r\n    }\r\n  }\r\n\r\n  private async _build(): Promise<THREE.Object3D> {\r\n    const adjustables: Selection[] = this._getAdjustables();\r\n    if (adjustables && adjustables.length === 0 && this._selections && this._selections.length > 0) { // check if article has a gameObject\r\n      if (this._selections[0].nodeType === NodeType.Article && this._selections[0].gameObject) {\r\n        adjustables.push(this._selections[0]);\r\n      }\r\n    }\r\n    if (adjustables && adjustables.length > 0) {\r\n      const obj: THREE.Object3D = new THREE.Object3D();\r\n      obj.visible = false; // no need to render visualy\r\n      this._scene.add(obj);\r\n      let connected = false;\r\n      this._log('build main model');\r\n      for (let i = 0, len: number = adjustables.length; i < len; i++) {\r\n        const adjustable: THREE.Object3D = this._createAdjustable(obj, adjustables[i]);\r\n        if (adjustable) {\r\n          for (let ii = this._placedAdjustables.length - 1; ii >= 0; ii--) {\r\n            if (SceneUtils.TrySelectorConnection(this._scene,\r\n              obj, this._placedAdjustables[ii], adjustable, i === 1)) {\r\n              this._placedAdjustables[ii].visible = true;\r\n              adjustable.visible = true;\r\n              connected = true;\r\n              break;\r\n            }\r\n            connected = false;\r\n          }\r\n        }\r\n        if (!connected && this._placedAdjustables.length > 1) {\r\n          console.warn('No connection found for: ', adjustable.name);\r\n        }\r\n      }\r\n      this._log('place addables');\r\n      this._placeAddables(obj);\r\n      this._log('update pivot');\r\n      this._updatePivot(obj);\r\n      this._log('load variations');\r\n      await this._loadVariations(obj);\r\n      // this._variationHelper.clearCache();\r\n      this._log('remove from scene');\r\n      this._scene.remove(obj);\r\n      ObjectUtils.DisposeObject(this._source);\r\n      // this._cleanUp();\r\n      this._log('ready!');\r\n      this.modelLoaded.next(obj);\r\n      return obj;\r\n    } else {\r\n      throw 'No adjustables found!';\r\n      // this._building = false;\r\n      // if (this.selections.length < 2) {\r\n      //     this._errorService.addError(this.activeInstance, {message: 'NO_SELECTIONS_OR_DECOS', description: 'NO_SELECTIONS_OR_DECOS_INFO'});\r\n      //     this.buildFinished.next({instanceId: this.activeInstance, resultType: ResultType.NoSelections});\r\n      // } else if (this.decos.size === 0) {\r\n      //     this._errorService.addError(this.activeInstance, {message: 'NO_SELECTIONS_OR_DECOS', description: 'NO_SELECTIONS_OR_DECOS_INFO'});\r\n      //     this.buildFinished.next({instanceId: this.activeInstance, resultType: ResultType.NoDecoNodes});\r\n      // } else {\r\n      //     this._errorService.addError(this.activeInstance, {message: 'NO_ADJUSTABLES', description: 'NO_ADJUSTABLES_INFO'});\r\n      //     this.buildFinished.next({instanceId: this.activeInstance, resultType: ResultType.NoAdjustables});\r\n      // }\r\n    }\r\n  }\r\n\r\n  private _prepareTheSelections(): void {\r\n    if (!this._selections || !this._selections.length) {\r\n      return;\r\n    }\r\n    const selections = this._selections.slice();\r\n    const selectionOfArticle: Selection = selections.find(s => s.nodeType === NodeType.Article);\r\n    const adjustableSelections: Selection[] = selections.filter(s => s.addAdjust === '2');\r\n    const isArticleWithMaterial: boolean =\r\n      adjustableSelections.length === 0 &&\r\n      selectionOfArticle.gameObject &&\r\n      selectionOfArticle.gameObject.length > 0;\r\n    // get generic variations\r\n    const globalVariations: DecoNode[] = this._selections\r\n      .filter(s => (s.generic || adjustableSelections.length === 1) && (s.decoNode as any).variation && !s.decoNode.type)\r\n      .map((value: Selection, index: number, array: Selection[]) => {\r\n        // find selection of variation\r\n        const sel: Selection = this._selections.find(s => s.artNodeIdDeco === (value.decoNode as any).variation.parentId);\r\n        if (sel) {\r\n          (value.decoNode as any).variation.supplierArticleNr = sel.supplierArticleNr;\r\n        }\r\n        (value.decoNode as any).variation.materialId = this._getMaterialIdFromParent(value.node);\r\n        return (value.decoNode as any).variation;\r\n      });\r\n    // commented out for the moment\r\n    // globalVariations.forEach(g => {\r\n    //   const parentIdx = selections.findIndex(s => s.decoNode && s.decoNode.id === g.parentId);\r\n    //   if (parentIdx) { // remove parent selection\r\n    //     selections.splice(parentIdx, 1);\r\n    //   }\r\n    //   const idx = selections.findIndex(s => s.decoNode && s.decoNode.id === g.id);\r\n    //   if (idx) { // move generic variations to top\r\n    //     const selection = selections[idx];\r\n    //     selections.splice(idx, 1);\r\n    //     selections.unshift(selection);\r\n    //   }\r\n    // });\r\n\r\n    // const usedVariations: FurniturePartVariation[] = [];\r\n    let globalVariationsRewrite: boolean = true;\r\n\r\n    const len: number = selections.length;\r\n    let lastAdded: Selection;\r\n    let lastAdjustable: Selection;\r\n    let newPart: boolean = false;\r\n    let previousPresLevel: number = -1;\r\n    let positioning: any;\r\n    let optionText: string;\r\n    for (let i = 0; i < len; i++) {\r\n      const selection: Selection = selections[i];\r\n      if (selection.presentationLevel === 1) {\r\n        positioning = selection.hdecoPositioning;\r\n        optionText = selection.question;\r\n      }\r\n      if (selection.presentationLevel > previousPresLevel) {\r\n        selection.hdecoPositioning = selection.hdecoPositioning || positioning;\r\n      }\r\n      if (selection.decoNode) {\r\n        if (selection.decoNode.type === DecoNodeType.Variation) {\r\n          const decoNode = selection.decoNode;\r\n          (decoNode as any).optionText = optionText;\r\n          // find selection of variation and set materialId in case of multimaterial\r\n          (decoNode as any).materialId = this._getMaterialIdFromParent(decoNode.nodeId);\r\n          if (lastAdded) {\r\n            if (newPart) {\r\n              if ((decoNode as any).materialId) {\r\n                lastAdded.variations.push(decoNode);\r\n              } else {\r\n                lastAdded.variations = [decoNode];\r\n              }\r\n            } else {\r\n              lastAdded.variations.push(decoNode);\r\n            }\r\n            newPart = false;\r\n          } else {\r\n            if (globalVariationsRewrite) {\r\n              globalVariations.length = 0;\r\n              globalVariationsRewrite = false;\r\n            }\r\n            if (!globalVariations.find(v => v.id === decoNode.id)) {\r\n              globalVariations.push(decoNode);\r\n            }\r\n          }\r\n          // const variation: FurniturePartVariation = new FurniturePartVariation();\r\n          // variation.BrandId = selection.decoNode.brandId;\r\n          // variation.Description = selection.decoNode.gameObjectName;\r\n          // variation.MaterialId = (selection.decoNode as any).materialId;\r\n          // variation.SupplierArticleNr = (selection.decoNode as any).supplierArticleNr;\r\n          // usedVariations.push(variation);\r\n        } else if ((selection.decoNode.type === DecoNodeType.Part &&\r\n          typeof selection.decoNode.gameObjectName === 'string' &&\r\n          selection.decoNode.gameObjectName.length) || (isArticleWithMaterial)) {\r\n          if (selection.decoNode.kind === DecoNodeKind.Adjustable || (isArticleWithMaterial)) {\r\n            selection.variations = globalVariations;\r\n            this._adjustables.push(selection);\r\n            if (!lastAdded || (lastAdded.nodeId !== selection.nodeId || lastAdded.node !== selection.node)) {\r\n              newPart = true;\r\n            }\r\n            lastAdded = selection;\r\n            lastAdjustable = selection;\r\n          } else if (selection.decoNode.kind === DecoNodeKind.Addable) {\r\n            selection.variations = lastAdjustable ? lastAdjustable.variations : globalVariations;\r\n            if (lastAdjustable) {\r\n              lastAdjustable.addables.push(selection);\r\n            }\r\n            this._addables.push(selection);\r\n            if (!lastAdded || (lastAdded.nodeId !== selection.nodeId || lastAdded.node !== selection.node)) {\r\n              newPart = true;\r\n            }\r\n            lastAdded = selection;\r\n          }\r\n        }\r\n      }\r\n      previousPresLevel = selection.presentationLevel;\r\n    }\r\n    // this._upsertFurniture(this.activeInstance,\r\n    //   {Variations: usedVariations});\r\n  }\r\n\r\n  /**\r\n   * Returns the materialId of the parent up the tree until presentionlevel 1 is reached\r\n   * @param id\r\n   * @private\r\n   */\r\n  private _getMaterialIdFromParent(id: number): string {\r\n    if (this._selections) {\r\n      const idx: number = this._selections.findIndex(s => s.node === id);\r\n      let currentLevel: number = 999;\r\n      if (idx > -1) {\r\n        for (let i = idx; i > 0; i--) {\r\n          const selection = this._selections[i];\r\n          if (selection.presentationLevel >= currentLevel) {\r\n            break;\r\n          }\r\n          currentLevel = selection.presentationLevel;\r\n          if (selection.hdecoGameObject) {\r\n            return selection.hdecoGameObject;\r\n          }\r\n        }\r\n      }\r\n    }\r\n    return undefined;\r\n  }\r\n\r\n  private _createAdjustable(parent: THREE.Object3D, adj: Selection): THREE.Object3D {\r\n    let obj: any = this._source ? this._source.getObjectByName(adj.decoNode.gameObjectName || adj.gameObject) : null;\r\n    if (!obj) {\r\n      // in case of glb files, the importer removes dots from names\r\n      const name = adj.decoNode.gameObjectName.replace(/[.]/g, '');\r\n      obj = this._source ? this._source.getObjectByName(name) : null;\r\n      if (!obj) {\r\n        console.warn(`No object with name ${adj.decoNode.gameObjectName} found!`);\r\n        return null;\r\n      }\r\n    }\r\n    let adjustable: any = obj.clone();\r\n    adjustable.name = this._createUniqueName(parent, obj);\r\n    adjustable.userData.selection = adj;\r\n    adjustable.position.set(0, 0, 0);\r\n    adjustable.traverse(c => {\r\n      c.visible = !c.name.toLowerCase().startsWith('c_');\r\n    });\r\n    parent.add(adjustable);\r\n    // the object being added to the customFloorGroup is being recreated so we loose the reference\r\n    // therefor we need to retrieve the created object again\r\n    adjustable = parent.getObjectByName(adjustable.name);\r\n    this._placedAdjustables.push(adjustable);\r\n    return adjustable;\r\n  }\r\n\r\n  private _createAddable(parent: THREE.Object3D, add: Selection, part2?: any, part1?: any): THREE.Object3D {\r\n    const obj: any = this._source.getObjectByName(add.decoNode.gameObjectName);\r\n    if (!obj) {\r\n      return null;\r\n    }\r\n    // const selection: Selection = this._getSelectionFromId(adj.artNodeIdDeco);\r\n    const addable: any = obj.clone();\r\n    addable.name = this._createUniqueName(parent, obj);\r\n    addable.userData.selection = add;\r\n    addable.position.set(0, 0, 0);\r\n    addable.visible = true;\r\n    if (part1 && part2) {\r\n      parent.add(addable);\r\n      this._placedAddables.push(addable);\r\n      return addable;\r\n    }\r\n    return addable;\r\n  }\r\n\r\n  private _placeAddables(parent: THREE.Object3D): void {\r\n    const len: number = this._placedAdjustables.length;\r\n    for (let i = 0; i < len; i++) {\r\n      if (this._placedAdjustables[i].userData.hasOwnProperty('selection') && this._placedAdjustables[i].userData.selection) {\r\n        const adjustableSelection: Selection = this._placedAdjustables[i].userData.selection;\r\n        if (adjustableSelection) {\r\n          const lena: number = adjustableSelection.addables.length;\r\n          let conAddable: any;\r\n          for (let ia = 0; ia < lena; ia++) {\r\n            SceneUtils.TrySelectorConnection(this._scene,\r\n              parent, this._placedAdjustables[i], adjustableSelection.addables[ia], false,\r\n              (add, part2?, part1?) => this._createAddable(parent, add, part2, part1));\r\n            if (conAddable) {\r\n              SceneUtils.TrySelectorConnection(this._scene,\r\n                parent, conAddable, adjustableSelection.addables[ia], false,\r\n                (add, part2?, part1?) => this._createAddable(parent, add, part2, part1));\r\n            }\r\n            conAddable = this._placedAddables[this._placedAddables.length - 1];\r\n          }\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  private _createUniqueName(parent: THREE.Object3D, obj: THREE.Object3D): string {\r\n    let iteration = 0;\r\n    let name = obj.name;\r\n    let existingObj = parent.getObjectByName(name);\r\n    while (existingObj) {\r\n      iteration++;\r\n      name = obj.name + (iteration !== 0 ? ('_' + iteration) : '');\r\n      existingObj = parent.getObjectByName(name);\r\n    }\r\n    return name;\r\n  }\r\n\r\n  private async _getGoodIdFromSku(sku: string): Promise<number> {\r\n    const response: DataServiceResponseData = await this._configuratorService.getGoodIdFromSku(sku, false);\r\n    if (response && response.validationResult && response.validationResult.success && response.resultObject) {\r\n      return response.resultObject;\r\n    }\r\n  }\r\n\r\n  private async _getArticle(sku: string, goodId: number): Promise<Article> {\r\n    if (this._articleCache.has(sku)) {\r\n      this.articleLoaded.next(this._articleCache.get(sku));\r\n      return this._articleCache.get(sku);\r\n    }\r\n    if (!goodId) {\r\n      goodId = await this._getGoodIdFromSku(sku)\r\n        .catch((error) => {\r\n          throw `Article with sku ${sku} not found!`;\r\n        });\r\n    }\r\n    let article: Article;\r\n    const articleResponse: DataServiceResponseData = await this._configuratorService.getArticleQuickSel(goodId, false);\r\n    if (articleResponse && articleResponse.validationResult && articleResponse.validationResult.success && articleResponse.resultObject) {\r\n      if (articleResponse.resultObject.hasOwnProperty('oArticle')) {\r\n        const obj = Array.isArray(articleResponse.resultObject['oArticle']) ? articleResponse.resultObject['oArticle'][0] : articleResponse.resultObject['oArticle'];\r\n        article = <Article>this._boFactory.makeWithRawBackendData(Article, obj);\r\n      } else {\r\n        article = <Article>this._boFactory.makeWithRawBackendData(Article, articleResponse.resultObject);\r\n      }\r\n    }\r\n    this._articleCache.set(sku, article);\r\n    this.articleLoaded.next(article);\r\n    return article;\r\n  }\r\n\r\n  private async _getSelections(instanceId: string, publicationCode?: number): Promise<void> {\r\n    this._selections = [];\r\n    const selectionResponse: DataServiceResponseData = await this._configuratorService.getSelections(false, publicationCode);\r\n    if (selectionResponse && selectionResponse.resultObjects && selectionResponse.resultObjects.length > 0) {\r\n      this._selections = <Selection[]>this._boFactory.makeBOArrayFromRawBackendDataArray(Selection, selectionResponse.resultObjects);\r\n      this._selections.forEach(s => s.instanceId = instanceId);\r\n      // const filtered: Selection[] = this._selections.filter(s => s.nodeType !== NodeType.Article && s.presentationLevel === 1);\r\n      this.selectionsReceived.next(this._selections);\r\n    } else {\r\n      throw 'No selections found!';\r\n    }\r\n  }\r\n\r\n  private async _getDecos(): Promise<void> {\r\n    this._decos = [];\r\n    const decosResponse: DataServiceResponseData = await this._configuratorService.getDecos(false);\r\n    if (decosResponse && decosResponse.resultObjects && decosResponse.resultObjects.length > 0) {\r\n      this._decos = <DecoNode[]>this._boFactory.makeBOArrayFromRawBackendDataArray(DecoNode, decosResponse.resultObjects);\r\n      this.decosReceived.next(this._decos);\r\n    } else {\r\n      throw 'No deconodes found!';\r\n    }\r\n  }\r\n\r\n  private _linkSelectionsAndDecos(): void {\r\n    if (!this._selections || !this._selections.length) {\r\n      return;\r\n    }\r\n    const len: number = this._selections.length;\r\n    for (let i = 0; i < len; i++) {\r\n      // const id: string = this.selections[i].artNodeIdDeco;\r\n      let deco: any = this._decos.find(d => d.nodeId === this._selections[i].node);\r\n      if (!deco) {\r\n        deco = new DecoNode();\r\n      }\r\n      if (deco.type !== DecoNodeType.Variation) {\r\n        const variation: any = this._getVariations().find(v => v.parentId === this._selections[i].artNodeIdDeco);\r\n        if (variation) {\r\n          deco.variation = variation;\r\n        }\r\n      }\r\n      this._selections[i].decoNode = deco;\r\n    }\r\n  }\r\n\r\n  private _getVariations(): DecoNode[] {\r\n    if (this._decos && this._decos.length) {\r\n      return this._decos.filter((deco: DecoNode) => {\r\n        return deco.type === DecoNodeType.Variation;\r\n      });\r\n    }\r\n    return [];\r\n  }\r\n\r\n  private async _loadVariations(obj: THREE.Object3D): Promise<void> {\r\n    this._log('load variation for parts');\r\n    await this._variationHelper.loadPart(obj, this._adjustables, true);\r\n    this._log('load variation for adjustables');\r\n    await this._variationHelper.loadVariation(obj, this._adjustables, true);\r\n    this._log('load variation for addables');\r\n    await this._variationHelper.loadVariation(obj, this._addables, true);\r\n    this._log('load variation clear cache');\r\n    this._variationHelper.clearCache();\r\n    this._log('load variations done');\r\n  }\r\n\r\n  private _getAdjustables(): Selection[] {\r\n    if (!this._selections || !this._selections.length) {\r\n      return [];\r\n    }\r\n    return this._selections.filter(s => {\r\n      const node: DecoNode = s.decoNode;\r\n      return node && node.gameObjectName && node.type === DecoNodeType.Part && node.kind === DecoNodeKind.Adjustable;\r\n    });\r\n  }\r\n\r\n  private _updatePivot(obj: THREE.Object3D) {\r\n    const boundingBox = new THREE.Box3().setFromObject(obj);\r\n    const bbCenterPivot = new THREE.Vector3();\r\n    boundingBox.getCenter(bbCenterPivot);\r\n    const delta: THREE.Vector3 = new THREE.Vector3().sub(bbCenterPivot).setY(Math.abs(Math.min(boundingBox.min.y, 0)));\r\n\r\n    obj.children.forEach((child: any) => {\r\n      child.position.add(delta);\r\n    });\r\n    obj.updateWorldMatrix(false, true);\r\n  }\r\n\r\n  private _reset(): void {\r\n    this._placedAddables.length = 0;\r\n    this._placedAdjustables.length = 0;\r\n    this._adjustables.length = 0;\r\n    this._addables.length = 0;\r\n    // this._prepareTheSelections();\r\n  }\r\n\r\n  private _log(message: string, force: boolean = false): void {\r\n    if (this.debug) {\r\n      this.debug(message);\r\n      console.log(new Date(), message);\r\n    }\r\n  }\r\n}\r\n"]}