@colijnit/homedecorator 255.1.1

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

@@ -0,0 +1,291 @@
+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 { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { CustomFloorGroupResult } from '../../../core3d/model/custom-floor-group-result';
+import { CustomButton } from '../../../../core/model/custom-button';
+import { isFloorDecoration, isWallDecoration, itemTypeFromPlacement } from '../../../core3d/items/factory';
+import { MessageType } from '../../../../core/enum/message-type.enum';
+import { ResultType } from '../../../core3d/enum/result-type.enum';
+import { ErrorMessage } from '../../../../core/model/error-message';
+import { isNill } from '../../../../core/utils/function/is-nill.function';
+import { RotationHelper } from '../../../core3d/hud/rotation-helper';
+import { Utils } from '../../../core3d/core/utils';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../../core/service/homedecorator-connector.service";
+import * as i2 from "../../../core3d/service/models.service";
+import * as i3 from "./threedselector.service";
+import * as i4 from "../../../../core/service/message-bus.service";
+import * as i5 from "./build-furniture.service";
+import * as i6 from "../../../../core/service/presets.service";
+import * as i7 from "../../../../core/service/homedecorator-dictionary.service";
+import * as i8 from "../../../../core/service/homedecorator-settings.service";
+import * as i9 from "../../../../shared/dialog/service/dialog.service";
+import * as i10 from "../../../../core/service/error.service";
+import * as i11 from "../../../../core/service/progress.service";
+import * as i12 from "../../../core3d/service/item.service";
+export class LoadFurnitureService {
+    constructor(_iOne, _modelService, _threedSelectorService, _messageBus, _buildFurnitureService, _presetService, _dictionaryService, _settingsService, _dialogService, _errorService, _progressService, _itemService) {
+        this._iOne = _iOne;
+        this._modelService = _modelService;
+        this._threedSelectorService = _threedSelectorService;
+        this._messageBus = _messageBus;
+        this._buildFurnitureService = _buildFurnitureService;
+        this._presetService = _presetService;
+        this._dictionaryService = _dictionaryService;
+        this._settingsService = _settingsService;
+        this._dialogService = _dialogService;
+        this._errorService = _errorService;
+        this._progressService = _progressService;
+        this._itemService = _itemService;
+        this.notLoaded = [];
+        this.notFixedObjectCache = [];
+        this.obsoleteObjectCache = [];
+        this.objectList = [];
+        this.objectListFixed = [];
+        this.simpleObjectList = [];
+        this.externalSourceNotAvailable = [];
+        this.shouldLoadSelections = true;
+        this.metadataSet = new BehaviorSubject(undefined);
+        this.articleLoaded = new BehaviorSubject(undefined);
+        this._fullObjectCache = new Map();
+        this._subs = [];
+        this._shouldCopyFurniture = true;
+        this._configurationDirty = false;
+        this.configureFurniture = (furniture) => __awaiter(this, void 0, void 0, function* () {
+            this._messageBus.emit(MessageType.HideLeftSidebar);
+            this.switchConfiguration(furniture);
+        });
+        this._subs.push(this._presetService.stateCreated.subscribe(() => this._saveConfiguration()), this._itemService.removeAllItems.subscribe(() => this._cleanUp()), this._messageBus.subscribe(MessageType.ItemRemoved, (result) => this._handleItemRemovedFromScene(result)), this._messageBus.subscribe(MessageType.SavePreset, () => this._saveConfiguration()), this._messageBus.subscribe(MessageType.RemoveItemFromScene, (instanceId) => this.deleteFromObjectList(instanceId)), this._messageBus.subscribe(MessageType.ShouldCopyFurnitureFromPreset, shouldCopy => this._shouldCopyFurniture = shouldCopy));
+        this.configureButton = new CustomButton('Configureren', this.configureFurniture);
+        window.onbeforeunload = () => this.ngOnDestroy();
+    }
+    set article(value) {
+        this._article = value;
+        if (this._article) {
+            this._buildFurnitureService.articleAssetPath = this._article.contentDeliveryUrl;
+        }
+        this.articleLoaded.next(this._article);
+    }
+    get article() {
+        return this._article;
+    }
+    ngOnDestroy() {
+        this._subs.forEach(s => s.unsubscribe());
+        this._cleanUp();
+    }
+    loadArticle(sku) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.article && this.article.sku === sku) {
+                return this.article;
+            }
+            this.article = yield this._iOne.getArticle(sku, this._settingsService.settings.branch);
+            return this.article;
+        });
+    }
+    loadFurniture(furnitureData, shouldCopyInstance = false, looseOriginalConfiguration = true, standAlone = false, fromScratch = false, fromPreset = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = new CustomFloorGroupResult(furnitureData.itemIdentifier, furnitureData.itemName ? furnitureData.itemName : furnitureData.itemIdentifier);
+            yield this._tryLoadArticle(furnitureData, result).catch((e) => {
+                if (result.resultType === ResultType.Timeout) {
+                    return Promise.reject(result);
+                }
+                if (result.metaData.externalSettings.externalSourceId === null || result.metaData.externalSettings.externalSourceId === undefined) {
+                    result.errorMessages.push(new ErrorMessage(result.metaData.externalSettings.name + ' EXTERNAL_SOURCE_NOT_FOUND', ''));
+                    result.resultType = ResultType.ExternalSourceNotAvailable;
+                    return Promise.reject(result);
+                }
+                // no article found, we can continue if there is instanceId and modelUrl provided in metadata
+                if (!result.metaData || !result.metaData.modelUrl) {
+                    // if (result.resultType !== ResultType.ConfigurationNotFixed) {
+                    result.errorMessages.push(new ErrorMessage('ARTICLE_NOT_FOUND', 'ARTICLE_NOT_FOUND_DESC'));
+                    result.resultType = ResultType.ArticleNotFound;
+                    // }
+                    return Promise.reject(result);
+                }
+            });
+            yield this._initFull3DObject(result, fromPreset)
+                .catch((e) => {
+                if (!standAlone) {
+                    return Promise.reject(result);
+                }
+            });
+            if (!result.metaData.configurable) { // simple 3d article, just load model
+                return this._buildFurnitureService.createSimple3DModel(result, standAlone);
+            }
+            else {
+                this._modelService.addCustomButton(this.configureButton);
+                this._configurationDirty = true;
+                return this._buildFurnitureService.startToBuild(result, result.metaData, shouldCopyInstance, looseOriginalConfiguration, standAlone, true);
+            }
+        });
+    }
+    switchConfiguration(furniture) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (furniture) {
+                this._buildFurnitureService.full3DObjectToUse =
+                    yield this.getFull3DObject(furniture.metadata.itemIdentifier, furniture.metadata.itemId, furniture.metadata.assetPath);
+                furniture.configuring = true;
+            }
+        });
+    }
+    deleteFromObjectList(id, useInstanceId = true) {
+        if (id !== undefined) {
+            if (useInstanceId) {
+                this.objectList.splice(this.objectList.findIndex(c => c.instanceId === id), 1);
+            }
+            else {
+                this.simpleObjectList.splice(this.simpleObjectList.findIndex(c => c.metaData.objectUUID === id), 1);
+            }
+        }
+    }
+    addToList(list, item) {
+        if (!item || (!item.instanceId && !item.metaData.objectUUID)) {
+            return;
+        }
+        if ((item.instanceId && !list.find(l => l.instanceId === item.instanceId)) ||
+            (item.metaData.objectUUID && !list.find(l => l.metaData.objectUUID === item.metaData.objectUUID))) {
+            list.push(item);
+        }
+    }
+    _tryLoadArticle(furnitureData, result) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.article = undefined;
+            const article = yield this.loadArticle(furnitureData.itemIdentifier).catch((e) => {
+                if (e === 'ECONNABORTED') {
+                    result.resultType = ResultType.Timeout;
+                    return Promise.reject();
+                }
+            });
+            if (article) {
+                this.article = article;
+                this._extendMetadataWithArticleData(furnitureData, article, result);
+                return;
+            }
+            else { // no article found
+                result.resultType = ResultType.ArticleNotFound;
+                result.metaData = furnitureData;
+                return Promise.reject();
+            }
+        });
+    }
+    _extendMetadataWithArticleData(furnitureData, article, result) {
+        furnitureData.resizable = false;
+        furnitureData.ione = true;
+        furnitureData.centerPivot = true;
+        furnitureData.ignoreInvisible = false;
+        furnitureData.modelUrl = article.assetUrl;
+        furnitureData.schema = article.distSchema ? article.distSchema : 'UP_DBA';
+        furnitureData.assetPath = article.contentDeliveryUrl;
+        furnitureData.itemType = itemTypeFromPlacement(article.placement);
+        furnitureData.canElevate = article.stackable;
+        furnitureData.configurable = article.goodType ? article.goodType.toLowerCase() === 'b' : true;
+        furnitureData.itemName = article.name;
+        furnitureData.goodId = article.id;
+        furnitureData.goodType = article.goodType;
+        // furnitureData.itemIdentifier = article.sku;
+        furnitureData.elevation = !furnitureData.elevation ? (article.defaultHeight ? article.defaultHeight / 100 : 0) : furnitureData.elevation;
+        furnitureData.elevationAdjustable = article.defaultHeightAdjustable;
+        furnitureData.elevationFixed = furnitureData.elevationFixed === true || article.defaultHeight ? true : !furnitureData.elevationAdjustable;
+        furnitureData.canRotateX = !isNill(article.canRotate) ? RotationHelper.CanRotateX(article.canRotate) : false;
+        furnitureData.canRotateY = !isNill(article.canRotate) ? RotationHelper.CanRotateY(article.canRotate) : true;
+        furnitureData.canRotateZ = !isNill(article.canRotate) ? RotationHelper.CanRotateZ(article.canRotate) : false;
+        furnitureData.default180 = !isNill(article.canRotate) ? RotationHelper.Default180(article.canRotate) : false;
+        result.metaData = furnitureData;
+        result.name = furnitureData.itemName;
+        this.metadataSet.next(result.metaData);
+    }
+    _handleItemRemovedFromScene(result) {
+        var _a;
+        if (result.addedToGroup) {
+            return;
+        }
+        const hasUUID = !!((_a = result.item.metadata) === null || _a === void 0 ? void 0 : _a.objectUUID);
+        if (result.item.userData && (result.item.userData.itemId || hasUUID)) {
+            this.deleteFromObjectList(hasUUID ? result.item.metadata.objectUUID : result.item.userData.itemId, !hasUUID);
+        }
+    }
+    _saveConfiguration() {
+        if (this._configurationDirty) {
+            this._iOne.saveConfigurations();
+            this._configurationDirty = false;
+        }
+    }
+    _cleanUp() {
+        this.notLoaded.length = 0;
+        this.notFixedObjectCache.length = 0;
+        this.obsoleteObjectCache.length = 0;
+        this.objectList.length = 0;
+        this.objectListFixed.length = 0;
+        const objs = Array.from(this._fullObjectCache.values());
+        objs.forEach(o => Utils.DisposeObject(o));
+        this._fullObjectCache.clear();
+    }
+    _needs3DModel(metaData) {
+        return !isFloorDecoration(metaData.itemType) && !isWallDecoration(metaData.itemType);
+    }
+    _initFull3DObject(result, fromPreset) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const obj = yield this.getFull3DObject(result.metaData.itemIdentifier, this._settingsService.settings.assetPath, result.metaData.itemName, result.metaData.modelUrl, !fromPreset)
+                .catch((e) => {
+                // this._errorService.addError(md.itemId, e);
+                if (this._settingsService.settings.options.onlyThreeD && this._needs3DModel(result.metaData)) {
+                    result.errorMessages.push(e);
+                    result.resultType = ResultType.No3DModel;
+                    return Promise.reject(result);
+                }
+            });
+            if (obj === null) {
+                if (this._settingsService.settings.options.onlyThreeD && this._needs3DModel(result.metaData)) {
+                    result.resultType = ResultType.No3DModel;
+                    return Promise.reject(result);
+                }
+                else {
+                    return Promise.resolve();
+                }
+            }
+            const fullObj = obj.clone();
+            this._buildFurnitureService.full3DObjectToUse = fullObj;
+            return;
+        });
+    }
+    getFull3DObject(sku, assetPath, name, assetUrl, prepareProgress = false) {
+        if (this._fullObjectCache.has(sku)) {
+            return Promise.resolve(this._fullObjectCache.get(sku));
+        }
+        else if (assetUrl) {
+            // const fileName: string = assetUrl.substr(0, assetUrl.lastIndexOf('.')).replace('.unity3d', '');
+            const fileName = assetUrl.replace('.unity3d', '');
+            return this._threedSelectorService.downloadAssetsAndReturn(fileName, assetPath, prepareProgress)
+                .then(res => {
+                const obj = res;
+                obj.name = name;
+                // obj.scale.set(100, 100, 100);
+                this._fullObjectCache.set(sku, obj);
+                return obj;
+            }, err => {
+                return Promise.reject(new ErrorMessage('THREED_MODEL_NOT_FOUND', err));
+            });
+            // }
+        }
+        else {
+            return Promise.resolve(null);
+        }
+    }
+}
+LoadFurnitureService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: LoadFurnitureService, deps: [{ token: i1.HomedecoratorConnectorService }, { token: i2.ModelsService }, { token: i3.ThreedselectorService }, { token: i4.MessageBusService }, { token: i5.BuildFurnitureService }, { token: i6.PresetsService }, { token: i7.HomedecoratorDictionaryService }, { token: i8.HomedecoratorSettingsService }, { token: i9.DialogService }, { token: i10.ErrorService }, { token: i11.ProgressService }, { token: i12.ItemService }], target: i0.ɵɵFactoryTarget.Injectable });
+LoadFurnitureService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: LoadFurnitureService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: LoadFurnitureService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HomedecoratorConnectorService }, { type: i2.ModelsService }, { type: i3.ThreedselectorService }, { type: i4.MessageBusService }, { type: i5.BuildFurnitureService }, { type: i6.PresetsService }, { type: i7.HomedecoratorDictionaryService }, { type: i8.HomedecoratorSettingsService }, { type: i9.DialogService }, { type: i10.ErrorService }, { type: i11.ProgressService }, { type: i12.ItemService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"load-furniture.service.js","sourceRoot":"","sources":["../../../../../../../../src/client/app/plugins/threedselector/threedselector/service/load-furniture.service.ts"],"names":[],"mappings":";;;;;;;;;AAAA,OAAO,EAAC,UAAU,EAAY,MAAM,eAAe,CAAC;AACpD,OAAO,EAAC,eAAe,EAAe,MAAM,MAAM,CAAC;AAGnD,OAAO,EAAC,sBAAsB,EAAC,MAAM,iDAAiD,CAAC;AACvF,OAAO,EAAC,YAAY,EAAC,MAAM,sCAAsC,CAAC;AAClE,OAAO,EAAC,iBAAiB,EAAE,gBAAgB,EAAE,qBAAqB,EAAC,MAAM,+BAA+B,CAAC;AAazG,OAAO,EAAC,WAAW,EAAC,MAAM,yCAAyC,CAAC;AACpE,OAAO,EAAC,UAAU,EAAC,MAAM,uCAAuC,CAAC;AACjE,OAAO,EAAC,YAAY,EAAC,MAAM,sCAAsC,CAAC;AAClE,OAAO,EAAC,MAAM,EAAC,MAAM,kDAAkD,CAAC;AACxE,OAAO,EAAC,cAAc,EAAC,MAAM,qCAAqC,CAAC;AACnE,OAAO,EAAC,KAAK,EAAC,MAAM,4BAA4B,CAAC;;;;;;;;;;;;;;AAWjD,MAAM,OAAO,oBAAoB;IAgC/B,YACU,KAAoC,EACpC,aAA4B,EAC5B,sBAA6C,EAC7C,WAA8B,EAC9B,sBAA6C,EAC7C,cAA8B,EAC9B,kBAAkD,EAClD,gBAA8C,EAC9C,cAA6B,EAC7B,aAA2B,EAC3B,gBAAiC,EACjC,YAAyB;QAXzB,UAAK,GAAL,KAAK,CAA+B;QACpC,kBAAa,GAAb,aAAa,CAAe;QAC5B,2BAAsB,GAAtB,sBAAsB,CAAuB;QAC7C,gBAAW,GAAX,WAAW,CAAmB;QAC9B,2BAAsB,GAAtB,sBAAsB,CAAuB;QAC7C,mBAAc,GAAd,cAAc,CAAgB;QAC9B,uBAAkB,GAAlB,kBAAkB,CAAgC;QAClD,qBAAgB,GAAhB,gBAAgB,CAA8B;QAC9C,mBAAc,GAAd,cAAc,CAAe;QAC7B,kBAAa,GAAb,aAAa,CAAc;QAC3B,qBAAgB,GAAhB,gBAAgB,CAAiB;QACjC,iBAAY,GAAZ,YAAY,CAAa;QA3C5B,cAAS,GAA6B,EAAE,CAAC;QACzC,wBAAmB,GAA6B,EAAE,CAAC;QACnD,wBAAmB,GAA6B,EAAE,CAAC;QACnD,eAAU,GAA6B,EAAE,CAAC;QAC1C,oBAAe,GAA6B,EAAE,CAAC;QAC/C,qBAAgB,GAA6B,EAAE,CAAC;QAChD,+BAA0B,GAA6B,EAAE,CAAC;QAE1D,yBAAoB,GAAY,IAAI,CAAC;QACrC,gBAAW,GAA8B,IAAI,eAAe,CAAW,SAAS,CAAC,CAAC;QAclF,kBAAa,GAA6B,IAAI,eAAe,CAAU,SAAS,CAAC,CAAC;QAExE,qBAAgB,GAA0B,IAAI,GAAG,EAAE,CAAC;QAE7D,UAAK,GAAmB,EAAE,CAAC;QAC3B,yBAAoB,GAAG,IAAI,CAAC;QAC5B,wBAAmB,GAAY,KAAK,CAAC;QAiGtC,uBAAkB,GAAG,CAAO,SAAc,EAAE,EAAE;YACnD,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,WAAW,CAAC,eAAe,CAAC,CAAC;YACnD,IAAI,CAAC,mBAAmB,CAAC,SAAS,CAAC,CAAC;QACtC,CAAC,CAAA,CAAA;QApFC,IAAI,CAAC,KAAK,CAAC,IAAI,CACb,IAAI,CAAC,cAAc,CAAC,YAAY,CAAC,SAAS,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,kBAAkB,EAAE,CAAC,EAC3E,IAAI,CAAC,YAAY,CAAC,cAAc,CAAC,SAAS,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,EACjE,IAAI,CAAC,WAAW,CAAC,SAAS,CACxB,WAAW,CAAC,WAAW,EAAE,CAAC,MAA4C,EAAE,EAAE,CAAC,IAAI,CAAC,2BAA2B,CAAC,MAAM,CAAC,CAAC,EACtH,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC,WAAW,CAAC,UAAU,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,kBAAkB,EAAE,CAAC,EACnF,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC,WAAW,CAAC,mBAAmB,EAAE,CAAC,UAAe,EAAE,EAAE,CAAC,IAAI,CAAC,oBAAoB,CAAC,UAAU,CAAC,CAAC,EACvH,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC,WAAW,CAAC,6BAA6B,EAAE,UAAU,CAAC,EAAE,CAAC,IAAI,CAAC,oBAAoB,GAAG,UAAU,CAAC,CAC5H,CAAC;QACF,IAAI,CAAC,eAAe,GAAG,IAAI,YAAY,CAAC,cAAc,EAAE,IAAI,CAAC,kBAAkB,CAAC,CAAC;QACjF,MAAM,CAAC,cAAc,GAAG,GAAG,EAAE,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC;IACnD,CAAC;IA7CD,IAAW,OAAO,CAAC,KAAc;QAC/B,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;QACtB,IAAI,IAAI,CAAC,QAAQ,EAAE;YACjB,IAAI,CAAC,sBAAsB,CAAC,gBAAgB,GAAG,IAAI,CAAC,QAAQ,CAAC,kBAAkB,CAAC;SACjF;QACD,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IACzC,CAAC;IAED,IAAW,OAAO;QAChB,OAAO,IAAI,CAAC,QAAQ,CAAC;IACvB,CAAC;IAqCD,WAAW;QACT,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC,CAAC;QACzC,IAAI,CAAC,QAAQ,EAAE,CAAC;IAClB,CAAC;IAEY,WAAW,CAAC,GAAW;;YAClC,IAAI,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,OAAO,CAAC,GAAG,KAAK,GAAG,EAAE;gBAC5C,OAAO,IAAI,CAAC,OAAO,CAAC;aACrB;YACD,IAAI,CAAC,OAAO,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,GAAG,EAAE,IAAI,CAAC,gBAAgB,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;YACvF,OAAO,IAAI,CAAC,OAAO,CAAC;QACtB,CAAC;KAAA;IAEY,aAAa,CACxB,aAAuB,EACvB,qBAA8B,KAAK,EACnC,6BAAsC,IAAI,EAC1C,aAAsB,KAAK,EAC3B,cAAuB,KAAK,EAC5B,aAAsB,KAAK;;YAE3B,MAAM,MAAM,GACV,IAAI,sBAAsB,CACxB,aAAa,CAAC,cAAc,EAAE,aAAa,CAAC,QAAQ,CAAC,CAAC,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC,CAAC,aAAa,CAAC,cAAc,CAAC,CAAC;YAElH,MAAM,IAAI,CAAC,eAAe,CAAC,aAAa,EAAE,MAAM,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE;gBAC5D,IAAI,MAAM,CAAC,UAAU,KAAK,UAAU,CAAC,OAAO,EAAE;oBAC5C,OAAO,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;iBAC/B;gBACD,IAAI,MAAM,CAAC,QAAQ,CAAC,gBAAgB,CAAC,gBAAgB,KAAK,IAAI,IAAI,MAAM,CAAC,QAAQ,CAAC,gBAAgB,CAAC,gBAAgB,KAAK,SAAS,EAAE;oBACjI,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,YAAY,CAAC,MAAM,CAAC,QAAQ,CAAC,gBAAgB,CAAC,IAAI,GAAG,4BAA4B,EAAE,EAAE,CAAC,CAAC,CAAC;oBACtH,MAAM,CAAC,UAAU,GAAG,UAAU,CAAC,0BAA0B,CAAC;oBAC1D,OAAO,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;iBAC/B;gBACD,6FAA6F;gBAC7F,IAAI,CAAC,MAAM,CAAC,QAAQ,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,QAAQ,EAAE;oBACjD,gEAAgE;oBAChE,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,YAAY,CAAC,mBAAmB,EAAE,wBAAwB,CAAC,CAAC,CAAC;oBAC3F,MAAM,CAAC,UAAU,GAAG,UAAU,CAAC,eAAe,CAAC;oBAC/C,IAAI;oBACJ,OAAO,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;iBAC/B;YACH,CAAC,CAAC,CAAC;YAEH,MAAM,IAAI,CAAC,iBAAiB,CAAC,MAAM,EAAE,UAAU,CAAC;iBAC7C,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE;gBACX,IAAI,CAAC,UAAU,EAAE;oBACf,OAAO,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;iBAC/B;YACH,CAAC,CAAC,CAAC;YAEL,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,YAAY,EAAE,EAAE,qCAAqC;gBACxE,OAAO,IAAI,CAAC,sBAAsB,CAAC,mBAAmB,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;aAC5E;iBAAM;gBACL,IAAI,CAAC,aAAa,CAAC,eAAe,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;gBACzD,IAAI,CAAC,mBAAmB,GAAG,IAAI,CAAC;gBAChC,OAAO,IAAI,CAAC,sBAAsB,CAAC,YAAY,CAAC,MAAM,EAAE,MAAM,CAAC,QAAQ,EAAE,kBAAkB,EAAE,0BAA0B,EAAE,UAAU,EAAE,IAAI,CAAC,CAAC;aAC5I;QACH,CAAC;KAAA;IAEY,mBAAmB,CAAC,SAAc;;YAC7C,IAAI,SAAS,EAAE;gBACb,IAAI,CAAC,sBAAsB,CAAC,iBAAiB;oBAC3C,MAAM,IAAI,CAAC,eAAe,CAAC,SAAS,CAAC,QAAQ,CAAC,cAAc,EAAE,SAAS,CAAC,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC;gBACzH,SAAS,CAAC,WAAW,GAAG,IAAI,CAAC;aAC9B;QACH,CAAC;KAAA;IAOM,oBAAoB,CAAC,EAAU,EAAE,gBAAyB,IAAI;QACnE,IAAI,EAAE,KAAK,SAAS,EAAE;YACpB,IAAI,aAAa,EAAE;gBACjB,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,UAAU,KAAK,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;aAChF;iBAAM;gBACL,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,IAAI,CAAC,gBAAgB,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,UAAU,KAAK,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;aACrG;SACF;IACH,CAAC;IAEM,SAAS,CAAC,IAA8B,EAAE,IAA4B;QAC3E,IAAI,CAAC,IAAI,IAAI,CAAC,CAAC,IAAI,CAAC,UAAU,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,EAAE;YAC5D,OAAO;SACR;QACD,IAAI,CAAC,IAAI,CAAC,UAAU,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,UAAU,KAAK,IAAI,CAAC,UAAU,CAAC,CAAC;YACxE,CAAC,IAAI,CAAC,QAAQ,CAAC,UAAU,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,UAAU,KAAK,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC,EAAE;YACnG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;SACjB;IACH,CAAC;IAEa,eAAe,CAAC,aAAuB,EAAE,MAA8B;;YACnF,IAAI,CAAC,OAAO,GAAG,SAAS,CAAC;YACzB,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,cAAc,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE;gBAC/E,IAAI,CAAC,KAAK,cAAc,EAAE;oBACxB,MAAM,CAAC,UAAU,GAAG,UAAU,CAAC,OAAO,CAAC;oBACvC,OAAO,OAAO,CAAC,MAAM,EAAE,CAAC;iBACzB;YACH,CAAC,CAAC,CAAC;YACH,IAAI,OAAO,EAAE;gBACX,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;gBACvB,IAAI,CAAC,8BAA8B,CAAC,aAAa,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;gBACpE,OAAO;aACR;iBAAM,EAAE,mBAAmB;gBAC1B,MAAM,CAAC,UAAU,GAAG,UAAU,CAAC,eAAe,CAAC;gBAC/C,MAAM,CAAC,QAAQ,GAAG,aAAa,CAAC;gBAChC,OAAO,OAAO,CAAC,MAAM,EAAE,CAAC;aACzB;QACH,CAAC;KAAA;IAEO,8BAA8B,CAAC,aAAuB,EAAE,OAAgB,EAAE,MAA8B;QAC9G,aAAa,CAAC,SAAS,GAAG,KAAK,CAAC;QAChC,aAAa,CAAC,IAAI,GAAG,IAAI,CAAC;QAC1B,aAAa,CAAC,WAAW,GAAG,IAAI,CAAC;QACjC,aAAa,CAAC,eAAe,GAAG,KAAK,CAAC;QACtC,aAAa,CAAC,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC;QAC1C,aAAa,CAAC,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,QAAQ,CAAC;QAC1E,aAAa,CAAC,SAAS,GAAG,OAAO,CAAC,kBAAkB,CAAC;QACrD,aAAa,CAAC,QAAQ,GAAG,qBAAqB,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;QAClE,aAAa,CAAC,UAAU,GAAG,OAAO,CAAC,SAAS,CAAC;QAC7C,aAAa,CAAC,YAAY,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,WAAW,EAAE,KAAK,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC;QAC9F,aAAa,CAAC,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;QACtC,aAAa,CAAC,MAAM,GAAG,OAAO,CAAC,EAAE,CAAC;QAClC,aAAa,CAAC,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC;QAC1C,8CAA8C;QAC9C,aAAa,CAAC,SAAS,GAAG,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,OAAO,CAAC,aAAa,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,aAAa,CAAC,SAAS,CAAC;QACzI,aAAa,CAAC,mBAAmB,GAAG,OAAO,CAAC,uBAAuB,CAAC;QACpE,aAAa,CAAC,cAAc,GAAG,aAAa,CAAC,cAAc,KAAK,IAAI,IAAI,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,aAAa,CAAC,mBAAmB,CAAC;QAC1I,aAAa,CAAC,UAAU,GAAG,CAAC,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,cAAc,CAAC,UAAU,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;QAC7G,aAAa,CAAC,UAAU,GAAG,CAAC,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,cAAc,CAAC,UAAU,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;QAC5G,aAAa,CAAC,UAAU,GAAG,CAAC,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,cAAc,CAAC,UAAU,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;QAC7G,aAAa,CAAC,UAAU,GAAG,CAAC,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,cAAc,CAAC,UAAU,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;QAC7G,MAAM,CAAC,QAAQ,GAAG,aAAa,CAAC;QAChC,MAAM,CAAC,IAAI,GAAG,aAAa,CAAC,QAAQ,CAAC;QACrC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;IACzC,CAAC;IAEO,2BAA2B,CAAC,MAA4C;;QAC9E,IAAI,MAAM,CAAC,YAAY,EAAE;YACvB,OAAO;SACR;QACD,MAAM,OAAO,GAAY,CAAC,CAAC,CAAA,MAAA,MAAM,CAAC,IAAI,CAAC,QAAQ,0CAAE,UAAU,CAAA,CAAC;QAC5D,IAAI,MAAM,CAAC,IAAI,CAAC,QAAQ,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,IAAI,OAAO,CAAC,EAAE;YACpE,IAAI,CAAC,oBAAoB,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC,OAAO,CAAC,CAAC;SAC9G;IACH,CAAC;IAEO,kBAAkB;QACxB,IAAI,IAAI,CAAC,mBAAmB,EAAE;YAC5B,IAAI,CAAC,KAAK,CAAC,kBAAkB,EAAE,CAAC;YAChC,IAAI,CAAC,mBAAmB,GAAG,KAAK,CAAC;SAClC;IACH,CAAC;IAEO,QAAQ;QACd,IAAI,CAAC,SAAS,CAAC,MAAM,GAAG,CAAC,CAAC;QAC1B,IAAI,CAAC,mBAAmB,CAAC,MAAM,GAAG,CAAC,CAAC;QACpC,IAAI,CAAC,mBAAmB,CAAC,MAAM,GAAG,CAAC,CAAC;QACpC,IAAI,CAAC,UAAU,CAAC,MAAM,GAAG,CAAC,CAAC;QAC3B,IAAI,CAAC,eAAe,CAAC,MAAM,GAAG,CAAC,CAAC;QAChC,MAAM,IAAI,GAAe,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,gBAAgB,CAAC,MAAM,EAAE,CAAC,CAAC;QACpE,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC;QAC1C,IAAI,CAAC,gBAAgB,CAAC,KAAK,EAAE,CAAC;IAChC,CAAC;IAEO,aAAa,CAAC,QAAkB;QACtC,OAAO,CAAC,iBAAiB,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,gBAAgB,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;IACvF,CAAC;IAEa,iBAAiB,CAAC,MAA8B,EAAE,UAAmB;;YACjF,MAAM,GAAG,GAAa,MAAM,IAAI,CAAC,eAAe,CAC9C,MAAM,CAAC,QAAQ,CAAC,cAAc,EAAE,IAAI,CAAC,gBAAgB,CAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC,QAAQ,CAAC,QAAQ,EAAE,CAAC,UAAU,CAAC;iBACzI,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE;gBACX,6CAA6C;gBAC7C,IAAI,IAAI,CAAC,gBAAgB,CAAC,QAAQ,CAAC,OAAO,CAAC,UAAU,IAAI,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE;oBAC5F,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;oBAC7B,MAAM,CAAC,UAAU,GAAG,UAAU,CAAC,SAAS,CAAC;oBACzC,OAAO,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;iBAC/B;YACH,CAAC,CAAC,CAAC;YACL,IAAI,GAAG,KAAK,IAAI,EAAE;gBAChB,IAAI,IAAI,CAAC,gBAAgB,CAAC,QAAQ,CAAC,OAAO,CAAC,UAAU,IAAI,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE;oBAC5F,MAAM,CAAC,UAAU,GAAG,UAAU,CAAC,SAAS,CAAC;oBACzC,OAAO,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;iBAC/B;qBAAM;oBACL,OAAO,OAAO,CAAC,OAAO,EAAE,CAAC;iBAC1B;aACF;YAED,MAAM,OAAO,GAAa,GAAG,CAAC,KAAK,EAAE,CAAC;YACtC,IAAI,CAAC,sBAAsB,CAAC,iBAAiB,GAAG,OAAO,CAAC;YACxD,OAAO;QACT,CAAC;KAAA;IAEM,eAAe,CACpB,GAAW,EACX,SAAiB,EACjB,IAAa,EACb,QAAiB,EACjB,kBAA2B,KAAK;QAEhC,IAAI,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE;YAClC,OAAO,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;SACxD;aAAM,IAAI,QAAQ,EAAE;YACnB,kGAAkG;YAClG,MAAM,QAAQ,GAAW,QAAQ,CAAC,OAAO,CAAC,UAAU,EAAE,EAAE,CAAC,CAAC;YAC1D,OAAO,IAAI,CAAC,sBAAsB,CAAC,uBAAuB,CAAC,QAAQ,EAAE,SAAS,EAAE,eAAe,CAAC;iBAC7F,IAAI,CACH,GAAG,CAAC,EAAE;gBACJ,MAAM,GAAG,GAAa,GAAG,CAAC;gBAC1B,GAAG,CAAC,IAAI,GAAG,IAAI,CAAC;gBAChB,gCAAgC;gBAChC,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;gBACpC,OAAO,GAAG,CAAC;YACb,CAAC,EACD,GAAG,CAAC,EAAE;gBACJ,OAAO,OAAO,CAAC,MAAM,CAAC,IAAI,YAAY,CAAC,wBAAwB,EAAE,GAAG,CAAC,CAAC,CAAC;YACzE,CAAC,CACF,CAAC;YACJ,IAAI;SACL;aAAM;YACL,OAAO,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;SAC9B;IACH,CAAC;;kHA5RU,oBAAoB;sHAApB,oBAAoB,cAFnB,MAAM;4FAEP,oBAAoB;kBAHhC,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import {Injectable, OnDestroy} from '@angular/core';\r\nimport {BehaviorSubject, Subscription} from 'rxjs';\r\nimport {Object3D} from 'three';\r\nimport {Article} from '@colijnit/configuratorapi/build/model/article';\r\nimport {CustomFloorGroupResult} from '../../../core3d/model/custom-floor-group-result';\r\nimport {CustomButton} from '../../../../core/model/custom-button';\r\nimport {isFloorDecoration, isWallDecoration, itemTypeFromPlacement} from '../../../core3d/items/factory';\r\nimport {Metadata} from '../../../core3d/items/metadata';\r\nimport {HomedecoratorConnectorService} from '../../../../core/service/homedecorator-connector.service';\r\nimport {ModelsService} from '../../../core3d/service/models.service';\r\nimport {MessageBusService} from '../../../../core/service/message-bus.service';\r\nimport {BuildFurnitureService} from './build-furniture.service';\r\nimport {PresetsService} from '../../../../core/service/presets.service';\r\nimport {HomedecoratorDictionaryService} from '../../../../core/service/homedecorator-dictionary.service';\r\nimport {HomedecoratorSettingsService} from '../../../../core/service/homedecorator-settings.service';\r\nimport {DialogService} from '../../../../shared/dialog/service/dialog.service';\r\nimport {ErrorService} from '../../../../core/service/error.service';\r\nimport {ProgressService} from '../../../../core/service/progress.service';\r\nimport {ItemService} from '../../../core3d/service/item.service';\r\nimport {MessageType} from '../../../../core/enum/message-type.enum';\r\nimport {ResultType} from '../../../core3d/enum/result-type.enum';\r\nimport {ErrorMessage} from '../../../../core/model/error-message';\r\nimport {isNill} from '../../../../core/utils/function/is-nill.function';\r\nimport {RotationHelper} from '../../../core3d/hud/rotation-helper';\r\nimport {Utils} from '../../../core3d/core/utils';\r\nimport {ThreedselectorService} from './threedselector.service';\r\n\r\nexport interface FurnitureInitialized {\r\n  initialized: boolean;\r\n  assetPath: string;\r\n}\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class LoadFurnitureService implements OnDestroy {\r\n  public notLoaded: CustomFloorGroupResult[] = [];\r\n  public notFixedObjectCache: CustomFloorGroupResult[] = [];\r\n  public obsoleteObjectCache: CustomFloorGroupResult[] = [];\r\n  public objectList: CustomFloorGroupResult[] = [];\r\n  public objectListFixed: CustomFloorGroupResult[] = [];\r\n  public simpleObjectList: CustomFloorGroupResult[] = [];\r\n  public externalSourceNotAvailable: CustomFloorGroupResult[] = [];\r\n  public configureButton: CustomButton;\r\n  public shouldLoadSelections: boolean = true;\r\n  public metadataSet: BehaviorSubject<Metadata> = new BehaviorSubject<Metadata>(undefined);\r\n\r\n  public set article(value: Article) {\r\n    this._article = value;\r\n    if (this._article) {\r\n      this._buildFurnitureService.articleAssetPath = this._article.contentDeliveryUrl;\r\n    }\r\n    this.articleLoaded.next(this._article);\r\n  }\r\n\r\n  public get article(): Article {\r\n    return this._article;\r\n  }\r\n\r\n  public articleLoaded: BehaviorSubject<Article> = new BehaviorSubject<Article>(undefined);\r\n\r\n  private readonly _fullObjectCache: Map<string, Object3D> = new Map();\r\n  private _article: Article;\r\n  private _subs: Subscription[] = [];\r\n  private _shouldCopyFurniture = true;\r\n  private _configurationDirty: boolean = false;\r\n\r\n  constructor(\r\n    private _iOne: HomedecoratorConnectorService,\r\n    private _modelService: ModelsService,\r\n    private _threedSelectorService: ThreedselectorService,\r\n    private _messageBus: MessageBusService,\r\n    private _buildFurnitureService: BuildFurnitureService,\r\n    private _presetService: PresetsService,\r\n    private _dictionaryService: HomedecoratorDictionaryService,\r\n    private _settingsService: HomedecoratorSettingsService,\r\n    private _dialogService: DialogService,\r\n    private _errorService: ErrorService,\r\n    private _progressService: ProgressService,\r\n    private _itemService: ItemService\r\n  ) {\r\n    this._subs.push(\r\n      this._presetService.stateCreated.subscribe(() => this._saveConfiguration()),\r\n      this._itemService.removeAllItems.subscribe(() => this._cleanUp()),\r\n      this._messageBus.subscribe(\r\n        MessageType.ItemRemoved, (result: { item: any, addedToGroup: boolean }) => this._handleItemRemovedFromScene(result)),\r\n      this._messageBus.subscribe(MessageType.SavePreset, () => this._saveConfiguration()),\r\n      this._messageBus.subscribe(MessageType.RemoveItemFromScene, (instanceId: any) => this.deleteFromObjectList(instanceId)),\r\n      this._messageBus.subscribe(MessageType.ShouldCopyFurnitureFromPreset, shouldCopy => this._shouldCopyFurniture = shouldCopy)\r\n    );\r\n    this.configureButton = new CustomButton('Configureren', this.configureFurniture);\r\n    window.onbeforeunload = () => this.ngOnDestroy();\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 loadArticle(sku: string): Promise<Article> {\r\n    if (this.article && this.article.sku === sku) {\r\n      return this.article;\r\n    }\r\n    this.article = await this._iOne.getArticle(sku, this._settingsService.settings.branch);\r\n    return this.article;\r\n  }\r\n\r\n  public async loadFurniture(\r\n    furnitureData: Metadata,\r\n    shouldCopyInstance: boolean = false,\r\n    looseOriginalConfiguration: boolean = true,\r\n    standAlone: boolean = false,\r\n    fromScratch: boolean = false,\r\n    fromPreset: boolean = false\r\n  ): Promise<CustomFloorGroupResult> {\r\n    const result: CustomFloorGroupResult =\r\n      new CustomFloorGroupResult(\r\n        furnitureData.itemIdentifier, furnitureData.itemName ? furnitureData.itemName : furnitureData.itemIdentifier);\r\n\r\n    await this._tryLoadArticle(furnitureData, result).catch((e) => {\r\n      if (result.resultType === ResultType.Timeout) {\r\n        return Promise.reject(result);\r\n      }\r\n      if (result.metaData.externalSettings.externalSourceId === null || result.metaData.externalSettings.externalSourceId === undefined) {\r\n        result.errorMessages.push(new ErrorMessage(result.metaData.externalSettings.name + ' EXTERNAL_SOURCE_NOT_FOUND', ''));\r\n        result.resultType = ResultType.ExternalSourceNotAvailable;\r\n        return Promise.reject(result);\r\n      }\r\n      // no article found, we can continue if there is instanceId and modelUrl provided in metadata\r\n      if (!result.metaData || !result.metaData.modelUrl) {\r\n        // if (result.resultType !== ResultType.ConfigurationNotFixed) {\r\n        result.errorMessages.push(new ErrorMessage('ARTICLE_NOT_FOUND', 'ARTICLE_NOT_FOUND_DESC'));\r\n        result.resultType = ResultType.ArticleNotFound;\r\n        // }\r\n        return Promise.reject(result);\r\n      }\r\n    });\r\n\r\n    await this._initFull3DObject(result, fromPreset)\r\n      .catch((e) => {\r\n        if (!standAlone) {\r\n          return Promise.reject(result);\r\n        }\r\n      });\r\n\r\n    if (!result.metaData.configurable) { // simple 3d article, just load model\r\n      return this._buildFurnitureService.createSimple3DModel(result, standAlone);\r\n    } else {\r\n      this._modelService.addCustomButton(this.configureButton);\r\n      this._configurationDirty = true;\r\n      return this._buildFurnitureService.startToBuild(result, result.metaData, shouldCopyInstance, looseOriginalConfiguration, standAlone, true);\r\n    }\r\n  }\r\n\r\n  public async switchConfiguration(furniture: any): Promise<void> {\r\n    if (furniture) {\r\n      this._buildFurnitureService.full3DObjectToUse =\r\n        await this.getFull3DObject(furniture.metadata.itemIdentifier, furniture.metadata.itemId, furniture.metadata.assetPath);\r\n      furniture.configuring = true;\r\n    }\r\n  }\r\n\r\n  public configureFurniture = async (furniture: any) => {\r\n    this._messageBus.emit(MessageType.HideLeftSidebar);\r\n    this.switchConfiguration(furniture);\r\n  }\r\n\r\n  public deleteFromObjectList(id: string, useInstanceId: boolean = true): void {\r\n    if (id !== undefined) {\r\n      if (useInstanceId) {\r\n        this.objectList.splice(this.objectList.findIndex(c => c.instanceId === id), 1);\r\n      } else {\r\n        this.simpleObjectList.splice(this.simpleObjectList.findIndex(c => c.metaData.objectUUID === id), 1);\r\n      }\r\n    }\r\n  }\r\n\r\n  public addToList(list: CustomFloorGroupResult[], item: CustomFloorGroupResult): void {\r\n    if (!item || (!item.instanceId && !item.metaData.objectUUID)) {\r\n      return;\r\n    }\r\n    if ((item.instanceId && !list.find(l => l.instanceId === item.instanceId)) ||\r\n      (item.metaData.objectUUID && !list.find(l => l.metaData.objectUUID === item.metaData.objectUUID))) {\r\n      list.push(item);\r\n    }\r\n  }\r\n\r\n  private async _tryLoadArticle(furnitureData: Metadata, result: CustomFloorGroupResult): Promise<void> {\r\n    this.article = undefined;\r\n    const article = await this.loadArticle(furnitureData.itemIdentifier).catch((e) => {\r\n      if (e === 'ECONNABORTED') {\r\n        result.resultType = ResultType.Timeout;\r\n        return Promise.reject();\r\n      }\r\n    });\r\n    if (article) {\r\n      this.article = article;\r\n      this._extendMetadataWithArticleData(furnitureData, article, result);\r\n      return;\r\n    } else { // no article found\r\n      result.resultType = ResultType.ArticleNotFound;\r\n      result.metaData = furnitureData;\r\n      return Promise.reject();\r\n    }\r\n  }\r\n\r\n  private _extendMetadataWithArticleData(furnitureData: Metadata, article: Article, result: CustomFloorGroupResult): void {\r\n    furnitureData.resizable = false;\r\n    furnitureData.ione = true;\r\n    furnitureData.centerPivot = true;\r\n    furnitureData.ignoreInvisible = false;\r\n    furnitureData.modelUrl = article.assetUrl;\r\n    furnitureData.schema = article.distSchema ? article.distSchema : 'UP_DBA';\r\n    furnitureData.assetPath = article.contentDeliveryUrl;\r\n    furnitureData.itemType = itemTypeFromPlacement(article.placement);\r\n    furnitureData.canElevate = article.stackable;\r\n    furnitureData.configurable = article.goodType ? article.goodType.toLowerCase() === 'b' : true;\r\n    furnitureData.itemName = article.name;\r\n    furnitureData.goodId = article.id;\r\n    furnitureData.goodType = article.goodType;\r\n    // furnitureData.itemIdentifier = article.sku;\r\n    furnitureData.elevation = !furnitureData.elevation ? (article.defaultHeight ? article.defaultHeight / 100 : 0) : furnitureData.elevation;\r\n    furnitureData.elevationAdjustable = article.defaultHeightAdjustable;\r\n    furnitureData.elevationFixed = furnitureData.elevationFixed === true || article.defaultHeight ? true : !furnitureData.elevationAdjustable;\r\n    furnitureData.canRotateX = !isNill(article.canRotate) ? RotationHelper.CanRotateX(article.canRotate) : false;\r\n    furnitureData.canRotateY = !isNill(article.canRotate) ? RotationHelper.CanRotateY(article.canRotate) : true;\r\n    furnitureData.canRotateZ = !isNill(article.canRotate) ? RotationHelper.CanRotateZ(article.canRotate) : false;\r\n    furnitureData.default180 = !isNill(article.canRotate) ? RotationHelper.Default180(article.canRotate) : false;\r\n    result.metaData = furnitureData;\r\n    result.name = furnitureData.itemName;\r\n    this.metadataSet.next(result.metaData);\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    const hasUUID: boolean = !!result.item.metadata?.objectUUID;\r\n    if (result.item.userData && (result.item.userData.itemId || hasUUID)) {\r\n      this.deleteFromObjectList(hasUUID ? result.item.metadata.objectUUID : result.item.userData.itemId, !hasUUID);\r\n    }\r\n  }\r\n\r\n  private _saveConfiguration(): void {\r\n    if (this._configurationDirty) {\r\n      this._iOne.saveConfigurations();\r\n      this._configurationDirty = false;\r\n    }\r\n  }\r\n\r\n  private _cleanUp(): void {\r\n    this.notLoaded.length = 0;\r\n    this.notFixedObjectCache.length = 0;\r\n    this.obsoleteObjectCache.length = 0;\r\n    this.objectList.length = 0;\r\n    this.objectListFixed.length = 0;\r\n    const objs: Object3D[] = Array.from(this._fullObjectCache.values());\r\n    objs.forEach(o => Utils.DisposeObject(o));\r\n    this._fullObjectCache.clear();\r\n  }\r\n\r\n  private _needs3DModel(metaData: Metadata): boolean {\r\n    return !isFloorDecoration(metaData.itemType) && !isWallDecoration(metaData.itemType);\r\n  }\r\n\r\n  private async _initFull3DObject(result: CustomFloorGroupResult, fromPreset: boolean): Promise<void> {\r\n    const obj: Object3D = await this.getFull3DObject(\r\n      result.metaData.itemIdentifier, this._settingsService.settings.assetPath, result.metaData.itemName, result.metaData.modelUrl, !fromPreset)\r\n      .catch((e) => {\r\n        // this._errorService.addError(md.itemId, e);\r\n        if (this._settingsService.settings.options.onlyThreeD && this._needs3DModel(result.metaData)) {\r\n          result.errorMessages.push(e);\r\n          result.resultType = ResultType.No3DModel;\r\n          return Promise.reject(result);\r\n        }\r\n      });\r\n    if (obj === null) {\r\n      if (this._settingsService.settings.options.onlyThreeD && this._needs3DModel(result.metaData)) {\r\n        result.resultType = ResultType.No3DModel;\r\n        return Promise.reject(result);\r\n      } else {\r\n        return Promise.resolve();\r\n      }\r\n    }\r\n\r\n    const fullObj: Object3D = obj.clone();\r\n    this._buildFurnitureService.full3DObjectToUse = fullObj;\r\n    return;\r\n  }\r\n\r\n  public getFull3DObject(\r\n    sku: string,\r\n    assetPath: string,\r\n    name?: string,\r\n    assetUrl?: string,\r\n    prepareProgress: boolean = false\r\n  ): Promise<Object3D> {\r\n    if (this._fullObjectCache.has(sku)) {\r\n      return Promise.resolve(this._fullObjectCache.get(sku));\r\n    } else if (assetUrl) {\r\n      // const fileName: string = assetUrl.substr(0, assetUrl.lastIndexOf('.')).replace('.unity3d', '');\r\n      const fileName: string = assetUrl.replace('.unity3d', '');\r\n      return this._threedSelectorService.downloadAssetsAndReturn(fileName, assetPath, prepareProgress)\r\n        .then(\r\n          res => {\r\n            const obj: Object3D = res;\r\n            obj.name = name;\r\n            // obj.scale.set(100, 100, 100);\r\n            this._fullObjectCache.set(sku, obj);\r\n            return obj;\r\n          },\r\n          err => {\r\n            return Promise.reject(new ErrorMessage('THREED_MODEL_NOT_FOUND', err));\r\n          }\r\n        );\r\n      // }\r\n    } else {\r\n      return Promise.resolve(null);\r\n    }\r\n  }\r\n\r\n}\r\n"]}

