rubyfox-server 2.13.4.1 → 2.16.0.0

data/lib/rubyfox/server/data/www/ROOT/admin/assets/js/core/modules/module-11.bundle.js

@@ -0,0 +1,71 @@
+/*! (c) gotoAndPlay | All rights reserved */
+(window["webpackJsonpapplication"] = window["webpackJsonpapplication"] || []).push([["module-11"],{
+
+/***/ "./src/modules/template.js":
+/*!*********************************!*\
+  !*** ./src/modules/template.js ***!
+  \*********************************/
+/*! exports provided: default */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return Template; });
+/* harmony import */ var _base_module__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./base-module */ "./src/modules/base-module.js");
+
+
+class Template extends _base_module__WEBPACK_IMPORTED_MODULE_0__["BaseModule"]
+{
+	constructor()
+	{
+	    super('template');
+	}
+
+	//------------------------------------
+	// COMMON MODULE INTERFACE METHODS
+	// This members are used by the main controller
+	// to communicate with the module's controller.
+	//------------------------------------
+
+	initialize(idData, shellController)
+	{
+		// Call super method
+		super.initialize(idData, shellController);
+
+	}
+
+	destroy()
+	{
+		// Call super method
+		super.destroy();
+	}
+
+	onExtensionCommand(command, data)
+	{
+
+	}
+
+	//---------------------------------
+	// UI EVENT LISTENERS
+	//---------------------------------
+
+
+
+	//------------------------------------
+	// PRIVATE METHODS
+	//------------------------------------
+
+
+
+	//---------------------------------
+	// PRIVATE GETTERS
+	//---------------------------------
+
+
+}
+
+
+/***/ })
+
+}]);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXNzZXRzL2pzL2NvcmUvbW9kdWxlcy9tb2R1bGUtMTEuYnVuZGxlLmpzIiwic291cmNlcyI6WyJ3ZWJwYWNrOi8vYXBwbGljYXRpb24vLi9zcmMvbW9kdWxlcy90ZW1wbGF0ZS5qcyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge0Jhc2VNb2R1bGV9IGZyb20gJy4vYmFzZS1tb2R1bGUnO1xuXG5leHBvcnQgZGVmYXVsdCBjbGFzcyBUZW1wbGF0ZSBleHRlbmRzIEJhc2VNb2R1bGVcbntcblx0Y29uc3RydWN0b3IoKVxuXHR7XG5cdCAgICBzdXBlcigndGVtcGxhdGUnKTtcblx0fVxuXG5cdC8vLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tXG5cdC8vIENPTU1PTiBNT0RVTEUgSU5URVJGQUNFIE1FVEhPRFNcblx0Ly8gVGhpcyBtZW1iZXJzIGFyZSB1c2VkIGJ5IHRoZSBtYWluIGNvbnRyb2xsZXJcblx0Ly8gdG8gY29tbXVuaWNhdGUgd2l0aCB0aGUgbW9kdWxlJ3MgY29udHJvbGxlci5cblx0Ly8tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS1cblxuXHRpbml0aWFsaXplKGlkRGF0YSwgc2hlbGxDb250cm9sbGVyKVxuXHR7XG5cdFx0Ly8gQ2FsbCBzdXBlciBtZXRob2Rcblx0XHRzdXBlci5pbml0aWFsaXplKGlkRGF0YSwgc2hlbGxDb250cm9sbGVyKTtcblxuXHR9XG5cblx0ZGVzdHJveSgpXG5cdHtcblx0XHQvLyBDYWxsIHN1cGVyIG1ldGhvZFxuXHRcdHN1cGVyLmRlc3Ryb3koKTtcblx0fVxuXG5cdG9uRXh0ZW5zaW9uQ29tbWFuZChjb21tYW5kLCBkYXRhKVxuXHR7XG5cblx0fVxuXG5cdC8vLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tXG5cdC8vIFVJIEVWRU5UIExJU1RFTkVSU1xuXHQvLy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLVxuXG5cblxuXHQvLy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLVxuXHQvLyBQUklWQVRFIE1FVEhPRFNcblx0Ly8tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS1cblxuXG5cblx0Ly8tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS1cblx0Ly8gUFJJVkFURSBHRVRURVJTXG5cdC8vLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tXG5cblxufVxuIl0sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7OztBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTs7Ozs7QSIsInNvdXJjZVJvb3QiOiIifQ==

data/lib/rubyfox/server/data/www/ROOT/admin/assets/js/core/modules/module-12.bundle.js

