@colijnit/homedecorator 255.1.1

package/esm2015/app/core/service/item-serialization.service.js

@@ -0,0 +1,188 @@
+import { Injectable } from '@angular/core';
+import { InWallItem, WallItem } from '../../plugins/core3d/items/wall-objects';
+import { ItemGroup } from '../../plugins/core3d/items/item-group';
+import { CylinderFaces, BoxGeometryFaces as BoxFaces, Face } from '../../plugins/core3d/model/face';
+import { ItemType } from '../../plugins/core3d/items/item-type';
+import * as i0 from "@angular/core";
+export class ItemSerializationService {
+    constructor() { }
+    itemToObject(item) {
+        const texture = item instanceof WallItem ? item.getTexture() : null;
+        const opening = item instanceof InWallItem ? item.opening : null;
+        const returnObj = {
+            item_name: item.metadata.itemName,
+            item_description: item.metadata.itemDescription,
+            item_type: item.metadata.itemType,
+            model_url: item.metadata.modelUrl,
+            ione: item.metadata.ione,
+            configurable: item.metadata.configurable,
+            locked: item.locked,
+            texture,
+            width: texture || item.isCustom ? item.getWidth() : undefined,
+            height: texture || item.isCustom ? item.getHeight() : undefined,
+            xpos: item.position.x,
+            ypos: item.position.y,
+            zpos: item.position.z,
+            rotation: item.rotation.y,
+            fixed: item.fixed,
+            decos: item.metadata.decos,
+            selections: item.metadata.selections ? item.metadata.selections.slice(0) : [],
+            externalSettings: item.metadata.externalSettings,
+            opening
+        };
+        if (item instanceof InWallItem && item.isCustom) {
+            returnObj.frameColor = item.frameColor;
+            returnObj.doorColor = item.doorColor;
+            returnObj.windowColor = item.windowColor;
+            returnObj.isGlass = item.isGlass;
+        }
+        return returnObj;
+    }
+    furnitureToObject(furniture) {
+        if (furniture instanceof ItemGroup) {
+            return this._serializeItemGroup(furniture);
+        }
+        else {
+            return this._serializeItem(furniture);
+        }
+    }
+    _serializeItem(object) {
+        if (!object.metadata) {
+            return;
+        }
+        switch (object.metadata.itemType) {
+            case ItemType.CustomShape:
+            case ItemType.CustomShapeWall: {
+                return this._buildCustomShapeRecord(object);
+            }
+            case ItemType.CustomCylinder:
+            case ItemType.CustomCylinderWall: {
+                return this._buildCustomCylinderRecord(object);
+            }
+            default: {
+                return this._buildItemRecord(object);
+            }
+        }
+    }
+    _serializeItemGroup(item) {
+        const children = item.children.map(object => {
+            return this._serializeItem(object);
+        });
+        const serializedGroup = this._buildItemRecord(item);
+        return Object.assign(Object.assign({}, serializedGroup), { children: children });
+    }
+    _buildCustomShapeRecord(shape) {
+        return {
+            item_name: shape.metadata && shape.metadata.itemName,
+            item_type: shape.metadata && shape.metadata.itemType,
+            locked: shape.locked,
+            xpos: shape.position.x,
+            ypos: shape.position.y,
+            zpos: shape.position.z,
+            rotation: shape.rotation.y,
+            height: shape.getHeight(),
+            width: shape.getWidth(),
+            depth: shape.getDepth(),
+            elevation: shape.elevation,
+            canElevate: shape.canElevate,
+            skin: this._prepareShapeSkin(shape.skin, BoxFaces),
+            fixed: shape.fixed
+        };
+    }
+    _buildCustomCylinderRecord(shape) {
+        if (shape.metadata.itemType === 14) {
+            return {
+                item_name: shape.metadata && shape.metadata.itemName,
+                item_type: shape.metadata && shape.metadata.itemType,
+                locked: shape.locked,
+                xpos: shape.position.x,
+                ypos: shape.position.y,
+                zpos: shape.position.z,
+                rotation: shape.rotation.y,
+                height: shape.getHeight(),
+                radius: shape.radius,
+                elevation: shape.elevation,
+                canElevate: shape.canElevate,
+                skin: this._prepareShapeSkin(shape.skin, CylinderFaces),
+                fixed: shape.fixed
+            };
+        }
+        else {
+            return {
+                item_name: shape.metadata && shape.metadata.itemName,
+                item_type: shape.metadata && shape.metadata.itemType,
+                locked: shape.locked,
+                xpos: shape.position.x,
+                ypos: shape.position.y,
+                zpos: shape.position.z,
+                rotation: shape.rotation.y,
+                height: shape.getDepth(),
+                radius: shape.radius,
+                elevation: shape.elevation,
+                canElevate: shape.canElevate,
+                skin: this._prepareShapeSkin(shape.skin, CylinderFaces),
+                fixed: shape.fixed
+            };
+        }
+    }
+    _buildItemRecord(item) {
+        const childParams = item.childParams;
+        const scale = childParams && childParams.scale || item.scale;
+        return {
+            item_name: item.metadata && item.metadata.itemName,
+            item_description: item.metadata && item.metadata.itemDescription,
+            item_type: item.userData.itemType,
+            item_id: item.metadata && (item.metadata.originalItemId ? item.metadata.originalItemId : item.metadata.itemId),
+            item_identifier: item.metadata && item.metadata.itemIdentifier,
+            item_goodId: item.metadata && item.metadata.goodId,
+            item_goodType: item.metadata && item.metadata.goodType,
+            locked: item.locked,
+            item_schema: item.metadata && item.metadata.schema,
+            item_assetPath: item.metadata && item.metadata.assetPath,
+            model_url: item.metadata && item.metadata.modelUrl,
+            configurable: item.metadata && item.metadata.configurable,
+            ione: item.metadata && item.metadata.ione,
+            elementConfiguration: item.metadata && item.metadata.elementConfiguration,
+            xpos: item.position.x,
+            ypos: item.position.y,
+            zpos: item.position.z,
+            scalable: item.scalable,
+            scalePercentage: item.scale.x * 100,
+            onWall: item.onWall,
+            rotation: item.rotation.y,
+            fixed: item.fixed,
+            center_pivot: item.centerPivot,
+            elevation: item.elevation,
+            elevationFixed: item.elevationFixed,
+            elevationAdjustable: item.elevationAdjustable,
+            decos: item.metadata.decos,
+            selections: item.metadata.selections ? item.metadata.selections.slice(0) : [],
+            externalSettings: item.metadata.externalSettings,
+            conversionGTMSend: item.metadata.conversionGTMSend,
+            conversionSubmittedPrice: item.metadata.conversionSubmittedPrice
+        };
+    }
+    _prepareShapeSkin(shapeSkin, faces) {
+        const skin = JSON.parse(JSON.stringify(shapeSkin));
+        if (!skin.hasOwnProperty(Face.All)) {
+            skin[Face.All] = { texture: null };
+        }
+        for (let i = 0, f = faces[i]; i < faces.length; ++i, f = faces[i]) {
+            if (skin[f].texture) {
+                if (skin[Face.All].texture && skin[f].texture.data === skin[Face.All].texture.data) {
+                    skin[f].texture.data = '<<all>>';
+                }
+            }
+        }
+        return skin;
+    }
+}
+ItemSerializationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ItemSerializationService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+ItemSerializationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ItemSerializationService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ItemSerializationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"item-serialization.service.js","sourceRoot":"","sources":["../../../../../../src/client/app/core/service/item-serialization.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injectable} from '@angular/core';\r\nimport {InWallItem, WallItem} from '../../plugins/core3d/items/wall-objects';\r\nimport {Item} from '../../plugins/core3d/items/item';\r\nimport {ItemGroup} from '../../plugins/core3d/items/item-group';\r\nimport {CylinderFaces, BoxGeometryFaces as BoxFaces, Face} from '../../plugins/core3d/model/face';\r\nimport {Skin} from '../../plugins/core3d/model/skin';\r\nimport {Furniture} from '../../plugins/core3d/items/furniture';\r\nimport {ItemType} from '../../plugins/core3d/items/item-type';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class ItemSerializationService {\r\n\r\n  constructor() { }\r\n\r\n  public itemToObject(item: Item) {\r\n    const texture = item instanceof WallItem ? (item as WallItem).getTexture() : null;\r\n    const opening = item instanceof InWallItem ? (item as InWallItem).opening : null;\r\n    const returnObj: {} = {\r\n      item_name: item.metadata.itemName,\r\n      item_description: item.metadata.itemDescription,\r\n      item_type: item.metadata.itemType,\r\n      model_url: item.metadata.modelUrl,\r\n      ione: item.metadata.ione,\r\n      configurable: item.metadata.configurable,\r\n      locked: item.locked,\r\n      texture,\r\n      width: texture || item.isCustom ? item.getWidth() : undefined,\r\n      height: texture || item.isCustom ? item.getHeight() : undefined,\r\n      xpos: item.position.x,\r\n      ypos: item.position.y,\r\n      zpos: item.position.z,\r\n      rotation: item.rotation.y,\r\n      fixed: item.fixed,\r\n      decos: item.metadata.decos,\r\n      selections: item.metadata.selections ? item.metadata.selections.slice(0) : [],\r\n      externalSettings: item.metadata.externalSettings,\r\n      opening\r\n    };\r\n    if (item instanceof InWallItem && item.isCustom) {\r\n      (returnObj as any).frameColor = item.frameColor;\r\n      (returnObj as any).doorColor = item.doorColor;\r\n      (returnObj as any).windowColor = item.windowColor;\r\n      (returnObj as any).isGlass = item.isGlass;\r\n    }\r\n\r\n    return returnObj;\r\n  }\r\n\r\n  public furnitureToObject(furniture: Furniture) {\r\n    if (furniture instanceof ItemGroup) {\r\n      return this._serializeItemGroup(furniture);\r\n    } else {\r\n      return this._serializeItem(furniture);\r\n    }\r\n  }\r\n\r\n  private _serializeItem(object: Item) {\r\n    if (!object.metadata) {\r\n      return;\r\n    }\r\n    switch (object.metadata.itemType) {\r\n      case ItemType.CustomShape:\r\n      case ItemType.CustomShapeWall: {\r\n        return this._buildCustomShapeRecord(object);\r\n      }\r\n      case ItemType.CustomCylinder:\r\n      case ItemType.CustomCylinderWall: {\r\n        return this._buildCustomCylinderRecord(object);\r\n      }\r\n      default: {\r\n        return this._buildItemRecord(object);\r\n      }\r\n    }\r\n  }\r\n\r\n  private _serializeItemGroup(item) {\r\n    const children = item.children.map(object => {\r\n      return this._serializeItem(object);\r\n    });\r\n    const serializedGroup = this._buildItemRecord(item);\r\n    return {...serializedGroup, children: children};\r\n  }\r\n\r\n  private _buildCustomShapeRecord(shape) {\r\n    return {\r\n      item_name: shape.metadata && shape.metadata.itemName,\r\n      item_type: shape.metadata && shape.metadata.itemType,\r\n      locked: shape.locked,\r\n\r\n      xpos: shape.position.x,\r\n      ypos: shape.position.y,\r\n      zpos: shape.position.z,\r\n\r\n      rotation: shape.rotation.y,\r\n\r\n      height: shape.getHeight(),\r\n      width: shape.getWidth(),\r\n      depth: shape.getDepth(),\r\n      elevation: shape.elevation,\r\n      canElevate: shape.canElevate,\r\n\r\n      skin: this._prepareShapeSkin(shape.skin, BoxFaces),\r\n\r\n      fixed: shape.fixed\r\n    };\r\n  }\r\n\r\n  private _buildCustomCylinderRecord(shape) {\r\n    if (shape.metadata.itemType === 14) {\r\n      return {\r\n        item_name: shape.metadata && shape.metadata.itemName,\r\n        item_type: shape.metadata && shape.metadata.itemType,\r\n        locked: shape.locked,\r\n\r\n        xpos: shape.position.x,\r\n        ypos: shape.position.y,\r\n        zpos: shape.position.z,\r\n\r\n        rotation: shape.rotation.y,\r\n\r\n        height: shape.getHeight(),\r\n        radius: shape.radius,\r\n        elevation: shape.elevation,\r\n        canElevate: shape.canElevate,\r\n\r\n        skin: this._prepareShapeSkin(shape.skin, CylinderFaces),\r\n        fixed: shape.fixed\r\n      };\r\n    } else {\r\n      return {\r\n        item_name: shape.metadata && shape.metadata.itemName,\r\n        item_type: shape.metadata && shape.metadata.itemType,\r\n        locked: shape.locked,\r\n\r\n        xpos: shape.position.x,\r\n        ypos: shape.position.y,\r\n        zpos: shape.position.z,\r\n\r\n        rotation: shape.rotation.y,\r\n\r\n        height: shape.getDepth(),\r\n        radius: shape.radius,\r\n        elevation: shape.elevation,\r\n        canElevate: shape.canElevate,\r\n\r\n        skin: this._prepareShapeSkin(shape.skin, CylinderFaces),\r\n        fixed: shape.fixed\r\n      };\r\n    }\r\n  }\r\n\r\n  private _buildItemRecord(item) {\r\n    const childParams = item.childParams;\r\n    const scale = childParams && childParams.scale || item.scale;\r\n    return {\r\n      item_name: item.metadata && item.metadata.itemName,\r\n      item_description: item.metadata && item.metadata.itemDescription,\r\n\r\n      item_type: item.userData.itemType,\r\n      item_id: item.metadata && (item.metadata.originalItemId ? item.metadata.originalItemId : item.metadata.itemId),\r\n      item_identifier: item.metadata && item.metadata.itemIdentifier,\r\n      item_goodId: item.metadata && item.metadata.goodId,\r\n      item_goodType: item.metadata && item.metadata.goodType,\r\n      locked: item.locked,\r\n\r\n      item_schema: item.metadata && item.metadata.schema,\r\n      item_assetPath: item.metadata && item.metadata.assetPath,\r\n      model_url: item.metadata && item.metadata.modelUrl,\r\n      configurable: item.metadata && item.metadata.configurable,\r\n      ione: item.metadata && item.metadata.ione,\r\n      elementConfiguration: item.metadata && item.metadata.elementConfiguration,\r\n\r\n      xpos: item.position.x,\r\n      ypos: item.position.y,\r\n      zpos: item.position.z,\r\n\r\n      scalable: item.scalable,\r\n      scalePercentage: item.scale.x * 100,\r\n      onWall: item.onWall,\r\n\r\n      rotation: item.rotation.y,\r\n\r\n      fixed: item.fixed,\r\n      center_pivot: item.centerPivot,\r\n      elevation: item.elevation,\r\n      elevationFixed: item.elevationFixed,\r\n      elevationAdjustable: item.elevationAdjustable,\r\n\r\n      decos: item.metadata.decos,\r\n      selections: item.metadata.selections ? item.metadata.selections.slice(0) : [],\r\n      externalSettings: item.metadata.externalSettings,\r\n      conversionGTMSend: item.metadata.conversionGTMSend,\r\n      conversionSubmittedPrice: item.metadata.conversionSubmittedPrice\r\n    };\r\n  }\r\n\r\n  private _prepareShapeSkin(shapeSkin: Skin, faces: Face[]): Skin {\r\n    const skin: Skin = JSON.parse(JSON.stringify(shapeSkin));\r\n    if (!skin.hasOwnProperty(Face.All)) {\r\n      skin[Face.All] = {texture: null};\r\n    }\r\n    for (let i = 0, f = faces[i]; i < faces.length; ++i, f = faces[i]) {\r\n      if (skin[f].texture) {\r\n        if (skin[Face.All].texture && skin[f].texture.data === skin[Face.All].texture.data) {\r\n          skin[f].texture.data = '<<all>>';\r\n        }\r\n      }\r\n    }\r\n    return skin;\r\n  }\r\n}\r\n"]}

