@colijnit/homedecorator 255.1.1

package/esm2015/app/plugins/threedselector/threedselector/service/build-furniture.service.js

@@ -0,0 +1,1343 @@
+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());
+    });
+};
+import { DecoNode } from '@colijnit/configuratorapi/build/model/deco-node';
+import { DecoNodeType } from '@colijnit/configuratorapi/build/enum/deco-node-type.enum';
+import { DecoNodeKind } from '@colijnit/configuratorapi/build/enum/deco-node-kind.enum';
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import { Euler, Vector3 } from 'three';
+import { NodeType } from '@colijnit/configuratorapi/build/enum/node-type.enum';
+import { HdecoPositioning } from '@colijnit/configuratorapi/build/enum/hdeco-positioning.enum';
+import { environment } from '../../../../../environments/environment';
+import * as TWEEN from '@tweenjs/tween.js';
+import { Factory } from '../../../core3d/items/factory';
+import { CustomFloorItem } from '../../../core3d/items/custom-floor-item';
+import { Item } from '../../../core3d/items/item';
+import { ItemType } from '../../../core3d/items/item-type';
+import { CustomFloorGroupResult } from '../../../core3d/model/custom-floor-group-result';
+import { FurnitureIntegration } from '../model/furniture-integration';
+import { MessageType } from '../../../../core/enum/message-type.enum';
+import { Scene3DUtil } from '../utils/scene-3d.utils';
+import { ErrorMessage } from '../../../../core/model/error-message';
+import { ViewMode } from '../../../../core/enum/view-mode.enum';
+import { ResultType } from '../../../core3d/enum/result-type.enum';
+import { isNill } from '../../../../core/utils/function/is-nill.function';
+import { Utils } from '../../../core3d/core/utils';
+import { MaterialUtils } from '../../../../core/utils/material.utils';
+import { FloorPin } from '../../../core3d/items/floor-pin';
+import { WallPin } from '../../../core3d/items/wall-pin';
+import { FurniturePartIntegration } from '../model/furniture-part-integration';
+import { CustomMesh, CustomObject3D } from '../../../core3d/items/custom-objects';
+import { FurniturePartVariation } from '../model/furniture-part-variation';
+import { FurnitureConnectedPartIntegration } from '../model/furniture-connected-part-integration';
+import { GoogleTagManagerEvent } from '../../../../core/enum/google-tag-manager-event.enum';
+import { CustomWallFloorItem } from '../../../core3d/items/custom-wall-floor-item';
+import { ObjectUtils } from '../../../../core/utils/object.utils';
+import { InfoDialogComponent } from '../../../../shared/info-dialog/info-dialog.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/dialog";
+import * as i2 from "../../../../core/service/homedecorator-connector.service";
+import * as i3 from "./threedselector.service";
+import * as i4 from "../../../core3d/collision-manager/collision-manager.service";
+import * as i5 from "../../../../core/service/message-bus.service";
+import * as i6 from "../../../../core/service/homedecorator-dictionary.service";
+import * as i7 from "../../../core3d/service/hud.service";
+import * as i8 from "../../../core3d/service/scene.service";
+import * as i9 from "../../../core3d/service/camera.service";
+import * as i10 from "../../../core3d/service/scene-event.service";
+import * as i11 from "../../../../core/service/homedecorator-app-event.service";
+import * as i12 from "../../../../core/service/presets.service";
+import * as i13 from "../../../core3d/service/item.service";
+import * as i14 from "./element.service";
+import * as i15 from "../../../../core/service/permanent-store.service";
+import * as i16 from "../../../../service/google-tag-manager.service";
+import * as i17 from "../../../../core/service/homedecorator-settings.service";
+import * as i18 from "../../../../core/service/utils.service";
+import * as i19 from "./variation.service";
+import * as i20 from "../../../../core/service/app-state.service";
+import * as i21 from "../../../../core/service/error.service";
+import * as i22 from "../../../core3d/service/item-group.service";
+import * as i23 from "./variation-cache.service";
+import * as i24 from "./resize.service";
+import * as i25 from "../../../../core/service/view-mode.service";
+import * as i26 from "../../../core3d/service/floor.service";
+const defaultPosition = new Vector3(4, 0, 1);
+const defaultRotation = new Euler(0, Math.PI, 0);
+export class BuildFurnitureService {
+    constructor(_dialog, _iOne, _threedSelectorService, _collisionManager, _messageBus, _dictionaryService, _hudService, _sceneService, _cameraService, _sceneEventService, _appEventService, _presetService, _itemService, _elementService, _permanentStoreService, _googleTagManager, _settingsService, _utilsService, _variationService, _appStateService, _errorService, _itemGroupService, _variationCacheService, _resizeService, _viewModeService, _floorService) {
+        this._dialog = _dialog;
+        this._iOne = _iOne;
+        this._threedSelectorService = _threedSelectorService;
+        this._collisionManager = _collisionManager;
+        this._messageBus = _messageBus;
+        this._dictionaryService = _dictionaryService;
+        this._hudService = _hudService;
+        this._sceneService = _sceneService;
+        this._cameraService = _cameraService;
+        this._sceneEventService = _sceneEventService;
+        this._appEventService = _appEventService;
+        this._presetService = _presetService;
+        this._itemService = _itemService;
+        this._elementService = _elementService;
+        this._permanentStoreService = _permanentStoreService;
+        this._googleTagManager = _googleTagManager;
+        this._settingsService = _settingsService;
+        this._utilsService = _utilsService;
+        this._variationService = _variationService;
+        this._appStateService = _appStateService;
+        this._errorService = _errorService;
+        this._itemGroupService = _itemGroupService;
+        this._variationCacheService = _variationCacheService;
+        this._resizeService = _resizeService;
+        this._viewModeService = _viewModeService;
+        this._floorService = _floorService;
+        this.toggleSelectedElement = new Subject();
+        this.configureModeChanged = new Subject();
+        this.buildFinished = new Subject();
+        this.answerSelected = new Subject();
+        this.arPlacementUpdate = new Subject();
+        this.showElementToolbar = false;
+        this.isMouseOverObject = false;
+        this.activeAnswers = [];
+        this.standAloneFirstBuildReady = false;
+        this._useNodeIdToLink = true;
+        this._standAlone = false;
+        this._originalElementPosition = new Vector3();
+        this._integrationEnabled = false;
+        this._placedAdjustables = [];
+        this._placedAddables = [];
+        this._adjustables = [];
+        this._addables = [];
+        this._genericSelection = false;
+        this._subs = [];
+        this._answerSelected = [];
+        this._furnitureConfigurations = [];
+        this.mouseOver = () => {
+            this.isMouseOverObject = true;
+        };
+        this.mouseOff = () => {
+            this.isMouseOverObject = false;
+        };
+        this.selectItem = (mesh) => {
+            // this.activeInstance = mesh.userData.itemId;
+        };
+        this.unSelectItem = () => {
+            // this.showLiteSelector = false;
+            // this.showSelections = false;
+        };
+        this.selectElement = (element, mousePos) => {
+            this._activeChildElement = element;
+            if (element.parent instanceof CustomObject3D) {
+                this._originalElementPosition.copy(element.parent.position);
+                // if (this._currentCustomFloorGroup.adjustable) {
+                if (this._isMoveableObject(element.parent)) {
+                    const connector = element.parent.children.find(c => c.name.toLowerCase().indexOf('c_') > -1);
+                    if (connector.connectedTo) {
+                        const baseElement = this._currentCustomFloorGroup.getObjectByName(connector.connectedTo);
+                        this.baseElementNodeId = baseElement.userData && baseElement.userData.selection ? baseElement.userData.selection.nodeId : 0;
+                    }
+                }
+            }
+            this.toggleSelectedElement.next(element);
+        };
+        this.unSelectElement = () => {
+            this._activeChildElement = undefined;
+            this.toggleSelectedElement.next(undefined);
+        };
+        this.moveChildElement = (element, pos) => {
+            const worldToLocalPos = this._currentCustomFloorGroup.worldToLocal(pos.clone());
+            this._moveChildElementToPosition(element, worldToLocalPos);
+        };
+        this.placeChildElement = (element) => __awaiter(this, void 0, void 0, function* () {
+            if (this._isMoveableObject(element) && element.moved) {
+                const baseElement = this._currentCustomFloorGroup.getObjectsByUserDataProp('selection', 'nodeId', this.baseElementNodeId);
+                // use instanceId from parent
+                const item = ObjectUtils.GetParentItem(element);
+                if (item) {
+                    const connector = yield this._elementService.placeElementOnConnector(item.metadata.itemId, element, baseElement.length > 0 ? baseElement[0] : null);
+                    this._saveElementConnector(element, connector);
+                }
+            }
+        });
+        this.changeConfigureMode = (metadata, configuring) => __awaiter(this, void 0, void 0, function* () {
+            this.configureModeChanged.next({ metadata: metadata, configuring: configuring });
+        });
+        this.dragConnector = (connector, pos) => __awaiter(this, void 0, void 0, function* () {
+            this._resizeService.dragConnectorToNewPosition(connector, pos);
+        });
+        this._subs.push(this._iOne.connectionReset.subscribe(() => this._handleConnectionReset()), this._messageBus.subscribe(MessageType.ItemRemoved, (result) => this._handleItemRemovedFromScene(result)), this._messageBus.subscribe(MessageType.Undo, () => this._startWithNew(false)), this._messageBus.subscribe(MessageType.Redo, () => this._startWithNew(false)), this._messageBus.subscribe(MessageType.StartWithEmptyRoom, () => this._startWithNew()), this._messageBus.subscribe(MessageType.StartWithPreset, () => this._startWithNew()), this._messageBus.subscribe(MessageType.LoadRoomFromPreset, () => this._startWithNew()), this._messageBus.subscribe(MessageType.LoadRoomFromCloud, () => this._startWithNew()), this._messageBus.subscribe(MessageType.NewRoom, () => this._startWithNew()), this._messageBus.subscribe(MessageType.ResetRoomplan, () => this._startWithNew()), this._messageBus.subscribe(MessageType.LoadScaledDiagram, () => this._startWithNew()), this._appEventService.enableIntegration.subscribe((enabled) => {
+            if (enabled) {
+                this._enableIntegration();
+            }
+        }), this._presetService.beforeLoad.subscribe(() => {
+            this._cleanupBeforePresetLoad();
+            this._startWithNew();
+        }), this._presetService.afterLoad.subscribe(() => this._handleAfterPresetLoad()), this._permanentStoreService.codeSet.subscribe((code) => {
+            if (code) {
+                this._setCodeOnFurnitureConfiguration();
+            }
+        }));
+    }
+    get useNodeIdToLink() {
+        return this._useNodeIdToLink;
+    }
+    get currentCustomFloorGroup() {
+        return this._currentCustomFloorGroup;
+    }
+    get standAlone() {
+        return this._standAlone;
+    }
+    set standAlone(value) {
+        this._standAlone = value;
+        if (this._standAlone) {
+            this._prepareStandAlone();
+        }
+    }
+    get selections() {
+        return this._iOne.selections;
+    }
+    get scene() {
+        return this._sceneService.getScene();
+    }
+    ngOnDestroy() {
+        this._subs.forEach(s => s.unsubscribe());
+        this._cleanup();
+    }
+    build(result) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._elementService.removeElement(result.instanceId);
+            if (result && result.metaData && result.metaData.itemType === ItemType.FloorDecoration) {
+                return this._buildFloor(result);
+            }
+            if (!this.full3DObjectToUse) { // there's no 3d model so get out
+                return result;
+            }
+            const adjustables = this._getAdjustables();
+            if (adjustables && adjustables.length === 0) { // check if article has a gameObject
+                if (this.selections[0].nodeType === NodeType.Article && this.selections[0].gameObject) {
+                    adjustables.push(this.selections[0]);
+                }
+            }
+            // this._currentCustomFloorGroup = this._createConfigurableItem(result.instanceId, result.metaData);
+            const item = this._createConfigurableItem(result.instanceId, result.metaData);
+            if (adjustables && adjustables.length > 0) {
+                let connected = false;
+                for (let i = 0, len = adjustables.length; i < len; i++) {
+                    const adjustable = this._createAdjustable(item, adjustables[i]);
+                    if (adjustable) {
+                        for (let ii = this._placedAdjustables.length - 1; ii >= 0; ii--) {
+                            if (this._isMoveableObject(adjustable)) { // vrije verplaatsing mogelijk, connecten aan opgeslagen connector
+                                const selection = adjustable.userData.selection;
+                                this._addElementOnConnector(item, adjustable, selection.decoConnection ? selection.decoConnection : this.activeConnector, this.baseElementNodeId);
+                                adjustable.visible = true;
+                                connected = true;
+                                break;
+                            }
+                            else {
+                                if (Scene3DUtil.TrySelectorConnection(this.scene, item, this._placedAdjustables[ii], adjustable, i === 1)) {
+                                    adjustable.visible = true;
+                                    connected = true;
+                                    break;
+                                }
+                            }
+                            connected = false;
+                        }
+                    }
+                    if (!connected && this._placedAdjustables.length > 1 && !environment.production) {
+                        result.errorMessages.push(new ErrorMessage(`No connection found for: ${adjustable ? adjustable.name : adjustables[i].decoNode.gameObjectName}`));
+                    }
+                }
+                this._placeAddables(item);
+                yield this._loadVariations(item, result.metaData.itemId);
+                this._currentCustomFloorGroup = yield this._replaceCurrentItem(item, result.metaData, true);
+                if (this._viewModeService.viewMode !== ViewMode.InPhotoView) {
+                    this._currentCustomFloorGroup.updatePivot();
+                }
+                result.furniture = this._currentCustomFloorGroup;
+                result.instanceId = result.metaData.itemId;
+                this.arPlacementUpdate.next(true);
+                this._handleIntegration(result.metaData.itemId, this._currentCustomFloorGroup);
+                if (this._currentCustomFloorGroup.itemGroup) {
+                    this._itemGroupService.reattachToItemGroup(this._currentCustomFloorGroup, this._currentCustomFloorGroup.itemGroup, this._currentCustomFloorGroup.position);
+                }
+                this._answerSelected.length = 0;
+                if (this._currentCustomFloorGroup.children.length === 0) {
+                    result.resultType = ResultType.GameobjectNameMismatchInSource;
+                    return Promise.reject(result);
+                }
+                this._hudService.updateSelectedItemHud();
+                this.buildFinished.next(result);
+            }
+            else {
+                result.errorMessages.push(new ErrorMessage('NO_ADJUSTABLES', 'NO_ADJUSTABLES_INFO'));
+                result.resultType = ResultType.NoAdjustables;
+                return Promise.reject(result);
+            }
+            if (result.resultType === ResultType.NoSelections) {
+                result.resultType = ResultType.ConfigurationFixed;
+            }
+            else if (result.resultType !== ResultType.Obsolete && result.resultType !== ResultType.ConfigurationFixed) { // don't override these
+                result.resultType = ResultType.Loaded;
+            }
+            this._appEventService.readyToRender.next(this.standAloneFirstBuildReady);
+            this._sceneService.updatePathTracer();
+            return result;
+        });
+    }
+    startToBuild(result, metadata, shouldCopyInstance = false, looseOriginalConfiguration = true, standAlone, firstBuild = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!isNill(standAlone)) {
+                this.standAlone = standAlone;
+            }
+            if (isNill(result)) {
+                result = new CustomFloorGroupResult(metadata ? metadata.itemIdentifier : '', metadata ? metadata.itemName : 'unknown');
+                result.metaData = metadata;
+            }
+            if (shouldCopyInstance) {
+                const originalInstanceId = result.metaData.itemId;
+                if (looseOriginalConfiguration) {
+                    result.metaData.itemId = yield this._iOne.copyInstanceAndLoseOriginalConfiguration(originalInstanceId, result)
+                        .catch((e) => {
+                        return originalInstanceId;
+                    });
+                }
+                else {
+                    result.metaData.itemId = yield this._iOne.copyInstanceAndSaveOriginalConfiguration(originalInstanceId, result)
+                        .catch((e) => {
+                        return originalInstanceId;
+                    });
+                }
+            }
+            if (result.resultType !== ResultType.ArticleNotFound) {
+                yield this._setInstanceToConfigure(result)
+                    .catch((e) => Promise.reject(result));
+            }
+            result.instanceId = result.metaData.itemId;
+            this.startPosition = result.metaData.position ? result.metaData.position.clone() : new Vector3();
+            const questionAndAnswers = yield this._iOne.getQuestionAndAnswersAsync(); // see if there is user input needed
+            if (questionAndAnswers.question && !questionAndAnswers.question.grouped) {
+                this._iOne.handleAnswersReceived(questionAndAnswers.answers);
+            }
+            this._appEventService.answerCountReceived.next(questionAndAnswers.answers.length);
+            if (questionAndAnswers.answers.length === 0) {
+                this.activeAnswers = [];
+                this.activeQuestion = undefined;
+                yield this._prepareSelectionsAndDecos(result)
+                    .catch((e) => Promise.reject(e));
+                return this.build(result);
+            }
+            else {
+                this.activeQuestion = questionAndAnswers.question;
+                this.activeAnswers = questionAndAnswers.answers;
+                if (firstBuild) {
+                    yield this._prepareSelectionsAndDecos(result)
+                        .catch((e) => Promise.reject(e));
+                    if (this._iOne.selections.length < 1) {
+                        result.resultType = ResultType.NeedsUserInput;
+                    }
+                    else if (this._iOne.selections.length < 2) {
+                        result.resultType = ResultType.BuildFromScratch;
+                    }
+                    else if (this._iOne.selections.length > 1) {
+                        result.resultType = ResultType.NeedsUserInput;
+                    }
+                    return result;
+                }
+            }
+        });
+    }
+    getOptionsFromSelection(baseSelection) {
+        const selections = [];
+        let nodeLevel = -1;
+        const len = this.selections.length;
+        for (let i = 0; i < len; i++) {
+            const selection = this.selections[i];
+            const level = selection.presentationLevel;
+            if (nodeLevel !== -1) {
+                if (nodeLevel < level && this._canConnectSelections(baseSelection, selection) && this._selectionPublished(selection)) {
+                    selections.push(selection);
+                }
+                if (nodeLevel >= level) {
+                    break;
+                }
+            }
+            if (selection.id === baseSelection.id && selection.node === baseSelection.node) {
+                nodeLevel = level;
+            }
+        }
+        return selections;
+    }
+    downloadCurrentCustomFloorgroup() {
+        const objectToExport = this._currentCustomFloorGroup ? this._currentCustomFloorGroup : this._itemService.items[0];
+        this._utilsService.showExportDialog(objectToExport);
+    }
+    downloadScene() {
+        const assetPath = this._settingsService.settings.assetPath;
+        // The ground plane looks odd in renders.
+        // The hud-ring and hud-circle are the walkthrough mode marker,
+        // which is not supposed to be rendered.
+        const elementsToRemove = ['ground-plane', 'hud-ring', 'hud-circle'];
+        let scene;
+        scene = this._sceneService.scene.clone();
+        elementsToRemove.forEach(elementName => {
+            const selectedObject = scene.getObjectByName(elementName);
+            scene.remove(selectedObject);
+        });
+        scene.add(this._cameraService.camera.clone());
+        this._utilsService.showExportDialog(scene);
+    }
+    createSimple3DModel(result, standAlone) {
+        if (!isNill(standAlone)) {
+            this.standAlone = standAlone;
+        }
+        if (!this.full3DObjectToUse) { // there's no 3d model so get out
+            return result;
+        }
+        // there are no selections or decos for simple articles, so empty lists for integration purposes
+        this._iOne.emptySelections();
+        this.full3DObjectToUse.children.forEach(c => c.visible = true);
+        if (!result.metaData.position) {
+            result.metaData.position = this.startPosition || defaultPosition;
+        }
+        if (!result.metaData.rotation) {
+            result.metaData.rotation = result.metaData.default180 ? defaultRotation : new Euler();
+        }
+        const itemConstructor = Factory.getClass(this.standAlone ? ItemType.FloorGroup : result.metaData.itemType);
+        const item = new itemConstructor(result.metaData, this.full3DObjectToUse);
+        result.metaData.objectUUID = item.uuid;
+        item.allowRotate = !this.standAlone;
+        item.highLightDisabled = !this._settingsService.settings.options.useStandaloneHighLight;
+        this._itemService.addItem(item);
+        if (item.itemGroup) {
+            this._itemGroupService.reattachToItemGroup(item, item.itemGroup, item.position);
+        }
+        // For simple articles we use object uuid, because they don't have an instanceId
+        this._upsertFurniture(item.uuid, { BrandIdentifier: result.metaData.itemIdentifier }, item);
+        this._handleIntegration(item.uuid, item);
+        result.furniture = item;
+        this._sceneService.updatePathTracer();
+        return result;
+    }
+    _buildFloor(result) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const item = this._floorService.floorToConfigure;
+            item.metadata = result.metaData;
+            item.children[0].userData.selection = this.selections[0];
+            item.configuringChangeHandler = this.changeConfigureMode;
+            item.selectedHandler = this.selectItem;
+            item.unselectedHandler = this.unSelectItem;
+            yield this._loadVariations(item, result.metaData.itemId);
+            this._floorService.unHighLightFloors();
+            this._sceneService.needsRender = true;
+            this._currentCustomFloorGroup = item;
+            result.furniture = this._currentCustomFloorGroup;
+            result.instanceId = result.metaData.itemId;
+            this._handleIntegration(result.metaData.itemId, this._currentCustomFloorGroup);
+            if (this._currentCustomFloorGroup.itemGroup) {
+                this._itemGroupService.reattachToItemGroup(this._currentCustomFloorGroup, this._currentCustomFloorGroup.itemGroup, this._currentCustomFloorGroup.position);
+            }
+            this._answerSelected.length = 0;
+            this._hudService.updateSelectedItemHud();
+            this.buildFinished.next(result);
+            if (result.resultType === ResultType.NoSelections) {
+                result.resultType = ResultType.ConfigurationFixed;
+            }
+            else if (result.resultType !== ResultType.Obsolete && result.resultType !== ResultType.ConfigurationFixed) { // don't override these
+                result.resultType = ResultType.Loaded;
+            }
+            return result;
+        });
+    }
+    _startToBuildFromConfigurator(metadata) {
+        return this.startToBuild(null, metadata);
+    }
+    _setInstanceToConfigure(result) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (result.resultType !== ResultType.Timeout) {
+                if (result.metaData.itemId) {
+                    yield this._iOne.setInstance(result.metaData.itemId)
+                        .catch((e) => {
+                        result.errorMessages.push(new ErrorMessage(e));
+                        Promise.reject(result);
+                    });
+                }
+                else {
+                    const response = yield this._iOne.initNodeInstance(result.metaData.itemIdentifier)
+                        .catch((e) => {
+                        result.errorMessages.push(new ErrorMessage(e));
+                        Promise.reject(result);
+                    });
+                    if (response && response.validationResult && response.validationResult.success) {
+                        result.metaData.itemId = response.resultObject;
+                    }
+                    else {
+                        Promise.reject(result);
+                    }
+                    yield this._iOne.setInstance(result.metaData.itemId)
+                        .catch((e) => {
+                        result.errorMessages.push(new ErrorMessage(e));
+                        Promise.reject(result);
+                    });
+                }
+                return result;
+            }
+            else {
+                return Promise.reject();
+            }
+        });
+    }
+    _prepareSelectionsAndDecos(result) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._reset();
+            try {
+                const selectionsAndDecoPromise = [];
+                selectionsAndDecoPromise.push(this._iOne.getSelectionsAsync(), this._iOne.getDecosAsync());
+                yield Promise.all(selectionsAndDecoPromise);
+                this._preloadMaterials(result.metaData.schema);
+            }
+            catch (e) {
+            }
+            if (this._iOne.selections.length < 2) { // no selections, only selection of type 'ART'
+                try {
+                    if (result.resultType !== ResultType.ArticleNotFound && !result.metaData.originalItemId) { // article found, so init that first
+                        result.metaData.originalItemId = result.metaData.itemId;
+                        result.metaData.itemId = null;
+                        yield this._setInstanceToConfigure(result);
+                        result.resultType = ResultType.NoSelections;
+                        return this.startToBuild(result); // 'restart' the build
+                    }
+                    this._getSelectionsAndDecosFromMetadata(result);
+                }
+                catch (e) {
+                    return Promise.reject(e);
+                }
+            }
+            this._iOne.selections.forEach(s => {
+                s.schema = result.metaData.schema;
+                s.instanceId = result.metaData.itemId;
+            }); // add schema for material creation
+            this._handleSelectionsReceived(result.metaData);
+            this._linkSelectionsAndDecos();
+            this._prepareTheSelections(result.metaData.itemId);
+        });
+    }
+    _preloadMaterials(schema) {
+        this._variationCacheService.preloadVariations(schema, this._iOne.decoNodes.map(d => d.gameObjectName), this.articleAssetPath);
+    }
+    _getSelectionsAndDecosFromMetadata(result) {
+        if (result.metaData.selections && result.metaData.decos) {
+            this._iOne.setSelections(result.metaData.selections);
+            this._iOne.setDecoNodes(Array.from(result.metaData.decos.values()));
+            result.metaData.obsolete = true;
+            if (result.resultType !== ResultType.ConfigurationNotFixed) {
+                result.resultType = ResultType.Obsolete;
+            }
+        }
+        else {
+            if (this._iOne.selections.length < 2 || this._iOne.decoNodes.length === 0) {
+                result.errorMessages.push(new ErrorMessage('NO_SELECTIONS_OR_DECOS', 'NO_SELECTIONS_OR_DECOS_INFO'));
+            }
+            throw result;
+        }
+    }
+    _selectionPublished(selection) {
+        return ((selection.hierarchicalPublicationCode === null) || ((selection.hierarchicalPublicationCode & 2) > 0)) &&
+            ((selection.nodeType === NodeType.Question &&
+                (((selection.questionPublicationCode & 2) > 0) ||
+                    selection.questionPublicationCode === null || selection.questionPublicationCode === undefined)) ||
+                (selection.nodeType === NodeType.Answer &&
+                    (((selection.answerPublicationCode & 2) > 0) ||
+                        selection.answerPublicationCode === null || selection.answerPublicationCode === undefined)));
+    }
+    _handleIntegration(instanceId, object) {
+        if (this._integrationEnabled && !object.metadata.obsolete) {
+            const genericVariationSelections = this._iOne.selections.filter(s => s.decoNode && s.generic &&
+                s.decoNode.variation && s.decoNode.variation.type === DecoNodeType.Variation);
+            if (genericVariationSelections && genericVariationSelections.length > 0) {
+                this._upsertFurniture(instanceId, {
+                    Variation: genericVariationSelections[0].decoNode.variation.brandId,
+                    VariationDescription: genericVariationSelections[0].decoNode.variation.gameObjectName,
+                    SupplierArticleNr: genericVariationSelections[0].decoNode.variation.supplierArticleNr
+                }, object);
+            }
+            this._handleIntegrationConnections(instanceId, object);
+            this._upsertFurniture(instanceId, { Position: object.position, Rotation: object.rotation }, object);
+            this._messageBus.emit(MessageType.ConfigurationChanged, this._furnitureConfigurations);
+            // console.log(this._furnitureConfigurations);
+        }
+    }
+    _startWithNew(cleanup = true) {
+        this._furnitureConfigurations.length = 0;
+        if (cleanup) {
+            this._placedAdjustables.forEach(a => Utils.DisposeObject(a));
+            this._placedAddables.forEach(a => Utils.DisposeObject(a));
+            this._cleanup();
+        }
+    }
+    _cleanupBeforePresetLoad() {
+        MaterialUtils.ClearCaches();
+    }
+    /*
+     * Clear variables to let objects being disposed properly
+     */
+    _handleAfterPresetLoad() {
+        // make sure nothing is keeping a lock
+        this._iOne.setInstance(null);
+        // clean
+        this._cleanup();
+    }
+    _cleanup() {
+        Utils.DisposeObject(this.full3DObjectToUse);
+        this.full3DObjectToUse = undefined;
+        this._currentCustomFloorGroup = undefined;
+        Utils.DisposeObject(this._activeChildElement);
+        this._activeChildElement = undefined;
+        this._placedAdjustables.length = 0;
+        this._placedAddables.length = 0;
+        this._adjustables.length = 0;
+        this._addables.length = 0;
+    }
+    _enableIntegration() {
+        this._integrationEnabled = true;
+    }
+    _handleItemRemovedFromScene(result) {
+        if (result.addedToGroup) {
+            return;
+        }
+        if (result.item instanceof Item && !(result.item instanceof FloorPin || result.item instanceof WallPin)) {
+            if (this._integrationEnabled && result.item.userData) {
+                const id = result.item.userData.itemId ? result.item.userData.itemId : result.item.uuid;
+                this._furnitureConfigurations.splice(this._furnitureConfigurations.findIndex(f => f.Id === id), 1);
+                this._messageBus.emit(MessageType.ConfigurationChanged, this._furnitureConfigurations);
+                // console.log(this._furnitureConfigurations);
+            }
+            this._clearElements(result.item);
+            this._cleanup();
+        }
+    }
+    _clearElements(item) {
+        if (item instanceof CustomFloorItem && item.userData && item.userData.itemId) {
+            this.baseElementNodeId = undefined;
+            this._originalElementPosition.set(0, 0, 0);
+            this._elementService.removeElement(item.userData.itemId);
+        }
+    }
+    _handleIntegrationConnections(id, object) {
+        const parts = [];
+        const childParts = object.configurable ? object.children : [object];
+        const len = childParts.length;
+        for (let i = 0; i < len; i++) {
+            const child = childParts[i];
+            const connection = new FurniturePartIntegration();
+            const variations = [];
+            if (child.userData && child.userData.selection && child.userData.selection.decoNode) {
+                connection.Id = childParts.findIndex(c => c === child).toString();
+                connection.SupplierArticleNr = child.userData.selection.supplierArticleNr;
+                connection.BrandIdentifier = child.userData.selection.decoNode.brandId;
+                connection.BrandDescription = child.userData.selection.decoNode.gameObjectName;
+                connection.Position = child.position;
+                connection.Rotation = child.rotation;
+                if (child.userData.selection.variations) {
+                    if (child.userData.selection.variations.length === 1) {
+                        const variation = child.userData.selection.variations[0];
+                        connection.Variation = variation.brandId;
+                        connection.VariationDescription = variation.gameObjectName;
+                    }
+                    else {
+                        for (let j = 0; j < child.userData.selection.variations.length; j++) {
+                            const variation = child.userData.selection.variations[j];
+                            const variationPart = new FurniturePartVariation();
+                            variationPart.Variation = variation.brandId;
+                            variationPart.VariationDescription = variation.gameObjectName;
+                            variationPart.MaterialId = variation.materialId;
+                            variationPart.SupplierArticleNr = variation.supplierArticleNr;
+                            variationPart.Option = variation.optionText;
+                            variations.push(variationPart);
+                        }
+                        connection.Variations = variations;
+                    }
+                }
+            }
+            else { // a-artikel
+                connection.Id = childParts.findIndex(c => c === child).toString();
+                connection.BrandIdentifier = child.metadata.itemIdentifier;
+                connection.BrandDescription = child.metadata.itemName;
+                connection.Position = child.position;
+                connection.Rotation = child.rotation;
+            }
+            const connectors = [];
+            const clen = child.children.length;
+            for (let j = 0; j < clen; j++) {
+                const connector = child.children[j];
+                if ((connector instanceof CustomObject3D || connector instanceof CustomMesh) && connector.connectedTo) {
+                    const conn = new FurnitureConnectedPartIntegration();
+                    conn.ConnectionLabel = connector.name;
+                    const foreignPartIdx = this._currentCustomFloorGroup.children.findIndex(c => c.name === connector.connectedTo);
+                    conn.ForeignConnectionLabel = this._currentCustomFloorGroup.children[foreignPartIdx].userData.selection.decoNode.gameObjectName;
+                    conn.ForeignPartId = foreignPartIdx.toString();
+                    conn.Position = connector.position;
+                    conn.Rotation = connector.rotation;
+                    connectors.push(conn);
+                }
+            }
+            connection.ConnectedParts = connectors;
+            parts.push(connection);
+        }
+        this._upsertFurniture(id, { Parts: parts }, object);
+    }
+    _upsertFurniture(id, object, item) {
+        if (this._integrationEnabled && !item.metadata.obsolete) {
+            const idx = this._furnitureConfigurations.findIndex(f => f.Id === id);
+            let furniture;
+            if (idx < 0) {
+                if (this._furnitureConfigurations.length === 1 && !this._furnitureConfigurations[0].Id) { // empty entry for mrp code, re-use that one
+                    furniture = this._furnitureConfigurations[0];
+                }
+                else {
+                    furniture = new FurnitureIntegration();
+                    this._furnitureConfigurations.push(furniture);
+                }
+                furniture.Id = id;
+            }
+            else {
+                furniture = this._furnitureConfigurations[idx];
+            }
+            furniture.MrpCode = this._permanentStoreService.code;
+            for (const key in object) {
+                if (furniture.hasOwnProperty(key) && object.hasOwnProperty(key)) {
+                    furniture[key] = object[key];
+                }
+            }
+        }
+    }
+    _setCodeOnFurnitureConfiguration() {
+        if (this._integrationEnabled) {
+            if (this._furnitureConfigurations.length < 1) {
+                const furniture = new FurnitureIntegration();
+                furniture.MrpCode = this._permanentStoreService.code;
+                this._furnitureConfigurations.push(furniture);
+            }
+            else {
+                this._furnitureConfigurations.forEach(f => f.MrpCode = this._permanentStoreService.code);
+            }
+            this._messageBus.emit(MessageType.ConfigurationChanged, this._furnitureConfigurations);
+        }
+    }
+    _canConnectSelections(sel1, sel2) {
+        if (!sel1.decoNode || !sel2.decoNode) {
+            return false;
+        }
+        let canConnect = sel2.decoNode.type !== DecoNodeType.Part;
+        if (!canConnect) {
+            const len = sel1.decoNode.connectors.length;
+            for (let i = 0; i < len; i++) {
+                const leni = sel2.decoNode.connectors.length;
+                for (let ii = 0; ii < leni; ii++) {
+                    canConnect = Scene3DUtil.CanSelectorConnect(sel1.decoNode.connectors, sel1.decoNode.connectors[i], sel2.decoNode.connectors[ii]);
+                    if (canConnect) {
+                        return true;
+                    }
+                }
+            }
+            return false;
+        }
+        return canConnect;
+    }
+    _handleSelectionsReceived(metadata) {
+        if (this._answerSelected.length > 0) {
+            const selection = this.selections.find(s => s.nodeId === this._answerSelected[this._answerSelected.length - 1].nodeId);
+            if (selection) {
+                let itemName = '';
+                if (metadata.itemName === '') {
+                    if (metadata.itemDescription !== '') {
+                        itemName = metadata.itemDescription;
+                    }
+                    else {
+                        itemName = metadata.itemIdentifier;
+                    }
+                }
+                else {
+                    itemName = metadata.itemName;
+                }
+                this._googleTagManager.sendEvent(GoogleTagManagerEvent.AnswerChosen, {
+                    'articleNr': metadata.itemIdentifier,
+                    'product': itemName,
+                    'optionDescription': selection.commercialAnswer ? selection.commercialAnswer : selection.answer,
+                    'optionPath': selection.selection
+                });
+            }
+        }
+    }
+    _handleConnectionReset() {
+        if (this._currentCustomFloorGroup) {
+            this._currentCustomFloorGroup.setUnselected();
+            this._messageBus.emit(MessageType.ItemUnselected, undefined);
+            this._showWarning({ title: 'WARNING', message: 'REFRESH_DUE_TO_INACTIVITY' });
+        }
+    }
+    _handleAnswerSelected(answer) {
+        this._answerSelected.push(answer);
+    }
+    cancelAnswer(metadata, rebuild = true, getAnswers = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._iOne.cancelAnswer();
+            if (rebuild) {
+                this._startToBuildFromConfigurator(metadata);
+            }
+            else if (getAnswers) { // if not rebuild then check if we need to get answers
+                const questionAndAnswers = yield this._iOne.getQuestionAndAnswersAsync(); // see if there is user input needed
+                this._iOne.handleAnswersReceived(questionAndAnswers.answers);
+                this._appEventService.answerCountReceived.next(questionAndAnswers.answers.length);
+            }
+        });
+    }
+    selectSelection(selection, metadata, forceBackToNode, after, connector) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._iOne.selectSelection(selection, forceBackToNode, after, connector);
+            this._genericSelection = selection.generic;
+            this._startToBuildFromConfigurator(metadata);
+        });
+    }
+    deleteSelection(selection, metadata) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._elementService.removeElement(selection.instanceId, selection.node);
+            yield this._iOne.deleteSelection(selection);
+            this._startToBuildFromConfigurator(metadata);
+        });
+    }
+    replaceSelection(selection, metadata) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._iOne.replaceSelection(selection);
+            this._startToBuildFromConfigurator(metadata);
+        });
+    }
+    selectAnswer(answer, input, metadata) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._preloadMaterial(answer);
+            yield this._iOne.selectAnswer(answer, input);
+            this._handleAnswerSelected(answer);
+            const result = yield this._startToBuildFromConfigurator(metadata);
+            this.answerSelected.next(result);
+        });
+    }
+    _getActiveFurniture(instanceId) {
+        const configurables = this._itemService.getConfigurables();
+        const len = configurables.length;
+        for (let i = 0; i < len; i++) {
+            if (configurables[i].metadata && configurables[i].metadata.itemId === instanceId && !configurables[i].tempObject) {
+                return configurables[i];
+            }
+        }
+    }
+    _linkSelectionsAndDecos() {
+        const len = this.selections.length;
+        for (let i = 0; i < len; i++) {
+            // const id: string = this.selections[i].artNodeIdDeco;
+            let deco = this._iOne.decoNodes.find(d => d.id === this.selections[i].artNodeIdDeco);
+            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;
+        }
+        this._iOne.selectionsAndDecosLinked.next();
+    }
+    _createConfigurableItem(instanceId, metadata) {
+        // const furniture: Item = this._getActiveFurniture(instanceId);
+        // const cloneSelections = JSON.parse(JSON.stringify(this.selections));
+        // cloneSelections.forEach(s => {
+        //   s.imageData = undefined;
+        //   s.imageDataLastAnswer = undefined;
+        // });
+        // if (furniture) {
+        //   furniture.metadata.decos = Array.from(this._iOne.decoNodes);
+        //   furniture.metadata.selections = cloneSelections;
+        //   furniture.markForDeletionChildren();
+        //   return furniture;
+        // }
+        if (!metadata.position) {
+            metadata.position = this.startPosition || defaultPosition;
+        }
+        if (!metadata.rotation) {
+            metadata.rotation = metadata.default180 ? defaultRotation : new Euler();
+        }
+        // If itemType is different in article compared to saved value in the .json, the itemType in article is applied
+        // metadata.itemType = this.itemType && this.itemType !== metadata.itemType ? this.itemType : metadata.itemType;
+        const itemConstructor = Factory.getClass(this.standAlone ? ItemType.CustomFloorGroup : metadata.itemType);
+        const item = new itemConstructor(metadata, undefined, // base on empty object
+        {
+            mouseOver: this.mouseOver,
+            mouseOff: this.mouseOff,
+            itemSelected: this.selectItem,
+            itemUnselected: this.unSelectItem,
+            elementSelected: this.selectElement,
+            elementUnselected: this.unSelectElement,
+            configuringChanged: this.changeConfigureMode,
+            childElementPositionChangedHandler: this.moveChildElement,
+            childElementPlaceHandler: this.placeChildElement
+            /*
+                    childElementPositionChangedHandler: adjustable ? this.moveChildElement : undefined,
+                    childElementPlaceHandler: adjustable ? this.placeChildElement : undefined
+            */
+        });
+        item.canDelete = !this.standAlone;
+        item.canCopy = !this.standAlone;
+        item.allwaysConfigureMode = this.standAlone;
+        item.highLightDisabled = !this._settingsService.settings.options.useStandaloneHighLight;
+        item.tempObject = true;
+        item.name = metadata.itemName + '_clone';
+        item.visible = false;
+        this._itemService.addItem(item);
+        // this._upsertFurniture(metadata.itemId, {BrandIdentifier: metadata.itemIdentifier}, item);
+        return item;
+    }
+    _createPositionAnimation(object, from, to, easing) {
+        const tweenFrom = new Vector3().copy(from);
+        const tween = new TWEEN.Tween(tweenFrom)
+            .to(to, 1000)
+            .easing(easing)
+            .onUpdate(() => {
+            object.position.copy(tweenFrom);
+            this._sceneService.needsRender = true;
+        });
+        return new Promise((resolve, reject) => tween.onComplete(resolve.bind(this, tween)).onStop(reject).start());
+    }
+    _animateChanges(furniture, changes) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // it's christmasss
+            const animations = [];
+            if (furniture instanceof CustomFloorItem) {
+                for (let i = 0; i < changes.length; i++) {
+                    const easing = !changes[i].oldPosition ? TWEEN.Easing.Exponential.Out :
+                        (!changes[i].newPosition ? TWEEN.Easing.Exponential.Out : TWEEN.Easing.Exponential.InOut);
+                    const from = changes[i].oldPosition ? new Vector3().copy(changes[i].oldPosition) : new Vector3().copy(changes[i].newPosition).setY(10);
+                    const to = changes[i].newPosition ? new Vector3().copy(changes[i].newPosition) : new Vector3().copy(changes[i].oldPosition).setY(10);
+                    const obj = furniture.getObjectByName(changes[i].name);
+                    if (!from.equals(to)) {
+                        animations.push(this._createPositionAnimation(obj, from, to, easing));
+                    }
+                }
+            }
+            return yield Promise.all(animations);
+        });
+    }
+    _replaceCurrentItem(newItem, metadata, animate = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const furniture = this._getActiveFurniture(metadata.itemId);
+            const cloneSelections = JSON.parse(JSON.stringify(this.selections));
+            cloneSelections.forEach(s => {
+                s.imageData = undefined;
+                s.imageDataLastAnswer = undefined;
+                if (s.addables) {
+                    s.addables.forEach(a => {
+                        a.imageData = undefined;
+                    });
+                }
+            });
+            if (furniture) {
+                furniture.metadata.decos = Array.from(this._iOne.decoNodes);
+                furniture.metadata.selections = cloneSelections;
+                if (furniture instanceof CustomWallFloorItem) {
+                    newItem.currentWall = furniture.currentWall;
+                }
+                newItem.updatePivot();
+                const changes = furniture instanceof CustomFloorItem ? ObjectUtils.GetChanges(furniture.children, newItem.children) : [];
+                // animate removed items
+                const removedChanges = changes.filter(c => !c.newPosition);
+                if (animate && removedChanges && removedChanges.length > 0) { // animate changes to the model
+                    yield this._animateChanges(furniture, removedChanges);
+                }
+                // remove children from furniture
+                furniture.clearChildren();
+                // add new children to furniture
+                newItem.children.map(c => furniture.addChild(c));
+                this._itemService.removeItem(newItem, false, false);
+                // animate (new) items
+                const otherChanges = changes.filter(c => c.newPosition);
+                if (animate && otherChanges && otherChanges.length > 0) { // animate changes to the model
+                    yield this._animateChanges(furniture, otherChanges);
+                }
+                return furniture;
+            }
+            else {
+                newItem.visible = true;
+                newItem.tempObject = false;
+                newItem.name = metadata.itemName;
+                this._upsertFurniture(metadata.itemId, { BrandIdentifier: metadata.itemIdentifier }, newItem);
+                return newItem;
+            }
+        });
+    }
+    cancelConfiguringCurrentInstance() {
+        if (this._currentCustomFloorGroup) {
+            this._currentCustomFloorGroup.configuring = false;
+        }
+    }
+    _isMoveableObject(obj) {
+        return obj.userData && obj.userData.selection && obj.userData.selection.hdecoPositioning === HdecoPositioning.Variable;
+    }
+    _addElementOnConnector(currentItem, element, connector, connectedNodeId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // const con: Object3D = this._currentCustomFloorGroup.getObjectByName(connector.connector);
+            // if (con) {e
+            // const pos: Vector3 = new Vector3().copy(con.position);
+            // con.localToWorld(pos);
+            const connectorFromElement = currentItem.connectorFromElement(element.userData.selection);
+            const idFromBaseElement = connectedNodeId ? connectedNodeId : connectorFromElement.connectedNodeId;
+            const baseElement = currentItem.getObjectsByUserDataProp('selection', 'nodeId', idFromBaseElement);
+            const item = ObjectUtils.GetParentItem(element);
+            if (item) {
+                const conn = yield this._elementService.placeElementOnConnector(item.metadata.itemId, element, baseElement.length > 0 ? baseElement[0] : null, false, connector, false);
+                this._saveElementConnector(element, conn);
+            }
+            // }
+        });
+    }
+    _saveElementConnector(element, connector) {
+        if (element && element.userData && element.userData.selection) {
+            this._currentCustomFloorGroup.updateElementConnector(element.userData.selection, connector, this.baseElementNodeId);
+        }
+    }
+    /**
+     * @param element The element to move
+     * @param pos The local position
+     * @private
+     */
+    _moveChildElementToPosition(element, pos) {
+        if (this._isMoveableObject(element)) {
+            const worldToLocalPos = new Vector3().copy(pos).add(this._originalElementPosition);
+            const baseElement = this._currentCustomFloorGroup.getObjectsByUserDataProp('selection', 'nodeId', this.baseElementNodeId);
+            const item = ObjectUtils.GetParentItem(element);
+            if (item) {
+                this._elementService.moveElementToNewPosition(item.metadata.itemId, element, worldToLocalPos, baseElement.length > 0 ? baseElement[0] : null);
+                // this._saveElementConnector(element, pos);
+            }
+        }
+    }
+    _reset() {
+        this._placedAdjustables.length = 0;
+        this._placedAddables.length = 0;
+        this._adjustables.length = 0;
+        this._addables.length = 0;
+        // this._prepareTheSelections();
+        // todo: check this
+        // this._elementService.removeElement(this.activeInstance);
+    }
+    /**
+     * Returns the materialId of the parent up the tree until presentionlevel 1 is reached
+     * @param id
+     * @private
+     */
+    _getMaterialIdFromParent(id) {
+        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;
+    }
+    _prepareTheSelections(instanceId) {
+        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 = [];
+        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;
+                        }
+                        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});
+    }
+    _getAdjustables(checkGameObject = true, checkType = true) {
+        return this.selections.filter(s => {
+            const node = s.decoNode;
+            return node && (checkGameObject ? node.gameObjectName : true) && (checkType ? node.type === DecoNodeType.Part : true) && node.kind === DecoNodeKind.Adjustable;
+        });
+    }
+    _getVariations() {
+        if (this._iOne.decoNodes.length === 0) {
+            return [];
+        }
+        return this._iOne.decoNodes.filter((deco) => {
+            return deco.type === DecoNodeType.Variation;
+        });
+    }
+    _createAdjustable(item, adj) {
+        let obj = this.full3DObjectToUse ? this.full3DObjectToUse.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.full3DObjectToUse ? this.full3DObjectToUse.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(item, obj);
+        adjustable.userData.selection = adj;
+        adjustable.position.set(0, 0, 0);
+        adjustable.traverse(c => {
+            c.visible = !c.name.toLowerCase().startsWith('c_');
+        });
+        item.addChild(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 = item.getObjectByName(adjustable.name);
+        this._placedAdjustables.push(adjustable);
+        return adjustable;
+    }
+    _createAddable(item, add, part2, part1) {
+        const obj = this.full3DObjectToUse.getObjectByName(add.decoNode.gameObjectName);
+        if (!obj) {
+            return null;
+        }
+        // const selection: Selection = this._getSelectionFromId(adj.artNodeIdDeco);
+        const addable = obj.clone();
+        addable.name = this._createUniqueName(item, obj);
+        addable.userData.selection = add;
+        addable.position.set(0, 0, 0);
+        addable.visible = true;
+        if (part1 && part2) {
+            return this._placeAddable(item, addable);
+        }
+        return addable;
+    }
+    _placeAddable(item, add) {
+        item.addChild(add);
+        const addable = item.getObjectByName(add.name);
+        this._placedAddables.push(addable);
+        return addable;
+    }
+    _createUniqueName(item, obj) {
+        let iteration = 0;
+        let name = `${item.name}_${obj.name}`;
+        let existingObj = item.getObjectByName(name);
+        while (existingObj) {
+            iteration++;
+            name = `${item.name}_${obj.name}` + (iteration !== 0 ? ('_' + iteration) : '');
+            existingObj = item.getObjectByName(name);
+        }
+        return name;
+    }
+    _placeAddables(item) {
+        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++) {
+                        Scene3DUtil.TrySelectorConnection(this.scene, item, this._placedAdjustables[i], adjustableSelection.addables[ia], false, (add, part2, part1) => this._createAddable(item, add, part2, part1));
+                        if (conAddable) {
+                            Scene3DUtil.TrySelectorConnection(this.scene, item, conAddable, adjustableSelection.addables[ia], false, (add, part2, part1) => this._createAddable(item, add, part2, part1));
+                        }
+                        conAddable = this._placedAddables[this._placedAddables.length - 1];
+                    }
+                }
+            }
+        }
+    }
+    _loadVariations(item, instanceId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._settingsService.settings.options.useVariationOnPart) {
+                yield this._variationService.loadPart(this._adjustables, instanceId, item, true);
+            }
+            yield this._variationService.loadVariation(this._adjustables, instanceId, item, true);
+            yield this._variationService.loadVariation(this._addables, instanceId, item, true);
+            this._variationService.clearCache();
+        });
+    }
+    _showWarning(data) {
+        const dialogData = {
+            title: this._dictionaryService.get(data.title), message: this._dictionaryService.get(data.message)
+        };
+        this._dialog.open(InfoDialogComponent, { data: dialogData });
+    }
+    _prepareStandAlone() {
+        this._collisionManager.checkCollisions = false;
+        if (this._settingsService.settings.options.cameraPositionFixed) {
+            this._cameraService.lockCamera();
+            this._cameraService.disableRotateHorizontal();
+            // this._cameraService.disableRotateVertical();
+            this._cameraService.disablePan();
+            this._cameraService.controls.target = new Vector3(0, 50, 0);
+        }
+        this._sceneEventService.rotateNoDrag = true;
+    }
+    _preloadMaterial(answer) {
+        if (answer.elementType === DecoNodeType.Variation && answer.gameObject) {
+            const variationDecoNode = new DecoNode();
+            variationDecoNode.gameObjectName = answer.gameObject;
+            const adjustablesClone = this._adjustables.map(s => Object.assign({}, s));
+            if (this._genericSelection) {
+                if (this.currentCustomFloorGroup) {
+                    adjustablesClone.forEach((selection) => selection.variations = [variationDecoNode]);
+                    this._variationCacheService.preloadVariationsAsync(adjustablesClone[0].schema, [variationDecoNode.gameObjectName], this.articleAssetPath)
+                        .then(() => {
+                        this._variationService.loadVariation(adjustablesClone, '', this.currentCustomFloorGroup, true)
+                            .then(() => this._sceneService.needsRender = true);
+                    });
+                }
+                else {
+                    this._adjustables.forEach((selection) => selection.variations = [variationDecoNode]);
+                }
+            }
+            else {
+                const currentSelection = ObjectUtils.GetSelectionFromSelectedObject(this._activeChildElement);
+                if (currentSelection) {
+                    if (this.currentCustomFloorGroup) {
+                        const selectionFromAdjustables = adjustablesClone
+                            .find((selection) => selection.nodeId === currentSelection.nodeId);
+                        if (selectionFromAdjustables) {
+                            selectionFromAdjustables.variations = [variationDecoNode];
+                            this._variationCacheService.preloadVariationsAsync(adjustablesClone[0].schema, [variationDecoNode.gameObjectName], this.articleAssetPath)
+                                .then(() => {
+                                this._variationService.loadVariation(adjustablesClone, '', this.currentCustomFloorGroup, true)
+                                    .then(() => this._sceneService.needsRender = true);
+                            });
+                        }
+                    }
+                    else {
+                        const selectionFromAdjustables = this._adjustables
+                            .find((selection) => selection.nodeId === currentSelection.nodeId);
+                        selectionFromAdjustables.variations = [variationDecoNode];
+                    }
+                }
+            }
+        }
+    }
+}
+BuildFurnitureService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: BuildFurnitureService, deps: [{ token: i1.MatDialog }, { token: i2.HomedecoratorConnectorService }, { token: i3.ThreedselectorService }, { token: i4.CollisionManagerService }, { token: i5.MessageBusService }, { token: i6.HomedecoratorDictionaryService }, { token: i7.HudService }, { token: i8.SceneService }, { token: i9.CameraService }, { token: i10.SceneEventService }, { token: i11.HomedecoratorAppEventService }, { token: i12.PresetsService }, { token: i13.ItemService }, { token: i14.ElementService }, { token: i15.PermanentStoreService }, { token: i16.GoogleTagManagerService }, { token: i17.HomedecoratorSettingsService }, { token: i18.UtilsService }, { token: i19.VariationService }, { token: i20.AppStateService }, { token: i21.ErrorService }, { token: i22.ItemGroupService }, { token: i23.VariationCacheService }, { token: i24.ResizeService }, { token: i25.ViewModeService }, { token: i26.FloorService }], target: i0.ɵɵFactoryTarget.Injectable });
+BuildFurnitureService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: BuildFurnitureService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: BuildFurnitureService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.MatDialog }, { type: i2.HomedecoratorConnectorService }, { type: i3.ThreedselectorService }, { type: i4.CollisionManagerService }, { type: i5.MessageBusService }, { type: i6.HomedecoratorDictionaryService }, { type: i7.HudService }, { type: i8.SceneService }, { type: i9.CameraService }, { type: i10.SceneEventService }, { type: i11.HomedecoratorAppEventService }, { type: i12.PresetsService }, { type: i13.ItemService }, { type: i14.ElementService }, { type: i15.PermanentStoreService }, { type: i16.GoogleTagManagerService }, { type: i17.HomedecoratorSettingsService }, { type: i18.UtilsService }, { type: i19.VariationService }, { type: i20.AppStateService }, { type: i21.ErrorService }, { type: i22.ItemGroupService }, { type: i23.VariationCacheService }, { type: i24.ResizeService }, { type: i25.ViewModeService }, { type: i26.FloorService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"build-furniture.service.js","sourceRoot":"","sources":["../../../../../../../../src/client/app/plugins/threedselector/threedselector/service/build-furniture.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {DecoNode} from '@colijnit/configuratorapi/build/model/deco-node';\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 {Selection} from '@colijnit/configuratorapi/build/model/selection';\r\nimport {Injectable, OnDestroy} from '@angular/core';\r\nimport {Subject, Subscription} from 'rxjs';\r\nimport {Answer} from '@colijnit/configuratorapi/build/model/answer';\r\nimport {Euler, Mesh, Object3D, Scene, Vector3} from 'three';\r\nimport {MatDialog} from '@angular/material/dialog';\r\nimport {NodeType} from '@colijnit/configuratorapi/build/enum/node-type.enum';\r\nimport {HdecoPositioning} from '@colijnit/configuratorapi/build/enum/hdeco-positioning.enum';\r\nimport {QuestionAndAnswers} from '@colijnit/configuratorapi/build/model/question-and-answers';\r\nimport {Question} from '@colijnit/configuratorapi/build/model/question';\r\nimport {environment} from '../../../../../environments/environment';\r\nimport * as TWEEN from '@tweenjs/tween.js';\r\nimport {Factory} from '../../../core3d/items/factory';\r\nimport {CustomFloorItem} from '../../../core3d/items/custom-floor-item';\r\nimport {Item} from '../../../core3d/items/item';\r\nimport {ItemType} from '../../../core3d/items/item-type';\r\nimport {Metadata} from '../../../core3d/items/metadata';\r\nimport {CustomFloorGroupResult} from '../../../core3d/model/custom-floor-group-result';\r\nimport {FurnitureIntegration} from '../model/furniture-integration';\r\nimport {ThreedselectorService} from './threedselector.service';\r\nimport {CollisionManagerService} from '../../../core3d/collision-manager/collision-manager.service';\r\nimport {MessageBusService} from '../../../../core/service/message-bus.service';\r\nimport {HudService} from '../../../core3d/service/hud.service';\r\nimport {SceneService} from '../../../core3d/service/scene.service';\r\nimport {CameraService} from '../../../core3d/service/camera.service';\r\nimport {SceneEventService} from '../../../core3d/service/scene-event.service';\r\nimport {PresetsService} from '../../../../core/service/presets.service';\r\nimport {ItemService} from '../../../core3d/service/item.service';\r\nimport {ElementService} from './element.service';\r\nimport {PermanentStoreService} from '../../../../core/service/permanent-store.service';\r\nimport {GoogleTagManagerService} from '../../../../service/google-tag-manager.service';\r\nimport {UtilsService} from '../../../../core/service/utils.service';\r\nimport {VariationService} from './variation.service';\r\nimport {AppStateService} from '../../../../core/service/app-state.service';\r\nimport {ErrorService} from '../../../../core/service/error.service';\r\nimport {ItemGroupService} from '../../../core3d/service/item-group.service';\r\nimport {VariationCacheService} from './variation-cache.service';\r\nimport {ResizeService} from './resize.service';\r\nimport {ViewModeService} from '../../../../core/service/view-mode.service';\r\nimport {MessageType} from '../../../../core/enum/message-type.enum';\r\nimport {Scene3DUtil} from '../utils/scene-3d.utils';\r\nimport {ErrorMessage} from '../../../../core/model/error-message';\r\nimport {ViewMode} from '../../../../core/enum/view-mode.enum';\r\nimport {ResultType} from '../../../core3d/enum/result-type.enum';\r\nimport {isNill} from '../../../../core/utils/function/is-nill.function';\r\nimport {Utils} from '../../../core3d/core/utils';\r\nimport {MaterialUtils} from '../../../../core/utils/material.utils';\r\nimport {FloorPin} from '../../../core3d/items/floor-pin';\r\nimport {WallPin} from '../../../core3d/items/wall-pin';\r\nimport {FurniturePartIntegration} from '../model/furniture-part-integration';\r\nimport {CustomMesh, CustomObject3D} from '../../../core3d/items/custom-objects';\r\nimport {FurniturePartVariation} from '../model/furniture-part-variation';\r\nimport {FurnitureConnectedPartIntegration} from '../model/furniture-connected-part-integration';\r\nimport {GoogleTagManagerEvent} from '../../../../core/enum/google-tag-manager-event.enum';\r\nimport {ChangesInterface} from '../../../../core/interface/changes.interface';\r\nimport {CustomWallFloorItem} from '../../../core3d/items/custom-wall-floor-item';\r\nimport {ObjectUtils} from '../../../../core/utils/object.utils';\r\nimport {InfoDialogComponent} from '../../../../shared/info-dialog/info-dialog.component';\r\nimport {InfoDialogData} from '../../../../core/interface/info-dialog-data.interface';\r\nimport {HomedecoratorConnectorService} from '../../../../core/service/homedecorator-connector.service';\r\nimport {HomedecoratorDictionaryService} from '../../../../core/service/homedecorator-dictionary.service';\r\nimport {HomedecoratorAppEventService} from '../../../../core/service/homedecorator-app-event.service';\r\nimport {HomedecoratorSettingsService} from '../../../../core/service/homedecorator-settings.service';\r\nimport {FloorService} from '../../../core3d/service/floor.service';\r\nimport {FloorPlaneItem} from '../../../core3d/items/floor-plane-item';\r\n\r\nconst defaultPosition = new Vector3(4, 0, 1);\r\nconst defaultRotation = new Euler(0, Math.PI, 0);\r\n\r\nexport interface ConfiguringModeChangeInterface {\r\n  metadata: Metadata;\r\n  configuring: boolean;\r\n}\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class BuildFurnitureService implements OnDestroy {\r\n  // public get decos(): Map<string, DecoNode> {\r\n  //   return this._getDecosFromInstance();\r\n  // }\r\n  public baseElementNodeId: number;\r\n\r\n  public articleAssetPath: string;\r\n\r\n  public toggleSelectedElement: Subject<Mesh> = new Subject<Mesh>();\r\n  public configureModeChanged: Subject<ConfiguringModeChangeInterface> = new Subject<{ metadata: {}, configuring: false }>();\r\n  public buildFinished: Subject<CustomFloorGroupResult> = new Subject<CustomFloorGroupResult>();\r\n  public answerSelected: Subject<CustomFloorGroupResult> = new Subject<CustomFloorGroupResult>();\r\n  public arPlacementUpdate: Subject<boolean> = new Subject<boolean>();\r\n  public showElementToolbar: boolean = false;\r\n\r\n  public startPosition: Vector3;\r\n  public full3DObjectToUse: Object3D;\r\n\r\n  public isMouseOverObject: boolean = false;\r\n\r\n  // used for elements, to place objects on\r\n  public activeConnector: any;\r\n\r\n  public get useNodeIdToLink() {\r\n    return this._useNodeIdToLink;\r\n  }\r\n\r\n  public get currentCustomFloorGroup() {\r\n    return this._currentCustomFloorGroup;\r\n  }\r\n\r\n  public activeQuestion: Question;\r\n  public activeAnswers: Answer[] = [];\r\n\r\n  public get standAlone(): boolean {\r\n    return this._standAlone;\r\n  }\r\n\r\n  public set standAlone(value: boolean) {\r\n    this._standAlone = value;\r\n    if (this._standAlone) {\r\n      this._prepareStandAlone();\r\n    }\r\n  }\r\n\r\n  public get selections(): Selection[] {\r\n    return this._iOne.selections;\r\n  }\r\n\r\n  public standAloneFirstBuildReady: boolean = false;\r\n\r\n  private get scene(): Scene {\r\n    return this._sceneService.getScene();\r\n  }\r\n\r\n  private _useNodeIdToLink: boolean = true;\r\n  private _standAlone: boolean = false;\r\n\r\n  private _activeChildElement: Mesh;\r\n\r\n  private _originalElementPosition: Vector3 = new Vector3();\r\n  private _integrationEnabled: boolean = false;\r\n  private _placedAdjustables: any[] = [];\r\n  private _placedAddables: any[] = [];\r\n  private _adjustables: any[] = [];\r\n  private _addables: any[] = [];\r\n  private _currentCustomFloorGroup: Item;\r\n  private _genericSelection = false;\r\n  private _subs: Subscription[] = [];\r\n  private _answerSelected: Answer[] = [];\r\n  private _furnitureConfigurations: FurnitureIntegration[] = [];\r\n\r\n  constructor(\r\n    private _dialog: MatDialog,\r\n    private _iOne: HomedecoratorConnectorService,\r\n    private _threedSelectorService: ThreedselectorService,\r\n    private _collisionManager: CollisionManagerService,\r\n    private _messageBus: MessageBusService,\r\n    private _dictionaryService: HomedecoratorDictionaryService,\r\n    private _hudService: HudService,\r\n    private _sceneService: SceneService,\r\n    private _cameraService: CameraService,\r\n    private _sceneEventService: SceneEventService,\r\n    private _appEventService: HomedecoratorAppEventService,\r\n    private _presetService: PresetsService,\r\n    private _itemService: ItemService,\r\n    private _elementService: ElementService,\r\n    private _permanentStoreService: PermanentStoreService,\r\n    private _googleTagManager: GoogleTagManagerService,\r\n    private _settingsService: HomedecoratorSettingsService,\r\n    private _utilsService: UtilsService,\r\n    private _variationService: VariationService,\r\n    private _appStateService: AppStateService,\r\n    private _errorService: ErrorService,\r\n    private _itemGroupService: ItemGroupService,\r\n    private _variationCacheService: VariationCacheService,\r\n    private _resizeService: ResizeService,\r\n    private _viewModeService: ViewModeService,\r\n    private _floorService: FloorService\r\n  ) {\r\n    this._subs.push(\r\n      this._iOne.connectionReset.subscribe(() => this._handleConnectionReset()),\r\n      this._messageBus.subscribe(MessageType.ItemRemoved, (result: { item: any, addedToGroup: boolean }) =>\r\n        this._handleItemRemovedFromScene(result)),\r\n      this._messageBus.subscribe(MessageType.Undo, () => this._startWithNew(false)),\r\n      this._messageBus.subscribe(MessageType.Redo, () => this._startWithNew(false)),\r\n      this._messageBus.subscribe(MessageType.StartWithEmptyRoom, () => this._startWithNew()),\r\n      this._messageBus.subscribe(MessageType.StartWithPreset, () => this._startWithNew()),\r\n      this._messageBus.subscribe(MessageType.LoadRoomFromPreset, () => this._startWithNew()),\r\n      this._messageBus.subscribe(MessageType.LoadRoomFromCloud, () => this._startWithNew()),\r\n      this._messageBus.subscribe(MessageType.NewRoom, () => this._startWithNew()),\r\n      this._messageBus.subscribe(MessageType.ResetRoomplan, () => this._startWithNew()),\r\n      this._messageBus.subscribe(MessageType.LoadScaledDiagram, () => this._startWithNew()),\r\n      this._appEventService.enableIntegration.subscribe((enabled: boolean) => {\r\n        if (enabled) {\r\n          this._enableIntegration();\r\n        }\r\n      }),\r\n      this._presetService.beforeLoad.subscribe(() => {\r\n        this._cleanupBeforePresetLoad();\r\n        this._startWithNew();\r\n      }),\r\n      this._presetService.afterLoad.subscribe(() => this._handleAfterPresetLoad()),\r\n      this._permanentStoreService.codeSet.subscribe((code: string) => {\r\n        if (code) {\r\n          this._setCodeOnFurnitureConfiguration();\r\n        }\r\n      })\r\n    );\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    this._subs.forEach(s => s.unsubscribe());\r\n    this._cleanup();\r\n  }\r\n\r\n  public async build(result: CustomFloorGroupResult): Promise<CustomFloorGroupResult> {\r\n    this._elementService.removeElement(result.instanceId);\r\n    if (result && result.metaData && result.metaData.itemType === ItemType.FloorDecoration) {\r\n      return this._buildFloor(result);\r\n    }\r\n    if (!this.full3DObjectToUse) { // there's no 3d model so get out\r\n      return result;\r\n    }\r\n    const adjustables: Selection[] = this._getAdjustables();\r\n    if (adjustables && adjustables.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    // this._currentCustomFloorGroup = this._createConfigurableItem(result.instanceId, result.metaData);\r\n    const item: Item = this._createConfigurableItem(result.instanceId, result.metaData);\r\n    if (adjustables && adjustables.length > 0) {\r\n      let connected = false;\r\n      for (let i = 0, len: number = adjustables.length; i < len; i++) {\r\n        const adjustable: Object3D = this._createAdjustable(item, adjustables[i]);\r\n        if (adjustable) {\r\n          for (let ii = this._placedAdjustables.length - 1; ii >= 0; ii--) {\r\n            if (this._isMoveableObject(adjustable)) { // vrije verplaatsing mogelijk, connecten aan opgeslagen connector\r\n              const selection: Selection = adjustable.userData.selection;\r\n              this._addElementOnConnector(\r\n                item, adjustable, selection.decoConnection ? selection.decoConnection : this.activeConnector, this.baseElementNodeId);\r\n              adjustable.visible = true;\r\n              connected = true;\r\n              break;\r\n            } else {\r\n              if (Scene3DUtil.TrySelectorConnection(this.scene,\r\n                item, this._placedAdjustables[ii], adjustable, i === 1)) {\r\n                adjustable.visible = true;\r\n                connected = true;\r\n                break;\r\n              }\r\n            }\r\n            connected = false;\r\n          }\r\n        }\r\n        if (!connected && this._placedAdjustables.length > 1 && !environment.production) {\r\n          result.errorMessages.push(new ErrorMessage(\r\n            `No connection found for: ${adjustable ? adjustable.name : adjustables[i].decoNode.gameObjectName}`));\r\n        }\r\n      }\r\n      this._placeAddables(item);\r\n      await this._loadVariations(item, result.metaData.itemId);\r\n      this._currentCustomFloorGroup = await this._replaceCurrentItem(item, result.metaData, true);\r\n      if (this._viewModeService.viewMode !== ViewMode.InPhotoView) {\r\n        this._currentCustomFloorGroup.updatePivot();\r\n      }\r\n      result.furniture = this._currentCustomFloorGroup;\r\n      result.instanceId = result.metaData.itemId;\r\n      this.arPlacementUpdate.next(true);\r\n      this._handleIntegration(result.metaData.itemId, this._currentCustomFloorGroup);\r\n\r\n      if (this._currentCustomFloorGroup.itemGroup) {\r\n        this._itemGroupService.reattachToItemGroup(\r\n          this._currentCustomFloorGroup,\r\n          this._currentCustomFloorGroup.itemGroup,\r\n          this._currentCustomFloorGroup.position);\r\n      }\r\n      this._answerSelected.length = 0;\r\n\r\n      if (this._currentCustomFloorGroup.children.length === 0) {\r\n        result.resultType = ResultType.GameobjectNameMismatchInSource;\r\n        return Promise.reject(result);\r\n      }\r\n      this._hudService.updateSelectedItemHud();\r\n      this.buildFinished.next(result);\r\n    } else {\r\n      result.errorMessages.push(new ErrorMessage('NO_ADJUSTABLES', 'NO_ADJUSTABLES_INFO'));\r\n      result.resultType = ResultType.NoAdjustables;\r\n      return Promise.reject(result);\r\n    }\r\n    if (result.resultType === ResultType.NoSelections) {\r\n      result.resultType = ResultType.ConfigurationFixed;\r\n    } else if (result.resultType !== ResultType.Obsolete && result.resultType !== ResultType.ConfigurationFixed) { // don't override these\r\n      result.resultType = ResultType.Loaded;\r\n    }\r\n    this._appEventService.readyToRender.next(this.standAloneFirstBuildReady);\r\n    this._sceneService.updatePathTracer();\r\n    return result;\r\n  }\r\n\r\n  public async startToBuild(\r\n    result?: CustomFloorGroupResult,\r\n    metadata?: Metadata,\r\n    shouldCopyInstance: boolean = false,\r\n    looseOriginalConfiguration: boolean = true,\r\n    standAlone?: boolean,\r\n    firstBuild: boolean = false\r\n  ): Promise<CustomFloorGroupResult> {\r\n    if (!isNill(standAlone)) {\r\n      this.standAlone = standAlone;\r\n    }\r\n    if (isNill(result)) {\r\n      result = new CustomFloorGroupResult(\r\n        metadata ? metadata.itemIdentifier : '',\r\n        metadata ? metadata.itemName : 'unknown');\r\n      result.metaData = metadata;\r\n    }\r\n\r\n    if (shouldCopyInstance) {\r\n      const originalInstanceId: string = result.metaData.itemId;\r\n      if (looseOriginalConfiguration) {\r\n        result.metaData.itemId = await this._iOne.copyInstanceAndLoseOriginalConfiguration(originalInstanceId, result)\r\n          .catch((e) => {\r\n            return originalInstanceId;\r\n          });\r\n      } else {\r\n        result.metaData.itemId = await this._iOne.copyInstanceAndSaveOriginalConfiguration(originalInstanceId, result)\r\n          .catch((e) => {\r\n            return originalInstanceId;\r\n          });\r\n      }\r\n    }\r\n\r\n    if (result.resultType !== ResultType.ArticleNotFound) {\r\n      await this._setInstanceToConfigure(result)\r\n        .catch((e) => Promise.reject(result));\r\n    }\r\n    result.instanceId = result.metaData.itemId;\r\n    this.startPosition = result.metaData.position ? result.metaData.position.clone() : new Vector3();\r\n\r\n    const questionAndAnswers: QuestionAndAnswers = await this._iOne.getQuestionAndAnswersAsync(); // see if there is user input needed\r\n    if (questionAndAnswers.question && !questionAndAnswers.question.grouped) {\r\n      this._iOne.handleAnswersReceived(questionAndAnswers.answers);\r\n    }\r\n    this._appEventService.answerCountReceived.next(questionAndAnswers.answers.length);\r\n    if (questionAndAnswers.answers.length === 0) {\r\n      this.activeAnswers = [];\r\n      this.activeQuestion = undefined;\r\n      await this._prepareSelectionsAndDecos(result)\r\n        .catch((e) => Promise.reject(e));\r\n      return this.build(result);\r\n    } else {\r\n      this.activeQuestion = questionAndAnswers.question;\r\n      this.activeAnswers = questionAndAnswers.answers;\r\n      if (firstBuild) {\r\n        await this._prepareSelectionsAndDecos(result)\r\n          .catch((e) => Promise.reject(e));\r\n        if (this._iOne.selections.length < 1) {\r\n          result.resultType = ResultType.NeedsUserInput;\r\n        } else if (this._iOne.selections.length < 2) {\r\n          result.resultType = ResultType.BuildFromScratch;\r\n        } else if (this._iOne.selections.length > 1) {\r\n          result.resultType = ResultType.NeedsUserInput;\r\n        }\r\n        return result;\r\n      }\r\n    }\r\n  }\r\n\r\n  public getOptionsFromSelection(baseSelection: Selection): Selection[] {\r\n    const selections: Selection[] = [];\r\n    let nodeLevel = -1;\r\n    const len: number = this.selections.length;\r\n    for (let i = 0; i < len; i++) {\r\n      const selection: Selection = this.selections[i];\r\n      const level: number = selection.presentationLevel;\r\n      if (nodeLevel !== -1) {\r\n        if (nodeLevel < level && this._canConnectSelections(baseSelection, selection) && this._selectionPublished(selection)) {\r\n          selections.push(selection);\r\n        }\r\n        if (nodeLevel >= level) {\r\n          break;\r\n        }\r\n      }\r\n      if (selection.id === baseSelection.id && selection.node === baseSelection.node) {\r\n        nodeLevel = level;\r\n      }\r\n    }\r\n    return selections;\r\n  }\r\n\r\n  public downloadCurrentCustomFloorgroup(): void {\r\n    const objectToExport: Object3D = this._currentCustomFloorGroup ? this._currentCustomFloorGroup : this._itemService.items[0];\r\n    this._utilsService.showExportDialog(objectToExport);\r\n  }\r\n\r\n  public downloadScene(): void {\r\n    const assetPath: string = this._settingsService.settings.assetPath;\r\n    // The ground plane looks odd in renders.\r\n    // The hud-ring and hud-circle are the walkthrough mode marker,\r\n    // which is not supposed to be rendered.\r\n    const elementsToRemove = ['ground-plane', 'hud-ring', 'hud-circle'];\r\n\r\n    let scene: Scene;\r\n    scene = this._sceneService.scene.clone();\r\n\r\n    elementsToRemove.forEach(elementName => {\r\n      const selectedObject: Object3D = scene.getObjectByName(elementName);\r\n      scene.remove(selectedObject);\r\n    });\r\n    scene.add(this._cameraService.camera.clone());\r\n\r\n    this._utilsService.showExportDialog(scene);\r\n  }\r\n\r\n  public createSimple3DModel(result: CustomFloorGroupResult, standAlone?: boolean): CustomFloorGroupResult {\r\n    if (!isNill(standAlone)) {\r\n      this.standAlone = standAlone;\r\n    }\r\n    if (!this.full3DObjectToUse) { // there's no 3d model so get out\r\n      return result;\r\n    }\r\n    // there are no selections or decos for simple articles, so empty lists for integration purposes\r\n    this._iOne.emptySelections();\r\n    this.full3DObjectToUse.children.forEach(c => c.visible = true);\r\n    if (!result.metaData.position) {\r\n      result.metaData.position = this.startPosition || defaultPosition;\r\n    }\r\n    if (!result.metaData.rotation) {\r\n      result.metaData.rotation = result.metaData.default180 ? defaultRotation : new Euler();\r\n    }\r\n    const itemConstructor = Factory.getClass(this.standAlone ? ItemType.FloorGroup : result.metaData.itemType);\r\n    const item = new itemConstructor(\r\n      result.metaData,\r\n      this.full3DObjectToUse\r\n    );\r\n    result.metaData.objectUUID = item.uuid;\r\n    item.allowRotate = !this.standAlone;\r\n    item.highLightDisabled = !this._settingsService.settings.options.useStandaloneHighLight;\r\n\r\n    this._itemService.addItem(item);\r\n    if (item.itemGroup) {\r\n      this._itemGroupService.reattachToItemGroup(item, item.itemGroup, item.position);\r\n    }\r\n    // For simple articles we use object uuid, because they don't have an instanceId\r\n    this._upsertFurniture(item.uuid, {BrandIdentifier: result.metaData.itemIdentifier}, item);\r\n    this._handleIntegration(item.uuid, item);\r\n\r\n    result.furniture = item;\r\n    this._sceneService.updatePathTracer();\r\n    return result;\r\n  }\r\n\r\n  private async _buildFloor(result: CustomFloorGroupResult): Promise<CustomFloorGroupResult> {\r\n    const item: FloorPlaneItem = this._floorService.floorToConfigure;\r\n    item.metadata = result.metaData;\r\n    item.children[0].userData.selection = this.selections[0];\r\n    item.configuringChangeHandler = this.changeConfigureMode;\r\n    item.selectedHandler = this.selectItem;\r\n    item.unselectedHandler = this.unSelectItem;\r\n    await this._loadVariations(item, result.metaData.itemId);\r\n    this._floorService.unHighLightFloors();\r\n    this._sceneService.needsRender = true;\r\n    this._currentCustomFloorGroup = item;\r\n    result.furniture = this._currentCustomFloorGroup;\r\n    result.instanceId = result.metaData.itemId;\r\n    this._handleIntegration(result.metaData.itemId, this._currentCustomFloorGroup);\r\n    if (this._currentCustomFloorGroup.itemGroup) {\r\n      this._itemGroupService.reattachToItemGroup(\r\n          this._currentCustomFloorGroup,\r\n          this._currentCustomFloorGroup.itemGroup,\r\n          this._currentCustomFloorGroup.position);\r\n    }\r\n    this._answerSelected.length = 0;\r\n    this._hudService.updateSelectedItemHud();\r\n    this.buildFinished.next(result);\r\n    if (result.resultType === ResultType.NoSelections) {\r\n      result.resultType = ResultType.ConfigurationFixed;\r\n    } else if (result.resultType !== ResultType.Obsolete && result.resultType !== ResultType.ConfigurationFixed) { // don't override these\r\n      result.resultType = ResultType.Loaded;\r\n    }\r\n    return result;\r\n  }\r\n\r\n  private _startToBuildFromConfigurator(metadata: Metadata): Promise<CustomFloorGroupResult> {\r\n    return this.startToBuild(null, metadata);\r\n  }\r\n\r\n  private async _setInstanceToConfigure(result: CustomFloorGroupResult): Promise<CustomFloorGroupResult> {\r\n    if (result.resultType !== ResultType.Timeout) {\r\n      if (result.metaData.itemId) {\r\n        await this._iOne.setInstance(result.metaData.itemId)\r\n          .catch((e) => {\r\n            result.errorMessages.push(new ErrorMessage(e));\r\n            Promise.reject(result);\r\n          });\r\n      } else {\r\n        const response = await this._iOne.initNodeInstance(result.metaData.itemIdentifier)\r\n          .catch((e) => {\r\n            result.errorMessages.push(new ErrorMessage(e));\r\n            Promise.reject(result);\r\n          });\r\n        if (response && response.validationResult && response.validationResult.success) {\r\n          result.metaData.itemId = response.resultObject;\r\n        } else {\r\n          Promise.reject(result);\r\n        }\r\n        await this._iOne.setInstance(result.metaData.itemId)\r\n          .catch((e) => {\r\n            result.errorMessages.push(new ErrorMessage(e));\r\n            Promise.reject(result);\r\n          });\r\n      }\r\n      return result;\r\n    } else {\r\n      return Promise.reject();\r\n    }\r\n  }\r\n\r\n  private async _prepareSelectionsAndDecos(result: CustomFloorGroupResult): Promise<CustomFloorGroupResult> {\r\n    this._reset();\r\n    try {\r\n      const selectionsAndDecoPromise: Promise<any>[] = [];\r\n      selectionsAndDecoPromise.push(this._iOne.getSelectionsAsync(), this._iOne.getDecosAsync());\r\n      await Promise.all(selectionsAndDecoPromise);\r\n      this._preloadMaterials(result.metaData.schema);\r\n    } catch (e) {\r\n    }\r\n    if (this._iOne.selections.length < 2) { // no selections, only selection of type 'ART'\r\n      try {\r\n        if (result.resultType !== ResultType.ArticleNotFound && !result.metaData.originalItemId) { // article found, so init that first\r\n          result.metaData.originalItemId = result.metaData.itemId;\r\n          result.metaData.itemId = null;\r\n          await this._setInstanceToConfigure(result);\r\n          result.resultType = ResultType.NoSelections;\r\n          return this.startToBuild(result); // 'restart' the build\r\n        }\r\n        this._getSelectionsAndDecosFromMetadata(result);\r\n      } catch (e) {\r\n        return Promise.reject(e);\r\n      }\r\n    }\r\n    this._iOne.selections.forEach(s => {\r\n      s.schema = result.metaData.schema;\r\n      s.instanceId = result.metaData.itemId;\r\n    }); // add schema for material creation\r\n    this._handleSelectionsReceived(result.metaData);\r\n    this._linkSelectionsAndDecos();\r\n    this._prepareTheSelections(result.metaData.itemId);\r\n  }\r\n\r\n  private _preloadMaterials(schema: string): void {\r\n    this._variationCacheService.preloadVariations(schema, this._iOne.decoNodes.map(d => d.gameObjectName), this.articleAssetPath);\r\n  }\r\n\r\n  private _getSelectionsAndDecosFromMetadata(result: CustomFloorGroupResult): void {\r\n    if (result.metaData.selections && result.metaData.decos) {\r\n      this._iOne.setSelections(result.metaData.selections);\r\n      this._iOne.setDecoNodes(Array.from(result.metaData.decos.values()));\r\n      result.metaData.obsolete = true;\r\n      if (result.resultType !== ResultType.ConfigurationNotFixed) {\r\n        result.resultType = ResultType.Obsolete;\r\n      }\r\n    } else {\r\n      if (this._iOne.selections.length < 2 || this._iOne.decoNodes.length === 0) {\r\n        result.errorMessages.push(new ErrorMessage('NO_SELECTIONS_OR_DECOS', 'NO_SELECTIONS_OR_DECOS_INFO'));\r\n      }\r\n      throw result;\r\n    }\r\n  }\r\n\r\n  private _selectionPublished(selection: Selection): boolean {\r\n    return ((selection.hierarchicalPublicationCode === null) || ((selection.hierarchicalPublicationCode & 2) > 0)) &&\r\n      (\r\n        (selection.nodeType === NodeType.Question &&\r\n          (((selection.questionPublicationCode & 2) > 0) ||\r\n            selection.questionPublicationCode === null || selection.questionPublicationCode === undefined)) ||\r\n        (selection.nodeType === NodeType.Answer &&\r\n          (((selection.answerPublicationCode & 2) > 0) ||\r\n            selection.answerPublicationCode === null || selection.answerPublicationCode === undefined))\r\n      );\r\n  }\r\n\r\n  private _handleIntegration(instanceId: string, object: Item): void {\r\n    if (this._integrationEnabled && !object.metadata.obsolete) {\r\n      const genericVariationSelections: Selection[] =\r\n        this._iOne.selections.filter(s => s.decoNode && s.generic &&\r\n          (s.decoNode as any).variation && (s.decoNode as any).variation.type === DecoNodeType.Variation);\r\n      if (genericVariationSelections && genericVariationSelections.length > 0) {\r\n        this._upsertFurniture(instanceId, {\r\n          Variation: (genericVariationSelections[0].decoNode as any).variation.brandId,\r\n          VariationDescription: (genericVariationSelections[0].decoNode as any).variation.gameObjectName,\r\n          SupplierArticleNr: (genericVariationSelections[0].decoNode as any).variation.supplierArticleNr\r\n        }, object);\r\n      }\r\n      this._handleIntegrationConnections(instanceId, object);\r\n      this._upsertFurniture(instanceId, {Position: object.position, Rotation: object.rotation}, object);\r\n      this._messageBus.emit(MessageType.ConfigurationChanged, this._furnitureConfigurations);\r\n      // console.log(this._furnitureConfigurations);\r\n    }\r\n  }\r\n\r\n  private _startWithNew(cleanup: boolean = true): void {\r\n    this._furnitureConfigurations.length = 0;\r\n    if (cleanup) {\r\n      this._placedAdjustables.forEach(a => Utils.DisposeObject(a));\r\n      this._placedAddables.forEach(a => Utils.DisposeObject(a));\r\n      this._cleanup();\r\n    }\r\n  }\r\n\r\n  private _cleanupBeforePresetLoad(): void {\r\n    MaterialUtils.ClearCaches();\r\n  }\r\n\r\n  /*\r\n   * Clear variables to let objects being disposed properly\r\n   */\r\n  private _handleAfterPresetLoad(): void {\r\n    // make sure nothing is keeping a lock\r\n    this._iOne.setInstance(null);\r\n    // clean\r\n    this._cleanup();\r\n  }\r\n\r\n  private _cleanup(): void {\r\n    Utils.DisposeObject(this.full3DObjectToUse);\r\n    this.full3DObjectToUse = undefined;\r\n    this._currentCustomFloorGroup = undefined;\r\n    Utils.DisposeObject(this._activeChildElement);\r\n    this._activeChildElement = undefined;\r\n    this._placedAdjustables.length = 0;\r\n    this._placedAddables.length = 0;\r\n    this._adjustables.length = 0;\r\n    this._addables.length = 0;\r\n  }\r\n\r\n  private _enableIntegration(): void {\r\n    this._integrationEnabled = true;\r\n  }\r\n\r\n  private _handleItemRemovedFromScene(result: { item: any, addedToGroup: boolean }): void {\r\n    if (result.addedToGroup) {\r\n      return;\r\n    }\r\n    if (result.item instanceof Item && !(result.item instanceof FloorPin || result.item instanceof WallPin)) {\r\n      if (this._integrationEnabled && result.item.userData) {\r\n        const id: string = result.item.userData.itemId ? result.item.userData.itemId : result.item.uuid;\r\n        this._furnitureConfigurations.splice(this._furnitureConfigurations.findIndex(f => f.Id === id), 1);\r\n        this._messageBus.emit(MessageType.ConfigurationChanged, this._furnitureConfigurations);\r\n        // console.log(this._furnitureConfigurations);\r\n      }\r\n      this._clearElements(result.item);\r\n      this._cleanup();\r\n    }\r\n  }\r\n\r\n  private _clearElements(item: Item): void {\r\n    if (item instanceof CustomFloorItem && item.userData && item.userData.itemId) {\r\n      this.baseElementNodeId = undefined;\r\n      this._originalElementPosition.set(0, 0, 0);\r\n      this._elementService.removeElement(item.userData.itemId);\r\n    }\r\n  }\r\n\r\n  private _handleIntegrationConnections(id: string, object: Item): void {\r\n    const parts: FurniturePartIntegration[] = [];\r\n    const childParts: Object3D[] = object.configurable ? object.children : [object];\r\n    const len: number = childParts.length;\r\n    for (let i = 0; i < len; i++) {\r\n      const child: any = <CustomObject3D>childParts[i];\r\n      const connection: FurniturePartIntegration = new FurniturePartIntegration();\r\n      const variations: FurniturePartVariation[] = [];\r\n      if (child.userData && child.userData.selection && child.userData.selection.decoNode) {\r\n        connection.Id = childParts.findIndex(c => c === child).toString();\r\n        connection.SupplierArticleNr = child.userData.selection.supplierArticleNr;\r\n        connection.BrandIdentifier = child.userData.selection.decoNode.brandId;\r\n        connection.BrandDescription = child.userData.selection.decoNode.gameObjectName;\r\n        connection.Position = child.position;\r\n        connection.Rotation = child.rotation;\r\n        if (child.userData.selection.variations) {\r\n          if (child.userData.selection.variations.length === 1) {\r\n            const variation: any = child.userData.selection.variations[0];\r\n            connection.Variation = variation.brandId;\r\n            connection.VariationDescription = variation.gameObjectName;\r\n          } else {\r\n            for (let j = 0; j < child.userData.selection.variations.length; j++) {\r\n              const variation: any = child.userData.selection.variations[j];\r\n              const variationPart: FurniturePartVariation = new FurniturePartVariation();\r\n              variationPart.Variation = variation.brandId;\r\n              variationPart.VariationDescription = variation.gameObjectName;\r\n              variationPart.MaterialId = variation.materialId;\r\n              variationPart.SupplierArticleNr = variation.supplierArticleNr;\r\n              variationPart.Option = variation.optionText;\r\n              variations.push(variationPart);\r\n            }\r\n            connection.Variations = variations;\r\n          }\r\n        }\r\n      } else { // a-artikel\r\n        connection.Id = childParts.findIndex(c => c === child).toString();\r\n        connection.BrandIdentifier = child.metadata.itemIdentifier;\r\n        connection.BrandDescription = child.metadata.itemName;\r\n        connection.Position = child.position;\r\n        connection.Rotation = child.rotation;\r\n      }\r\n      const connectors: FurnitureConnectedPartIntegration[] = [];\r\n      const clen: number = child.children.length;\r\n      for (let j = 0; j < clen; j++) {\r\n        const connector: any = child.children[j];\r\n        if ((connector instanceof CustomObject3D || connector instanceof CustomMesh) && (connector as any).connectedTo) {\r\n          const conn: FurnitureConnectedPartIntegration = new FurnitureConnectedPartIntegration();\r\n          conn.ConnectionLabel = connector.name;\r\n          const foreignPartIdx: number = this._currentCustomFloorGroup.children.findIndex(c => c.name === (connector as any).connectedTo);\r\n          conn.ForeignConnectionLabel = this._currentCustomFloorGroup.children[foreignPartIdx].userData.selection.decoNode.gameObjectName;\r\n          conn.ForeignPartId = foreignPartIdx.toString();\r\n          conn.Position = connector.position;\r\n          conn.Rotation = connector.rotation;\r\n          connectors.push(conn);\r\n        }\r\n      }\r\n      connection.ConnectedParts = connectors;\r\n      parts.push(connection);\r\n    }\r\n    this._upsertFurniture(id, {Parts: parts}, object);\r\n  }\r\n\r\n  private _upsertFurniture(id: string, object: any, item: Item): void {\r\n    if (this._integrationEnabled && !item.metadata.obsolete) {\r\n      const idx: number = this._furnitureConfigurations.findIndex(f => f.Id === id);\r\n      let furniture: FurnitureIntegration;\r\n      if (idx < 0) {\r\n        if (this._furnitureConfigurations.length === 1 && !this._furnitureConfigurations[0].Id) { // empty entry for mrp code, re-use that one\r\n          furniture = this._furnitureConfigurations[0];\r\n        } else {\r\n          furniture = new FurnitureIntegration();\r\n          this._furnitureConfigurations.push(furniture);\r\n        }\r\n        furniture.Id = id;\r\n      } else {\r\n        furniture = this._furnitureConfigurations[idx];\r\n      }\r\n      furniture.MrpCode = this._permanentStoreService.code;\r\n      for (const key in object) {\r\n        if (furniture.hasOwnProperty(key) && object.hasOwnProperty(key)) {\r\n          furniture[key] = object[key];\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  private _setCodeOnFurnitureConfiguration(): void {\r\n    if (this._integrationEnabled) {\r\n      if (this._furnitureConfigurations.length < 1) {\r\n        const furniture: FurnitureIntegration = new FurnitureIntegration();\r\n        furniture.MrpCode = this._permanentStoreService.code;\r\n        this._furnitureConfigurations.push(furniture);\r\n      } else {\r\n        this._furnitureConfigurations.forEach(f => f.MrpCode = this._permanentStoreService.code);\r\n      }\r\n      this._messageBus.emit(MessageType.ConfigurationChanged, this._furnitureConfigurations);\r\n    }\r\n  }\r\n\r\n  private _canConnectSelections(sel1: Selection, sel2: Selection): boolean {\r\n    if (!sel1.decoNode || !sel2.decoNode) {\r\n      return false;\r\n    }\r\n    let canConnect: boolean = sel2.decoNode.type !== DecoNodeType.Part;\r\n    if (!canConnect) {\r\n      const len: number = sel1.decoNode.connectors.length;\r\n      for (let i = 0; i < len; i++) {\r\n        const leni: number = sel2.decoNode.connectors.length;\r\n        for (let ii = 0; ii < leni; ii++) {\r\n          canConnect = Scene3DUtil.CanSelectorConnect(sel1.decoNode.connectors, sel1.decoNode.connectors[i], sel2.decoNode.connectors[ii]);\r\n          if (canConnect) {\r\n            return true;\r\n          }\r\n        }\r\n      }\r\n      return false;\r\n    }\r\n    return canConnect;\r\n  }\r\n\r\n  private _handleSelectionsReceived(metadata: Metadata) {\r\n    if (this._answerSelected.length > 0) {\r\n      const selection: Selection =\r\n        this.selections.find(s => s.nodeId === this._answerSelected[this._answerSelected.length - 1].nodeId);\r\n      if (selection) {\r\n        let itemName: string = '';\r\n        if (metadata.itemName === '') {\r\n          if (metadata.itemDescription !== '') {\r\n            itemName = metadata.itemDescription;\r\n          } else {\r\n            itemName = metadata.itemIdentifier;\r\n          }\r\n        } else {\r\n          itemName = metadata.itemName;\r\n        }\r\n        this._googleTagManager.sendEvent(GoogleTagManagerEvent.AnswerChosen, {\r\n          'articleNr': metadata.itemIdentifier,\r\n          'product': itemName,\r\n          'optionDescription': selection.commercialAnswer ? selection.commercialAnswer : selection.answer,\r\n          'optionPath': selection.selection\r\n        });\r\n      }\r\n    }\r\n  }\r\n\r\n  private _handleConnectionReset(): void {\r\n    if (this._currentCustomFloorGroup) {\r\n      this._currentCustomFloorGroup.setUnselected();\r\n      this._messageBus.emit(MessageType.ItemUnselected, undefined);\r\n      this._showWarning({title: 'WARNING', message: 'REFRESH_DUE_TO_INACTIVITY'});\r\n    }\r\n  }\r\n\r\n  private _handleAnswerSelected(answer: Answer): void {\r\n    this._answerSelected.push(answer);\r\n  }\r\n\r\n  public async cancelAnswer(metadata: Metadata, rebuild: boolean = true, getAnswers: boolean = false): Promise<void> {\r\n    await this._iOne.cancelAnswer();\r\n    if (rebuild) {\r\n      this._startToBuildFromConfigurator(metadata);\r\n    } else if (getAnswers) { // if not rebuild then check if we need to get answers\r\n      const questionAndAnswers: QuestionAndAnswers = await this._iOne.getQuestionAndAnswersAsync(); // see if there is user input needed\r\n      this._iOne.handleAnswersReceived(questionAndAnswers.answers);\r\n      this._appEventService.answerCountReceived.next(questionAndAnswers.answers.length);\r\n    }\r\n  }\r\n\r\n  public async selectSelection(\r\n    selection: Selection, metadata: Metadata, forceBackToNode?: boolean, after?: boolean, connector?: string): Promise<void> {\r\n    await this._iOne.selectSelection(selection, forceBackToNode, after, connector);\r\n    this._genericSelection = selection.generic;\r\n    this._startToBuildFromConfigurator(metadata);\r\n  }\r\n\r\n  public async deleteSelection(selection: Selection, metadata: Metadata): Promise<void> {\r\n    this._elementService.removeElement(selection.instanceId, selection.node);\r\n    await this._iOne.deleteSelection(selection);\r\n    this._startToBuildFromConfigurator(metadata);\r\n  }\r\n\r\n  public async replaceSelection(selection: Selection, metadata: Metadata): Promise<void> {\r\n    await this._iOne.replaceSelection(selection);\r\n    this._startToBuildFromConfigurator(metadata);\r\n  }\r\n\r\n  public async selectAnswer(answer: Answer, input: string, metadata: Metadata): Promise<void> {\r\n    this._preloadMaterial(answer);\r\n    await this._iOne.selectAnswer(answer, input);\r\n    this._handleAnswerSelected(answer);\r\n    const result: CustomFloorGroupResult = await this._startToBuildFromConfigurator(metadata);\r\n    this.answerSelected.next(result);\r\n  }\r\n\r\n  private _getActiveFurniture(instanceId: string): Item {\r\n    const configurables: any[] = this._itemService.getConfigurables();\r\n    const len: number = configurables.length;\r\n    for (let i = 0; i < len; i++) {\r\n      if (configurables[i].metadata && configurables[i].metadata.itemId === instanceId && !configurables[i].tempObject) {\r\n        return configurables[i];\r\n      }\r\n    }\r\n  }\r\n\r\n  private _linkSelectionsAndDecos(): void {\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._iOne.decoNodes.find(d => d.id === this.selections[i].artNodeIdDeco);\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    this._iOne.selectionsAndDecosLinked.next();\r\n  }\r\n\r\n  private _createConfigurableItem(instanceId: string, metadata: Metadata): Item {\r\n    // const furniture: Item = this._getActiveFurniture(instanceId);\r\n    // const cloneSelections = JSON.parse(JSON.stringify(this.selections));\r\n    // cloneSelections.forEach(s => {\r\n    //   s.imageData = undefined;\r\n    //   s.imageDataLastAnswer = undefined;\r\n    // });\r\n    // if (furniture) {\r\n    //   furniture.metadata.decos = Array.from(this._iOne.decoNodes);\r\n    //   furniture.metadata.selections = cloneSelections;\r\n    //   furniture.markForDeletionChildren();\r\n    //   return furniture;\r\n    // }\r\n    if (!metadata.position) {\r\n      metadata.position = this.startPosition || defaultPosition;\r\n    }\r\n    if (!metadata.rotation) {\r\n      metadata.rotation = metadata.default180 ? defaultRotation : new Euler();\r\n    }\r\n    // If itemType is different in article compared to saved value in the .json, the itemType in article is applied\r\n    // metadata.itemType = this.itemType && this.itemType !== metadata.itemType ? this.itemType : metadata.itemType;\r\n    const itemConstructor = Factory.getClass(this.standAlone ? ItemType.CustomFloorGroup : metadata.itemType);\r\n    const item = new itemConstructor(\r\n      metadata,\r\n      undefined, // base on empty object\r\n      {\r\n        mouseOver: this.mouseOver,\r\n        mouseOff: this.mouseOff,\r\n        itemSelected: this.selectItem,\r\n        itemUnselected: this.unSelectItem,\r\n        elementSelected: this.selectElement,\r\n        elementUnselected: this.unSelectElement,\r\n        configuringChanged: this.changeConfigureMode,\r\n        childElementPositionChangedHandler: this.moveChildElement,\r\n        childElementPlaceHandler: this.placeChildElement\r\n        /*\r\n                childElementPositionChangedHandler: adjustable ? this.moveChildElement : undefined,\r\n                childElementPlaceHandler: adjustable ? this.placeChildElement : undefined\r\n        */\r\n      }\r\n    );\r\n    item.canDelete = !this.standAlone;\r\n    item.canCopy = !this.standAlone;\r\n    item.allwaysConfigureMode = this.standAlone;\r\n    item.highLightDisabled = !this._settingsService.settings.options.useStandaloneHighLight;\r\n    item.tempObject = true;\r\n    item.name = metadata.itemName + '_clone';\r\n    item.visible = false;\r\n    this._itemService.addItem(item);\r\n    // this._upsertFurniture(metadata.itemId, {BrandIdentifier: metadata.itemIdentifier}, item);\r\n    return item;\r\n  }\r\n\r\n  private _createPositionAnimation(object: Object3D, from: Vector3, to: Vector3, easing: TWEEN.Easing): Promise<void> {\r\n    const tweenFrom: Vector3 = new Vector3().copy(from);\r\n    const tween = new TWEEN.Tween(tweenFrom)\r\n      .to(to, 1000)\r\n      .easing(easing)\r\n      .onUpdate(() => {\r\n        object.position.copy(tweenFrom);\r\n        this._sceneService.needsRender = true;\r\n      });\r\n    return new Promise((resolve: Function, reject: Function) => tween.onComplete(resolve.bind(this, tween)).onStop(reject).start());\r\n  }\r\n\r\n  private async _animateChanges(furniture: Item, changes: ChangesInterface[]): Promise<void[]> {\r\n    // it's christmasss\r\n    const animations: Promise<void>[] = [];\r\n    if (furniture instanceof CustomFloorItem) {\r\n      for (let i = 0; i < changes.length; i++) {\r\n        const easing: TWEEN.Easing = !changes[i].oldPosition ? TWEEN.Easing.Exponential.Out :\r\n          (!changes[i].newPosition ? TWEEN.Easing.Exponential.Out : TWEEN.Easing.Exponential.InOut);\r\n        const from: Vector3 =\r\n          changes[i].oldPosition ? new Vector3().copy(changes[i].oldPosition) : new Vector3().copy(changes[i].newPosition).setY(10);\r\n        const to: Vector3 =\r\n          changes[i].newPosition ? new Vector3().copy(changes[i].newPosition) : new Vector3().copy(changes[i].oldPosition).setY(10);\r\n        const obj: Object3D = furniture.getObjectByName(changes[i].name);\r\n        if (!from.equals(to)) {\r\n          animations.push(\r\n            this._createPositionAnimation(obj, from, to, easing)\r\n          );\r\n        }\r\n      }\r\n    }\r\n    return await Promise.all(animations);\r\n  }\r\n\r\n  private async _replaceCurrentItem(newItem: Item, metadata: Metadata, animate: boolean = false): Promise<Item> {\r\n    const furniture: Item = this._getActiveFurniture(metadata.itemId);\r\n    const cloneSelections = JSON.parse(JSON.stringify(this.selections));\r\n    cloneSelections.forEach(s => {\r\n      s.imageData = undefined;\r\n      s.imageDataLastAnswer = undefined;\r\n      if (s.addables) {\r\n        s.addables.forEach(a => {\r\n          a.imageData = undefined;\r\n        });\r\n      }\r\n    });\r\n    if (furniture) {\r\n      furniture.metadata.decos = Array.from(this._iOne.decoNodes);\r\n      furniture.metadata.selections = cloneSelections;\r\n      if (furniture instanceof CustomWallFloorItem) {\r\n        (newItem as CustomWallFloorItem).currentWall = furniture.currentWall;\r\n      }\r\n      newItem.updatePivot();\r\n      const changes: ChangesInterface[] = furniture instanceof CustomFloorItem ? ObjectUtils.GetChanges(furniture.children, newItem.children) : [];\r\n      // animate removed items\r\n      const removedChanges: ChangesInterface[] = changes.filter(c => !c.newPosition);\r\n      if (animate && removedChanges && removedChanges.length > 0) { // animate changes to the model\r\n        await this._animateChanges(furniture, removedChanges);\r\n      }\r\n      // remove children from furniture\r\n      furniture.clearChildren();\r\n      // add new children to furniture\r\n      newItem.children.map(c => furniture.addChild(c));\r\n      this._itemService.removeItem(newItem, false, false);\r\n      // animate (new) items\r\n      const otherChanges: ChangesInterface[] = changes.filter(c => c.newPosition);\r\n      if (animate && otherChanges && otherChanges.length > 0) { // animate changes to the model\r\n        await this._animateChanges(furniture, otherChanges);\r\n      }\r\n      return furniture;\r\n    } else {\r\n      newItem.visible = true;\r\n      newItem.tempObject = false;\r\n      newItem.name = metadata.itemName;\r\n      this._upsertFurniture(metadata.itemId, {BrandIdentifier: metadata.itemIdentifier}, newItem);\r\n      return newItem;\r\n    }\r\n  }\r\n\r\n  public mouseOver = () => {\r\n    this.isMouseOverObject = true;\r\n  };\r\n\r\n  public mouseOff = () => {\r\n    this.isMouseOverObject = false;\r\n  };\r\n\r\n  public selectItem = (mesh: Mesh) => {\r\n    // this.activeInstance = mesh.userData.itemId;\r\n  };\r\n\r\n  public unSelectItem = () => {\r\n    // this.showLiteSelector = false;\r\n    // this.showSelections = false;\r\n  };\r\n\r\n  public selectElement = (element: Mesh, mousePos: Vector3) => {\r\n    this._activeChildElement = element;\r\n    if (element.parent instanceof CustomObject3D) {\r\n      this._originalElementPosition.copy(element.parent.position);\r\n      // if (this._currentCustomFloorGroup.adjustable) {\r\n      if (this._isMoveableObject(element.parent)) {\r\n        const connector: any = element.parent.children.find(c => c.name.toLowerCase().indexOf('c_') > -1);\r\n        if (connector.connectedTo) {\r\n          const baseElement: Object3D = <CustomObject3D>this._currentCustomFloorGroup.getObjectByName(connector.connectedTo);\r\n          this.baseElementNodeId = baseElement.userData && baseElement.userData.selection ? baseElement.userData.selection.nodeId : 0;\r\n        }\r\n      }\r\n    }\r\n    this.toggleSelectedElement.next(element);\r\n  };\r\n\r\n  public unSelectElement = () => {\r\n    this._activeChildElement = undefined;\r\n    this.toggleSelectedElement.next(undefined);\r\n  };\r\n\r\n  public moveChildElement = (element: CustomObject3D, pos: Vector3) => {\r\n    const worldToLocalPos: Vector3 = this._currentCustomFloorGroup.worldToLocal(pos.clone());\r\n    this._moveChildElementToPosition(element, worldToLocalPos);\r\n  };\r\n\r\n  public placeChildElement = async (element: CustomObject3D) => {\r\n    if (this._isMoveableObject(element) && (element as any).moved) {\r\n      const baseElement: Object3D[] =\r\n        this._currentCustomFloorGroup.getObjectsByUserDataProp('selection', 'nodeId', this.baseElementNodeId);\r\n      // use instanceId from parent\r\n      const item: Item = ObjectUtils.GetParentItem(element);\r\n      if (item) {\r\n        const connector: string =\r\n          await this._elementService.placeElementOnConnector(\r\n            item.metadata.itemId, element, baseElement.length > 0 ? baseElement[0] : null);\r\n        this._saveElementConnector(element, connector);\r\n      }\r\n    }\r\n  };\r\n\r\n  public changeConfigureMode = async (metadata: Metadata, configuring: boolean) => {\r\n    this.configureModeChanged.next({metadata: metadata, configuring: configuring});\r\n  };\r\n\r\n  public dragConnector = async (connector: CustomMesh, pos: Vector3) => {\r\n    this._resizeService.dragConnectorToNewPosition(connector, pos);\r\n  };\r\n\r\n  public cancelConfiguringCurrentInstance(): void {\r\n    if (this._currentCustomFloorGroup) {\r\n      this._currentCustomFloorGroup.configuring = false;\r\n    }\r\n  }\r\n\r\n  private _isMoveableObject(obj: Object3D): boolean {\r\n    return obj.userData && obj.userData.selection && obj.userData.selection.hdecoPositioning === HdecoPositioning.Variable;\r\n  }\r\n\r\n  private async _addElementOnConnector(currentItem: Item, element: Object3D, connector: string, connectedNodeId: number): Promise<void> {\r\n    // const con: Object3D = this._currentCustomFloorGroup.getObjectByName(connector.connector);\r\n    // if (con) {e\r\n    // const pos: Vector3 = new Vector3().copy(con.position);\r\n    // con.localToWorld(pos);\r\n    const connectorFromElement = currentItem.connectorFromElement(element.userData.selection);\r\n    const idFromBaseElement: number = connectedNodeId ? connectedNodeId : connectorFromElement.connectedNodeId;\r\n    const baseElement: Object3D[] = currentItem.getObjectsByUserDataProp('selection', 'nodeId', idFromBaseElement);\r\n\r\n    const item: Item = ObjectUtils.GetParentItem(element);\r\n    if (item) {\r\n      const conn: string =\r\n        await this._elementService.placeElementOnConnector(\r\n          item.metadata.itemId, element, baseElement.length > 0 ? baseElement[0] : null, false, connector, false);\r\n      this._saveElementConnector(element, conn);\r\n    }\r\n    // }\r\n  }\r\n\r\n  private _saveElementConnector(element: Object3D, connector: string): void {\r\n    if (element && element.userData && element.userData.selection) {\r\n      this._currentCustomFloorGroup.updateElementConnector(element.userData.selection, connector, this.baseElementNodeId);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * @param element The element to move\r\n   * @param pos The local position\r\n   * @private\r\n   */\r\n  private _moveChildElementToPosition(element: Object3D, pos: Vector3): void {\r\n    if (this._isMoveableObject(element)) {\r\n      const worldToLocalPos: Vector3 = new Vector3().copy(pos).add(this._originalElementPosition);\r\n      const baseElement: Object3D[] =\r\n        this._currentCustomFloorGroup.getObjectsByUserDataProp('selection', 'nodeId', this.baseElementNodeId);\r\n      const item: Item = ObjectUtils.GetParentItem(element);\r\n      if (item) {\r\n        this._elementService.moveElementToNewPosition(\r\n          item.metadata.itemId, element, worldToLocalPos, baseElement.length > 0 ? baseElement[0] : null);\r\n        // this._saveElementConnector(element, pos);\r\n      }\r\n    }\r\n  }\r\n\r\n  private _reset(): void {\r\n    this._placedAdjustables.length = 0;\r\n    this._placedAddables.length = 0;\r\n    this._adjustables.length = 0;\r\n    this._addables.length = 0;\r\n    // this._prepareTheSelections();\r\n    // todo: check this\r\n    // this._elementService.removeElement(this.activeInstance);\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    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    return undefined;\r\n  }\r\n\r\n  private _prepareTheSelections(instanceId: string): void {\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            globalVariations.push(decoNode);\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  private _getAdjustables(checkGameObject: boolean = true, checkType: boolean = true): Selection[] {\r\n    return this.selections.filter(s => {\r\n      const node: DecoNode = s.decoNode;\r\n      return node && (checkGameObject ? node.gameObjectName : true) && (checkType ? node.type === DecoNodeType.Part : true) && node.kind === DecoNodeKind.Adjustable;\r\n    });\r\n  }\r\n\r\n  private _getVariations(): any[] {\r\n    if (this._iOne.decoNodes.length === 0) {\r\n      return [];\r\n    }\r\n    return this._iOne.decoNodes.filter((deco: DecoNode) => {\r\n      return deco.type === DecoNodeType.Variation;\r\n    });\r\n  }\r\n\r\n  private _createAdjustable(item: Item, adj: Selection): CustomObject3D {\r\n    let obj: any = this.full3DObjectToUse ? this.full3DObjectToUse.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.full3DObjectToUse ? this.full3DObjectToUse.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(item, 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    item.addChild(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 = item.getObjectByName(adjustable.name);\r\n    this._placedAdjustables.push(adjustable);\r\n    return adjustable;\r\n  }\r\n\r\n  private _createAddable(item: Item, add: Selection, part2?: any, part1?: any): CustomObject3D {\r\n    const obj: any = this.full3DObjectToUse.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(item, 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      return this._placeAddable(item, addable);\r\n    }\r\n    return addable;\r\n  }\r\n\r\n  private _placeAddable(item: Item, add: any): CustomObject3D {\r\n    item.addChild(add);\r\n    const addable: CustomObject3D = item.getObjectByName(add.name) as CustomObject3D;\r\n    this._placedAddables.push(addable);\r\n    return addable;\r\n  }\r\n\r\n  private _createUniqueName(item: Item, obj: Object3D): string {\r\n    let iteration = 0;\r\n    let name = `${item.name}_${obj.name}`;\r\n    let existingObj = item.getObjectByName(name);\r\n    while (existingObj) {\r\n      iteration++;\r\n      name = `${item.name}_${obj.name}` + (iteration !== 0 ? ('_' + iteration) : '');\r\n      existingObj = item.getObjectByName(name);\r\n    }\r\n    return name;\r\n  }\r\n\r\n  private _placeAddables(item: Item): 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            Scene3DUtil.TrySelectorConnection(this.scene,\r\n              item, this._placedAdjustables[i], adjustableSelection.addables[ia], false,\r\n              (add, part2?, part1?) => this._createAddable(item, add, part2, part1));\r\n            if (conAddable) {\r\n              Scene3DUtil.TrySelectorConnection(this.scene,\r\n                item, conAddable, adjustableSelection.addables[ia], false,\r\n                (add, part2?, part1?) => this._createAddable(item, 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 async _loadVariations(item: Item, instanceId: string): Promise<void> {\r\n    if (this._settingsService.settings.options.useVariationOnPart) {\r\n      await this._variationService.loadPart(this._adjustables, instanceId, item, true);\r\n    }\r\n    await this._variationService.loadVariation(this._adjustables, instanceId, item, true);\r\n    await this._variationService.loadVariation(this._addables, instanceId, item, true);\r\n    this._variationService.clearCache();\r\n  }\r\n\r\n  private _showWarning(data: InfoDialogData) {\r\n    const dialogData: InfoDialogData = {\r\n      title: this._dictionaryService.get(data.title), message: this._dictionaryService.get(data.message)\r\n    };\r\n    this._dialog.open(InfoDialogComponent, {data: dialogData});\r\n  }\r\n\r\n  private _prepareStandAlone(): void {\r\n    this._collisionManager.checkCollisions = false;\r\n    if (this._settingsService.settings.options.cameraPositionFixed) {\r\n      this._cameraService.lockCamera();\r\n      this._cameraService.disableRotateHorizontal();\r\n      // this._cameraService.disableRotateVertical();\r\n      this._cameraService.disablePan();\r\n      this._cameraService.controls.target = new Vector3(0, 50, 0);\r\n    }\r\n    this._sceneEventService.rotateNoDrag = true;\r\n  }\r\n\r\n  private _preloadMaterial(answer: Answer): void {\r\n    if (answer.elementType === DecoNodeType.Variation && answer.gameObject) {\r\n      const variationDecoNode: DecoNode = new DecoNode();\r\n      variationDecoNode.gameObjectName = answer.gameObject;\r\n      const adjustablesClone: Selection[] = this._adjustables.map(s => Object.assign({}, s));\r\n\r\n      if (this._genericSelection) {\r\n        if (this.currentCustomFloorGroup) {\r\n          adjustablesClone.forEach((selection: Selection) => selection.variations = [variationDecoNode]);\r\n          this._variationCacheService.preloadVariationsAsync(adjustablesClone[0].schema, [variationDecoNode.gameObjectName], this.articleAssetPath)\r\n            .then(() => {\r\n              this._variationService.loadVariation(adjustablesClone, '', this.currentCustomFloorGroup, true)\r\n                .then(() => this._sceneService.needsRender = true);\r\n            });\r\n        } else {\r\n          this._adjustables.forEach((selection: Selection) => selection.variations = [variationDecoNode]);\r\n        }\r\n      } else {\r\n        const currentSelection: Selection = ObjectUtils.GetSelectionFromSelectedObject(this._activeChildElement);\r\n        if (currentSelection) {\r\n          if (this.currentCustomFloorGroup) {\r\n            const selectionFromAdjustables: Selection = adjustablesClone\r\n              .find((selection: Selection) => selection.nodeId === currentSelection.nodeId);\r\n            if (selectionFromAdjustables) {\r\n              selectionFromAdjustables.variations = [variationDecoNode];\r\n              this._variationCacheService.preloadVariationsAsync(adjustablesClone[0].schema, [variationDecoNode.gameObjectName], this.articleAssetPath)\r\n                .then(() => {\r\n                  this._variationService.loadVariation(adjustablesClone, '', this.currentCustomFloorGroup, true)\r\n                    .then(() => this._sceneService.needsRender = true);\r\n                });\r\n            }\r\n          } else {\r\n            const selectionFromAdjustables: Selection = this._adjustables\r\n              .find((selection: Selection) => selection.nodeId === currentSelection.nodeId);\r\n            selectionFromAdjustables.variations = [variationDecoNode];\r\n          }\r\n        }\r\n      }\r\n    }\r\n  }\r\n}\r\n"]}