@@ -0,0 +1,1184 @@
+/*! (c) gotoAndPlay | All rights reserved */
+(window["webpackJsonpapplication"] = window["webpackJsonpapplication"] || []).push([["module-12"],{
+
+/***/ "./src/components/sidebar-layout.js":
+/*!******************************************!*\
+  !*** ./src/components/sidebar-layout.js ***!
+  \******************************************/
+/*! exports provided: SidebarLayout */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "SidebarLayout", function() { return SidebarLayout; });
+class SidebarLayout extends HTMLElement
+{
+	constructor()
+	{
+	    super();
+
+		// Attach a shadow root
+		const shadowRoot = this.attachShadow({mode: 'open'});
+		shadowRoot.innerHTML = `
+			<style>
+				:host {
+					display: flex;
+					flex-direction: row;
+				}
+
+				@media (max-width: 575.98px) {
+					:host(.split-xs) ::slotted(:not([aria-selected="true"])) {
+						display: none !important;
+				    }
+
+					:host(.split-xs) ::slotted([aria-selected="true"]) {
+						flex-grow: 1;
+				    }
+				}
+
+				@media (max-width: 767.98px) {
+					:host(.split-sm) ::slotted(:not([aria-selected="true"])) {
+						display: none !important;
+				    }
+
+					:host(.split-sm) ::slotted([aria-selected="true"]) {
+						flex-grow: 1;
+				    }
+				}
+
+				@media (max-width: 991.98px) {
+					:host(.split-md) ::slotted(:not([aria-selected="true"])) {
+						display: none !important;
+				    }
+
+					:host(.split-md) ::slotted([aria-selected="true"]) {
+						flex-grow: 1;
+				    }
+				}
+
+				@media (max-width: 1199.98px) {
+					:host(.split-lg) ::slotted(:not([aria-selected="true"])) {
+						display: none !important;
+				    }
+
+					:host(.split-lg) ::slotted([aria-selected="true"]) {
+						flex-grow: 1;
+				    }
+				}
+
+				.side-col::slotted(*) {
+				}
+
+				.main-col::slotted(*) {
+					flex-grow: 1;
+				}
+			</style>
+
+			<slot class="side-col" name="side-column"></slot>
+			<slot class="main-col" name="main-column"></slot>
+		`;
+
+		// Set initial selection
+		this.selectedIndex = 0;
+	}
+
+	get selectedPanel()
+	{
+		return this._selectedPanel;
+	}
+
+	set selectedPanel(element) // 'side' or 'main'
+	{
+		if (element != null && element.parentNode == this)
+		{
+			this._selectedPanel = element;
+
+			for (let element of this.children)
+			{
+				if (element == this._selectedPanel)
+					element.setAttribute('aria-selected', 'true');
+				else
+					element.removeAttribute('aria-selected');
+			}
+		}
+		else
+		{
+			console.error('Element is not a child of SidebarLayout');
+		}
+	}
+
+	get selectedIndex()
+	{
+		return Array.from(this.children).indexOf(this._selectedPanel);
+	}
+
+	set selectedIndex(index)
+	{
+		if (this.children.length > 0)
+		{
+			if (this.children[index] == null)
+			{
+				console.error('Invalid SidebarLayout index');
+				return;
+			}
+
+			let element = this.children[index];
+			this.selectedPanel = element;
+		}
+	}
+}
+
+// DEFINE COMPONENT
+if (!window.customElements.get('sidebar-layout'))
+	window.customElements.define('sidebar-layout', SidebarLayout);
+
+
+/***/ }),
+
+/***/ "./src/modules/zone-configurator.js":
+/*!******************************************!*\
+  !*** ./src/modules/zone-configurator.js ***!
+  \******************************************/
+/*! exports provided: default */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* WEBPACK VAR INJECTION */(function($) {/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return ZoneConfigurator; });
+/* harmony import */ var _base_module__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./base-module */ "./src/modules/base-module.js");
+/* harmony import */ var _components_view_stack__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../components/view-stack */ "./src/components/view-stack.js");
+/* harmony import */ var _components_sidebar_layout__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../components/sidebar-layout */ "./src/components/sidebar-layout.js");
+/* harmony import */ var _utils_uibuilder_config_interface_builder__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../utils/uibuilder/config-interface-builder */ "./src/utils/uibuilder/config-interface-builder.js");
+/* harmony import */ var _utils_utilities__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../utils/utilities */ "./src/utils/utilities.js");
+
+
+
+
+
+
+class ZoneConfigurator extends _base_module__WEBPACK_IMPORTED_MODULE_0__["BaseModule"]
+{
+	constructor()
+	{
+	    super('zoneConfig');
+
+		this.ITEM_TYPE_ZONE = 'zone';
+		this.ITEM_TYPE_ROOM = 'room';
+
+		// Outgoing requests
+		this.REQ_GET_ZONES = 'getZones';
+
+		this.REQ_GET_ZONE_CONFIG = 'getZoneConfig';
+		this.REQ_SAVE_ZONE_CONFIG = 'saveZoneConfig';
+		this.REQ_NEW_ZONE_CONFIG = 'newZoneConfig';
+		this.REQ_DELETE_ZONE_CONFIG = 'delZoneConfig';
+		this.REQ_ACTIVATE_ZONE = 'actZone';
+
+		this.REQ_GET_ROOM_CONFIG = 'getRoomConfig';
+		this.REQ_SAVE_ROOM_CONFIG = 'saveRoomConfig';
+		this.REQ_NEW_ROOM_CONFIG = 'newRoomConfig';
+		this.REQ_DELETE_ROOM_CONFIG = 'delRoomConfig';
+
+		// Incoming responses
+		this.RESP_ZONES = 'zones';
+
+		this.RESP_ZONE_CONFIG = 'zoneConfig';
+		this.RESP_ZONE_CONFIG_UPDATE_CONFIRM = 'zoneCfgUpd';
+		this.RESP_ZONE_ADDED = 'zoneAdded';
+		this.RESP_ZONE_REFUSED = 'zoneRefused';
+		this.RESP_ZONE_DELETED = 'zoneDel';
+		this.RESP_ZONE_ACTIVATED = 'zoneAct';
+		this.RESP_ZONE_ACTIVATION_ERROR = 'zoneActErr';
+
+		this.RESP_ROOM_CONFIG = 'roomConfig';
+		this.RESP_ROOM_CONFIG_UPDATE_CONFIRM = 'roomCfgUpd';
+		this.RESP_ROOM_ADDED = 'roomAdded';
+		this.RESP_ROOM_REFUSED = 'roomRefused';
+		this.RESP_ROOM_DELETED = 'roomDel';
+	}
+
+	//------------------------------------
+	// COMMON MODULE INTERFACE METHODS
+	// This members are used by the main controller
+	// to communicate with the module's controller.
+	// This methods override those in BaseModule class.
+	//------------------------------------
+
+	initialize(idData, shellController)
+	{
+		// Call super method
+		super.initialize(idData, shellController);
+
+		// Create interface builder instance
+		this._interfaceBuilder = new _utils_uibuilder_config_interface_builder__WEBPACK_IMPORTED_MODULE_3__["ConfigInterfaceBuilder"]();
+
+		// Set listener for custom actions triggered by configuration interface
+		$('#znc-tabNavigator').on('value-set', $.proxy(this._onConfigValueSet, this));
+
+		// Initialize Zones/Rooms treeview
+		this._treeview = $('#znc-treeView').kendoTreeView({
+			loadOnDemand: false,
+			dataTextField: 'name',
+			template: kendo.template('<span class="# if (!item.active) { # inactive-list-item # } #">#: item.name #</span>'),
+			change: $.proxy(this._onZoneRoomChange, this),
+		}).data('kendoTreeView');
+
+		// Lestend to treeview double-click event
+		$('#znc-treeView').on('dblclick', $.proxy(this._onTreeItemDoubleClick, this));
+
+		// Request zones & rooms list to server instance
+		this.sendExtensionRequest(this.REQ_GET_ZONES);
+
+		// Initialize progress bar
+		$('#znc-progressBar').kendoProgressBar({
+			min: 0,
+            max: 100,
+			value: false,
+            type: 'value',
+            animation: {
+                duration: 400
+            }
+        });
+
+		// Add listeners to utility buttons
+		$('#znc-addZoneButton').on('click', $.proxy(this._onAddZoneClick, this));
+		$('#znc-addRoomButton').on('click', $.proxy(this._onAddRoomClick, this));
+		$('#znc-editButton').on('click', $.proxy(this._onEditClick, this));
+		$('#znc-removeButton').on('click', $.proxy(this._onRemoveClick, this));
+		$('#znc-activateButton').on('click', $.proxy(this._onActivateClick, this));
+
+		// Add listener to interface buttons
+		$('#znc-cancelButton').on('click', $.proxy(this._onCancelClick, this));
+		$('#znc-reloadButton').on('click', $.proxy(this._onReloadClick, this));
+		$('#znc-submitButton').on('click', $.proxy(this._onSubmitClick, this));
+	}
+
+	destroy()
+	{
+		// Call super method
+		super.destroy();
+
+		// Remove tree view doubleclick listener
+		$('#znc-treeView').off('dblclick');
+
+		// Remove listener for custom actions triggered by configuration interface
+		$('#znc-tabNavigator').off('value-set');
+
+		// Remove listener for zone/room activation event
+		$('#znc-addZoneButton').off('click');
+		$('#znc-addRoomButton').off('click');
+		$('#znc-editButton').off('click');
+		$('#znc-removeButton').off('click');
+		$('#znc-activateButton').off('click');
+
+		// Remove interface buttons click listeners
+		$('#znc-cancelButton').off('click');
+		$('#znc-reloadButton').off('click');
+		$('#znc-submitButton').off('click');
+
+		// Clear tabs container
+		this._clearTabs();
+	}
+
+	onExtensionCommand(command, data)
+	{
+		const username = data.getUtfString('user');
+
+		/****** ZONES & ROOMS ******/
+
+		// Zones & rooms list received
+		if (command == this.RESP_ZONES)
+			this._populateTree(data);
+
+		// Zone or room configuration data received
+		else if (command == this.RESP_ZONE_CONFIG || command == this.RESP_ROOM_CONFIG)
+		{
+			// Build user interface based on received data
+			this._interfaceBuilder.buildInterface(data.getSFSArray('settings'), 'znc-tabNavigator', false);
+
+			// Enable scrolling tabs (if needed)
+			if (this._reinitTabs)
+			{
+				$('#znc-tabNavigator #tabs').scrollingTabs({
+					bootstrapVersion: 4,
+					scrollToTabEdge: true,
+					enableSwiping: true,
+					disableScrollArrowsOnFullyScrolled: true,
+					cssClassLeftArrow: 'fa fa-chevron-left',
+					cssClassRightArrow: 'fa fa-chevron-right'
+				});
+			}
+
+			// Enable interface
+			this._enableConfigInterface(true);
+		}
+
+		/****** ZONES ******/
+
+		// Zone configuration update confirmation
+		else if (command == this.RESP_ZONE_CONFIG_UPDATE_CONFIRM)
+		{
+			// If a 'name' parameter is received, it means the zone name changed, and we have to update the zones list
+			if (data.getUtfString('zName') != null)
+				this._updateZoneNameInList(data.getInt('zId'), data.getUtfString('zName'));
+
+			// If the current user is the updater, show a notification; otherwise, show a dialog box suggesting to reload
+			if (username == this.smartFox.mySelf.name)
+			{
+				// Enable interface
+				this._enableConfigInterface(true);
+
+				// Display notification
+				this.shellCtrl.showNotification('Zone modified', `Zone settings updated successfully; changes will be applied on next <strong>server restart</strong>`);
+
+				// Reset the 'modified' flag
+				this._interfaceBuilder.resetIsModified();
+			}
+			else
+			{
+				// An alert box is displayed if the user is currently editing the same zone
+				if (data.getInt('zId') == this._editedZoneId)
+				{
+					// Show alert
+					this.shellCtrl.showSimpleAlert(`Administrator ${username} has modified the Zone you are currently editing; please reload to update your view.`);
+
+					// Disable submit button
+					$('#znc-submitButton').attr('disabled', true);
+				}
+				else
+				{
+					// Display notification
+					if (data.getUtfString('zName') != null)
+						this.shellCtrl.showNotification('Zone renamed', `Administrator ${username} has changed the name on one of the Zones`);
+				}
+			}
+		}
+
+		// New zone added
+		else if (command == this.RESP_ZONE_ADDED)
+		{
+			const zoneName = data.getSFSObject('zone').getUtfString('name');
+
+			// If the current user is the updater, reset the interface; otherwise, just show a notification
+			if (username == this.smartFox.mySelf.name)
+			{
+				// Reset interface
+				this._onCancelClick();
+
+				// Display notification
+				this.shellCtrl.showNotification('Zone added', `Zone '${zoneName}' created successfully`);
+			}
+			else
+			{
+				// Display notification
+				this.shellCtrl.showNotification('Zone added', `Administrator ${username} created Zone '${zoneName}'`);
+			}
+
+			// Add new zone to tree
+			let zonesDS = this._treeview.dataSource;
+			zonesDS.add(this._createZoneObject(data.getSFSObject('zone')));
+			zonesDS.sync();
+		}
+
+		// New zone creation refused due to invalid zone name
+		else if (command == this.RESP_ZONE_REFUSED)
+		{
+			// Re-enable interface
+			this._enableConfigInterface(true);
+
+			// Show warning
+			this.shellCtrl.showSimpleAlert('Zone configuration can\'t be saved because another Zone with the same name already exists.', true);
+		}
+
+		// Existing zone deleted
+		else if (command == this.RESP_ZONE_DELETED)
+		{
+			// If the current user is the deleter, reset the interface; otherwise, just show a notification
+			if (username == this.smartFox.mySelf.name)
+			{
+				// Re-enable interface
+				this._enableListInterface(true);
+
+				// Display notification
+				this.shellCtrl.showNotification('Zone removed', `Zone '${data.getUtfString('zName')}' deleted successfully`);
+			}
+			else
+			{
+				// An alert box is displayed if the user is currently editing the same zone
+				if (data.getInt('zId') == this._editedZoneId)
+				{
+					// Show alert
+					this.shellCtrl.showSimpleAlert(`Administrator ${username} has deleted the Zone you are currently modifying; you have to cancel your editing.`);
+
+					// Disable submit and reload buttons
+					$('#znc-reloadButton').attr('disabled', true);
+					$('#znc-submitButton').attr('disabled', true);
+				}
+				else
+				{
+					// Display notification
+					this.shellCtrl.showNotification('Zone removed', `Administrator ${username} deleted Zone '${data.getUtfString('zName')}'`);
+				}
+			}
+
+			// Reset selection if the currently selected item or its parent is being removed
+			let selectedNode = this._treeview.select();
+			let selectedDataItem = this._treeview.dataItem(selectedNode);
+			if (selectedDataItem)
+			{
+				if (selectedDataItem.type == this.ITEM_TYPE_ZONE && selectedDataItem.id == data.getInt('zId'))
+					this._deselectTreeItem();
+
+				if (selectedDataItem.type == this.ITEM_TYPE_ROOM)
+				{
+					let parentDataItem = this._treeview.dataItem(this._treeview.parent(selectedNode));
+
+					if (parentDataItem.id == data.getInt('zId'))
+						this._deselectTreeItem();
+				}
+			}
+
+			// Remove zone from tree
+			let dataItem = this._getZoneDataItemById(data.getInt('zId'));
+			let zonesDS = this._treeview.dataSource;
+			zonesDS.remove(dataItem);
+			zonesDS.sync();
+		}
+
+		// Zone activated
+		else if (command == this.RESP_ZONE_ACTIVATED)
+		{
+			// Set zone activation status
+			const zoneName = this._setZoneActivationStatus(data.getInt('zId'), data.getUtfString('actRooms'), true);
+
+			// Display notification
+			if (username == this.smartFox.mySelf.name)
+				this.shellCtrl.showNotification('Zone activated', `Zone '${zoneName}' activated successfully`);
+			else
+				this.shellCtrl.showNotification('Zone activated', `Administrator ${username} activated Zone '${zoneName}'`);
+		}
+
+		// Zone activation error
+		else if (command == this.RESP_ZONE_ACTIVATION_ERROR)
+		{
+			// Set zone activation status
+			this._setZoneActivationStatus(data.getInt('zId'), '', false);
+
+			// Show alert
+			this.shellCtrl.showSimpleAlert(data.getUtfString('error'), true);
+		}
+
+		/****** ROOMS ******/
+
+		// Room configuration update confirmation
+		else if (command == this.RESP_ROOM_CONFIG_UPDATE_CONFIRM)
+		{
+			if (data.getUtfString('rName') != null)
+				this._updateRoomNameInList(data.getInt('zId'), data.getInt('rId'), data.getUtfString('rName'));
+
+			// If the current user is the updater, show a notification; otherwise, show a dialog box suggesting to reload
+			if (username == this.smartFox.mySelf.name)
+			{
+				// Enable interface
+				this._enableConfigInterface(true);
+
+				// Display notification
+				this.shellCtrl.showNotification('Room modified', `Room settings updated successfully; changes will be applied on next <strong>server restart</strong>`);
+
+				// Reset the 'modified' flag
+				this._interfaceBuilder.resetIsModified();
+			}
+			else
+			{
+				// An alert box is displayed if the user is currently editing the same room
+				if (data.getInt('rId') == this._editedRoomId)
+				{
+					// Show alert
+					this.shellCtrl.showSimpleAlert(`Administrator ${username} has modified the Room you are currently editing; please reload to update your view.`);
+
+					// Disable submit button
+					$('#znc-submitButton').attr('disabled', true);
+				}
+				else
+				{
+					// Display notification
+					if (data.getUtfString('rName') != null)
+						this.shellCtrl.showNotification('Room renamed', `Administrator ${username} has changed the name on one of the Rooms`);
+				}
+			}
+		}
+
+		// New room added
+		else if (command == this.RESP_ROOM_ADDED)
+		{
+			const roomData = data.getSFSObject('room');
+			const zoneId = data.getInt('zId');
+
+			let zonesDS = this._treeview.dataSource;
+			let zoneItem = zonesDS.get(zoneId);
+
+			// If the current user is the updater, reset the interface; otherwise, just show a notification
+			if (username == this.smartFox.mySelf.name)
+			{
+				// Reset interface
+				this._onCancelClick();
+
+				// Display notification
+				this.shellCtrl.showNotification('Room added', `Room '${roomData.getUtfString('name')}' created successfully`);
+			}
+			else
+			{
+				// Display notification
+				this.shellCtrl.showNotification('Room added', `Administrator ${username} created Room '${roomData.getUtfString('name')}' in Zone '${zoneItem.name}'`);
+			}
+
+			// Add new room to tree
+			zoneItem.append(this._createRoomObject(roomData, zoneId));
+			zonesDS.sync();
+
+			// Expand zone node where room was added
+			this._treeview.expand(this._treeview.select());
+		}
+
+		// New room creation refused due to invalid room name
+		else if (command == this.RESP_ROOM_REFUSED)
+		{
+			// Re-enable interface
+			this._enableConfigInterface(true);
+
+			// Show warning
+			this.shellCtrl.showSimpleAlert('Room configuration can\'t be saved because another Room with the same name already exists.', true);
+		}
+
+		// Existing room deleted
+		else if (command == this.RESP_ROOM_DELETED)
+		{
+			let zoneItem = this._getZoneDataItemById(data.getInt('zId'));
+			let roomItem = this._getRoomDataItemById(data.getInt('zId'), data.getInt('rId'));
+
+			// If the current user is the deleter, reset the interface; otherwise, just show a notification
+			if (username == this.smartFox.mySelf.name)
+			{
+				// Re-enable interface
+				this._enableListInterface(true);
+
+				// Display notification
+				this.shellCtrl.showNotification('Room removed', `Room '${roomItem.name}' deleted successfully`);
+			}
+			else
+			{
+				// An alert box is displayed if the user is currently editing the same room
+				if (data.getInt('rId') == this._editedRoomId)
+				{
+					// Show alert
+					this.shellCtrl.showSimpleAlert(`Administrator ${username} has deleted the Room you are currently modifying; you have to cancel your editing.`);
+
+					// Disable submit and reload buttons
+					$('#znc-reloadButton').attr('disabled', true);
+					$('#znc-submitButton').attr('disabled', true);
+				}
+				else
+				{
+					// Display notification
+					this.shellCtrl.showNotification('Room removed', `Administrator ${username} deleted Room '${roomItem.name}' from Zone '${zoneItem.name}'`);
+				}
+			}
+
+			// Reset selection if the currently selected item or its parent is being removed
+			let selectedNode = this._treeview.select();
+			let selectedDataItem = this._treeview.dataItem(selectedNode);
+			if (selectedDataItem)
+			{
+				if (selectedDataItem.type == this.ITEM_TYPE_ROOM && selectedDataItem.id == data.getInt('rId'))
+					this._deselectTreeItem();
+			}
+
+			// Remove room from tree
+			zoneItem.children.remove(roomItem);
+			this._treeview.dataSource.sync();
+		}
+
+		// else if ()
+	}
+
+	//---------------------------------
+	// UI EVENT LISTENERS
+	//---------------------------------
+
+	_onTreeItemDoubleClick(e)
+	{
+		// Get event target's closest tree node
+		let treeNode = $(e.target).closest('.k-item[role=treeitem]');
+
+		// Get associated data item
+		let dataItem = this._treeview.dataItem(treeNode);
+
+		// Load configuration
+		this._loadConfiguration(dataItem.type);
+	}
+
+	_onZoneRoomChange()
+	{
+		// Reset utility buttons
+		this._setUtilityButtonsState(this._selectedItem);
+	}
+
+	// Utility buttons listeners
+
+	_onAddZoneClick()
+	{
+		// Deselect list item
+		this._deselectTreeItem();
+
+		// Load configuration
+		this._loadConfiguration(this.ITEM_TYPE_ZONE);
+	}
+
+	_onAddRoomClick()
+	{
+		// Select parent list item
+		this._selectParentTreeItem();
+
+		// Load configuration
+		this._loadConfiguration(this.ITEM_TYPE_ROOM);
+	}
+
+	_onEditClick()
+	{
+		// Load configuration
+		this._loadConfiguration(this._selectedItem.type);
+	}
+
+	_onRemoveClick()
+	{
+		this.shellCtrl.showConfirmWarning(`Are you sure you want to delete the selected ${this._selectedItem.type == this.ITEM_TYPE_ZONE ? 'Zone' : 'Room'} configuration?`, $.proxy(this._onRemoveConfirm, this));
+	}
+
+	_onRemoveConfirm()
+	{
+		// Disable zone/room selection list
+		this._enableListInterface(false);
+
+		let params = new SFS2X.SFSObject();
+
+		// Request zone removal
+		if (this._selectedItem.type == this.ITEM_TYPE_ZONE)
+		{
+			params.putInt('zId', this._selectedItem.id);
+			this.sendExtensionRequest(this.REQ_DELETE_ZONE_CONFIG, params);
+		}
+		else
+		{
+			params.putInt('zId', this._selectedItemParent.id);
+			params.putInt('rId', this._selectedItem.id);
+			this.sendExtensionRequest(this.REQ_DELETE_ROOM_CONFIG, params);
+		}
+	}
+
+	_onActivateClick()
+	{
+		// Get selected data item
+		if (this._selectedItem.type == this.ITEM_TYPE_ZONE)
+		{
+			let params = new SFS2X.SFSObject();
+			params.putInt('zId', this._selectedItem.id);
+
+			this.sendExtensionRequest(this.REQ_ACTIVATE_ZONE, params);
+		}
+	}
+
+	// Configuration buttons listeners
+
+	_onCancelClick()
+	{
+		// Enable zone/room selection lists
+		this._enableListInterface(true);
+
+		// Disable configuration interface
+		this._enableConfigInterface(false);
+
+		// Clear main container
+		this._resetTabsContainer(false, true);
+
+		// Set isEditing flag
+		this._isEditing = false;
+		this._editedItemType = '';
+
+		// Switch panel
+		this._switchPanel('znc-sidebarPanel');
+	}
+
+	_onReloadClick()
+	{
+		// Hide validation messages
+		this._interfaceBuilder.resetValidation();
+
+		// Reload configuration
+		this._loadConfiguration(this._editedItemType, false);
+	}
+
+	_onSubmitClick()
+	{
+		// Check validity
+		if (this._interfaceBuilder.checkIsValid())
+		{
+			let changes = this._interfaceBuilder.getChangedData();
+
+			if (changes.size() > 0)
+			{
+				//console.log(changes.getDump())
+
+				// In case the zone/room name changed, check it against the list (duplicate names not allowed!)
+				if (this._validateName(changes))
+				{
+					// Disable configuration interface
+					this._enableConfigInterface(false);
+
+					// Send settings to server instance
+					let params = new SFS2X.SFSObject();
+					params.putSFSArray('settings', changes);
+					params.putBool('backup', $('#znc-backupCheck').prop('checked'));
+					params.putInt('zId', this._editedZoneId);
+					params.putInt('rId', this._editedRoomId);
+
+					if (this._editedItemType == this.ITEM_TYPE_ZONE)
+					{
+						// Submit zone settings
+						if (this._editedZoneId > -1)
+							this.sendExtensionRequest(this.REQ_SAVE_ZONE_CONFIG, params);
+						else
+							this.sendExtensionRequest(this.REQ_NEW_ZONE_CONFIG, params);
+					}
+					else
+					{
+						// Submit room settings
+						if (this._editedRoomId > -1)
+							this.sendExtensionRequest(this.REQ_SAVE_ROOM_CONFIG, params);
+						else
+							this.sendExtensionRequest(this.REQ_NEW_ROOM_CONFIG, params);
+					}
+				}
+				else
+				{
+					// Show alert
+					this.shellCtrl.showSimpleAlert(`Unable to submit configuration because the ${Object(_utils_utilities__WEBPACK_IMPORTED_MODULE_4__["capitalizeFirst"])(this._editedItemType)} name already exists; duplicate names are not allowed.`, true);
+				}
+			}
+		}
+		else
+		{
+			// Show alert
+			this.shellCtrl.showSimpleAlert('Unable to submit configuration changes due to an invalid value; please verify the highlighted form fields in all tabs.', true);
+		}
+	}
+
+	_onConfigValueSet(e) // SAME METHOD DUPLICATED IN zone-monitor.js
+	{
+		const configParam = e.target.data;
+
+		// Handle extension name/type dropdowns update and update the main class dropdown datasource accordingly
+		if (configParam.name == 'extension.name' || configParam.name == 'extension.type' || configParam.name == 'extension.filterClass')
+		{
+			// All involved ConfigFormItems must be available and initialized to proceed
+			const nameFormItem = this._interfaceBuilder.getConfigFormItem('extension.name');
+			const typeFormItem = this._interfaceBuilder.getConfigFormItem('extension.type');
+			const classFormItem = this._interfaceBuilder.getConfigFormItem('extension.file');
+			const filterFormItem = this._interfaceBuilder.getConfigFormItem('extension.filterClass');
+
+			if (nameFormItem != null && typeFormItem != null && classFormItem != null && filterFormItem != null)
+			{
+				const source = nameFormItem.data;
+				let classesList = [];
+
+				let data = source.triggerData;
+				for (let i = 0; i < data.size(); i++)
+				{
+					let ext = data.getSFSObject(i);
+
+					if (ext.getUtfString('name') == nameFormItem.data.value && ext.getUtfString('type') == typeFormItem.data.value)
+					{
+						let classes = ext.getUtfString('classesString').split(',');
+
+						if (filterFormItem.data.value == true)
+						{
+							let filteredClasses = classes.filter(_utils_utilities__WEBPACK_IMPORTED_MODULE_4__["filterClassName"]);
+							classes = filteredClasses;
+						}
+
+						classesList = classesList.concat(classes);
+					}
+				}
+
+				let currentClass = classFormItem.data.value;
+
+				// If the classes list doesn't contain the current value, create an empty entry and reset the value
+				if (classesList.indexOf(currentClass) < 0)
+				{
+					if (classesList.length == 0)
+					{
+						classesList.push('');
+						currentClass = '';
+					}
+					else
+						currentClass = classesList[0];
+				}
+
+				let mainClassDropDown = classFormItem._innerWidget;
+				mainClassDropDown.setDataSource(classesList);
+
+				classFormItem.data.value = currentClass;
+				classFormItem._setWidgetValue();
+			}
+		}
+	}
+
+	//---------------------------------
+	// PRIVATE METHODS
+	//---------------------------------
+
+	_enableListInterface(enabled)
+	{
+		$('#znc-utilButtons').attr('disabled', !enabled);
+		$('#znc-treeView').attr('disabled', !enabled);
+	}
+
+	_setUtilityButtonsState(dataItem = null)
+	{
+		let disable = true;
+
+		if (dataItem)
+		{
+			// Enable 'activate zone' button if zone is inactive
+			$('#znc-activateButton').attr('disabled', (dataItem.type != this.ITEM_TYPE_ZONE || dataItem.active));
+
+			disable = false;
+		}
+		else
+		{
+			// Disable 'activate zone' button
+			$('#znc-activateButton').attr('disabled', true);
+		}
+
+		// Enable/disable other utility buttons
+		$('#znc-addZoneButton').attr('disabled', false); // Always enabled
+		$('#znc-addRoomButton').attr('disabled', disable);
+		$('#znc-editButton').attr('disabled', disable);
+		$('#znc-removeButton').attr('disabled', disable);
+	}
+
+	_enableConfigInterface(enabled)
+	{
+		$('#znc-cancelButton').attr('disabled', !enabled);
+		$('#znc-reloadButton').attr('disabled', !enabled);
+		$('#znc-submitButton').attr('disabled', !enabled);
+		$('#znc-backupCheck').attr('disabled', !enabled);
+
+		this._interfaceBuilder.disableInterface(!enabled);
+
+		// Also switch view when enabled
+		if (enabled)
+			this._switchView('znc-main');
+	}
+
+	_switchView(viewId)
+	{
+		document.getElementById('znc-viewstack').selectedElement = document.getElementById(viewId);
+	}
+
+	_clearTabs()
+	{
+		// Destroy scrolling tabs
+		$('#znc-tabNavigator #tabs').scrollingTabs('destroy');
+
+		// Remove all tab navigator content
+		this._interfaceBuilder.destroyInterface();
+
+		// Set flag to re-initialize tabs if needed
+		this._reinitTabs = true;
+	}
+
+	_populateTree(data)
+	{
+		let zData = data.getSFSArray('zones');
+
+		let zonesArr = [];
+		for (let z = 0; z < zData.size(); z++)
+			zonesArr.push( this._createZoneObject(zData.getSFSObject(z)) );
+
+		// Create datasource
+		let zones = new kendo.data.HierarchicalDataSource({
+            data: zonesArr,
+			sort: {
+				field: 'name',
+				dir: 'asc'
+			},
+            schema: {
+                model: {
+					id: 'id',
+                    children: {
+						schema: {
+							data: 'rooms',
+							sort: {
+								field: 'name',
+								dir: 'asc'
+							}
+						}
+					}
+                }
+            }
+        });
+
+		// Set tree view dataprovider
+		this._treeview.setDataSource(zones);
+
+		// Set utility buttons state (add, remove, edit, etc)
+		this._setUtilityButtonsState();
+	}
+
+	_createZoneObject(zoneData)
+	{
+		let zone = {
+			type: this.ITEM_TYPE_ZONE,
+			name: zoneData.getUtfString('name'),
+			id: zoneData.getInt('id'),
+			active: zoneData.getBool('act')
+		}
+
+		// Create rooms list dataprovider
+		let rData = zoneData.getSFSArray('rooms');
+
+		let roomsArr = [];
+		for (let r = 0; r < rData.size(); r++)
+			roomsArr.push( this._createRoomObject(rData.getSFSObject(r), zoneData.getInt('id')) );
+
+		zone.rooms = roomsArr;
+
+		return zone;
+	}
+
+	_createRoomObject(roomData, zoneId)
+	{
+		let room = {
+			type: this.ITEM_TYPE_ROOM,
+			name: roomData.getUtfString('name'),
+			id: roomData.getInt('id'),
+			active: roomData.getBool('act'),
+			parentId: zoneId,
+			spriteCssClass: this._getRoomListIconCssClass(roomData.getBool('act'))
+		};
+
+		return room;
+	}
+
+	_getRoomListIconCssClass(isActive)
+	{
+		return isActive ? 'fas fa-door-open' : 'fas fa-door-closed inactive-list-item';
+	}
+
+	_setZoneActivationStatus(zoneId, activeRooms, isActive)
+	{
+		let zoneDI = this._getZoneDataItemById(zoneId);
+
+		zoneDI.active = isActive;
+
+		let activeRoomsArr = activeRooms.split(',');
+
+		if (zoneDI.hasChildren)
+		{
+			for (let i = 0; i < zoneDI.children.data().length; i++)
+			{
+				let room = zoneDI.children.data()[i];
+				room.active = (isActive && activeRoomsArr.indexOf(room.name) > -1);
+				room.spriteCssClass = this._getRoomListIconCssClass(room.active)
+			}
+		}
+
+		// Refresh list
+		this._treeview.dataSource.sync();
+
+		// Return zone name
+		return zoneDI.name;
+	}
+
+	_deselectTreeItem()
+	{
+		this._treeview.select($());
+	}
+
+	_selectParentTreeItem()
+	{
+		let selectedNode = this._treeview.select();
+		let selectedDataItem = this._treeview.dataItem(selectedNode);
+
+		if (selectedDataItem.type == this.ITEM_TYPE_ROOM)
+		{
+			let parentNode = this._treeview.parent(selectedNode);
+			this._treeview.select(parentNode);
+		}
+	}
+
+	_loadConfiguration(type, resetTabs = true)
+	{
+		// Disable zone/room selection list
+		this._enableListInterface(false);
+
+		// Disable configuration interface
+		this._enableConfigInterface(false);
+
+		// Clear main container
+		this._resetTabsContainer(true, resetTabs);
+
+		// Set isEditing flag
+		this._isEditing = true;
+		this._editedItemType = type;
+
+		// Request zone or room configuration data to server instance
+		let params = new SFS2X.SFSObject();
+		params.putInt('zId', this._editedZoneId);
+		params.putInt('rId', this._editedRoomId);
+
+		// If no room is selected, then we are editing a zone
+		if (this._editedItemType == this.ITEM_TYPE_ZONE)
+			this.sendExtensionRequest(this.REQ_GET_ZONE_CONFIG, params);
+		else
+			this.sendExtensionRequest(this.REQ_GET_ROOM_CONFIG, params);
+
+		// Switch panel
+		this._switchPanel('znc-mainPanel');
+	}
+
+	_resetTabsContainer(isLoading, resetTabs)
+	{
+		if (resetTabs)
+			this._clearTabs();
+		else
+			this._reinitTabs = false;
+
+		if (!isLoading)
+			this._switchView('znc-select');
+		else
+			this._switchView('znc-loading');
+	}
+
+	_switchPanel(panelId)
+	{
+		document.getElementById('znc-view').selectedPanel = document.getElementById(panelId);
+	}
+
+	_getZoneDataItemById(zoneId)
+	{
+		let zonesDS = this._treeview.dataSource;
+		return zonesDS.get(zoneId);
+	}
+
+	_getRoomDataItemById(zoneId, roomId)
+	{
+		let zoneDI = this._getZoneDataItemById(zoneId);
+
+		if (zoneDI.hasChildren)
+			return zoneDI.children.get(roomId);
+
+		return null;
+	}
+
+	_updateZoneNameInList(zoneId, zoneName)
+	{
+		this._getZoneDataItemById(zoneId).name = zoneName;
+		this._treeview.dataSource.sync();
+	}
+
+	_updateRoomNameInList(zoneId, roomId, roomName)
+	{
+		this._getRoomDataItemById(zoneId, roomId).name = roomName;
+		this._treeview.dataSource.sync();
+	}
+
+	_validateName(changes)
+	{
+		const zoneId = this._editedZoneId;
+
+		for (let i = 0; i < changes.size(); i++)
+		{
+			const setting = changes.getSFSObject(i);
+
+			if (setting.containsKey('name') && setting.getUtfString('name') == 'name')
+			{
+				// Get name value
+				const name = setting.getText('value');
+
+				// Get data source
+				let ds = [];
+
+				if (this._editedItemType == this.ITEM_TYPE_ZONE)
+					ds = this._treeview.dataSource.data();
+				else
+				{
+					if (this._getZoneDataItemById(zoneId).hasChildren)
+						ds = this._getZoneDataItemById(zoneId).children.data();
+				}
+
+
+				// Check if name exists in data source
+				for (let j = 0; j < ds.length; j++)
+				{
+					if (ds[j].name == name)
+					{
+						return false;
+					}
+				}
+
+				break;
+			}
+		}
+
+		return true;
+	}
+
+	//---------------------------------
+	// PRIVATE GETTERS
+	//---------------------------------
+
+	get _selectedItem()
+	{
+		return this._treeview.dataItem(this._treeview.select());
+	}
+
+	get _selectedItemParent()
+	{
+		let selectedNode = this._treeview.select();
+		let parentNode = this._treeview.parent(selectedNode);
+
+		return this._treeview.dataItem(parentNode);
+	}
+
+	get _editedZoneId()
+	{
+		if (this._isEditing && this._selectedItem)
+		{
+			if (this._selectedItem.type == this.ITEM_TYPE_ZONE)
+				return this._selectedItem.id;
+			else
+				return this._selectedItemParent.id;
+		}
+
+		return -1;
+	}
+
+	get _editedRoomId()
+	{
+		if (this._isEditing && this._selectedItem)
+		{
+			if (this._selectedItem.type == this.ITEM_TYPE_ROOM)
+				return this._selectedItem.id;
+		}
+
+		return -1;
+	}
+}
+
+/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! jquery */ "jquery")))
+
+/***/ })
+
+}]);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"assets/js/core/modules/module-12.bundle.js","sources":["webpack://application/./src/components/sidebar-layout.js","webpack://application/./src/modules/zone-configurator.js"],"sourcesContent":["export class SidebarLayout extends HTMLElement\n{\n\tconstructor()\n\t{\n\t    super();\n\n\t\t// Attach a shadow root\n\t\tconst shadowRoot = this.attachShadow({mode: 'open'});\n\t\tshadowRoot.innerHTML = `\n\t\t\t<style>\n\t\t\t\t:host {\n\t\t\t\t\tdisplay: flex;\n\t\t\t\t\tflex-direction: row;\n\t\t\t\t}\n\n\t\t\t\t@media (max-width: 575.98px) {\n\t\t\t\t\t:host(.split-xs) ::slotted(:not([aria-selected=\"true\"])) {\n\t\t\t\t\t\tdisplay: none !important;\n\t\t\t\t    }\n\n\t\t\t\t\t:host(.split-xs) ::slotted([aria-selected=\"true\"]) {\n\t\t\t\t\t\tflex-grow: 1;\n\t\t\t\t    }\n\t\t\t\t}\n\n\t\t\t\t@media (max-width: 767.98px) {\n\t\t\t\t\t:host(.split-sm) ::slotted(:not([aria-selected=\"true\"])) {\n\t\t\t\t\t\tdisplay: none !important;\n\t\t\t\t    }\n\n\t\t\t\t\t:host(.split-sm) ::slotted([aria-selected=\"true\"]) {\n\t\t\t\t\t\tflex-grow: 1;\n\t\t\t\t    }\n\t\t\t\t}\n\n\t\t\t\t@media (max-width: 991.98px) {\n\t\t\t\t\t:host(.split-md) ::slotted(:not([aria-selected=\"true\"])) {\n\t\t\t\t\t\tdisplay: none !important;\n\t\t\t\t    }\n\n\t\t\t\t\t:host(.split-md) ::slotted([aria-selected=\"true\"]) {\n\t\t\t\t\t\tflex-grow: 1;\n\t\t\t\t    }\n\t\t\t\t}\n\n\t\t\t\t@media (max-width: 1199.98px) {\n\t\t\t\t\t:host(.split-lg) ::slotted(:not([aria-selected=\"true\"])) {\n\t\t\t\t\t\tdisplay: none !important;\n\t\t\t\t    }\n\n\t\t\t\t\t:host(.split-lg) ::slotted([aria-selected=\"true\"]) {\n\t\t\t\t\t\tflex-grow: 1;\n\t\t\t\t    }\n\t\t\t\t}\n\n\t\t\t\t.side-col::slotted(*) {\n\t\t\t\t}\n\n\t\t\t\t.main-col::slotted(*) {\n\t\t\t\t\tflex-grow: 1;\n\t\t\t\t}\n\t\t\t</style>\n\n\t\t\t<slot class=\"side-col\" name=\"side-column\"></slot>\n\t\t\t<slot class=\"main-col\" name=\"main-column\"></slot>\n\t\t`;\n\n\t\t// Set initial selection\n\t\tthis.selectedIndex = 0;\n\t}\n\n\tget selectedPanel()\n\t{\n\t\treturn this._selectedPanel;\n\t}\n\n\tset selectedPanel(element) // 'side' or 'main'\n\t{\n\t\tif (element != null && element.parentNode == this)\n\t\t{\n\t\t\tthis._selectedPanel = element;\n\n\t\t\tfor (let element of this.children)\n\t\t\t{\n\t\t\t\tif (element == this._selectedPanel)\n\t\t\t\t\telement.setAttribute('aria-selected', 'true');\n\t\t\t\telse\n\t\t\t\t\telement.removeAttribute('aria-selected');\n\t\t\t}\n\t\t}\n\t\telse\n\t\t{\n\t\t\tconsole.error('Element is not a child of SidebarLayout');\n\t\t}\n\t}\n\n\tget selectedIndex()\n\t{\n\t\treturn Array.from(this.children).indexOf(this._selectedPanel);\n\t}\n\n\tset selectedIndex(index)\n\t{\n\t\tif (this.children.length > 0)\n\t\t{\n\t\t\tif (this.children[index] == null)\n\t\t\t{\n\t\t\t\tconsole.error('Invalid SidebarLayout index');\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tlet element = this.children[index];\n\t\t\tthis.selectedPanel = element;\n\t\t}\n\t}\n}\n\n// DEFINE COMPONENT\nif (!window.customElements.get('sidebar-layout'))\n\twindow.customElements.define('sidebar-layout', SidebarLayout);\n","import {BaseModule} from './base-module';\nimport {ViewStack} from '../components/view-stack';\nimport {SidebarLayout} from '../components/sidebar-layout';\nimport {ConfigInterfaceBuilder} from '../utils/uibuilder/config-interface-builder';\nimport {capitalizeFirst, filterClassName} from '../utils/utilities';\n\nexport default class ZoneConfigurator extends BaseModule\n{\n\tconstructor()\n\t{\n\t    super('zoneConfig');\n\n\t\tthis.ITEM_TYPE_ZONE = 'zone';\n\t\tthis.ITEM_TYPE_ROOM = 'room';\n\n\t\t// Outgoing requests\n\t\tthis.REQ_GET_ZONES = 'getZones';\n\n\t\tthis.REQ_GET_ZONE_CONFIG = 'getZoneConfig';\n\t\tthis.REQ_SAVE_ZONE_CONFIG = 'saveZoneConfig';\n\t\tthis.REQ_NEW_ZONE_CONFIG = 'newZoneConfig';\n\t\tthis.REQ_DELETE_ZONE_CONFIG = 'delZoneConfig';\n\t\tthis.REQ_ACTIVATE_ZONE = 'actZone';\n\n\t\tthis.REQ_GET_ROOM_CONFIG = 'getRoomConfig';\n\t\tthis.REQ_SAVE_ROOM_CONFIG = 'saveRoomConfig';\n\t\tthis.REQ_NEW_ROOM_CONFIG = 'newRoomConfig';\n\t\tthis.REQ_DELETE_ROOM_CONFIG = 'delRoomConfig';\n\n\t\t// Incoming responses\n\t\tthis.RESP_ZONES = 'zones';\n\n\t\tthis.RESP_ZONE_CONFIG = 'zoneConfig';\n\t\tthis.RESP_ZONE_CONFIG_UPDATE_CONFIRM = 'zoneCfgUpd';\n\t\tthis.RESP_ZONE_ADDED = 'zoneAdded';\n\t\tthis.RESP_ZONE_REFUSED = 'zoneRefused';\n\t\tthis.RESP_ZONE_DELETED = 'zoneDel';\n\t\tthis.RESP_ZONE_ACTIVATED = 'zoneAct';\n\t\tthis.RESP_ZONE_ACTIVATION_ERROR = 'zoneActErr';\n\n\t\tthis.RESP_ROOM_CONFIG = 'roomConfig';\n\t\tthis.RESP_ROOM_CONFIG_UPDATE_CONFIRM = 'roomCfgUpd';\n\t\tthis.RESP_ROOM_ADDED = 'roomAdded';\n\t\tthis.RESP_ROOM_REFUSED = 'roomRefused';\n\t\tthis.RESP_ROOM_DELETED = 'roomDel';\n\t}\n\n\t//------------------------------------\n\t// COMMON MODULE INTERFACE METHODS\n\t// This members are used by the main controller\n\t// to communicate with the module's controller.\n\t// This methods override those in BaseModule class.\n\t//------------------------------------\n\n\tinitialize(idData, shellController)\n\t{\n\t\t// Call super method\n\t\tsuper.initialize(idData, shellController);\n\n\t\t// Create interface builder instance\n\t\tthis._interfaceBuilder = new ConfigInterfaceBuilder();\n\n\t\t// Set listener for custom actions triggered by configuration interface\n\t\t$('#znc-tabNavigator').on('value-set', $.proxy(this._onConfigValueSet, this));\n\n\t\t// Initialize Zones/Rooms treeview\n\t\tthis._treeview = $('#znc-treeView').kendoTreeView({\n\t\t\tloadOnDemand: false,\n\t\t\tdataTextField: 'name',\n\t\t\ttemplate: kendo.template('<span class=\"# if (!item.active) { # inactive-list-item # } #\">#: item.name #</span>'),\n\t\t\tchange: $.proxy(this._onZoneRoomChange, this),\n\t\t}).data('kendoTreeView');\n\n\t\t// Lestend to treeview double-click event\n\t\t$('#znc-treeView').on('dblclick', $.proxy(this._onTreeItemDoubleClick, this));\n\n\t\t// Request zones & rooms list to server instance\n\t\tthis.sendExtensionRequest(this.REQ_GET_ZONES);\n\n\t\t// Initialize progress bar\n\t\t$('#znc-progressBar').kendoProgressBar({\n\t\t\tmin: 0,\n            max: 100,\n\t\t\tvalue: false,\n            type: 'value',\n            animation: {\n                duration: 400\n            }\n        });\n\n\t\t// Add listeners to utility buttons\n\t\t$('#znc-addZoneButton').on('click', $.proxy(this._onAddZoneClick, this));\n\t\t$('#znc-addRoomButton').on('click', $.proxy(this._onAddRoomClick, this));\n\t\t$('#znc-editButton').on('click', $.proxy(this._onEditClick, this));\n\t\t$('#znc-removeButton').on('click', $.proxy(this._onRemoveClick, this));\n\t\t$('#znc-activateButton').on('click', $.proxy(this._onActivateClick, this));\n\n\t\t// Add listener to interface buttons\n\t\t$('#znc-cancelButton').on('click', $.proxy(this._onCancelClick, this));\n\t\t$('#znc-reloadButton').on('click', $.proxy(this._onReloadClick, this));\n\t\t$('#znc-submitButton').on('click', $.proxy(this._onSubmitClick, this));\n\t}\n\n\tdestroy()\n\t{\n\t\t// Call super method\n\t\tsuper.destroy();\n\n\t\t// Remove tree view doubleclick listener\n\t\t$('#znc-treeView').off('dblclick');\n\n\t\t// Remove listener for custom actions triggered by configuration interface\n\t\t$('#znc-tabNavigator').off('value-set');\n\n\t\t// Remove listener for zone/room activation event\n\t\t$('#znc-addZoneButton').off('click');\n\t\t$('#znc-addRoomButton').off('click');\n\t\t$('#znc-editButton').off('click');\n\t\t$('#znc-removeButton').off('click');\n\t\t$('#znc-activateButton').off('click');\n\n\t\t// Remove interface buttons click listeners\n\t\t$('#znc-cancelButton').off('click');\n\t\t$('#znc-reloadButton').off('click');\n\t\t$('#znc-submitButton').off('click');\n\n\t\t// Clear tabs container\n\t\tthis._clearTabs();\n\t}\n\n\tonExtensionCommand(command, data)\n\t{\n\t\tconst username = data.getUtfString('user');\n\n\t\t/****** ZONES & ROOMS ******/\n\n\t\t// Zones & rooms list received\n\t\tif (command == this.RESP_ZONES)\n\t\t\tthis._populateTree(data);\n\n\t\t// Zone or room configuration data received\n\t\telse if (command == this.RESP_ZONE_CONFIG || command == this.RESP_ROOM_CONFIG)\n\t\t{\n\t\t\t// Build user interface based on received data\n\t\t\tthis._interfaceBuilder.buildInterface(data.getSFSArray('settings'), 'znc-tabNavigator', false);\n\n\t\t\t// Enable scrolling tabs (if needed)\n\t\t\tif (this._reinitTabs)\n\t\t\t{\n\t\t\t\t$('#znc-tabNavigator #tabs').scrollingTabs({\n\t\t\t\t\tbootstrapVersion: 4,\n\t\t\t\t\tscrollToTabEdge: true,\n\t\t\t\t\tenableSwiping: true,\n\t\t\t\t\tdisableScrollArrowsOnFullyScrolled: true,\n\t\t\t\t\tcssClassLeftArrow: 'fa fa-chevron-left',\n\t\t\t\t\tcssClassRightArrow: 'fa fa-chevron-right'\n\t\t\t\t});\n\t\t\t}\n\n\t\t\t// Enable interface\n\t\t\tthis._enableConfigInterface(true);\n\t\t}\n\n\t\t/****** ZONES ******/\n\n\t\t// Zone configuration update confirmation\n\t\telse if (command == this.RESP_ZONE_CONFIG_UPDATE_CONFIRM)\n\t\t{\n\t\t\t// If a 'name' parameter is received, it means the zone name changed, and we have to update the zones list\n\t\t\tif (data.getUtfString('zName') != null)\n\t\t\t\tthis._updateZoneNameInList(data.getInt('zId'), data.getUtfString('zName'));\n\n\t\t\t// If the current user is the updater, show a notification; otherwise, show a dialog box suggesting to reload\n\t\t\tif (username == this.smartFox.mySelf.name)\n\t\t\t{\n\t\t\t\t// Enable interface\n\t\t\t\tthis._enableConfigInterface(true);\n\n\t\t\t\t// Display notification\n\t\t\t\tthis.shellCtrl.showNotification('Zone modified', `Zone settings updated successfully; changes will be applied on next <strong>server restart</strong>`);\n\n\t\t\t\t// Reset the 'modified' flag\n\t\t\t\tthis._interfaceBuilder.resetIsModified();\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\t// An alert box is displayed if the user is currently editing the same zone\n\t\t\t\tif (data.getInt('zId') == this._editedZoneId)\n\t\t\t\t{\n\t\t\t\t\t// Show alert\n\t\t\t\t\tthis.shellCtrl.showSimpleAlert(`Administrator ${username} has modified the Zone you are currently editing; please reload to update your view.`);\n\n\t\t\t\t\t// Disable submit button\n\t\t\t\t\t$('#znc-submitButton').attr('disabled', true);\n\t\t\t\t}\n\t\t\t\telse\n\t\t\t\t{\n\t\t\t\t\t// Display notification\n\t\t\t\t\tif (data.getUtfString('zName') != null)\n\t\t\t\t\t\tthis.shellCtrl.showNotification('Zone renamed', `Administrator ${username} has changed the name on one of the Zones`);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// New zone added\n\t\telse if (command == this.RESP_ZONE_ADDED)\n\t\t{\n\t\t\tconst zoneName = data.getSFSObject('zone').getUtfString('name');\n\n\t\t\t// If the current user is the updater, reset the interface; otherwise, just show a notification\n\t\t\tif (username == this.smartFox.mySelf.name)\n\t\t\t{\n\t\t\t\t// Reset interface\n\t\t\t\tthis._onCancelClick();\n\n\t\t\t\t// Display notification\n\t\t\t\tthis.shellCtrl.showNotification('Zone added', `Zone '${zoneName}' created successfully`);\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\t// Display notification\n\t\t\t\tthis.shellCtrl.showNotification('Zone added', `Administrator ${username} created Zone '${zoneName}'`);\n\t\t\t}\n\n\t\t\t// Add new zone to tree\n\t\t\tlet zonesDS = this._treeview.dataSource;\n\t\t\tzonesDS.add(this._createZoneObject(data.getSFSObject('zone')));\n\t\t\tzonesDS.sync();\n\t\t}\n\n\t\t// New zone creation refused due to invalid zone name\n\t\telse if (command == this.RESP_ZONE_REFUSED)\n\t\t{\n\t\t\t// Re-enable interface\n\t\t\tthis._enableConfigInterface(true);\n\n\t\t\t// Show warning\n\t\t\tthis.shellCtrl.showSimpleAlert('Zone configuration can\\'t be saved because another Zone with the same name already exists.', true);\n\t\t}\n\n\t\t// Existing zone deleted\n\t\telse if (command == this.RESP_ZONE_DELETED)\n\t\t{\n\t\t\t// If the current user is the deleter, reset the interface; otherwise, just show a notification\n\t\t\tif (username == this.smartFox.mySelf.name)\n\t\t\t{\n\t\t\t\t// Re-enable interface\n\t\t\t\tthis._enableListInterface(true);\n\n\t\t\t\t// Display notification\n\t\t\t\tthis.shellCtrl.showNotification('Zone removed', `Zone '${data.getUtfString('zName')}' deleted successfully`);\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\t// An alert box is displayed if the user is currently editing the same zone\n\t\t\t\tif (data.getInt('zId') == this._editedZoneId)\n\t\t\t\t{\n\t\t\t\t\t// Show alert\n\t\t\t\t\tthis.shellCtrl.showSimpleAlert(`Administrator ${username} has deleted the Zone you are currently modifying; you have to cancel your editing.`);\n\n\t\t\t\t\t// Disable submit and reload buttons\n\t\t\t\t\t$('#znc-reloadButton').attr('disabled', true);\n\t\t\t\t\t$('#znc-submitButton').attr('disabled', true);\n\t\t\t\t}\n\t\t\t\telse\n\t\t\t\t{\n\t\t\t\t\t// Display notification\n\t\t\t\t\tthis.shellCtrl.showNotification('Zone removed', `Administrator ${username} deleted Zone '${data.getUtfString('zName')}'`);\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Reset selection if the currently selected item or its parent is being removed\n\t\t\tlet selectedNode = this._treeview.select();\n\t\t\tlet selectedDataItem = this._treeview.dataItem(selectedNode);\n\t\t\tif (selectedDataItem)\n\t\t\t{\n\t\t\t\tif (selectedDataItem.type == this.ITEM_TYPE_ZONE && selectedDataItem.id == data.getInt('zId'))\n\t\t\t\t\tthis._deselectTreeItem();\n\n\t\t\t\tif (selectedDataItem.type == this.ITEM_TYPE_ROOM)\n\t\t\t\t{\n\t\t\t\t\tlet parentDataItem = this._treeview.dataItem(this._treeview.parent(selectedNode));\n\n\t\t\t\t\tif (parentDataItem.id == data.getInt('zId'))\n\t\t\t\t\t\tthis._deselectTreeItem();\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Remove zone from tree\n\t\t\tlet dataItem = this._getZoneDataItemById(data.getInt('zId'));\n\t\t\tlet zonesDS = this._treeview.dataSource;\n\t\t\tzonesDS.remove(dataItem);\n\t\t\tzonesDS.sync();\n\t\t}\n\n\t\t// Zone activated\n\t\telse if (command == this.RESP_ZONE_ACTIVATED)\n\t\t{\n\t\t\t// Set zone activation status\n\t\t\tconst zoneName = this._setZoneActivationStatus(data.getInt('zId'), data.getUtfString('actRooms'), true);\n\n\t\t\t// Display notification\n\t\t\tif (username == this.smartFox.mySelf.name)\n\t\t\t\tthis.shellCtrl.showNotification('Zone activated', `Zone '${zoneName}' activated successfully`);\n\t\t\telse\n\t\t\t\tthis.shellCtrl.showNotification('Zone activated', `Administrator ${username} activated Zone '${zoneName}'`);\n\t\t}\n\n\t\t// Zone activation error\n\t\telse if (command == this.RESP_ZONE_ACTIVATION_ERROR)\n\t\t{\n\t\t\t// Set zone activation status\n\t\t\tthis._setZoneActivationStatus(data.getInt('zId'), '', false);\n\n\t\t\t// Show alert\n\t\t\tthis.shellCtrl.showSimpleAlert(data.getUtfString('error'), true);\n\t\t}\n\n\t\t/****** ROOMS ******/\n\n\t\t// Room configuration update confirmation\n\t\telse if (command == this.RESP_ROOM_CONFIG_UPDATE_CONFIRM)\n\t\t{\n\t\t\tif (data.getUtfString('rName') != null)\n\t\t\t\tthis._updateRoomNameInList(data.getInt('zId'), data.getInt('rId'), data.getUtfString('rName'));\n\n\t\t\t// If the current user is the updater, show a notification; otherwise, show a dialog box suggesting to reload\n\t\t\tif (username == this.smartFox.mySelf.name)\n\t\t\t{\n\t\t\t\t// Enable interface\n\t\t\t\tthis._enableConfigInterface(true);\n\n\t\t\t\t// Display notification\n\t\t\t\tthis.shellCtrl.showNotification('Room modified', `Room settings updated successfully; changes will be applied on next <strong>server restart</strong>`);\n\n\t\t\t\t// Reset the 'modified' flag\n\t\t\t\tthis._interfaceBuilder.resetIsModified();\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\t// An alert box is displayed if the user is currently editing the same room\n\t\t\t\tif (data.getInt('rId') == this._editedRoomId)\n\t\t\t\t{\n\t\t\t\t\t// Show alert\n\t\t\t\t\tthis.shellCtrl.showSimpleAlert(`Administrator ${username} has modified the Room you are currently editing; please reload to update your view.`);\n\n\t\t\t\t\t// Disable submit button\n\t\t\t\t\t$('#znc-submitButton').attr('disabled', true);\n\t\t\t\t}\n\t\t\t\telse\n\t\t\t\t{\n\t\t\t\t\t// Display notification\n\t\t\t\t\tif (data.getUtfString('rName') != null)\n\t\t\t\t\t\tthis.shellCtrl.showNotification('Room renamed', `Administrator ${username} has changed the name on one of the Rooms`);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// New room added\n\t\telse if (command == this.RESP_ROOM_ADDED)\n\t\t{\n\t\t\tconst roomData = data.getSFSObject('room');\n\t\t\tconst zoneId = data.getInt('zId');\n\n\t\t\tlet zonesDS = this._treeview.dataSource;\n\t\t\tlet zoneItem = zonesDS.get(zoneId);\n\n\t\t\t// If the current user is the updater, reset the interface; otherwise, just show a notification\n\t\t\tif (username == this.smartFox.mySelf.name)\n\t\t\t{\n\t\t\t\t// Reset interface\n\t\t\t\tthis._onCancelClick();\n\n\t\t\t\t// Display notification\n\t\t\t\tthis.shellCtrl.showNotification('Room added', `Room '${roomData.getUtfString('name')}' created successfully`);\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\t// Display notification\n\t\t\t\tthis.shellCtrl.showNotification('Room added', `Administrator ${username} created Room '${roomData.getUtfString('name')}' in Zone '${zoneItem.name}'`);\n\t\t\t}\n\n\t\t\t// Add new room to tree\n\t\t\tzoneItem.append(this._createRoomObject(roomData, zoneId));\n\t\t\tzonesDS.sync();\n\n\t\t\t// Expand zone node where room was added\n\t\t\tthis._treeview.expand(this._treeview.select());\n\t\t}\n\n\t\t// New room creation refused due to invalid room name\n\t\telse if (command == this.RESP_ROOM_REFUSED)\n\t\t{\n\t\t\t// Re-enable interface\n\t\t\tthis._enableConfigInterface(true);\n\n\t\t\t// Show warning\n\t\t\tthis.shellCtrl.showSimpleAlert('Room configuration can\\'t be saved because another Room with the same name already exists.', true);\n\t\t}\n\n\t\t// Existing room deleted\n\t\telse if (command == this.RESP_ROOM_DELETED)\n\t\t{\n\t\t\tlet zoneItem = this._getZoneDataItemById(data.getInt('zId'));\n\t\t\tlet roomItem = this._getRoomDataItemById(data.getInt('zId'), data.getInt('rId'));\n\n\t\t\t// If the current user is the deleter, reset the interface; otherwise, just show a notification\n\t\t\tif (username == this.smartFox.mySelf.name)\n\t\t\t{\n\t\t\t\t// Re-enable interface\n\t\t\t\tthis._enableListInterface(true);\n\n\t\t\t\t// Display notification\n\t\t\t\tthis.shellCtrl.showNotification('Room removed', `Room '${roomItem.name}' deleted successfully`);\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\t// An alert box is displayed if the user is currently editing the same room\n\t\t\t\tif (data.getInt('rId') == this._editedRoomId)\n\t\t\t\t{\n\t\t\t\t\t// Show alert\n\t\t\t\t\tthis.shellCtrl.showSimpleAlert(`Administrator ${username} has deleted the Room you are currently modifying; you have to cancel your editing.`);\n\n\t\t\t\t\t// Disable submit and reload buttons\n\t\t\t\t\t$('#znc-reloadButton').attr('disabled', true);\n\t\t\t\t\t$('#znc-submitButton').attr('disabled', true);\n\t\t\t\t}\n\t\t\t\telse\n\t\t\t\t{\n\t\t\t\t\t// Display notification\n\t\t\t\t\tthis.shellCtrl.showNotification('Room removed', `Administrator ${username} deleted Room '${roomItem.name}' from Zone '${zoneItem.name}'`);\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Reset selection if the currently selected item or its parent is being removed\n\t\t\tlet selectedNode = this._treeview.select();\n\t\t\tlet selectedDataItem = this._treeview.dataItem(selectedNode);\n\t\t\tif (selectedDataItem)\n\t\t\t{\n\t\t\t\tif (selectedDataItem.type == this.ITEM_TYPE_ROOM && selectedDataItem.id == data.getInt('rId'))\n\t\t\t\t\tthis._deselectTreeItem();\n\t\t\t}\n\n\t\t\t// Remove room from tree\n\t\t\tzoneItem.children.remove(roomItem);\n\t\t\tthis._treeview.dataSource.sync();\n\t\t}\n\n\t\t// else if ()\n\t}\n\n\t//---------------------------------\n\t// UI EVENT LISTENERS\n\t//---------------------------------\n\n\t_onTreeItemDoubleClick(e)\n\t{\n\t\t// Get event target's closest tree node\n\t\tlet treeNode = $(e.target).closest('.k-item[role=treeitem]');\n\n\t\t// Get associated data item\n\t\tlet dataItem = this._treeview.dataItem(treeNode);\n\n\t\t// Load configuration\n\t\tthis._loadConfiguration(dataItem.type);\n\t}\n\n\t_onZoneRoomChange()\n\t{\n\t\t// Reset utility buttons\n\t\tthis._setUtilityButtonsState(this._selectedItem);\n\t}\n\n\t// Utility buttons listeners\n\n\t_onAddZoneClick()\n\t{\n\t\t// Deselect list item\n\t\tthis._deselectTreeItem();\n\n\t\t// Load configuration\n\t\tthis._loadConfiguration(this.ITEM_TYPE_ZONE);\n\t}\n\n\t_onAddRoomClick()\n\t{\n\t\t// Select parent list item\n\t\tthis._selectParentTreeItem();\n\n\t\t// Load configuration\n\t\tthis._loadConfiguration(this.ITEM_TYPE_ROOM);\n\t}\n\n\t_onEditClick()\n\t{\n\t\t// Load configuration\n\t\tthis._loadConfiguration(this._selectedItem.type);\n\t}\n\n\t_onRemoveClick()\n\t{\n\t\tthis.shellCtrl.showConfirmWarning(`Are you sure you want to delete the selected ${this._selectedItem.type == this.ITEM_TYPE_ZONE ? 'Zone' : 'Room'} configuration?`, $.proxy(this._onRemoveConfirm, this));\n\t}\n\n\t_onRemoveConfirm()\n\t{\n\t\t// Disable zone/room selection list\n\t\tthis._enableListInterface(false);\n\n\t\tlet params = new SFS2X.SFSObject();\n\n\t\t// Request zone removal\n\t\tif (this._selectedItem.type == this.ITEM_TYPE_ZONE)\n\t\t{\n\t\t\tparams.putInt('zId', this._selectedItem.id);\n\t\t\tthis.sendExtensionRequest(this.REQ_DELETE_ZONE_CONFIG, params);\n\t\t}\n\t\telse\n\t\t{\n\t\t\tparams.putInt('zId', this._selectedItemParent.id);\n\t\t\tparams.putInt('rId', this._selectedItem.id);\n\t\t\tthis.sendExtensionRequest(this.REQ_DELETE_ROOM_CONFIG, params);\n\t\t}\n\t}\n\n\t_onActivateClick()\n\t{\n\t\t// Get selected data item\n\t\tif (this._selectedItem.type == this.ITEM_TYPE_ZONE)\n\t\t{\n\t\t\tlet params = new SFS2X.SFSObject();\n\t\t\tparams.putInt('zId', this._selectedItem.id);\n\n\t\t\tthis.sendExtensionRequest(this.REQ_ACTIVATE_ZONE, params);\n\t\t}\n\t}\n\n\t// Configuration buttons listeners\n\n\t_onCancelClick()\n\t{\n\t\t// Enable zone/room selection lists\n\t\tthis._enableListInterface(true);\n\n\t\t// Disable configuration interface\n\t\tthis._enableConfigInterface(false);\n\n\t\t// Clear main container\n\t\tthis._resetTabsContainer(false, true);\n\n\t\t// Set isEditing flag\n\t\tthis._isEditing = false;\n\t\tthis._editedItemType = '';\n\n\t\t// Switch panel\n\t\tthis._switchPanel('znc-sidebarPanel');\n\t}\n\n\t_onReloadClick()\n\t{\n\t\t// Hide validation messages\n\t\tthis._interfaceBuilder.resetValidation();\n\n\t\t// Reload configuration\n\t\tthis._loadConfiguration(this._editedItemType, false);\n\t}\n\n\t_onSubmitClick()\n\t{\n\t\t// Check validity\n\t\tif (this._interfaceBuilder.checkIsValid())\n\t\t{\n\t\t\tlet changes = this._interfaceBuilder.getChangedData();\n\n\t\t\tif (changes.size() > 0)\n\t\t\t{\n\t\t\t\t//console.log(changes.getDump())\n\n\t\t\t\t// In case the zone/room name changed, check it against the list (duplicate names not allowed!)\n\t\t\t\tif (this._validateName(changes))\n\t\t\t\t{\n\t\t\t\t\t// Disable configuration interface\n\t\t\t\t\tthis._enableConfigInterface(false);\n\n\t\t\t\t\t// Send settings to server instance\n\t\t\t\t\tlet params = new SFS2X.SFSObject();\n\t\t\t\t\tparams.putSFSArray('settings', changes);\n\t\t\t\t\tparams.putBool('backup', $('#znc-backupCheck').prop('checked'));\n\t\t\t\t\tparams.putInt('zId', this._editedZoneId);\n\t\t\t\t\tparams.putInt('rId', this._editedRoomId);\n\n\t\t\t\t\tif (this._editedItemType == this.ITEM_TYPE_ZONE)\n\t\t\t\t\t{\n\t\t\t\t\t\t// Submit zone settings\n\t\t\t\t\t\tif (this._editedZoneId > -1)\n\t\t\t\t\t\t\tthis.sendExtensionRequest(this.REQ_SAVE_ZONE_CONFIG, params);\n\t\t\t\t\t\telse\n\t\t\t\t\t\t\tthis.sendExtensionRequest(this.REQ_NEW_ZONE_CONFIG, params);\n\t\t\t\t\t}\n\t\t\t\t\telse\n\t\t\t\t\t{\n\t\t\t\t\t\t// Submit room settings\n\t\t\t\t\t\tif (this._editedRoomId > -1)\n\t\t\t\t\t\t\tthis.sendExtensionRequest(this.REQ_SAVE_ROOM_CONFIG, params);\n\t\t\t\t\t\telse\n\t\t\t\t\t\t\tthis.sendExtensionRequest(this.REQ_NEW_ROOM_CONFIG, params);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\telse\n\t\t\t\t{\n\t\t\t\t\t// Show alert\n\t\t\t\t\tthis.shellCtrl.showSimpleAlert(`Unable to submit configuration because the ${capitalizeFirst(this._editedItemType)} name already exists; duplicate names are not allowed.`, true);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\telse\n\t\t{\n\t\t\t// Show alert\n\t\t\tthis.shellCtrl.showSimpleAlert('Unable to submit configuration changes due to an invalid value; please verify the highlighted form fields in all tabs.', true);\n\t\t}\n\t}\n\n\t_onConfigValueSet(e) // SAME METHOD DUPLICATED IN zone-monitor.js\n\t{\n\t\tconst configParam = e.target.data;\n\n\t\t// Handle extension name/type dropdowns update and update the main class dropdown datasource accordingly\n\t\tif (configParam.name == 'extension.name' || configParam.name == 'extension.type' || configParam.name == 'extension.filterClass')\n\t\t{\n\t\t\t// All involved ConfigFormItems must be available and initialized to proceed\n\t\t\tconst nameFormItem = this._interfaceBuilder.getConfigFormItem('extension.name');\n\t\t\tconst typeFormItem = this._interfaceBuilder.getConfigFormItem('extension.type');\n\t\t\tconst classFormItem = this._interfaceBuilder.getConfigFormItem('extension.file');\n\t\t\tconst filterFormItem = this._interfaceBuilder.getConfigFormItem('extension.filterClass');\n\n\t\t\tif (nameFormItem != null && typeFormItem != null && classFormItem != null && filterFormItem != null)\n\t\t\t{\n\t\t\t\tconst source = nameFormItem.data;\n\t\t\t\tlet classesList = [];\n\n\t\t\t\tlet data = source.triggerData;\n\t\t\t\tfor (let i = 0; i < data.size(); i++)\n\t\t\t\t{\n\t\t\t\t\tlet ext = data.getSFSObject(i);\n\n\t\t\t\t\tif (ext.getUtfString('name') == nameFormItem.data.value && ext.getUtfString('type') == typeFormItem.data.value)\n\t\t\t\t\t{\n\t\t\t\t\t\tlet classes = ext.getUtfString('classesString').split(',');\n\n\t\t\t\t\t\tif (filterFormItem.data.value == true)\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tlet filteredClasses = classes.filter(filterClassName);\n\t\t\t\t\t\t\tclasses = filteredClasses;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\tclassesList = classesList.concat(classes);\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tlet currentClass = classFormItem.data.value;\n\n\t\t\t\t// If the classes list doesn't contain the current value, create an empty entry and reset the value\n\t\t\t\tif (classesList.indexOf(currentClass) < 0)\n\t\t\t\t{\n\t\t\t\t\tif (classesList.length == 0)\n\t\t\t\t\t{\n\t\t\t\t\t\tclassesList.push('');\n\t\t\t\t\t\tcurrentClass = '';\n\t\t\t\t\t}\n\t\t\t\t\telse\n\t\t\t\t\t\tcurrentClass = classesList[0];\n\t\t\t\t}\n\n\t\t\t\tlet mainClassDropDown = classFormItem._innerWidget;\n\t\t\t\tmainClassDropDown.setDataSource(classesList);\n\n\t\t\t\tclassFormItem.data.value = currentClass;\n\t\t\t\tclassFormItem._setWidgetValue();\n\t\t\t}\n\t\t}\n\t}\n\n\t//---------------------------------\n\t// PRIVATE METHODS\n\t//---------------------------------\n\n\t_enableListInterface(enabled)\n\t{\n\t\t$('#znc-utilButtons').attr('disabled', !enabled);\n\t\t$('#znc-treeView').attr('disabled', !enabled);\n\t}\n\n\t_setUtilityButtonsState(dataItem = null)\n\t{\n\t\tlet disable = true;\n\n\t\tif (dataItem)\n\t\t{\n\t\t\t// Enable 'activate zone' button if zone is inactive\n\t\t\t$('#znc-activateButton').attr('disabled', (dataItem.type != this.ITEM_TYPE_ZONE || dataItem.active));\n\n\t\t\tdisable = false;\n\t\t}\n\t\telse\n\t\t{\n\t\t\t// Disable 'activate zone' button\n\t\t\t$('#znc-activateButton').attr('disabled', true);\n\t\t}\n\n\t\t// Enable/disable other utility buttons\n\t\t$('#znc-addZoneButton').attr('disabled', false); // Always enabled\n\t\t$('#znc-addRoomButton').attr('disabled', disable);\n\t\t$('#znc-editButton').attr('disabled', disable);\n\t\t$('#znc-removeButton').attr('disabled', disable);\n\t}\n\n\t_enableConfigInterface(enabled)\n\t{\n\t\t$('#znc-cancelButton').attr('disabled', !enabled);\n\t\t$('#znc-reloadButton').attr('disabled', !enabled);\n\t\t$('#znc-submitButton').attr('disabled', !enabled);\n\t\t$('#znc-backupCheck').attr('disabled', !enabled);\n\n\t\tthis._interfaceBuilder.disableInterface(!enabled);\n\n\t\t// Also switch view when enabled\n\t\tif (enabled)\n\t\t\tthis._switchView('znc-main');\n\t}\n\n\t_switchView(viewId)\n\t{\n\t\tdocument.getElementById('znc-viewstack').selectedElement = document.getElementById(viewId);\n\t}\n\n\t_clearTabs()\n\t{\n\t\t// Destroy scrolling tabs\n\t\t$('#znc-tabNavigator #tabs').scrollingTabs('destroy');\n\n\t\t// Remove all tab navigator content\n\t\tthis._interfaceBuilder.destroyInterface();\n\n\t\t// Set flag to re-initialize tabs if needed\n\t\tthis._reinitTabs = true;\n\t}\n\n\t_populateTree(data)\n\t{\n\t\tlet zData = data.getSFSArray('zones');\n\n\t\tlet zonesArr = [];\n\t\tfor (let z = 0; z < zData.size(); z++)\n\t\t\tzonesArr.push( this._createZoneObject(zData.getSFSObject(z)) );\n\n\t\t// Create datasource\n\t\tlet zones = new kendo.data.HierarchicalDataSource({\n            data: zonesArr,\n\t\t\tsort: {\n\t\t\t\tfield: 'name',\n\t\t\t\tdir: 'asc'\n\t\t\t},\n            schema: {\n                model: {\n\t\t\t\t\tid: 'id',\n                    children: {\n\t\t\t\t\t\tschema: {\n\t\t\t\t\t\t\tdata: 'rooms',\n\t\t\t\t\t\t\tsort: {\n\t\t\t\t\t\t\t\tfield: 'name',\n\t\t\t\t\t\t\t\tdir: 'asc'\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n                }\n            }\n        });\n\n\t\t// Set tree view dataprovider\n\t\tthis._treeview.setDataSource(zones);\n\n\t\t// Set utility buttons state (add, remove, edit, etc)\n\t\tthis._setUtilityButtonsState();\n\t}\n\n\t_createZoneObject(zoneData)\n\t{\n\t\tlet zone = {\n\t\t\ttype: this.ITEM_TYPE_ZONE,\n\t\t\tname: zoneData.getUtfString('name'),\n\t\t\tid: zoneData.getInt('id'),\n\t\t\tactive: zoneData.getBool('act')\n\t\t}\n\n\t\t// Create rooms list dataprovider\n\t\tlet rData = zoneData.getSFSArray('rooms');\n\n\t\tlet roomsArr = [];\n\t\tfor (let r = 0; r < rData.size(); r++)\n\t\t\troomsArr.push( this._createRoomObject(rData.getSFSObject(r), zoneData.getInt('id')) );\n\n\t\tzone.rooms = roomsArr;\n\n\t\treturn zone;\n\t}\n\n\t_createRoomObject(roomData, zoneId)\n\t{\n\t\tlet room = {\n\t\t\ttype: this.ITEM_TYPE_ROOM,\n\t\t\tname: roomData.getUtfString('name'),\n\t\t\tid: roomData.getInt('id'),\n\t\t\tactive: roomData.getBool('act'),\n\t\t\tparentId: zoneId,\n\t\t\tspriteCssClass: this._getRoomListIconCssClass(roomData.getBool('act'))\n\t\t};\n\n\t\treturn room;\n\t}\n\n\t_getRoomListIconCssClass(isActive)\n\t{\n\t\treturn isActive ? 'fas fa-door-open' : 'fas fa-door-closed inactive-list-item';\n\t}\n\n\t_setZoneActivationStatus(zoneId, activeRooms, isActive)\n\t{\n\t\tlet zoneDI = this._getZoneDataItemById(zoneId);\n\n\t\tzoneDI.active = isActive;\n\n\t\tlet activeRoomsArr = activeRooms.split(',');\n\n\t\tif (zoneDI.hasChildren)\n\t\t{\n\t\t\tfor (let i = 0; i < zoneDI.children.data().length; i++)\n\t\t\t{\n\t\t\t\tlet room = zoneDI.children.data()[i];\n\t\t\t\troom.active = (isActive && activeRoomsArr.indexOf(room.name) > -1);\n\t\t\t\troom.spriteCssClass = this._getRoomListIconCssClass(room.active)\n\t\t\t}\n\t\t}\n\n\t\t// Refresh list\n\t\tthis._treeview.dataSource.sync();\n\n\t\t// Return zone name\n\t\treturn zoneDI.name;\n\t}\n\n\t_deselectTreeItem()\n\t{\n\t\tthis._treeview.select($());\n\t}\n\n\t_selectParentTreeItem()\n\t{\n\t\tlet selectedNode = this._treeview.select();\n\t\tlet selectedDataItem = this._treeview.dataItem(selectedNode);\n\n\t\tif (selectedDataItem.type == this.ITEM_TYPE_ROOM)\n\t\t{\n\t\t\tlet parentNode = this._treeview.parent(selectedNode);\n\t\t\tthis._treeview.select(parentNode);\n\t\t}\n\t}\n\n\t_loadConfiguration(type, resetTabs = true)\n\t{\n\t\t// Disable zone/room selection list\n\t\tthis._enableListInterface(false);\n\n\t\t// Disable configuration interface\n\t\tthis._enableConfigInterface(false);\n\n\t\t// Clear main container\n\t\tthis._resetTabsContainer(true, resetTabs);\n\n\t\t// Set isEditing flag\n\t\tthis._isEditing = true;\n\t\tthis._editedItemType = type;\n\n\t\t// Request zone or room configuration data to server instance\n\t\tlet params = new SFS2X.SFSObject();\n\t\tparams.putInt('zId', this._editedZoneId);\n\t\tparams.putInt('rId', this._editedRoomId);\n\n\t\t// If no room is selected, then we are editing a zone\n\t\tif (this._editedItemType == this.ITEM_TYPE_ZONE)\n\t\t\tthis.sendExtensionRequest(this.REQ_GET_ZONE_CONFIG, params);\n\t\telse\n\t\t\tthis.sendExtensionRequest(this.REQ_GET_ROOM_CONFIG, params);\n\n\t\t// Switch panel\n\t\tthis._switchPanel('znc-mainPanel');\n\t}\n\n\t_resetTabsContainer(isLoading, resetTabs)\n\t{\n\t\tif (resetTabs)\n\t\t\tthis._clearTabs();\n\t\telse\n\t\t\tthis._reinitTabs = false;\n\n\t\tif (!isLoading)\n\t\t\tthis._switchView('znc-select');\n\t\telse\n\t\t\tthis._switchView('znc-loading');\n\t}\n\n\t_switchPanel(panelId)\n\t{\n\t\tdocument.getElementById('znc-view').selectedPanel = document.getElementById(panelId);\n\t}\n\n\t_getZoneDataItemById(zoneId)\n\t{\n\t\tlet zonesDS = this._treeview.dataSource;\n\t\treturn zonesDS.get(zoneId);\n\t}\n\n\t_getRoomDataItemById(zoneId, roomId)\n\t{\n\t\tlet zoneDI = this._getZoneDataItemById(zoneId);\n\n\t\tif (zoneDI.hasChildren)\n\t\t\treturn zoneDI.children.get(roomId);\n\n\t\treturn null;\n\t}\n\n\t_updateZoneNameInList(zoneId, zoneName)\n\t{\n\t\tthis._getZoneDataItemById(zoneId).name = zoneName;\n\t\tthis._treeview.dataSource.sync();\n\t}\n\n\t_updateRoomNameInList(zoneId, roomId, roomName)\n\t{\n\t\tthis._getRoomDataItemById(zoneId, roomId).name = roomName;\n\t\tthis._treeview.dataSource.sync();\n\t}\n\n\t_validateName(changes)\n\t{\n\t\tconst zoneId = this._editedZoneId;\n\n\t\tfor (let i = 0; i < changes.size(); i++)\n\t\t{\n\t\t\tconst setting = changes.getSFSObject(i);\n\n\t\t\tif (setting.containsKey('name') && setting.getUtfString('name') == 'name')\n\t\t\t{\n\t\t\t\t// Get name value\n\t\t\t\tconst name = setting.getText('value');\n\n\t\t\t\t// Get data source\n\t\t\t\tlet ds = [];\n\n\t\t\t\tif (this._editedItemType == this.ITEM_TYPE_ZONE)\n\t\t\t\t\tds = this._treeview.dataSource.data();\n\t\t\t\telse\n\t\t\t\t{\n\t\t\t\t\tif (this._getZoneDataItemById(zoneId).hasChildren)\n\t\t\t\t\t\tds = this._getZoneDataItemById(zoneId).children.data();\n\t\t\t\t}\n\n\n\t\t\t\t// Check if name exists in data source\n\t\t\t\tfor (let j = 0; j < ds.length; j++)\n\t\t\t\t{\n\t\t\t\t\tif (ds[j].name == name)\n\t\t\t\t\t{\n\t\t\t\t\t\treturn false;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\n\t\treturn true;\n\t}\n\n\t//---------------------------------\n\t// PRIVATE GETTERS\n\t//---------------------------------\n\n\tget _selectedItem()\n\t{\n\t\treturn this._treeview.dataItem(this._treeview.select());\n\t}\n\n\tget _selectedItemParent()\n\t{\n\t\tlet selectedNode = this._treeview.select();\n\t\tlet parentNode = this._treeview.parent(selectedNode);\n\n\t\treturn this._treeview.dataItem(parentNode);\n\t}\n\n\tget _editedZoneId()\n\t{\n\t\tif (this._isEditing && this._selectedItem)\n\t\t{\n\t\t\tif (this._selectedItem.type == this.ITEM_TYPE_ZONE)\n\t\t\t\treturn this._selectedItem.id;\n\t\t\telse\n\t\t\t\treturn this._selectedItemParent.id;\n\t\t}\n\n\t\treturn -1;\n\t}\n\n\tget _editedRoomId()\n\t{\n\t\tif (this._isEditing && this._selectedItem)\n\t\t{\n\t\t\tif (this._selectedItem.type == this.ITEM_TYPE_ROOM)\n\t\t\t\treturn this._selectedItem.id;\n\t\t}\n\n\t\treturn -1;\n\t}\n}\n"],"mappings":";;;;;;;;;;;AAAA;AAAA;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;ACvHA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;A","sourceRoot":""}