package/esm2015/app/core/service/json-utils.service.js

@@ -0,0 +1,56 @@
+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 * as i0 from "@angular/core";
+export class JsonUtilsService {
+    readJsonFile(filePath, includeBaseUrl = true) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    filePath = includeBaseUrl ? this._includeBaseUrl(filePath) : filePath;
+                    const response = yield fetch(filePath);
+                    if (!response.ok) {
+                        reject();
+                    }
+                    else {
+                        let empty = false;
+                        yield response.clone().text().then((value) => {
+                            if (value === '') {
+                                empty = true;
+                            }
+                        });
+                        resolve(empty ? {} : response.json());
+                    }
+                }
+                catch (e) {
+                    reject();
+                }
+            }));
+        });
+    }
+    _includeBaseUrl(url) {
+        if (url[0] === '.') {
+            url = url.replace('.', '');
+        }
+        if (url[0] === '/') {
+            url = url.replace('/', '');
+        }
+        return './' + url;
+    }
+}
+JsonUtilsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: JsonUtilsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+JsonUtilsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: JsonUtilsService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: JsonUtilsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/app/core/service/message-bus.service.js

@@ -0,0 +1,28 @@
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import { MessageType } from '../enum/message-type.enum';
+import * as i0 from "@angular/core";
+export class MessageBusService {
+    constructor() {
+        this.emitters = new Map();
+        const messageTypes = Object.keys(MessageType)
+            .filter((t) => typeof t === 'string')
+            .map((t) => MessageType[t]);
+        messageTypes.forEach((msgType) => this.emitters.set(msgType, new Subject()));
+    }
+    emit(type, payload) {
+        this.emitters.get(type).next(payload);
+    }
+    subscribe(messageType, observer) {
+        return this.emitters.get(messageType).subscribe(observer);
+    }
+}
+MessageBusService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MessageBusService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+MessageBusService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MessageBusService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MessageBusService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/app/core/service/permanent-store.service.js

