rubyfox-server 2.13.7.3 → 2.16.0.4

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

@@ -0,0 +1,766 @@
+/*! (c) gotoAndPlay | All rights reserved */
+(window["webpackJsonpapplication"] = window["webpackJsonpapplication"] || []).push([["module-10"],{
+
+/***/ "./src/managers/file-datasource-manager.js":
+/*!*************************************************!*\
+  !*** ./src/managers/file-datasource-manager.js ***!
+  \*************************************************/
+/*! exports provided: FileDataSourceManager */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "FileDataSourceManager", function() { return FileDataSourceManager; });
+class FileDataSourceManager
+{
+	constructor(libFolder, protectedFolders, fileSeparator)
+	{
+		this._protectedFolders = protectedFolders; // Folders which can't be deleted (but their content can)
+		this._libFolder = libFolder;
+		this._fileSeparator = fileSeparator;
+	}
+
+	get dataSource()
+	{
+		return this._dataSource;
+	}
+
+	init()
+	{
+		this._dataSource = new kendo.data.TreeListDataSource({
+			data: [],
+			schema: {
+				model: {
+					id: 'id',
+					parentId: 'parentId',
+					expanded: false
+				}
+			},
+			sort: { field: 'name', dir: 'asc' }
+		});
+	}
+
+	addFile(fileObj, parentLevel = null)
+	{
+		let file = {};
+
+		file.name = fileObj.getUtfString('name');
+		file.isDir = fileObj.getBool('isDir');
+		file.lastMod = fileObj.getLong('lastMod');
+		file.isLib = (file.isDir && file.name == this._libFolder);
+		file.isProtected = (file.isDir && this._protectedFolders.indexOf(file.name) > -1);
+		file.size = 0;
+
+		if (parentLevel == null)
+			file.level = 0;
+		else
+			file.level = parentLevel + 1;
+
+		if (fileObj.containsKey('parent'))
+		{
+			file.parentId = fileObj.getUtfString('parent');
+			file.id = file.parentId + this._fileSeparator + file.name;
+		}
+		else
+		{
+			file.parentId = null;
+			file.id = file.name;
+		}
+
+		// Add child files
+		if (file.isDir)
+		{
+			let filesArr = fileObj.getSFSArray('files');
+
+			for (let i = 0; i < filesArr.size(); i++)
+				file.size += this.addFile(filesArr.getSFSObject(i), file.level);
+		}
+		else
+			file.size = fileObj.getLong('size');
+
+		// Add file to data source
+		this._dataSource.add(file);
+
+		// Return file size
+		return file.size;
+	}
+
+	removeFile(id)
+	{
+		let fileItem = this._dataSource.get(id);
+
+		if (fileItem)
+		{
+			if (fileItem.parentId)
+			{
+				// Subtract old size from parent size
+				let parentItem = this._dataSource.get(fileItem.parentId);
+				this._updateParentSize(parentItem, -fileItem.size);
+			}
+
+			this._dataSource.remove(fileItem);
+
+			// Return parent item
+			if (fileItem.parentId)
+				return this._dataSource.get(fileItem.parentId);
+		}
+	}
+
+	getFileById(id)
+	{
+		return this._dataSource.get(id);
+	}
+
+	addFileToParent(fileObj, parentId)
+	{
+		let parentItem = this._dataSource.get(parentId);
+
+		if (parentItem != null && parentItem.isDir)
+		{
+			const fileId = parentId + this._fileSeparator + fileObj.getUtfString('name');
+			let fileItem = this._dataSource.get(fileId);
+
+			if (fileItem != null)
+			{
+				// Subtract old size from parent size
+				this._updateParentSize(parentItem, -fileItem.size);
+
+				// Update existing item
+				fileItem.name = fileObj.getUtfString('name');
+				fileItem.lastMod = fileObj.getLong('lastMod');
+				fileItem.size = fileObj.getLong('size');
+			}
+			else
+			{
+				// Add new item
+				this.addFile(fileObj, parentItem.level);
+			}
+
+			// Update parent item size
+			this._updateParentSize(parentItem, fileObj.getLong('size'));
+
+			return fileId;
+		}
+		else
+			throw new Error(`An unexpected error occurred while adding file '${fileObj.getUtfString('name')}' (target: ${parentId}).`);
+	}
+
+	_updateParentSize(parentItem, value)
+	{
+		parentItem.size += value;
+
+		if (parentItem.parentId)
+		{
+			let grandParent = this._dataSource.get(parentItem.parentId);
+			this._updateParentSize(grandParent, value);
+		}
+	}
+}
+
+
+/***/ }),
+
+/***/ "./src/modules/servlet-manager.js":
+/*!****************************************!*\
+  !*** ./src/modules/servlet-manager.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 ServletManager; });
+/* harmony import */ var _base_module__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./base-module */ "./src/modules/base-module.js");
+/* harmony import */ var _managers_file_datasource_manager__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../managers/file-datasource-manager */ "./src/managers/file-datasource-manager.js");
+/* harmony import */ var _utils_utilities__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../utils/utilities */ "./src/utils/utilities.js");
+
+
+
+
+class ServletManager extends _base_module__WEBPACK_IMPORTED_MODULE_0__["BaseModule"]
+{
+	constructor()
+	{
+	    super('servletMan');
+
+		// Outgoing requests
+		this.REQ_INIT = 'init';
+		this.REQ_GET_SERVLETS = 'getServlets';
+		this.REQ_CREATE_FOLDER = 'createFolder';
+		this.REQ_DELETE_FILES = 'deleteSrvltFiles';
+
+		// Incoming responses
+		this.RESP_LOCKED = 'lock';
+		this.RESP_INIT = 'init';
+		this.RESP_SERVLETS = 'servlets';
+		this.RESP_FILE_ADDED = 'fileAdded';
+		this.RESP_FILES_DELETED = 'filesDeleted';
+		this.RESP_ERROR = 'error';
+	}
+
+	//------------------------------------
+	// 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);
+
+		// Initialize progress bar
+		$('#svm-progressBar').kendoProgressBar({
+			min: 0,
+            max: 100,
+			value: false,
+            type: 'value',
+            animation: {
+                duration: 400
+            }
+        });
+
+		// Add listeners to buttons
+		$('#svm-retryBt').on('click', $.proxy(this._onRetryClick, this));
+		$('#svm-refreshBt').on('click', $.proxy(this._onRefreshClick, this));
+
+		// Initialize files list
+		this._filesList = $('#svm-fileList').kendoTreeList({
+            dataSource: [],
+			resizable: true,
+			selectable: true,
+            columns: [
+                {
+					field: 'name',
+					title: 'Name',
+					template: kendo.template(`
+						<div >
+							# if (isDir) { #
+								# if (expanded) { #
+									<i class="fas fa-folder-open"></i>
+								# } else { #
+									<i class="fas fa-folder"></i>
+								# } #
+							# } else { #
+								<i class="far fa-file"></i>
+							# } #
+
+							#: name #
+
+						</div>
+						<div class="file-controls flex-grow-1 text-right" data-item-id="#:id#">
+							# if (isDir) { #
+								<button type="button" class="k-button k-primary my-1 create-folder-bt"><i class="fas fa-folder-plus"></i></button>
+								<button type="button" class="k-button k-primary my-1 upload-files-bt"><i class="fas fa-file-upload"></i></button>
+							# } #
+
+							# if (level > 0 && !isProtected) { #
+								<button type="button" class="k-button k-primary my-1 remove-file-bt"><i class="fas fa-minus-circle"></i></button>
+							# } #
+						</div>
+					`),
+				},
+                {
+					field: 'size',
+					title: 'Size',
+					template: function(dataItem) {
+						dataItem.bytesToSize = _utils_utilities__WEBPACK_IMPORTED_MODULE_2__["bytesToSize"]; // Pass bytesToSize utility function to template
+						return kendo.template(`
+							#: bytesToSize(size, 2, 'KB') #
+						`)(dataItem);
+					},
+					width: 120,
+					minScreenWidth: 576
+				},
+                {
+					field: 'lastMod',
+					title: 'Last Modified',
+					template: kendo.template(`
+						#: kendo.toString(new Date(lastMod), 'dd MMM yyyy HH:mm:ss') #
+					`),
+					width: 200,
+					minScreenWidth: 768
+				},
+            ],
+			change: $.proxy(this._onFileSelectedChange, this)
+        }).data('kendoTreeList');
+
+		//-------------------------------------------
+
+		// Add listeners to catch control button clicks on rows
+		$('#svm-fileList').on('click', '.create-folder-bt', $.proxy(this._showAddFolderModalClick, this));
+		$('#svm-fileList').on('click', '.upload-files-bt', $.proxy(this._showUploadFilesModalClick, this));
+		$('#svm-fileList').on('click', '.remove-file-bt', $.proxy(this._onRemoveFileClick, this));
+
+		//-------------------------------------------
+
+		// Initialize "add folder" modal
+		this._addFolderModal = $('#svm-addFolderModal');
+		this._addFolderModal.modal({
+			backdrop: 'static',
+			keyboard: false,
+			show: false
+		});
+
+		// Add listener to modal hide event
+		this._addFolderModal.on('hidden.bs.modal', $.proxy(this._onAddFolderModalHidden, this));
+
+		// Add listener to Add button click
+		$('#svm-addFolderBt').on('click', $.proxy(this._onAddFolderClick, this));
+
+		// Initialize kendo validation on folder name form
+		this._addFolderValidator = $('#svm-addFolderForm').kendoValidator({}).data('kendoValidator');
+
+		//-------------------------------------------
+
+		// Initialize "upload files" modal
+		this._uploadFilesModal = $('#svm-uploadModal');
+		this._uploadFilesModal.modal({
+			backdrop: 'static',
+			keyboard: false,
+			show: false
+		});
+
+		// Initialize kendo uploader
+		this._uploader = $('#svm-uploader').kendoUpload({
+			multiple: true,
+			async: {
+				saveUrl: 'http://localhost', // This will be changed later in _onUploadStart method
+				autoUpload: true,
+			},
+			directoryDrop: true,
+			upload: $.proxy(this._onUploadStart, this),
+			complete: $.proxy(this._onUploadEnd, this),
+			localization: {
+				select: 'Select files...'
+			}
+		}).data('kendoUpload');
+
+		// Add listener to Upload button click
+		$('#svm-clearFilesBt').on('click', $.proxy(this._onClearFilesClick, this));
+
+		//-------------------------------------------
+
+		// Send initialization request
+		this.sendExtensionRequest(this.REQ_INIT);
+	}
+
+	destroy()
+	{
+		// Call super method
+		super.destroy();
+
+		$('#svm-retryBt').off('click');
+		$('#svm-refreshBt').off('click');
+
+		$('#svm-fileList').off('click');
+
+		this._addFolderModal.off('hidden.bs.modal');
+		this._addFolderModal.modal('dispose');
+		$('#svm-addFolderBt').off('click');
+
+		this._uploadFilesModal.modal('dispose');
+		$('#svm-clearFilesBt').off('click');
+	}
+
+	onExtensionCommand(command, data)
+	{
+		// Module can be enabled (no locking file exists)
+		if (command == this.RESP_INIT)
+		{
+			// Retrieve file separator
+			this._fileSeparator = data.getUtfString('sep');
+
+			// Create file data source manager
+			this._fileManager = new _managers_file_datasource_manager__WEBPACK_IMPORTED_MODULE_1__["FileDataSourceManager"](null, [], this._fileSeparator);
+
+			// Retrieve HTTP port to be used for files uploading
+			const uploadHttpPort = data.getInt('httpPort');
+
+			// Retrieve module id sent by the server (required because multiple modules use file uploading service)
+			const uploadModuleId = data.getUtfString('modId');
+
+			// Set file uploading target configuration
+			this._uploadTargetConfig = {
+				sessionToken: this.smartFox.sessionToken,
+				host: this.smartFox.config.host,
+				httpPort: uploadHttpPort,
+				moduleId: uploadModuleId,
+			};
+
+			// Request Servlet files data to server instance
+			this._refreshDataList();
+		}
+
+		/*
+		 * This response is returned if the file UploadsLock.txt exists in the /config folder of the server.
+		 * This is an additional security measure to avoid unwanted files to be uploaded by malicius users accessing the server
+		 * with the default credentials, in case they have not been changed by the administrator after the installation.
+		 * The file must be removed manually before accessing the Servlet Manager module for the first time
+		 */
+		else if (command == this.RESP_LOCKED)
+		{
+			// Show warning
+			this._switchView('svm-locked');
+		}
+
+		// Servlet folders and files
+		else if (command == this.RESP_SERVLETS)
+		{
+			// Retrieve Servlets file list
+			let servletsObj = data.getSFSObject('servlets');
+
+			// Initialize manager
+			this._fileManager.init();
+
+			// Add list to manager
+			this._fileManager.addFile(servletsObj);
+
+			// Set TreeList data source
+			this._filesList.setDataSource(this._fileManager.dataSource);
+
+			// Expand first level
+			this._filesList.expand($('#svm-fileList tbody>tr:eq(0)'));
+
+			// Enable interface
+			this._enableInterface(true);
+
+			// Show module's main view
+			this._switchView('svm-main');
+		}
+
+		// An error occurred while managing servlet files
+		else if (command == this.RESP_ERROR)
+		{
+			// Hide add folder modal
+			this._addFolderModal.modal('hide');
+
+			// Re-enable interface
+			this._enableInterface(true);
+
+			// Show an alert
+			this.shellCtrl.showSimpleAlert(data.getUtfString('error'));
+		}
+
+		// Servlet folder or file added
+		else if (command == this.RESP_FILE_ADDED)
+		{
+			// Get name of the user who added the file/folder
+			const requester = data.getUtfString('user');
+
+			// Get the object representing the file/folder being added
+			const fileObj = data.getSFSObject('file');
+
+			// Get the target folder where the new file/folder should be added
+			const parentPath = data.getUtfString('parent');
+
+			// Get the flag notifying this was a file upload
+			const isUpload = data.getBool('isUpload');
+
+			try
+			{
+				// Add/update item on data source
+				const filePath = this._fileManager.addFileToParent(fileObj, parentPath);
+
+				// Refresh view
+				this._filesList.refresh();
+
+				if (requester == this.smartFox.mySelf.name)
+				{
+					// Expand parent
+					this._filesList.expand($(`#svm-fileList .file-controls[data-item-id="${parentPath}"]`).closest('tr'));
+
+					if (!isUpload)
+					{
+						// Hide modal
+						this._addFolderModal.modal('hide');
+
+						// Select upload file
+						this._filesList.select($(`#svm-fileList .file-controls[data-item-id="${filePath}"]`).closest('tr'));
+					}
+
+					// Update selection
+					this._onFileSelectedChange();
+				}
+				else
+				{
+					// Display notification
+					if (!isUpload)
+						this.shellCtrl.showNotification(`Folder created`, `Administrator ${requester} created folder: <strong>${filePath}</strong>`);
+					else
+						this.shellCtrl.showNotification(`File uploaded`, `Administrator ${requester} uploaded file: <strong>${filePath}</strong>`);
+				}
+			}
+			catch (e)
+			{
+				// This should not happen... data source is corrupted?
+				if (requester == this.smartFox.mySelf.name)
+					this.shellCtrl.showSimpleAlert(e.message, true);
+			}
+
+			// Enable interface
+			this._enableInterface(true);
+		}
+
+		// Servlet files deleted
+		else if (command == this.RESP_FILES_DELETED)
+		{
+			// Get name of the user who deleted the file/s
+			const requester = data.getUtfString('user');
+
+			// Get the list of deleted files
+			let files = data.getSFSArray('files');
+
+			let filesArr = [];
+
+			// Update data source
+			for (let j = 0; j < files.size(); j++)
+			{
+				let path = files.getUtfString(j);
+				filesArr.push(path);
+
+				//------------------------
+
+				// Remove item from data source; parent item is returned
+				let parentItem = this._fileManager.removeFile(path);
+
+				// Collapse parent if the last of its children was deleted
+				if (parentItem && !parentItem.hasChildren)
+					this._filesList.collapse($(`#svm-fileList .file-controls[data-item-id="${parentItem.id}"]`).closest('tr'));
+			}
+
+			if (requester == this.smartFox.mySelf.name)
+			{
+				// Display notification
+				this.shellCtrl.showNotification(`${this._selectedItem.isDir ? 'Folder' : 'File'} deleted`, `${this._selectedItem.isDir ? 'Folder' : 'File'} '${this._selectedItem.name}' deleted successfully`);
+
+				this._selectedItem = null;
+
+				this._enableInterface(true);
+			}
+			else
+			{
+				// Display notification
+				this.shellCtrl.showNotification(`File deleted`, `Administrator ${requester} deleted the following file${filesArr.length > 1 ? 's' : ''}: <strong>${filesArr.join('<br> ')}</strong>`);
+			}
+
+			// Reset selection
+			this._onFileSelectedChange();
+		}
+
+		// else if ()
+	}
+
+	//---------------------------------
+	// UI EVENT LISTENERS
+	//---------------------------------
+
+	_onRetryClick()
+	{
+		this._switchView('svm-init');
+
+		// Re-send initialization request
+		this.sendExtensionRequest(this.REQ_INIT);
+	}
+
+	_onRefreshClick()
+	{
+		this._filesList.clearSelection();
+		this._refreshDataList();
+	}
+
+	_onFileSelectedChange()
+	{
+		// Hide control buttons on currently selected item
+		if (this._selectedItem)
+			$(`#svm-fileList .file-controls[data-item-id="${this._selectedItem.id}"]`).hide();
+
+		// Get selected item
+		let selectedRows = this._filesList.select();
+
+		if (selectedRows.length > 0)
+		{
+			// Save ref. to selected item
+			this._selectedItem = this._filesList.dataItem(selectedRows[0]);
+
+			// Show control buttons on new selected item
+			$(`#svm-fileList .file-controls[data-item-id="${this._selectedItem.id}"]`).show();
+		}
+		else
+			this._selectedItem = null;
+	}
+
+	_showAddFolderModalClick()
+	{
+		if (this._selectedItem && this._selectedItem.isDir)
+		{
+			this._addFolderModal.modal('show');
+			$('#svm-folderNameIn').focus();
+		}
+	}
+
+	_onAddFolderClick()
+	{
+		// The parent folder could have been deleted while user is still typing the name of the new child folder
+		if (!this._selectedItem)
+		{
+			this._addFolderModal.modal('hide');
+			this.shellCtrl.showSimpleAlert('Unable to create folder; the parent folder doesn\'t exist.');
+			return;
+		}
+
+		if (this._addFolderValidator.validate())
+		{
+			// Disable modal interface
+			this._enableAddFolderModal(false);
+
+			let data = new SFS2X.SFSObject();
+			data.putUtfString('folder', this._selectedItem.id + this._fileSeparator + $('#svm-folderNameIn').val());
+
+			// Send request to server
+			this.sendExtensionRequest(this.REQ_CREATE_FOLDER, data);
+		}
+	}
+
+	_onAddFolderModalHidden()
+	{
+		$('#svm-folderNameIn').val('');
+		this._resetAddFolderValidation();
+
+		// Enable modal interface
+		this._enableAddFolderModal(true);
+	}
+
+	_showUploadFilesModalClick()
+	{
+		if (this._selectedItem)
+			this._uploadFilesModal.modal('show');
+	}
+
+	_onClearFilesClick()
+	{
+		this._uploader.clearAllFiles();
+	}
+
+	_onUploadStart(e)
+	{
+		// Disable clear button
+		$('#svm-clearFilesBt').attr('disabled', true);
+
+		// Set destination url
+		const url = 'http://' + this._uploadTargetConfig.host + ':' + this._uploadTargetConfig.httpPort + '/BlueBox/SFS2XFileUpload?sessHashId=' + this._uploadTargetConfig.sessionToken;
+
+		e.sender.options.async.saveUrl = url;
+
+		// Set payload
+		const params = new FormData();
+		params.append('__module', this._uploadTargetConfig.moduleId);
+		params.append('__target', this._selectedItem.id);
+
+		for (let f = 0; f < e.files.length; f++)
+			params.append('files[]', e.files[f].rawFile);
+
+		e.formData = params;
+	}
+
+	_onUploadEnd(e)
+	{
+		// Enable clear button
+		$('#svm-clearFilesBt').attr('disabled', false);
+	}
+
+	_onFilesUploadEnd(response)
+	{
+		// Nothing to do: we have to wait the upload process completion to be signaled by the server through the dedicated Extension response
+
+		//=================================================================
+
+		// TODO Should we handle this response in some way? For some unknown reason we always get ok=false and status=0
+		// console.log(response)
+		// console.log(response.ok)
+		// console.log(response.status)
+	}
+
+	_onRemoveFileClick()
+	{
+		if (this._selectedItem)
+			this.shellCtrl.showConfirmWarning(`Are you sure you want to delete the selected ${this._selectedItem.isDir ? 'folder' : 'file'}?<br><br>Path: <strong>${this._selectedItem.id}</strong>`, $.proxy(this._onRemoveFileConfirm, this));
+	}
+
+	_onRemoveFileConfirm()
+	{
+		// Disable interface
+		this._enableInterface(false);
+
+		// Request Servlet files removal
+		// NOTE: for compatibility with older AdminTool, the file to be deleted is sent
+		// in an array of strings, even if we can't delete more than 1 file at once in this AdminTool
+
+		let files = new SFS2X.SFSArray();
+		files.addUtfString(this._selectedItem.id);
+
+		let params = new SFS2X.SFSObject();
+		params.putSFSArray('files', files);
+
+		this.sendExtensionRequest(this.REQ_DELETE_FILES, params);
+	}
+
+	//------------------------------------
+	// PRIVATE METHODS
+	//------------------------------------
+
+	_switchView(viewId)
+	{
+		document.getElementById('svm-viewstack').selectedElement = document.getElementById(viewId);
+	}
+
+	_enableInterface(enable)
+	{
+		$('#svm-fileList').attr('disabled', !enable);
+		$('#svm-refreshBt').attr('disabled', !enable);
+	}
+
+	_refreshDataList()
+	{
+		// Disable interface
+		this._enableInterface(false);
+
+		// Send request to server
+		this.sendExtensionRequest(this.REQ_GET_SERVLETS)
+	}
+
+	_resetAddFolderValidation()
+	{
+		this._addFolderValidator.hideMessages();
+
+		// The method above doesn't remove the k-invalid classes and aria-invalid="true" attributes from inputs
+		// Let's do it manually
+		$('#svm-addFolderForm .k-invalid').removeClass('k-invalid');
+		$('#svm-addFolderForm [aria-invalid="true"]').removeAttr('aria-invalid');
+	}
+
+	_enableAddFolderModal(enable)
+	{
+		// Disable modal close buttons
+		$('#svm-addFolderModal button[data-dismiss="modal"]').attr('disabled', !enable);
+
+		// Disable add button
+		$('#svm-addFolderBt').attr('disabled', !enable);
+
+		// Disable fieldset
+		$('#svm-addFolderForm').attr('disabled', !enable);
+	}
+
+	//---------------------------------
+	// PRIVATE GETTERS
+	//---------------------------------
+
+
+}
+
+/* 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-10.bundle.js","sources":["webpack://application/./src/managers/file-datasource-manager.js","webpack://application/./src/modules/servlet-manager.js"],"sourcesContent":["export class FileDataSourceManager\n{\n\tconstructor(libFolder, protectedFolders, fileSeparator)\n\t{\n\t\tthis._protectedFolders = protectedFolders; // Folders which can't be deleted (but their content can)\n\t\tthis._libFolder = libFolder;\n\t\tthis._fileSeparator = fileSeparator;\n\t}\n\n\tget dataSource()\n\t{\n\t\treturn this._dataSource;\n\t}\n\n\tinit()\n\t{\n\t\tthis._dataSource = new kendo.data.TreeListDataSource({\n\t\t\tdata: [],\n\t\t\tschema: {\n\t\t\t\tmodel: {\n\t\t\t\t\tid: 'id',\n\t\t\t\t\tparentId: 'parentId',\n\t\t\t\t\texpanded: false\n\t\t\t\t}\n\t\t\t},\n\t\t\tsort: { field: 'name', dir: 'asc' }\n\t\t});\n\t}\n\n\taddFile(fileObj, parentLevel = null)\n\t{\n\t\tlet file = {};\n\n\t\tfile.name = fileObj.getUtfString('name');\n\t\tfile.isDir = fileObj.getBool('isDir');\n\t\tfile.lastMod = fileObj.getLong('lastMod');\n\t\tfile.isLib = (file.isDir && file.name == this._libFolder);\n\t\tfile.isProtected = (file.isDir && this._protectedFolders.indexOf(file.name) > -1);\n\t\tfile.size = 0;\n\n\t\tif (parentLevel == null)\n\t\t\tfile.level = 0;\n\t\telse\n\t\t\tfile.level = parentLevel + 1;\n\n\t\tif (fileObj.containsKey('parent'))\n\t\t{\n\t\t\tfile.parentId = fileObj.getUtfString('parent');\n\t\t\tfile.id = file.parentId + this._fileSeparator + file.name;\n\t\t}\n\t\telse\n\t\t{\n\t\t\tfile.parentId = null;\n\t\t\tfile.id = file.name;\n\t\t}\n\n\t\t// Add child files\n\t\tif (file.isDir)\n\t\t{\n\t\t\tlet filesArr = fileObj.getSFSArray('files');\n\n\t\t\tfor (let i = 0; i < filesArr.size(); i++)\n\t\t\t\tfile.size += this.addFile(filesArr.getSFSObject(i), file.level);\n\t\t}\n\t\telse\n\t\t\tfile.size = fileObj.getLong('size');\n\n\t\t// Add file to data source\n\t\tthis._dataSource.add(file);\n\n\t\t// Return file size\n\t\treturn file.size;\n\t}\n\n\tremoveFile(id)\n\t{\n\t\tlet fileItem = this._dataSource.get(id);\n\n\t\tif (fileItem)\n\t\t{\n\t\t\tif (fileItem.parentId)\n\t\t\t{\n\t\t\t\t// Subtract old size from parent size\n\t\t\t\tlet parentItem = this._dataSource.get(fileItem.parentId);\n\t\t\t\tthis._updateParentSize(parentItem, -fileItem.size);\n\t\t\t}\n\n\t\t\tthis._dataSource.remove(fileItem);\n\n\t\t\t// Return parent item\n\t\t\tif (fileItem.parentId)\n\t\t\t\treturn this._dataSource.get(fileItem.parentId);\n\t\t}\n\t}\n\n\tgetFileById(id)\n\t{\n\t\treturn this._dataSource.get(id);\n\t}\n\n\taddFileToParent(fileObj, parentId)\n\t{\n\t\tlet parentItem = this._dataSource.get(parentId);\n\n\t\tif (parentItem != null && parentItem.isDir)\n\t\t{\n\t\t\tconst fileId = parentId + this._fileSeparator + fileObj.getUtfString('name');\n\t\t\tlet fileItem = this._dataSource.get(fileId);\n\n\t\t\tif (fileItem != null)\n\t\t\t{\n\t\t\t\t// Subtract old size from parent size\n\t\t\t\tthis._updateParentSize(parentItem, -fileItem.size);\n\n\t\t\t\t// Update existing item\n\t\t\t\tfileItem.name = fileObj.getUtfString('name');\n\t\t\t\tfileItem.lastMod = fileObj.getLong('lastMod');\n\t\t\t\tfileItem.size = fileObj.getLong('size');\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\t// Add new item\n\t\t\t\tthis.addFile(fileObj, parentItem.level);\n\t\t\t}\n\n\t\t\t// Update parent item size\n\t\t\tthis._updateParentSize(parentItem, fileObj.getLong('size'));\n\n\t\t\treturn fileId;\n\t\t}\n\t\telse\n\t\t\tthrow new Error(`An unexpected error occurred while adding file '${fileObj.getUtfString('name')}' (target: ${parentId}).`);\n\t}\n\n\t_updateParentSize(parentItem, value)\n\t{\n\t\tparentItem.size += value;\n\n\t\tif (parentItem.parentId)\n\t\t{\n\t\t\tlet grandParent = this._dataSource.get(parentItem.parentId);\n\t\t\tthis._updateParentSize(grandParent, value);\n\t\t}\n\t}\n}\n","import {BaseModule} from './base-module';\nimport {FileDataSourceManager} from '../managers/file-datasource-manager';\nimport {bytesToSize} from '../utils/utilities';\n\nexport default class ServletManager extends BaseModule\n{\n\tconstructor()\n\t{\n\t    super('servletMan');\n\n\t\t// Outgoing requests\n\t\tthis.REQ_INIT = 'init';\n\t\tthis.REQ_GET_SERVLETS = 'getServlets';\n\t\tthis.REQ_CREATE_FOLDER = 'createFolder';\n\t\tthis.REQ_DELETE_FILES = 'deleteSrvltFiles';\n\n\t\t// Incoming responses\n\t\tthis.RESP_LOCKED = 'lock';\n\t\tthis.RESP_INIT = 'init';\n\t\tthis.RESP_SERVLETS = 'servlets';\n\t\tthis.RESP_FILE_ADDED = 'fileAdded';\n\t\tthis.RESP_FILES_DELETED = 'filesDeleted';\n\t\tthis.RESP_ERROR = 'error';\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//------------------------------------\n\n\tinitialize(idData, shellController)\n\t{\n\t\t// Call super method\n\t\tsuper.initialize(idData, shellController);\n\n\t\t// Initialize progress bar\n\t\t$('#svm-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 buttons\n\t\t$('#svm-retryBt').on('click', $.proxy(this._onRetryClick, this));\n\t\t$('#svm-refreshBt').on('click', $.proxy(this._onRefreshClick, this));\n\n\t\t// Initialize files list\n\t\tthis._filesList = $('#svm-fileList').kendoTreeList({\n            dataSource: [],\n\t\t\tresizable: true,\n\t\t\tselectable: true,\n            columns: [\n                {\n\t\t\t\t\tfield: 'name',\n\t\t\t\t\ttitle: 'Name',\n\t\t\t\t\ttemplate: kendo.template(`\n\t\t\t\t\t\t<div >\n\t\t\t\t\t\t\t# if (isDir) { #\n\t\t\t\t\t\t\t\t# if (expanded) { #\n\t\t\t\t\t\t\t\t\t<i class=\"fas fa-folder-open\"></i>\n\t\t\t\t\t\t\t\t# } else { #\n\t\t\t\t\t\t\t\t\t<i class=\"fas fa-folder\"></i>\n\t\t\t\t\t\t\t\t# } #\n\t\t\t\t\t\t\t# } else { #\n\t\t\t\t\t\t\t\t<i class=\"far fa-file\"></i>\n\t\t\t\t\t\t\t# } #\n\n\t\t\t\t\t\t\t#: name #\n\n\t\t\t\t\t\t</div>\n\t\t\t\t\t\t<div class=\"file-controls flex-grow-1 text-right\" data-item-id=\"#:id#\">\n\t\t\t\t\t\t\t# if (isDir) { #\n\t\t\t\t\t\t\t\t<button type=\"button\" class=\"k-button k-primary my-1 create-folder-bt\"><i class=\"fas fa-folder-plus\"></i></button>\n\t\t\t\t\t\t\t\t<button type=\"button\" class=\"k-button k-primary my-1 upload-files-bt\"><i class=\"fas fa-file-upload\"></i></button>\n\t\t\t\t\t\t\t# } #\n\n\t\t\t\t\t\t\t# if (level > 0 && !isProtected) { #\n\t\t\t\t\t\t\t\t<button type=\"button\" class=\"k-button k-primary my-1 remove-file-bt\"><i class=\"fas fa-minus-circle\"></i></button>\n\t\t\t\t\t\t\t# } #\n\t\t\t\t\t\t</div>\n\t\t\t\t\t`),\n\t\t\t\t},\n                {\n\t\t\t\t\tfield: 'size',\n\t\t\t\t\ttitle: 'Size',\n\t\t\t\t\ttemplate: function(dataItem) {\n\t\t\t\t\t\tdataItem.bytesToSize = bytesToSize; // Pass bytesToSize utility function to template\n\t\t\t\t\t\treturn kendo.template(`\n\t\t\t\t\t\t\t#: bytesToSize(size, 2, 'KB') #\n\t\t\t\t\t\t`)(dataItem);\n\t\t\t\t\t},\n\t\t\t\t\twidth: 120,\n\t\t\t\t\tminScreenWidth: 576\n\t\t\t\t},\n                {\n\t\t\t\t\tfield: 'lastMod',\n\t\t\t\t\ttitle: 'Last Modified',\n\t\t\t\t\ttemplate: kendo.template(`\n\t\t\t\t\t\t#: kendo.toString(new Date(lastMod), 'dd MMM yyyy HH:mm:ss') #\n\t\t\t\t\t`),\n\t\t\t\t\twidth: 200,\n\t\t\t\t\tminScreenWidth: 768\n\t\t\t\t},\n            ],\n\t\t\tchange: $.proxy(this._onFileSelectedChange, this)\n        }).data('kendoTreeList');\n\n\t\t//-------------------------------------------\n\n\t\t// Add listeners to catch control button clicks on rows\n\t\t$('#svm-fileList').on('click', '.create-folder-bt', $.proxy(this._showAddFolderModalClick, this));\n\t\t$('#svm-fileList').on('click', '.upload-files-bt', $.proxy(this._showUploadFilesModalClick, this));\n\t\t$('#svm-fileList').on('click', '.remove-file-bt', $.proxy(this._onRemoveFileClick, this));\n\n\t\t//-------------------------------------------\n\n\t\t// Initialize \"add folder\" modal\n\t\tthis._addFolderModal = $('#svm-addFolderModal');\n\t\tthis._addFolderModal.modal({\n\t\t\tbackdrop: 'static',\n\t\t\tkeyboard: false,\n\t\t\tshow: false\n\t\t});\n\n\t\t// Add listener to modal hide event\n\t\tthis._addFolderModal.on('hidden.bs.modal', $.proxy(this._onAddFolderModalHidden, this));\n\n\t\t// Add listener to Add button click\n\t\t$('#svm-addFolderBt').on('click', $.proxy(this._onAddFolderClick, this));\n\n\t\t// Initialize kendo validation on folder name form\n\t\tthis._addFolderValidator = $('#svm-addFolderForm').kendoValidator({}).data('kendoValidator');\n\n\t\t//-------------------------------------------\n\n\t\t// Initialize \"upload files\" modal\n\t\tthis._uploadFilesModal = $('#svm-uploadModal');\n\t\tthis._uploadFilesModal.modal({\n\t\t\tbackdrop: 'static',\n\t\t\tkeyboard: false,\n\t\t\tshow: false\n\t\t});\n\n\t\t// Initialize kendo uploader\n\t\tthis._uploader = $('#svm-uploader').kendoUpload({\n\t\t\tmultiple: true,\n\t\t\tasync: {\n\t\t\t\tsaveUrl: 'http://localhost', // This will be changed later in _onUploadStart method\n\t\t\t\tautoUpload: true,\n\t\t\t},\n\t\t\tdirectoryDrop: true,\n\t\t\tupload: $.proxy(this._onUploadStart, this),\n\t\t\tcomplete: $.proxy(this._onUploadEnd, this),\n\t\t\tlocalization: {\n\t\t\t\tselect: 'Select files...'\n\t\t\t}\n\t\t}).data('kendoUpload');\n\n\t\t// Add listener to Upload button click\n\t\t$('#svm-clearFilesBt').on('click', $.proxy(this._onClearFilesClick, this));\n\n\t\t//-------------------------------------------\n\n\t\t// Send initialization request\n\t\tthis.sendExtensionRequest(this.REQ_INIT);\n\t}\n\n\tdestroy()\n\t{\n\t\t// Call super method\n\t\tsuper.destroy();\n\n\t\t$('#svm-retryBt').off('click');\n\t\t$('#svm-refreshBt').off('click');\n\n\t\t$('#svm-fileList').off('click');\n\n\t\tthis._addFolderModal.off('hidden.bs.modal');\n\t\tthis._addFolderModal.modal('dispose');\n\t\t$('#svm-addFolderBt').off('click');\n\n\t\tthis._uploadFilesModal.modal('dispose');\n\t\t$('#svm-clearFilesBt').off('click');\n\t}\n\n\tonExtensionCommand(command, data)\n\t{\n\t\t// Module can be enabled (no locking file exists)\n\t\tif (command == this.RESP_INIT)\n\t\t{\n\t\t\t// Retrieve file separator\n\t\t\tthis._fileSeparator = data.getUtfString('sep');\n\n\t\t\t// Create file data source manager\n\t\t\tthis._fileManager = new FileDataSourceManager(null, [], this._fileSeparator);\n\n\t\t\t// Retrieve HTTP port to be used for files uploading\n\t\t\tconst uploadHttpPort = data.getInt('httpPort');\n\n\t\t\t// Retrieve module id sent by the server (required because multiple modules use file uploading service)\n\t\t\tconst uploadModuleId = data.getUtfString('modId');\n\n\t\t\t// Set file uploading target configuration\n\t\t\tthis._uploadTargetConfig = {\n\t\t\t\tsessionToken: this.smartFox.sessionToken,\n\t\t\t\thost: this.smartFox.config.host,\n\t\t\t\thttpPort: uploadHttpPort,\n\t\t\t\tmoduleId: uploadModuleId,\n\t\t\t};\n\n\t\t\t// Request Servlet files data to server instance\n\t\t\tthis._refreshDataList();\n\t\t}\n\n\t\t/*\n\t\t * This response is returned if the file UploadsLock.txt exists in the /config folder of the server.\n\t\t * This is an additional security measure to avoid unwanted files to be uploaded by malicius users accessing the server\n\t\t * with the default credentials, in case they have not been changed by the administrator after the installation.\n\t\t * The file must be removed manually before accessing the Servlet Manager module for the first time\n\t\t */\n\t\telse if (command == this.RESP_LOCKED)\n\t\t{\n\t\t\t// Show warning\n\t\t\tthis._switchView('svm-locked');\n\t\t}\n\n\t\t// Servlet folders and files\n\t\telse if (command == this.RESP_SERVLETS)\n\t\t{\n\t\t\t// Retrieve Servlets file list\n\t\t\tlet servletsObj = data.getSFSObject('servlets');\n\n\t\t\t// Initialize manager\n\t\t\tthis._fileManager.init();\n\n\t\t\t// Add list to manager\n\t\t\tthis._fileManager.addFile(servletsObj);\n\n\t\t\t// Set TreeList data source\n\t\t\tthis._filesList.setDataSource(this._fileManager.dataSource);\n\n\t\t\t// Expand first level\n\t\t\tthis._filesList.expand($('#svm-fileList tbody>tr:eq(0)'));\n\n\t\t\t// Enable interface\n\t\t\tthis._enableInterface(true);\n\n\t\t\t// Show module's main view\n\t\t\tthis._switchView('svm-main');\n\t\t}\n\n\t\t// An error occurred while managing servlet files\n\t\telse if (command == this.RESP_ERROR)\n\t\t{\n\t\t\t// Hide add folder modal\n\t\t\tthis._addFolderModal.modal('hide');\n\n\t\t\t// Re-enable interface\n\t\t\tthis._enableInterface(true);\n\n\t\t\t// Show an alert\n\t\t\tthis.shellCtrl.showSimpleAlert(data.getUtfString('error'));\n\t\t}\n\n\t\t// Servlet folder or file added\n\t\telse if (command == this.RESP_FILE_ADDED)\n\t\t{\n\t\t\t// Get name of the user who added the file/folder\n\t\t\tconst requester = data.getUtfString('user');\n\n\t\t\t// Get the object representing the file/folder being added\n\t\t\tconst fileObj = data.getSFSObject('file');\n\n\t\t\t// Get the target folder where the new file/folder should be added\n\t\t\tconst parentPath = data.getUtfString('parent');\n\n\t\t\t// Get the flag notifying this was a file upload\n\t\t\tconst isUpload = data.getBool('isUpload');\n\n\t\t\ttry\n\t\t\t{\n\t\t\t\t// Add/update item on data source\n\t\t\t\tconst filePath = this._fileManager.addFileToParent(fileObj, parentPath);\n\n\t\t\t\t// Refresh view\n\t\t\t\tthis._filesList.refresh();\n\n\t\t\t\tif (requester == this.smartFox.mySelf.name)\n\t\t\t\t{\n\t\t\t\t\t// Expand parent\n\t\t\t\t\tthis._filesList.expand($(`#svm-fileList .file-controls[data-item-id=\"${parentPath}\"]`).closest('tr'));\n\n\t\t\t\t\tif (!isUpload)\n\t\t\t\t\t{\n\t\t\t\t\t\t// Hide modal\n\t\t\t\t\t\tthis._addFolderModal.modal('hide');\n\n\t\t\t\t\t\t// Select upload file\n\t\t\t\t\t\tthis._filesList.select($(`#svm-fileList .file-controls[data-item-id=\"${filePath}\"]`).closest('tr'));\n\t\t\t\t\t}\n\n\t\t\t\t\t// Update selection\n\t\t\t\t\tthis._onFileSelectedChange();\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 (!isUpload)\n\t\t\t\t\t\tthis.shellCtrl.showNotification(`Folder created`, `Administrator ${requester} created folder: <strong>${filePath}</strong>`);\n\t\t\t\t\telse\n\t\t\t\t\t\tthis.shellCtrl.showNotification(`File uploaded`, `Administrator ${requester} uploaded file: <strong>${filePath}</strong>`);\n\t\t\t\t}\n\t\t\t}\n\t\t\tcatch (e)\n\t\t\t{\n\t\t\t\t// This should not happen... data source is corrupted?\n\t\t\t\tif (requester == this.smartFox.mySelf.name)\n\t\t\t\t\tthis.shellCtrl.showSimpleAlert(e.message, true);\n\t\t\t}\n\n\t\t\t// Enable interface\n\t\t\tthis._enableInterface(true);\n\t\t}\n\n\t\t// Servlet files deleted\n\t\telse if (command == this.RESP_FILES_DELETED)\n\t\t{\n\t\t\t// Get name of the user who deleted the file/s\n\t\t\tconst requester = data.getUtfString('user');\n\n\t\t\t// Get the list of deleted files\n\t\t\tlet files = data.getSFSArray('files');\n\n\t\t\tlet filesArr = [];\n\n\t\t\t// Update data source\n\t\t\tfor (let j = 0; j < files.size(); j++)\n\t\t\t{\n\t\t\t\tlet path = files.getUtfString(j);\n\t\t\t\tfilesArr.push(path);\n\n\t\t\t\t//------------------------\n\n\t\t\t\t// Remove item from data source; parent item is returned\n\t\t\t\tlet parentItem = this._fileManager.removeFile(path);\n\n\t\t\t\t// Collapse parent if the last of its children was deleted\n\t\t\t\tif (parentItem && !parentItem.hasChildren)\n\t\t\t\t\tthis._filesList.collapse($(`#svm-fileList .file-controls[data-item-id=\"${parentItem.id}\"]`).closest('tr'));\n\t\t\t}\n\n\t\t\tif (requester == this.smartFox.mySelf.name)\n\t\t\t{\n\t\t\t\t// Display notification\n\t\t\t\tthis.shellCtrl.showNotification(`${this._selectedItem.isDir ? 'Folder' : 'File'} deleted`, `${this._selectedItem.isDir ? 'Folder' : 'File'} '${this._selectedItem.name}' deleted successfully`);\n\n\t\t\t\tthis._selectedItem = null;\n\n\t\t\t\tthis._enableInterface(true);\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(`File deleted`, `Administrator ${requester} deleted the following file${filesArr.length > 1 ? 's' : ''}: <strong>${filesArr.join('<br> ')}</strong>`);\n\t\t\t}\n\n\t\t\t// Reset selection\n\t\t\tthis._onFileSelectedChange();\n\t\t}\n\n\t\t// else if ()\n\t}\n\n\t//---------------------------------\n\t// UI EVENT LISTENERS\n\t//---------------------------------\n\n\t_onRetryClick()\n\t{\n\t\tthis._switchView('svm-init');\n\n\t\t// Re-send initialization request\n\t\tthis.sendExtensionRequest(this.REQ_INIT);\n\t}\n\n\t_onRefreshClick()\n\t{\n\t\tthis._filesList.clearSelection();\n\t\tthis._refreshDataList();\n\t}\n\n\t_onFileSelectedChange()\n\t{\n\t\t// Hide control buttons on currently selected item\n\t\tif (this._selectedItem)\n\t\t\t$(`#svm-fileList .file-controls[data-item-id=\"${this._selectedItem.id}\"]`).hide();\n\n\t\t// Get selected item\n\t\tlet selectedRows = this._filesList.select();\n\n\t\tif (selectedRows.length > 0)\n\t\t{\n\t\t\t// Save ref. to selected item\n\t\t\tthis._selectedItem = this._filesList.dataItem(selectedRows[0]);\n\n\t\t\t// Show control buttons on new selected item\n\t\t\t$(`#svm-fileList .file-controls[data-item-id=\"${this._selectedItem.id}\"]`).show();\n\t\t}\n\t\telse\n\t\t\tthis._selectedItem = null;\n\t}\n\n\t_showAddFolderModalClick()\n\t{\n\t\tif (this._selectedItem && this._selectedItem.isDir)\n\t\t{\n\t\t\tthis._addFolderModal.modal('show');\n\t\t\t$('#svm-folderNameIn').focus();\n\t\t}\n\t}\n\n\t_onAddFolderClick()\n\t{\n\t\t// The parent folder could have been deleted while user is still typing the name of the new child folder\n\t\tif (!this._selectedItem)\n\t\t{\n\t\t\tthis._addFolderModal.modal('hide');\n\t\t\tthis.shellCtrl.showSimpleAlert('Unable to create folder; the parent folder doesn\\'t exist.');\n\t\t\treturn;\n\t\t}\n\n\t\tif (this._addFolderValidator.validate())\n\t\t{\n\t\t\t// Disable modal interface\n\t\t\tthis._enableAddFolderModal(false);\n\n\t\t\tlet data = new SFS2X.SFSObject();\n\t\t\tdata.putUtfString('folder', this._selectedItem.id + this._fileSeparator + $('#svm-folderNameIn').val());\n\n\t\t\t// Send request to server\n\t\t\tthis.sendExtensionRequest(this.REQ_CREATE_FOLDER, data);\n\t\t}\n\t}\n\n\t_onAddFolderModalHidden()\n\t{\n\t\t$('#svm-folderNameIn').val('');\n\t\tthis._resetAddFolderValidation();\n\n\t\t// Enable modal interface\n\t\tthis._enableAddFolderModal(true);\n\t}\n\n\t_showUploadFilesModalClick()\n\t{\n\t\tif (this._selectedItem)\n\t\t\tthis._uploadFilesModal.modal('show');\n\t}\n\n\t_onClearFilesClick()\n\t{\n\t\tthis._uploader.clearAllFiles();\n\t}\n\n\t_onUploadStart(e)\n\t{\n\t\t// Disable clear button\n\t\t$('#svm-clearFilesBt').attr('disabled', true);\n\n\t\t// Set destination url\n\t\tconst url = 'http://' + this._uploadTargetConfig.host + ':' + this._uploadTargetConfig.httpPort + '/BlueBox/SFS2XFileUpload?sessHashId=' + this._uploadTargetConfig.sessionToken;\n\n\t\te.sender.options.async.saveUrl = url;\n\n\t\t// Set payload\n\t\tconst params = new FormData();\n\t\tparams.append('__module', this._uploadTargetConfig.moduleId);\n\t\tparams.append('__target', this._selectedItem.id);\n\n\t\tfor (let f = 0; f < e.files.length; f++)\n\t\t\tparams.append('files[]', e.files[f].rawFile);\n\n\t\te.formData = params;\n\t}\n\n\t_onUploadEnd(e)\n\t{\n\t\t// Enable clear button\n\t\t$('#svm-clearFilesBt').attr('disabled', false);\n\t}\n\n\t_onFilesUploadEnd(response)\n\t{\n\t\t// Nothing to do: we have to wait the upload process completion to be signaled by the server through the dedicated Extension response\n\n\t\t//=================================================================\n\n\t\t// TODO Should we handle this response in some way? For some unknown reason we always get ok=false and status=0\n\t\t// console.log(response)\n\t\t// console.log(response.ok)\n\t\t// console.log(response.status)\n\t}\n\n\t_onRemoveFileClick()\n\t{\n\t\tif (this._selectedItem)\n\t\t\tthis.shellCtrl.showConfirmWarning(`Are you sure you want to delete the selected ${this._selectedItem.isDir ? 'folder' : 'file'}?<br><br>Path: <strong>${this._selectedItem.id}</strong>`, $.proxy(this._onRemoveFileConfirm, this));\n\t}\n\n\t_onRemoveFileConfirm()\n\t{\n\t\t// Disable interface\n\t\tthis._enableInterface(false);\n\n\t\t// Request Servlet files removal\n\t\t// NOTE: for compatibility with older AdminTool, the file to be deleted is sent\n\t\t// in an array of strings, even if we can't delete more than 1 file at once in this AdminTool\n\n\t\tlet files = new SFS2X.SFSArray();\n\t\tfiles.addUtfString(this._selectedItem.id);\n\n\t\tlet params = new SFS2X.SFSObject();\n\t\tparams.putSFSArray('files', files);\n\n\t\tthis.sendExtensionRequest(this.REQ_DELETE_FILES, params);\n\t}\n\n\t//------------------------------------\n\t// PRIVATE METHODS\n\t//------------------------------------\n\n\t_switchView(viewId)\n\t{\n\t\tdocument.getElementById('svm-viewstack').selectedElement = document.getElementById(viewId);\n\t}\n\n\t_enableInterface(enable)\n\t{\n\t\t$('#svm-fileList').attr('disabled', !enable);\n\t\t$('#svm-refreshBt').attr('disabled', !enable);\n\t}\n\n\t_refreshDataList()\n\t{\n\t\t// Disable interface\n\t\tthis._enableInterface(false);\n\n\t\t// Send request to server\n\t\tthis.sendExtensionRequest(this.REQ_GET_SERVLETS)\n\t}\n\n\t_resetAddFolderValidation()\n\t{\n\t\tthis._addFolderValidator.hideMessages();\n\n\t\t// The method above doesn't remove the k-invalid classes and aria-invalid=\"true\" attributes from inputs\n\t\t// Let's do it manually\n\t\t$('#svm-addFolderForm .k-invalid').removeClass('k-invalid');\n\t\t$('#svm-addFolderForm [aria-invalid=\"true\"]').removeAttr('aria-invalid');\n\t}\n\n\t_enableAddFolderModal(enable)\n\t{\n\t\t// Disable modal close buttons\n\t\t$('#svm-addFolderModal button[data-dismiss=\"modal\"]').attr('disabled', !enable);\n\n\t\t// Disable add button\n\t\t$('#svm-addFolderBt').attr('disabled', !enable);\n\n\t\t// Disable fieldset\n\t\t$('#svm-addFolderForm').attr('disabled', !enable);\n\t}\n\n\t//---------------------------------\n\t// PRIVATE GETTERS\n\t//---------------------------------\n\n\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;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;AChJA;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;;;;;;A","sourceRoot":""}