package/esm2015/app/plugins/threedselector/threedselector/service/resize.service.js

@@ -0,0 +1,70 @@
+import { Injectable } from '@angular/core';
+import { Mesh, Vector3 } from 'three';
+import * as BufferGeometryUtils from 'three/examples/jsm/utils/BufferGeometryUtils';
+import { ObjectUtils } from '../../../../core/utils/object.utils';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../core3d/service/scene.service";
+export class ResizeService {
+    constructor(_sceneService) {
+        this._sceneService = _sceneService;
+    }
+    dragConnectorToNewPosition(connector, pos) {
+        if (!connector) {
+            return;
+        }
+        const parent = connector.parent;
+        const repeat = connector.name && connector.name.match(/rep_.*x/) !== null;
+        this._sceneService.scene.attach(connector);
+        connector.position.x = pos.x;
+        // connector.position.z = pos.z;
+        parent.attach(connector);
+        this._repositionChildren(connector);
+        this._sceneService.needsRender = true;
+    }
+    resizeElement(connector, parent) {
+        if (parent) {
+            for (let i = 0; i < parent.children.length; i++) {
+                const child = parent.children[i];
+                if (child instanceof Mesh && !child.name.toLowerCase().startsWith('c_')) { // it's a mesh, resize it
+                    if (!child.originalGeo) {
+                        child.originalGeo = child.geometry.clone();
+                    }
+                    const geo = child.originalGeo.clone();
+                    child.geometry.computeBoundingBox();
+                    geo.translate(child.geometry.boundingBox.max.x - child.geometry.boundingBox.min.x, 0, 0); // extend over x-axis
+                    // geo.translate(0, child.geometry.boundingBox.max.y - child.geometry.boundingBox.min.y, 0); // extend over y-axis
+                    child.geometry = BufferGeometryUtils.mergeGeometries([child.geometry, geo]);
+                    child.geometry.computeBoundingBox();
+                }
+            }
+        }
+        this._sceneService.needsRender = true;
+    }
+    _repositionChildren(connector) {
+        // @ts-ignore
+        const parentItem = ObjectUtils.GetParentItem(connector);
+        const connectorParent = connector.parent;
+        const connectedObject = connector.connectedTo ? parentItem.getObjectByName(connector.connectedTo) : undefined;
+        const worldPosConnector = new Vector3();
+        connector.getWorldPosition(worldPosConnector);
+        if (connectedObject) { // object is connected, find opposite connector and reposition
+            const male = connector.name.toLowerCase().indexOf('m') > -1;
+            const oppositeConnector = connectedObject.children.find(c => c.name.toLowerCase().indexOf(male ? 'f' : 'm') > -1);
+            if (oppositeConnector) {
+                this._sceneService.scene.attach(oppositeConnector);
+                oppositeConnector.position.x = worldPosConnector.x;
+                oppositeConnector.position.z = worldPosConnector.z;
+                connectedObject.attach(oppositeConnector);
+            }
+        }
+    }
+}
+ResizeService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ResizeService, deps: [{ token: i1.SceneService }], target: i0.ɵɵFactoryTarget.Injectable });
+ResizeService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ResizeService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ResizeService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.SceneService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"resize.service.js","sourceRoot":"","sources":["../../../../../../../../src/client/app/plugins/threedselector/threedselector/service/resize.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injectable} from '@angular/core';\r\nimport {Mesh, Object3D, Vector3} from 'three';\r\nimport * as BufferGeometryUtils from 'three/examples/jsm/utils/BufferGeometryUtils';\r\nimport {SceneService} from '../../../core3d/service/scene.service';\r\nimport {CustomFloorItem} from '../../../core3d/items/custom-floor-item';\r\nimport {CustomMesh} from '../../../core3d/items/custom-objects';\r\nimport {ObjectUtils} from '../../../../core/utils/object.utils';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class ResizeService {\r\n\r\n  constructor(\r\n    private _sceneService: SceneService\r\n  ) {\r\n  }\r\n\r\n  public dragConnectorToNewPosition(connector: CustomMesh, pos: Vector3): void {\r\n    if (!connector) {\r\n      return;\r\n    }\r\n    const parent: Object3D = connector.parent;\r\n    const repeat: boolean = connector.name && connector.name.match(/rep_.*x/) !== null;\r\n\r\n    this._sceneService.scene.attach(connector);\r\n    connector.position.x = pos.x;\r\n    // connector.position.z = pos.z;\r\n    parent.attach(connector);\r\n\r\n    this._repositionChildren(connector);\r\n\r\n    this._sceneService.needsRender = true;\r\n  }\r\n\r\n  public resizeElement(connector: string, parent: Object3D): void {\r\n    if (parent) {\r\n      for (let i: number = 0; i < parent.children.length; i++) {\r\n        const child = parent.children[i];\r\n        if (child instanceof Mesh && !child.name.toLowerCase().startsWith('c_')) { // it's a mesh, resize it\r\n          if (!(child as any).originalGeo) {\r\n            (child as any).originalGeo = child.geometry.clone();\r\n          }\r\n          const geo = (child as any).originalGeo.clone();\r\n          child.geometry.computeBoundingBox();\r\n          geo.translate(child.geometry.boundingBox.max.x - child.geometry.boundingBox.min.x, 0, 0); // extend over x-axis\r\n          // geo.translate(0, child.geometry.boundingBox.max.y - child.geometry.boundingBox.min.y, 0); // extend over y-axis\r\n          child.geometry = BufferGeometryUtils.mergeGeometries([child.geometry, geo]);\r\n          child.geometry.computeBoundingBox();\r\n        }\r\n      }\r\n    }\r\n    this._sceneService.needsRender = true;\r\n  }\r\n\r\n  private _repositionChildren(connector: CustomMesh): void {\r\n    // @ts-ignore\r\n    const parentItem: CustomFloorItem = ObjectUtils.GetParentItem(connector);\r\n    const connectorParent: Object3D = connector.parent;\r\n    const connectedObject: Object3D = connector.connectedTo ? parentItem.getObjectByName(connector.connectedTo) : undefined;\r\n    const worldPosConnector: Vector3 = new Vector3();\r\n    connector.getWorldPosition(worldPosConnector);\r\n\r\n    if (connectedObject) { // object is connected, find opposite connector and reposition\r\n      const male: boolean = connector.name.toLowerCase().indexOf('m') > -1;\r\n      const oppositeConnector = connectedObject.children.find(c => c.name.toLowerCase().indexOf(male ? 'f' : 'm') > -1);\r\n      if (oppositeConnector) {\r\n        this._sceneService.scene.attach(oppositeConnector);\r\n        oppositeConnector.position.x = worldPosConnector.x;\r\n        oppositeConnector.position.z = worldPosConnector.z;\r\n        connectedObject.attach(oppositeConnector);\r\n      }\r\n    }\r\n  }\r\n\r\n}\r\n"]}