@@ -0,0 +1,135 @@
+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 { Observable, Subject } from 'rxjs';
+import { Injectable } from '@angular/core';
+import { HttpHeaders } from '@angular/common/http';
+import axios from 'axios';
+import { MessageType } from '../enum/message-type.enum';
+import * as i0 from "@angular/core";
+import * as i1 from "./message-bus.service";
+import * as i2 from "@angular/common/http";
+import * as i3 from "./environment.service";
+import * as i4 from "./homedecorator-settings.service";
+export class PermanentStoreService {
+    constructor(messageService, _http, _configuration, _settingsService) {
+        this._http = _http;
+        this._configuration = _configuration;
+        this._settingsService = _settingsService;
+        this._isLoading = false;
+        this._subs = [];
+        // Max processable size of schema [approx < 16mib = 16777216b to avoid edge cases]
+        this.maxSchemaSize = 16770000;
+        this.showLocalSave = false;
+        this.codeSet = new Subject();
+        this.create = (json) => {
+            return this._http.post(`${this._settingsService.settings.apiUrl ? this._settingsService.settings.apiUrl : this._configuration.apiUrl}/api/roomPlan`, json, { headers: this._httpHeaders });
+        };
+        this.update = (json, code) => {
+            return this._http.put(`${this._settingsService.settings.apiUrl ? this._settingsService.settings.apiUrl : this._configuration.apiUrl}/api/roomPlan/${code}`, json, { headers: this._httpHeaders });
+        };
+        this._httpHeaders = new HttpHeaders({
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${_configuration.jwtToken}`,
+        });
+        this._subs.push(messageService.subscribe(MessageType.ResetRoomplan, () => {
+            if (!this._isLoading) {
+                this.code = null;
+            }
+        }));
+    }
+    static randomNumericChar() {
+        return `${Math.trunc(Math.random() * 10)}`;
+    }
+    ngOnDestroy() {
+        this._subs.forEach(s => s.unsubscribe());
+    }
+    set code(value) {
+        this._code = value;
+        this.codeSet.next(this._code);
+    }
+    get code() {
+        return this._code;
+    }
+    queryCode(code) {
+        return this._http.get(`${this._settingsService.settings.apiUrl ? this._settingsService.settings.apiUrl : this._configuration.apiUrl}/api/roomPlan/${code}`, { headers: this._httpHeaders });
+    }
+    load(code) {
+        this.code = null; // discard current code
+        return Observable.create(obs => {
+            this.queryCode(code).subscribe(storedPlan => {
+                this.code = storedPlan.code;
+                this._isLoading = true;
+                obs.next(storedPlan.json);
+                this._isLoading = false;
+            }, error => obs.error(error));
+        });
+    }
+    save(json, forceNewCode = false) {
+        const saveFn = (!this.code || forceNewCode)
+            ? this.create
+            : this.update;
+        return new Observable(obs => {
+            saveFn(json, this.code).subscribe(storedPlan => {
+                this._originalProjectCode = !this.code ? '' : this.code;
+                this.code = storedPlan.code;
+                this.updateRegisterForm(this._getFurniture(typeof storedPlan.json === 'string' ? JSON.parse(storedPlan.json) : storedPlan.json));
+                obs.next(this.code);
+            }, error => {
+                obs.error(error);
+            });
+        });
+    }
+    get registerFormID() {
+        return this._registerFormID;
+    }
+    set registerFormID(value) {
+        this._registerFormID = value;
+    }
+    updateRegisterForm(furniture) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const collectiveSheetKey = '13V6FBPWbICfjonrtAEReucHkE61ijWRmau806u5EGZs';
+            const collectiveSheetScriptURL = 'https://script.google.com/macros/s/AKfycbwtgNNj0PjBPdNiiYgKtYAAUVFu1GwKzMkwMFnEDm7Va-QiYdc/exec';
+            const customSheetScriptURL = 'https://script.google.com/macros/s/AKfycby-iJ_RdsdeCZ3TJN_qEMiv_DGhetyFMFIeNJGqvi-jQmDA2NBuSWFI-wmF-NtNQDLL/exec';
+            const sheetKey = this._settingsService.settings.spreadsheetSheetKey ? this._settingsService.settings.spreadsheetSheetKey : collectiveSheetKey;
+            const postUrl = customSheetScriptURL;
+            const hostUrl = (window.location !== window.parent.location) ? document.referrer : document.location.href;
+            const payLoad = this.registerFormID ?
+                { 'registerID': this.registerFormID, 'sheetKey': sheetKey, 'Code': this.code, 'InitCode': this._originalProjectCode, 'Furniture': JSON.stringify(furniture) } :
+                { 'sheetKey': sheetKey, 'Code': this.code, 'InitCode': this._originalProjectCode, 'URL': hostUrl, 'Furniture': JSON.stringify(furniture) };
+            axios({
+                method: 'post',
+                url: postUrl,
+                params: payLoad
+            }).then(response => {
+                if (response.data.result === 'success') {
+                    this.registerFormID = null;
+                }
+            }).catch(error => {
+                console.error(error);
+            });
+        });
+    }
+    _getFurniture(j) {
+        const temp = [];
+        for (let i = 0; i < j.furniture.length; i++) {
+            temp.push(j.furniture[i]['item_name']);
+        }
+        return temp;
+    }
+}
+PermanentStoreService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: PermanentStoreService, deps: [{ token: i1.MessageBusService }, { token: i2.HttpClient }, { token: i3.EnvironmentService }, { token: i4.HomedecoratorSettingsService }], target: i0.ɵɵFactoryTarget.Injectable });
+PermanentStoreService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: PermanentStoreService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: PermanentStoreService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.MessageBusService }, { type: i2.HttpClient }, { type: i3.EnvironmentService }, { type: i4.HomedecoratorSettingsService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"permanent-store.service.js","sourceRoot":"","sources":["../../../../../../src/client/app/core/service/permanent-store.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Observable, Subject, Subscription} from 'rxjs';\r\nimport {Injectable, OnDestroy} from '@angular/core';\r\nimport {HttpClient, HttpHeaders} from '@angular/common/http';\r\nimport {EnvironmentService} from './environment.service';\r\nimport axios from 'axios';\r\nimport {MessageBusService} from './message-bus.service';\r\nimport {HomedecoratorSettingsService} from './homedecorator-settings.service';\r\nimport {MessageType} from '../enum/message-type.enum';\r\n\r\ninterface StoredPlan {\r\n  code: string;\r\n  json: string;\r\n}\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class PermanentStoreService implements OnDestroy {\r\n\r\n  private _httpHeaders: HttpHeaders;\r\n  private _code: string;\r\n  private _originalProjectCode: string;\r\n  private _registerFormID: number;\r\n  private _isLoading = false;\r\n\r\n  private _subs: Subscription[] = [];\r\n\r\n  // Max processable size of schema [approx < 16mib = 16777216b to avoid edge cases]\r\n  public readonly maxSchemaSize = 16770000;\r\n\r\n  public showLocalSave: boolean = false;\r\n\r\n  public codeSet: Subject<string> = new Subject<string>();\r\n\r\n  static randomNumericChar(): string {\r\n    return `${Math.trunc(Math.random() * 10)}`;\r\n  }\r\n\r\n  constructor (\r\n    messageService: MessageBusService,\r\n    private _http: HttpClient,\r\n    private _configuration: EnvironmentService,\r\n    private _settingsService: HomedecoratorSettingsService\r\n  ) {\r\n    this._httpHeaders = new HttpHeaders({\r\n      'Content-Type': 'application/json',\r\n      'Authorization': `Bearer ${_configuration.jwtToken}`,\r\n    });\r\n    this._subs.push(messageService.subscribe(MessageType.ResetRoomplan, () => {\r\n      if (!this._isLoading) {\r\n        this.code = null;\r\n      }\r\n    }));\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    this._subs.forEach(s => s.unsubscribe());\r\n  }\r\n\r\n  public set code(value: string) {\r\n    this._code = value;\r\n    this.codeSet.next(this._code);\r\n  }\r\n\r\n  public get code(): string {\r\n    return this._code;\r\n  }\r\n\r\n  private queryCode(code: string): Observable<StoredPlan> {\r\n    return this._http.get<StoredPlan>(\r\n      `${this._settingsService.settings.apiUrl ? this._settingsService.settings.apiUrl : this._configuration.apiUrl}/api/roomPlan/${code}`,\r\n      { headers: this._httpHeaders }\r\n    );\r\n  }\r\n\r\n  public load(code: string): Observable<string> {\r\n    this.code = null; // discard current code\r\n    return Observable.create(obs => {\r\n      this.queryCode(code).subscribe(\r\n        storedPlan => {\r\n          this.code = storedPlan.code;\r\n          this._isLoading = true;\r\n          obs.next(storedPlan.json);\r\n          this._isLoading = false;\r\n        },\r\n        error => obs.error(error)\r\n      );\r\n    });\r\n  }\r\n\r\n  private create = (json: string): Observable<StoredPlan> => {\r\n    return this._http.post<StoredPlan>(\r\n      `${this._settingsService.settings.apiUrl ? this._settingsService.settings.apiUrl : this._configuration.apiUrl}/api/roomPlan`,\r\n      json,\r\n      { headers: this._httpHeaders }\r\n    );\r\n  }\r\n\r\n  private update = (json: string, code: string): Observable<StoredPlan> => {\r\n    return this._http.put<StoredPlan>(\r\n      `${this._settingsService.settings.apiUrl ? this._settingsService.settings.apiUrl : this._configuration.apiUrl}/api/roomPlan/${code}`,\r\n      json,\r\n      { headers: this._httpHeaders }\r\n    );\r\n  }\r\n\r\n  public save(json: string, forceNewCode = false): Observable<string> {\r\n    const saveFn = (!this.code || forceNewCode)\r\n      ? this.create\r\n      : this.update;\r\n    return new Observable(obs => {\r\n      saveFn(json, this.code).subscribe(\r\n        storedPlan => {\r\n          this._originalProjectCode = !this.code ? '' : this.code;\r\n          this.code = storedPlan.code;\r\n          this.updateRegisterForm(this._getFurniture(typeof storedPlan.json === 'string' ? JSON.parse(storedPlan.json) : storedPlan.json));\r\n          obs.next(this.code);\r\n        },\r\n        error => {\r\n          obs.error(error);\r\n        });\r\n    });\r\n  }\r\n\r\n  get registerFormID(): number {\r\n    return this._registerFormID;\r\n  }\r\n\r\n  set registerFormID(value: number) {\r\n    this._registerFormID = value;\r\n  }\r\n\r\n  public async updateRegisterForm(furniture: any) {\r\n    const collectiveSheetKey: string = '13V6FBPWbICfjonrtAEReucHkE61ijWRmau806u5EGZs';\r\n    const collectiveSheetScriptURL: string = 'https://script.google.com/macros/s/AKfycbwtgNNj0PjBPdNiiYgKtYAAUVFu1GwKzMkwMFnEDm7Va-QiYdc/exec';\r\n    const customSheetScriptURL: string = 'https://script.google.com/macros/s/AKfycby-iJ_RdsdeCZ3TJN_qEMiv_DGhetyFMFIeNJGqvi-jQmDA2NBuSWFI-wmF-NtNQDLL/exec';\r\n\r\n    const sheetKey: string = this._settingsService.settings.spreadsheetSheetKey ? this._settingsService.settings.spreadsheetSheetKey : collectiveSheetKey;\r\n    const postUrl: string = customSheetScriptURL;\r\n    const hostUrl: string = (window.location !== window.parent.location) ? document.referrer : document.location.href;\r\n    const payLoad = this.registerFormID ?\r\n      {'registerID': this.registerFormID, 'sheetKey': sheetKey, 'Code': this.code, 'InitCode': this._originalProjectCode, 'Furniture': JSON.stringify(furniture)} :\r\n      {'sheetKey': sheetKey, 'Code': this.code, 'InitCode': this._originalProjectCode, 'URL': hostUrl, 'Furniture': JSON.stringify(furniture)};\r\n\r\n    axios({\r\n      method: 'post',\r\n      url: postUrl,\r\n      params: payLoad\r\n    }).then(response => {\r\n      if (response.data.result === 'success') {\r\n        this.registerFormID = null;\r\n      }\r\n    }).catch(error => {\r\n      console.error(error);\r\n    });\r\n  }\r\n\r\n  private _getFurniture(j: any) {\r\n    const temp = [];\r\n    for (let i = 0; i < j.furniture.length; i++) {\r\n      temp.push(j.furniture[i]['item_name']);\r\n    }\r\n    return temp;\r\n  }\r\n}\r\n"]}