From fb2b44f3c13f6d903dfb16dee18e3ec4c44c209d Mon Sep 17 00:00:00 2001
From: Salandora <Sunpack@web.de>
Date: Mon, 7 Sep 2015 10:32:28 +0200
Subject: [PATCH 01/25] Changes to the API to enchance folder support

---
 src/octoprint/filemanager/storage.py |  20 +++-
 src/octoprint/server/api/files.py    | 137 +++++++++++++++++----------
 2 files changed, 106 insertions(+), 51 deletions(-)

diff --git a/src/octoprint/filemanager/storage.py b/src/octoprint/filemanager/storage.py
index 9f238cf9..273107ff 100644
--- a/src/octoprint/filemanager/storage.py
+++ b/src/octoprint/filemanager/storage.py
@@ -977,13 +977,29 @@ class LocalFileStorage(StorageInterface):
 
 			# folder recursion
 			elif os.path.isdir(entry_path) and recursive:
-				sub_result = self._list_folder(entry_path, filter=filter)
-				result[entry] = dict(
+				sub_result = self._list_folder(entry_path, filter=filter, recursive=recursive)
+				entry_data = dict(
 					name=entry,
 					type="folder",
 					children=sub_result
 				)
 
+				if not filter or filter(entry, entry_data):
+					def get_size(start_path):
+						total_size = 0
+						for dirpath, dirnames, filenames in os.walk(start_path):
+							for f in filenames:
+								fp = os.path.join(dirpath, f)
+								total_size += os.path.getsize(fp)
+						return total_size
+
+					# only add folders passing the optional filter
+					extended_entry_data = dict()
+					extended_entry_data.update(entry_data)
+					extended_entry_data["size"] = get_size(entry_path)
+
+					result[entry] = extended_entry_data
+
 		# TODO recreate links if we have metadata less entries
 
 		# save metadata
diff --git a/src/octoprint/server/api/files.py b/src/octoprint/server/api/files.py
index 33ae4efd..2804f5d5 100644
--- a/src/octoprint/server/api/files.py
+++ b/src/octoprint/server/api/files.py
@@ -26,10 +26,16 @@ import psutil
 @api.route("/files", methods=["GET"])
 def readGcodeFiles():
 	filter = None
+	recursive = False
 	if "filter" in request.values:
 		filter = request.values["filter"]
-	files = _getFileList(FileDestinations.LOCAL, filter=filter)
+
+	if "recursive" in request.values:
+		recursive = request.values["recursive"] == 'true'
+
+	files = _getFileList(FileDestinations.LOCAL, filter=filter, recursive=recursive)
 	files.extend(_getFileList(FileDestinations.SDCARD))
+
 	usage = psutil.disk_usage(settings().getBaseFolder("uploads"))
 	return jsonify(files=files, free=usage.free, total=usage.total)
 
@@ -39,7 +45,11 @@ def readGcodeFilesForOrigin(origin):
 	if origin not in [FileDestinations.LOCAL, FileDestinations.SDCARD]:
 		return make_response("Unknown origin: %s" % origin, 404)
 
-	files = _getFileList(origin)
+	recursive = False
+	if "recursive" in request.values:
+		recursive = request.values["recursive"] == 'true'
+
+	files = _getFileList(origin, recursive=recursive)
 
 	if origin == FileDestinations.LOCAL:
 		usage = psutil.disk_usage(settings().getBaseFolder("uploads"))
@@ -48,15 +58,24 @@ def readGcodeFilesForOrigin(origin):
 		return jsonify(files=files)
 
 
-def _getFileDetails(origin, filename):
-	files = _getFileList(origin)
-	for file in files:
-		if file["name"] == filename:
-			return file
-	return None
+def _getFileDetails(origin, path):
+	files = _getFileList(origin, recursive=True)
+	path = path.split('/')
+
+	def recursive_get_filedetails(files, path):
+		for file in files:
+			if file["name"] == path[0]:
+				if len(path) > 1:
+					return recursive_get_filedetails(file["children"], path[1:])
+				else:
+					return file
+
+		return None
+
+	return recursive_get_filedetails(files, path)
 
 
-def _getFileList(origin, filter=None):
+def _getFileList(origin, filter=None, recursive=False):
 	if origin == FileDestinations.SDCARD:
 		sdFileList = printer.get_sd_files()
 
@@ -78,45 +97,56 @@ def _getFileList(origin, filter=None):
 		filter_func = None
 		if filter:
 			filter_func = lambda entry, entry_data: octoprint.filemanager.valid_file_type(entry, type=filter)
-		files = fileManager.list_files(origin, filter=filter_func, recursive=False)[origin].values()
-		for file in files:
-			file["origin"] = FileDestinations.LOCAL
 
-			if "analysis" in file and octoprint.filemanager.valid_file_type(file["name"], type="gcode"):
-				file["gcodeAnalysis"] = file["analysis"]
-				del file["analysis"]
+		files = fileManager.list_files(origin, filter=filter_func, recursive=recursive)[origin].values()
 
-			if "history" in file and octoprint.filemanager.valid_file_type(file["name"], type="gcode"):
-				# convert print log
-				history = file["history"]
-				del file["history"]
-				success = 0
-				failure = 0
-				last = None
-				for entry in history:
-					success += 1 if "success" in entry and entry["success"] else 0
-					failure += 1 if "success" in entry and not entry["success"] else 0
-					if not last or ("timestamp" in entry and "timestamp" in last and entry["timestamp"] > last["timestamp"]):
-						last = entry
-				if last:
-					prints = dict(
-						success=success,
-						failure=failure,
-						last=dict(
-							success=last["success"],
-							date=last["timestamp"]
+		def recursive_analysis(files, path):
+			for file in files:
+				file["origin"] = FileDestinations.LOCAL
+
+				if file["type"] == "folder":
+					file["children"] = recursive_analysis(file["children"].values(), path + file["name"] + "/")
+
+				if "analysis" in file and octoprint.filemanager.valid_file_type(file["name"], type="gcode"):
+					file["gcodeAnalysis"] = file["analysis"]
+					del file["analysis"]
+
+				if "history" in file and octoprint.filemanager.valid_file_type(file["name"], type="gcode"):
+					# convert print log
+					history = file["history"]
+					del file["history"]
+					success = 0
+					failure = 0
+					last = None
+					for entry in history:
+						success += 1 if "success" in entry and entry["success"] else 0
+						failure += 1 if "success" in entry and not entry["success"] else 0
+						if not last or ("timestamp" in entry and "timestamp" in last and entry["timestamp"] > last["timestamp"]):
+							last = entry
+					if last:
+						prints = dict(
+							success=success,
+							failure=failure,
+							last=dict(
+								success=last["success"],
+								date=last["timestamp"]
+							)
 						)
-					)
-					if "printTime" in last:
-						prints["last"]["printTime"] = last["printTime"]
-					file["prints"] = prints
+						if "printTime" in last:
+							prints["last"]["printTime"] = last["printTime"]
+						file["prints"] = prints
+
+				file.update({
+					"refs": {
+						"resource": url_for(".readGcodeFile", target=FileDestinations.LOCAL, filename=path + file["name"], _external=True),
+						"download": url_for("index", _external=True) + "downloads/files/" + FileDestinations.LOCAL + "/" + path + file["name"]
+					}
+				})
+
+			return files
+
+		files = recursive_analysis(files, "")
 
-			file.update({
-				"refs": {
-					"resource": url_for(".readGcodeFile", target=FileDestinations.LOCAL, filename=file["name"], _external=True),
-					"download": url_for("index", _external=True) + "downloads/files/" + FileDestinations.LOCAL + "/" + file["name"]
-				}
-			})
 	return files
 
 
@@ -166,24 +196,33 @@ def uploadGcodeFile(target):
 
 	# determine current job
 	currentFilename = None
+	currentFullPath = None
 	currentOrigin = None
 	currentJob = printer.get_current_job()
 	if currentJob is not None and "file" in currentJob.keys():
 		currentJobFile = currentJob["file"]
-		if "name" in currentJobFile.keys() and "origin" in currentJobFile.keys():
-			currentFilename = currentJobFile["name"]
+		if currentJobFile is not None and "name" in currentJobFile.keys() and "origin" in currentJobFile.keys() and currentJobFile["name"] is not None and currentJobFile["origin"] is not None:
+			currentPath, currentFilename = fileManager.sanitize(currentJobFile["origin"], currentJobFile["name"])
+			currentFullPath = fileManager.join_path(target, currentPath, currentFilename)
 			currentOrigin = currentJobFile["origin"]
 
 	# determine future filename of file to be uploaded, abort if it can't be uploaded
 	try:
-		futureFilename = fileManager.sanitize_name(FileDestinations.LOCAL, upload.filename)
+		futurePath, futureFilename = fileManager.sanitize(target, upload.filename)
 	except:
+		futurePath = None
 		futureFilename = None
+
 	if futureFilename is None:
 		return make_response("Can not upload file %s, wrong format?" % upload.filename, 415)
 
+	if "path" in request.values:
+		futurePath = fileManager.sanitize_path(target, request.values["path"])
+
+	futureFullPath = fileManager.join_path(target, futurePath, futureFilename)
+
 	# prohibit overwriting currently selected file while it's being printed
-	if futureFilename == currentFilename and target == currentOrigin and printer.is_printing() or printer.is_paused():
+	if futureFullPath == currentFullPath and target == currentOrigin and printer.is_printing() or printer.is_paused():
 		return make_response("Trying to overwrite file that is currently being printed: %s" % currentFilename, 409)
 
 	def fileProcessingFinished(filename, absFilename, destination):
@@ -212,7 +251,7 @@ def uploadGcodeFile(target):
 		if octoprint.filemanager.valid_file_type(added_file, "gcode") and (selectAfterUpload or printAfterSelect or (currentFilename == filename and currentOrigin == destination)):
 			printer.select_file(absFilename, destination == FileDestinations.SDCARD, printAfterSelect)
 
-	added_file = fileManager.add_file(FileDestinations.LOCAL, upload.filename, upload, allow_overwrite=True)
+	added_file = fileManager.add_file(FileDestinations.LOCAL, futureFullPath, upload, allow_overwrite=True)
 	if added_file is None:
 		return make_response("Could not upload the file %s" % upload.filename, 500)
 	if octoprint.filemanager.valid_file_type(added_file, "stl"):

From 5f3ee7dfdabca37f3020e2c95cb7b888645e9d4f Mon Sep 17 00:00:00 2001
From: Salandora <Sunpack@web.de>
Date: Mon, 7 Sep 2015 10:34:47 +0200
Subject: [PATCH 02/25] Changes to the WebUI to support folders

---
 src/octoprint/static/js/app/main.js           |   6 +-
 .../static/js/app/viewmodels/files.js         | 147 +++++++++++++++---
 src/octoprint/templates/sidebar/files.jinja2  |  29 +++-
 .../templates/sidebar/files_header.jinja2     |   4 +
 4 files changed, 159 insertions(+), 27 deletions(-)

diff --git a/src/octoprint/static/js/app/main.js b/src/octoprint/static/js/app/main.js
index c1237505..753f371d 100644
--- a/src/octoprint/static/js/app/main.js
+++ b/src/octoprint/static/js/app/main.js
@@ -223,11 +223,15 @@ $(function() {
             },
             update: function(element, valueAccessor, allBindings, viewModel, bindingContext) {
                 setTimeout(function() {
-                    $(element).slimScroll({scrollBy: 0});
+                    if (element.nodeName == "#comment")
+                        $(element.parentElement).slimScroll({scrollBy: 0});
+                    else
+                        $(element).slimScroll({scrollBy: 0});
                 }, 10);
                 return ko.bindingHandlers.foreach.update(element, valueAccessor(), allBindings, viewModel, bindingContext);
             }
         };
+        ko.virtualElements.allowedBindings.slimScrolledForeach = true;
 
         ko.bindingHandlers.qrcode = {
             update: function(element, valueAccessor, allBindings, viewModel, bindingContext) {
diff --git a/src/octoprint/static/js/app/viewmodels/files.js b/src/octoprint/static/js/app/viewmodels/files.js
index 885f5a40..6e3522e4 100644
--- a/src/octoprint/static/js/app/viewmodels/files.js
+++ b/src/octoprint/static/js/app/viewmodels/files.js
@@ -54,6 +54,10 @@ $(function() {
 
         self.uploadButton = undefined;
 
+        self.allItems = ko.observable(undefined);
+        self.listStyle = ko.observable("folders_files");
+        self.currentPath = ko.observable("");
+
         // initialize list helper
         self.listHelper = new ItemListHelper(
             "gcodeFiles",
@@ -78,28 +82,42 @@ $(function() {
                 }
             },
             {
-                "printed": function(file) {
-                    return !(file["prints"] && file["prints"]["success"] && file["prints"]["success"] > 0);
+                "printed": function(data) {
+                    return !(data["prints"] && data["prints"]["success"] && data["prints"]["success"] > 0) || (data["type"] && data["type"] == "folder");
                 },
-                "sd": function(file) {
-                    return file["origin"] && file["origin"] == "sdcard";
+                "sd": function(data) {
+                    return data["origin"] && data["origin"] == "sdcard";
                 },
-                "local": function(file) {
-                    return !(file["origin"] && file["origin"] == "sdcard");
+                "local": function(data) {
+                    return !(data["origin"] && data["origin"] == "sdcard");
                 },
-                "machinecode": function(file) {
-                    return file["type"] && file["type"] == "machinecode";
+                "machinecode": function(data) {
+                    return data["type"] && (data["type"] == "machinecode" || data["type"] == "folder");
                 },
-                "model": function(file) {
-                    return file["type"] && file["type"] == "model";
+                "model": function(data) {
+                    return data["type"] && (data["type"] == "model" || data["type"] == "folder");
+                },
+                "emptyFolder": function(data) {
+                    return data["type"] && data["type"] != "folder" || (data["size"] && data["size"] != 0);
                 }
             },
             "name",
-            [],
+            ["emptyFolder"],
             [["sd", "local"], ["machinecode", "model"]],
             0
         );
 
+        self.foldersOnlyList = ko.dependentObservable(function() {
+            filter = function(data) { return data["type"] && data["type"] == "folder"; };
+            var items = _.filter(self.listHelper.paginatedItems(), filter);
+            return items;
+        });
+        self.filesOnlyList = ko.dependentObservable(function() {
+            filter = function(data) { return data["type"] && data["type"] != "folder"; };
+            var items = _.filter(self.listHelper.paginatedItems(), filter);
+            return items;
+        });
+
         self.isLoadActionPossible = ko.computed(function() {
             return self.loginState.isUser() && !self.isPrinting() && !self.isPaused() && !self.isLoading();
         });
@@ -142,7 +160,7 @@ $(function() {
         };
 
         self._otherRequestInProgress = false;
-        self.requestData = function(filenameToFocus, locationToFocus) {
+        self.requestData = function(filenameToFocus, locationToFocus, switchToPath) {
             if (self._otherRequestInProgress) return;
 
             self._otherRequestInProgress = true;
@@ -150,8 +168,9 @@ $(function() {
                 url: API_BASEURL + "files",
                 method: "GET",
                 dataType: "json",
+                data: {"recursive": true},
                 success: function(response) {
-                    self.fromResponse(response, filenameToFocus, locationToFocus);
+                    self.fromResponse(response, filenameToFocus, locationToFocus, switchToPath);
                     self._otherRequestInProgress = false;
                 },
                 error: function() {
@@ -160,13 +179,32 @@ $(function() {
             });
         };
 
-        self.fromResponse = function(response, filenameToFocus, locationToFocus) {
+        self.fromResponse = function(response, filenameToFocus, locationToFocus, switchToPath) {
             var files = response.files;
-            _.each(files, function(element, index, list) {
+            recursiveCheck = function(element, index, list) {
+                if (!element.hasOwnProperty("parent")) element.parent = { children: list, parent: undefined };
                 if (!element.hasOwnProperty("size")) element.size = undefined;
                 if (!element.hasOwnProperty("date")) element.date = undefined;
-            });
-            self.listHelper.updateItems(files);
+
+                if (element.type == "folder")
+                {
+                    for (var i = 0; i < element.children.length; i++) {
+                        element.children[i].parent = element;
+                        recursiveCheck(element.children[i], i, element.children);
+                    }
+                }
+            };
+            _.each(files, recursiveCheck);
+
+            self.allItems(files);
+            self.currentPath("");
+            self.listHelper.addFilter("emptyFolder");
+            if (!switchToPath) {
+                self.listHelper.updateItems(files);
+            }
+            else {
+                self.changeFolderByPath(switchToPath);
+            }
 
             if (filenameToFocus) {
                 // got a file to scroll to
@@ -191,6 +229,52 @@ $(function() {
             self.highlightFilename(self.printerState.filename());
         };
 
+        self.changeFolder = function(data) {
+            self.currentPath(self.pathByElement(data));
+            self.listHelper.updateItems(data.children);
+        };
+        self.changeFolderByPath = function(path) {
+            var element = self.elementByPath(path, { children: self.allItems() });
+            if (element) {
+                self.currentPath(path);
+                self.listHelper.updateItems(element.children);
+            }
+            else{
+                self.currentPath("");
+                self.listHelper.updateItems(self.allItems());
+            }
+        }
+
+        self.pathByElement = function(element) {
+            if (!element || element.parent == undefined)
+                return "";
+
+            recursivePath = function(element, path) {
+              if (element.parent !== undefined)
+                  return recursivePath(element.parent, element.name + "/" + path);
+
+              return path;
+            };
+            return recursivePath(element.parent, element.name);
+        };
+        self.elementByPath = function(path, startElement) {
+            recursiveSearch = function(path, element) {
+                if (path.length == 0)
+                    return element;
+
+                var name = path.shift();
+                for(var i = 0; i< startElement.children.length; i++) {
+                    if (name == startElement.children[i].name) {
+                        return recursivePath(path, startElement.children[i]);
+                    }
+                }
+
+                return undefined;
+            };
+
+            return recursiveSearch(path.split("/"), startElement);
+        };
+
         self.loadFile = function(file, printAfterLoad) {
             if (!file || !file.refs || !file.refs.hasOwnProperty("resource")) return;
 
@@ -206,11 +290,22 @@ $(function() {
         self.removeFile = function(file) {
             if (!file || !file.refs || !file.refs.hasOwnProperty("resource")) return;
 
+            var index = self.listHelper.paginatedItems().indexOf(file) + 1;
+            if (index >= self.listHelper.paginatedItems().length)
+                index = index - 2;
+            if (index < 0)
+                index = 0;
+
+            var filenameToFocus = undefined;
+            var fileToFocus = self.listHelper.paginatedItems()[index];
+            if (fileToFocus)
+                filenameToFocus = fileToFocus.name;
+
             $.ajax({
                 url: file.refs.resource,
                 type: "DELETE",
                 success: function() {
-                    self.requestData();
+                    self.requestData(undefined, filenameToFocus, self.pathByElement(file.parent));
                 }
             });
         };
@@ -352,7 +447,7 @@ $(function() {
         };
 
         self.onDataUpdaterReconnect = function() {
-            self.requestData();
+            self.requestData(undefined, undefined, self.currentPath());
         };
 
         self.onUserLoggedIn = function(user) {
@@ -397,7 +492,7 @@ $(function() {
                     filename = data.result.files.local.name;
                     location = "local";
                 }
-                self.requestData(filename, location);
+                self.requestData(filename, location, self.currentPath());
 
                 if (_.endsWith(filename.toLowerCase(), ".stl")) {
                     self.slicing.show(location, filename);
@@ -442,6 +537,8 @@ $(function() {
                     done: gcode_upload_done,
                     fail: gcode_upload_fail,
                     progressall: gcode_upload_progress
+                }).bind('fileuploadsubmit', function(e, data) {
+                    data.formData = { path: self.currentPath() };
                 });
             }
 
@@ -464,6 +561,8 @@ $(function() {
                     done: gcode_upload_done,
                     fail: gcode_upload_fail,
                     progressall: gcode_upload_progress
+                }).bind('fileuploadsubmit', function(e, data) {
+                    data.formData = { path: self.currentPath() };
                 });
             }
 
@@ -585,20 +684,20 @@ $(function() {
 
         self.onEventUpdatedFiles = function(payload) {
             if (payload.type == "gcode") {
-                self.requestData();
+                self.requestData(undefined, undefined, self.currentPath());
             }
         };
 
         self.onEventSlicingDone = function(payload) {
-            self.requestData();
+            self.requestData(undefined, undefined, self.currentPath());
         };
 
         self.onEventMetadataAnalysisFinished = function(payload) {
-            self.requestData();
+            self.requestData(undefined, undefined, self.currentPath());
         };
 
         self.onEventMetadataStatisticsUpdated = function(payload) {
-            self.requestData();
+            self.requestData(undefined, undefined, self.currentPath());
         };
     }
 
diff --git a/src/octoprint/templates/sidebar/files.jinja2 b/src/octoprint/templates/sidebar/files.jinja2
index 39b4d9c8..5b128027 100644
--- a/src/octoprint/templates/sidebar/files.jinja2
+++ b/src/octoprint/templates/sidebar/files.jinja2
@@ -1,8 +1,32 @@
 <form class="form-search" data-bind="submit: performSearch">
     <input type="text" class="input-block search-query" data-bind="value: searchQuery, valueUpdate: 'input'" placeholder="{{ _('Search...') }}">
 </form>
-<div class="gcode_files" data-bind="slimScrolledForeach: listHelper.paginatedItems">
+<div class="gcode_files">
+    <!-- ko if: currentPath() != "" -->
+    <div class="entry" data-bind="click: function() { var path = $root.currentPath().split('/'); path.shift(); $root.changeFolderByPath(path.join('/')); }"><i class="icon-arrow-left"></i> {{  _('Back') }}</div>
+    <!-- /ko -->
+
+    <!-- ko if: listStyle() == 'folders_files' -->
+    <!-- ko slimScrolledForeach: foldersOnlyList -->
     <div class="entry" data-bind="attr: { id: $root.getEntryId($data) }, template: { name: $root.templateFor($data), data: $data }"></div>
+    <!-- /ko -->
+    <!-- ko slimScrolledForeach: filesOnlyList -->
+    <div class="entry" data-bind="attr: { id: $root.getEntryId($data) }, template: { name: $root.templateFor($data), data: $data }"></div>
+    <!-- /ko -->
+    <!-- /ko -->
+    <!-- ko if: listStyle() == 'files_folders' -->
+    <!-- ko slimScrolledForeach: filesOnlyList -->
+    <div class="entry" data-bind="attr: { id: $root.getEntryId($data) }, template: { name: $root.templateFor($data), data: $data }"></div>
+    <!-- /ko -->
+    <!-- ko slimScrolledForeach: foldersOnlyList -->
+    <div class="entry" data-bind="attr: { id: $root.getEntryId($data) }, template: { name: $root.templateFor($data), data: $data }"></div>
+    <!-- /ko -->
+    <!-- /ko -->
+    <!-- ko if: listStyle() == 'mixed' -->
+    <!-- ko slimScrolledForeach: listHelper.paginatedItems -->
+    <div class="entry" data-bind="attr: { id: $root.getEntryId($data) }, template: { name: $root.templateFor($data), data: $data }"></div>
+    <!-- /ko -->
+    <!-- /ko -->
 
     <script type="text/html" id="files_template_machinecode">
         <div class="title" data-bind="css: $root.getSuccessClass($data), style: { 'font-weight': $root.listHelper.isSelected($data) ? 'bold' : 'normal' }, text: name"></div>
@@ -30,7 +54,8 @@
     </script>
 
     <script type="text/html" id="files_template_folder">
-        <div class="title" data-bind="text: name"></div>
+        <div class="title" data-bind="click: $root.changeFolder"><i class="icon-folder-open"></i> <span data-bind="text: name"></span></div>
+        <div class="size">{{ _('Size') }}: <span data-bind="text: formatSize(size)"></span></div>
     </script>
 </div>
 <div class="text-right muted" data-bind="attr: {title: diskusageString}, css: {'text-error': diskusageCritical}, style: {'font-weight': diskusageCritical() || diskusageWarning() ? 'bold' : 'normal'}">
diff --git a/src/octoprint/templates/sidebar/files_header.jinja2 b/src/octoprint/templates/sidebar/files_header.jinja2
index 3a4810a0..1e7eebc7 100644
--- a/src/octoprint/templates/sidebar/files_header.jinja2
+++ b/src/octoprint/templates/sidebar/files_header.jinja2
@@ -3,6 +3,10 @@
         <span class="icon-wrench"></span>
     </a>
     <ul class="dropdown-menu">
+        <li><a href="#" data-bind="click: function() { $root.listStyle('folders_files'); }"><i class="icon-ok" data-bind="style: {visibility: listStyle() == 'folders_files' ? 'visible' : 'hidden'}"></i> {{ _('Sort by Folders, Files') }}</a></li>
+        <li><a href="#" data-bind="click: function() { $root.listStyle('files_folders'); }"><i class="icon-ok" data-bind="style: {visibility: listStyle() == 'files_folders' ? 'visible' : 'hidden'}"></i> {{ _('Sort by Files, Folders') }}</a></li>
+        <li><a href="#" data-bind="click: function() { $root.listStyle('mixed'); }"><i class="icon-ok" data-bind="style: {visibility: listStyle() == 'mixed' ? 'visible' : 'hidden'}"></i> {{ _('Mixed') }}</a></li>
+        <li class="divider"></li>
         <li><a href="#" data-bind="click: function() { $root.listHelper.changeSorting('name'); }"><i class="icon-ok" data-bind="style: {visibility: listHelper.currentSorting() == 'name' ? 'visible' : 'hidden'}"></i> {{ _('Sort by name') }} ({{ _('ascending') }})</a></li>
         <li><a href="#" data-bind="click: function() { $root.listHelper.changeSorting('upload'); }"><i class="icon-ok" data-bind="style: {visibility: listHelper.currentSorting() == 'upload' ? 'visible' : 'hidden'}"></i> {{ _('Sort by upload date') }} ({{ _('descending') }})</a></li>
         <li><a href="#" data-bind="click: function() { $root.listHelper.changeSorting('size'); }"><i class="icon-ok" data-bind="style: {visibility: listHelper.currentSorting() == 'size' ? 'visible' : 'hidden'}"></i> {{ _('Sort by file size') }} ({{ _('descending') }})</a></li>

From 2d5bfca9fdab0a0dfc71cfca6789ef544a5d636d Mon Sep 17 00:00:00 2001
From: Salandora <Sunpack@web.de>
Date: Mon, 7 Sep 2015 10:37:26 +0200
Subject: [PATCH 03/25] Started work on move and rename commands in API and
 FileManager/StorageInterface

---
 src/octoprint/filemanager/__init__.py |  4 ++
 src/octoprint/filemanager/storage.py  | 70 +++++++++++++++++++++++++++
 src/octoprint/server/api/files.py     |  6 ++-
 3 files changed, 79 insertions(+), 1 deletion(-)

diff --git a/src/octoprint/filemanager/__init__.py b/src/octoprint/filemanager/__init__.py
index fad1fc41..e63731a5 100644
--- a/src/octoprint/filemanager/__init__.py
+++ b/src/octoprint/filemanager/__init__.py
@@ -344,6 +344,10 @@ class FileManager(object):
 		self._storage(destination).remove_file(path)
 		eventManager().fire(Events.UPDATED_FILES, dict(type="printables"))
 
+	def move_file(self, destination, oldpath, newpath):
+		self._storage(destination).move_file(oldpath, newpath)
+		eventManager().fire(Events.UPDATED_FILES, dict(type="printables"))
+
 	def add_folder(self, destination, path, ignore_existing=True):
 		folder_path = self._storage(destination).add_folder(path, ignore_existing=ignore_existing)
 		eventManager().fire(Events.UPDATED_FILES, dict(type="printables"))
diff --git a/src/octoprint/filemanager/storage.py b/src/octoprint/filemanager/storage.py
index 273107ff..30cba083 100644
--- a/src/octoprint/filemanager/storage.py
+++ b/src/octoprint/filemanager/storage.py
@@ -10,6 +10,7 @@ import logging
 import os
 import pylru
 import tempfile
+import shutil
 
 import octoprint.filemanager
 
@@ -112,6 +113,15 @@ class StorageInterface(object):
 		"""
 		raise NotImplementedError()
 
+	def move_folder(self, oldpath, newpath):
+		"""
+		Moves the folder ``oldpath`` to ``newpath``
+
+		:param string oldpath: path to the old folder
+		:param string newpath: path to the new folder
+		"""
+		raise NotImplementedError()
+
 	def add_file(self, path, file_object, printer_profile=None, links=None, allow_overwrite=False):
 		"""
 		Adds the file ``file_object`` as ``path``
@@ -136,6 +146,15 @@ class StorageInterface(object):
 		"""
 		raise NotImplementedError()
 
+	def move_file(self, oldpath, newpath):
+		"""
+		Moves the file ``oldpath`` to ``newpath``
+
+		:param string oldpath: path to the old file
+		:param string newpath: path to the new file
+		"""
+		raise NotImplementedError()
+
 	def get_metadata(self, path):
 		"""
 		Retrieves the metadata for the file ``path``.
@@ -414,6 +433,25 @@ class LocalFileStorage(StorageInterface):
 		import shutil
 		shutil.rmtree(folder_path)
 
+	def move_folder(self, oldpath, newpath):
+		oldpath, oldname = self.sanitize(oldpath)
+		newpath, newname = self.sanitize(newpath)
+
+		oldfolder_path = os.path.join(oldpath, oldname)
+		if not os.path.exists(oldfolder_path):
+			return
+		if not os.path.isdir(oldfolder_path):
+			raise RuntimeError("{name} in {path} is not a folder".format(**locals()))
+
+		newfolder_path = os.path.join(newpath, newname)
+		if os.path.exists(newfolder_path):
+			return
+
+		try:
+			shutil.move(oldfolder_path, newfolder_path)
+		except Exception as e:
+			raise RuntimeError("Could not move/rename {oldname} in {oldpath} to {newname} in {newpath}".format(**locals()), e)
+
 	def add_file(self, path, file_object, printer_profile=None, links=None, allow_overwrite=False):
 		path, name = self.sanitize(path)
 		if not octoprint.filemanager.valid_file_type(name):
@@ -488,6 +526,38 @@ class LocalFileStorage(StorageInterface):
 			del metadata[name]
 			self._save_metadata(path, metadata)
 
+	def move_file(self, oldpath, newpath):
+		oldpath, oldname = self.sanitize(oldpath)
+		newpath, newname = self.sanitize(newpath)
+
+		oldmetadata = self._get_metadata(oldpath)
+		newmetadata = self._get_metadata(newpath)
+
+		oldfile_path = os.path.join(oldpath, oldname)
+		if not os.path.exists(oldfile_path):
+			return
+		if not os.path.isfile(oldfile_path):
+			raise RuntimeError("{name} in {path} is not a file".format(**locals()))
+
+		newfile_path = os.path.join(newpath, newname)
+		if os.path.exists(newfile_path):
+			return
+
+		try:
+			shutil.move(oldfile_path, newfile_path)
+		except Exception as e:
+			raise RuntimeError("Could not move/rename {oldname} in {oldpath} to {newname} in {newpath}".format(**locals()), e)
+
+		if oldname in oldmetadata:
+			metadata = oldmetadata[oldname]
+			del metadata[oldname]
+			self._save_metadata(oldpath, oldmetadata)
+
+			newmetadata[newname] = metadata
+			newmetadata[newname]["hash"] = self._create_hash(os.path.join(newpath, newname))
+			self._save_metadata(newpath, newmetadata)
+
+
 	def get_metadata(self, path):
 		path, name = self.sanitize(path)
 
diff --git a/src/octoprint/server/api/files.py b/src/octoprint/server/api/files.py
index 2804f5d5..aacd5bdf 100644
--- a/src/octoprint/server/api/files.py
+++ b/src/octoprint/server/api/files.py
@@ -325,7 +325,9 @@ def gcodeFileCommand(filename, target):
 	# valid file commands, dict mapping command name to mandatory parameters
 	valid_commands = {
 		"select": [],
-		"slice": []
+		"slice": [],
+		"move": ["newpath"],
+		"rename": ["newpath"],
 	}
 
 	command, data, response = get_json_command_from_request(request, valid_commands)
@@ -457,6 +459,8 @@ def gcodeFileCommand(filename, target):
 		r = make_response(jsonify(result), 202)
 		r.headers["Location"] = location
 		return r
+	elif command == "mode" or command == "rename":
+		fileManager.move_file(target, filename, data["newpath"])
 
 	return NO_CONTENT
 

From 6eeb3546c09a0995c2a43785c6ba87329859a836 Mon Sep 17 00:00:00 2001
From: Salandora <Sunpack@web.de>
Date: Wed, 30 Sep 2015 10:56:52 +0200
Subject: [PATCH 04/25] Further implemented the move and copy commands

---
 src/octoprint/filemanager/__init__.py |  16 ++-
 src/octoprint/filemanager/storage.py  | 173 ++++++++++++++++++++------
 src/octoprint/server/api/files.py     |  18 ++-
 3 files changed, 163 insertions(+), 44 deletions(-)

diff --git a/src/octoprint/filemanager/__init__.py b/src/octoprint/filemanager/__init__.py
index e63731a5..38e23611 100644
--- a/src/octoprint/filemanager/__init__.py
+++ b/src/octoprint/filemanager/__init__.py
@@ -344,8 +344,12 @@ class FileManager(object):
 		self._storage(destination).remove_file(path)
 		eventManager().fire(Events.UPDATED_FILES, dict(type="printables"))
 
-	def move_file(self, destination, oldpath, newpath):
-		self._storage(destination).move_file(oldpath, newpath)
+	def copy_file(self, destination, source, dst, allow_overwrite=False):
+		self._storage(destination).copy_file(source, dst, allow_overwrite)
+		eventManager().fire(Events.UPDATED_FILES, dict(type="printables"))
+
+	def move_file(self, destination, source, dst, allow_overwrite=False):
+		self._storage(destination).move_file(source, dst, allow_overwrite)
 		eventManager().fire(Events.UPDATED_FILES, dict(type="printables"))
 
 	def add_folder(self, destination, path, ignore_existing=True):
@@ -357,6 +361,14 @@ class FileManager(object):
 		self._storage(destination).remove_folder(path, recursive=recursive)
 		eventManager().fire(Events.UPDATED_FILES, dict(type="printables"))
 
+	def copy_folder(self, destination, source, dst):
+		self._storage(destination).copy_folder(source, dst)
+		eventManager().fire(Events.UPDATED_FILES, dict(type="printables"))
+
+	def move_folder(self, destination, source, dst, allow_overwrite=False):
+		self._storage(destination).move_folder(source, dst, allow_overwrite)
+		eventManager().fire(Events.UPDATED_FILES, dict(type="printables"))
+
 	def get_metadata(self, destination, path):
 		return self._storage(destination).get_metadata(path)
 
diff --git a/src/octoprint/filemanager/storage.py b/src/octoprint/filemanager/storage.py
index 30cba083..81e6eb60 100644
--- a/src/octoprint/filemanager/storage.py
+++ b/src/octoprint/filemanager/storage.py
@@ -42,6 +42,14 @@ class StorageInterface(object):
 		"""
 		raise NotImplementedError()
 
+	def folder_exists(self, path):
+		"""
+		Returns whether the folder indicated by ``path`` exists or not.
+		:param string path: the path to check for existence
+		:return: ``True`` if the folder exists, ``False`` otherwise
+		"""
+		raise NotImplementedError()
+
 	def list_files(self, path=None, filter=None, recursive=True):
 		"""
 		List all files in storage starting at ``path``. If ``recursive`` is set to True (the default), also dives into
@@ -113,12 +121,21 @@ class StorageInterface(object):
 		"""
 		raise NotImplementedError()
 
-	def move_folder(self, oldpath, newpath):
+	def copy_folder(self, source, destination):
 		"""
-		Moves the folder ``oldpath`` to ``newpath``
+		Copys the folder ``source`` to ``destination``
 
-		:param string oldpath: path to the old folder
-		:param string newpath: path to the new folder
+		:param string source: path to the source folder
+		:param string destination: path to destination
+		"""
+		raise NotImplementedError()
+
+	def move_folder(self, source, destination, allow_overwrite=False):
+		"""
+		Moves the folder ``source`` to ``destination``
+
+		:param string source: path to the source folder
+		:param string destination: path to destination
 		"""
 		raise NotImplementedError()
 
@@ -146,12 +163,21 @@ class StorageInterface(object):
 		"""
 		raise NotImplementedError()
 
-	def move_file(self, oldpath, newpath):
+	def copy_file(self, source, destination, allow_overwrite=False):
 		"""
-		Moves the file ``oldpath`` to ``newpath``
+		Copys the file ``source`` to ``destination``
 
-		:param string oldpath: path to the old file
-		:param string newpath: path to the new file
+		:param string source: path to the source file
+		:param string destination: path to destination
+		"""
+		raise NotImplementedError()
+
+	def move_file(self, source, destination, allow_overwrite=False):
+		"""
+		Moves the file ``source`` to ``destination``
+
+		:param string source: path to the source file
+		:param string destination: path to destination
 		"""
 		raise NotImplementedError()
 
@@ -398,6 +424,11 @@ class LocalFileStorage(StorageInterface):
 		file_path = os.path.join(path, name)
 		return os.path.exists(file_path) and os.path.isfile(file_path)
 
+	def folder_exists(self, path):
+		path, name = self.sanitize(path)
+		folder_path = os.path.join(path, name)
+		return os.path.exists(folder_path) and os.path.isdir(folder_path)
+
 	def list_files(self, path=None, filter=None, recursive=True):
 		if path:
 			path = self.sanitize_path(path)
@@ -433,24 +464,45 @@ class LocalFileStorage(StorageInterface):
 		import shutil
 		shutil.rmtree(folder_path)
 
-	def move_folder(self, oldpath, newpath):
-		oldpath, oldname = self.sanitize(oldpath)
-		newpath, newname = self.sanitize(newpath)
+	def copy_folder(self, source, destination):
+		sourcepath, sourcename = self.sanitize(source)
+		destinationpath, destinationname = self.sanitize(destination)
 
-		oldfolder_path = os.path.join(oldpath, oldname)
-		if not os.path.exists(oldfolder_path):
+		sourcefolder_path = os.path.join(sourcepath, sourcename)
+		if not os.path.exists(sourcefolder_path):
 			return
-		if not os.path.isdir(oldfolder_path):
+
+		if not os.path.isdir(sourcefolder_path):
 			raise RuntimeError("{name} in {path} is not a folder".format(**locals()))
 
-		newfolder_path = os.path.join(newpath, newname)
-		if os.path.exists(newfolder_path):
-			return
+		destinationfolder_path = os.path.join(destinationpath, destinationname)
+		if os.path.exists(destinationfolder_path):
+			raise RuntimeError("{newname} does already exist in {newpath}".format(**locals()))
 
 		try:
-			shutil.move(oldfolder_path, newfolder_path)
+			shutil.copytree(sourcefolder_path, destinationfolder_path)
 		except Exception as e:
-			raise RuntimeError("Could not move/rename {oldname} in {oldpath} to {newname} in {newpath}".format(**locals()), e)
+			raise RuntimeError("Could not copy {oldname} in {oldpath} to {newname} in {newpath}".format(**locals()), e)
+
+	def move_folder(self, source, destination, allow_overwrite=False):
+		sourcepath, sourcename = self.sanitize(source)
+		destinationpath, destinationname = self.sanitize(destination)
+
+		sourcefolder_path = os.path.join(sourcepath, sourcename)
+		if not os.path.exists(sourcefolder_path):
+			return
+
+		if not os.path.isdir(sourcefolder_path):
+			raise RuntimeError("{name} in {path} is not a folder".format(**locals()))
+
+		destinationfolder_path = os.path.join(destinationpath, destinationname)
+		if os.path.exists(destinationfolder_path) and not allow_overwrite:
+			raise RuntimeError("{newname} does already exist in {newpath} and overwriting is prohibited".format(**locals()))
+
+		try:
+			shutil.move(sourcefolder_path, destinationfolder_path)
+		except Exception as e:
+			raise RuntimeError("Could not move {oldname} in {oldpath} to {newname} in {newpath}".format(**locals()), e)
 
 	def add_file(self, path, file_object, printer_profile=None, links=None, allow_overwrite=False):
 		path, name = self.sanitize(path)
@@ -526,36 +578,77 @@ class LocalFileStorage(StorageInterface):
 			del metadata[name]
 			self._save_metadata(path, metadata)
 
-	def move_file(self, oldpath, newpath):
-		oldpath, oldname = self.sanitize(oldpath)
-		newpath, newname = self.sanitize(newpath)
+	def copy_file(self, source, destination, allow_overwrite=False):
+		sourcepath, sourcename = self.sanitize(source)
+		destinationpath, destinationname = self.sanitize(destination)
 
-		oldmetadata = self._get_metadata(oldpath)
-		newmetadata = self._get_metadata(newpath)
+		oldmetadata = self._get_metadata(sourcepath)
+		if not oldmetadata:
+			oldmetadata = dict()
 
-		oldfile_path = os.path.join(oldpath, oldname)
-		if not os.path.exists(oldfile_path):
+		newmetadata = self._get_metadata(destinationpath)
+		if not newmetadata:
+			newmetadata = dict()
+
+		sourcefile_path = os.path.join(sourcepath, sourcename)
+		if not os.path.exists(sourcefile_path):
 			return
-		if not os.path.isfile(oldfile_path):
-			raise RuntimeError("{name} in {path} is not a file".format(**locals()))
 
-		newfile_path = os.path.join(newpath, newname)
-		if os.path.exists(newfile_path):
-			return
+		if not os.path.isfile(sourcefile_path):
+			raise RuntimeError("{oldname} in {oldpath} is not a file".format(**locals()))
+
+		destinationfile_path = os.path.join(destinationpath, destinationname)
+		if os.path.exists(destinationfile_path) and not allow_overwrite:
+			raise RuntimeError("{newname} does already exist in {newpath} and overwriting is prohibited".format(**locals()))
 
 		try:
-			shutil.move(oldfile_path, newfile_path)
+			shutil.copy2(sourcefile_path, destinationfile_path)
 		except Exception as e:
-			raise RuntimeError("Could not move/rename {oldname} in {oldpath} to {newname} in {newpath}".format(**locals()), e)
+			raise RuntimeError("Could not copy {oldname} in {oldpath} to {newname} in {newpath}".format(**locals()), e)
 
-		if oldname in oldmetadata:
-			metadata = oldmetadata[oldname]
-			del metadata[oldname]
-			self._save_metadata(oldpath, oldmetadata)
+		if sourcename in oldmetadata:
+			metadata = oldmetadata[sourcename]
 
-			newmetadata[newname] = metadata
-			newmetadata[newname]["hash"] = self._create_hash(os.path.join(newpath, newname))
-			self._save_metadata(newpath, newmetadata)
+			newmetadata[destinationname] = metadata
+			newmetadata[destinationname]["hash"] = self._create_hash(destinationfile_path)
+			self._save_metadata(destinationpath, newmetadata)
+
+	def move_file(self, source, destination, allow_overwrite=False):
+		sourcepath, sourcename = self.sanitize(source)
+		destinationpath, destinationname = self.sanitize(destination)
+
+		oldmetadata = self._get_metadata(sourcepath)
+		if not oldmetadata:
+			oldmetadata = dict()
+
+		newmetadata = self._get_metadata(destinationpath)
+		if not newmetadata:
+			newmetadata = dict()
+
+		sourcefile_path = os.path.join(sourcepath, sourcename)
+		if not os.path.exists(sourcefile_path):
+			return
+
+		if not os.path.isfile(sourcefile_path):
+			raise RuntimeError("{oldname} in {oldpath} is not a file".format(**locals()))
+
+		destinationfile_path = os.path.join(destinationpath, destinationname)
+		if os.path.exists(destinationfile_path) and not allow_overwrite:
+			raise RuntimeError("{newname} does already exist in {newpath} and overwriting is prohibited".format(**locals()))
+
+		try:
+			shutil.move(sourcefile_path, destinationfile_path)
+		except Exception as e:
+			raise RuntimeError("Could not move {oldname} in {oldpath} to {newname} in {newpath}".format(**locals()), e)
+
+		if sourcename in oldmetadata:
+			metadata = oldmetadata[sourcename]
+			del oldmetadata[sourcename]
+			self._save_metadata(sourcepath, oldmetadata)
+
+			newmetadata[destinationname] = metadata
+			newmetadata[destinationname]["hash"] = self._create_hash(destinationfile_path)
+			self._save_metadata(destinationpath, newmetadata)
 
 
 	def get_metadata(self, path):
diff --git a/src/octoprint/server/api/files.py b/src/octoprint/server/api/files.py
index aacd5bdf..1980d24d 100644
--- a/src/octoprint/server/api/files.py
+++ b/src/octoprint/server/api/files.py
@@ -459,8 +459,22 @@ def gcodeFileCommand(filename, target):
 		r = make_response(jsonify(result), 202)
 		r.headers["Location"] = location
 		return r
-	elif command == "mode" or command == "rename":
-		fileManager.move_file(target, filename, data["newpath"])
+	elif command == "move":
+		oldpath = fileManager.path_on_disk(target, filename)
+		newpath = fileManager.path_on_disk(target, data["newpath"])
+
+		if _verifyFileExists(target, newpath):
+			return make_response("File already exists", 404)
+
+		fileManager.move_file(target, oldpath, newpath)
+	elif command == "rename":
+		oldpath, oldname = fileManager.sanitize(target, filename)
+		newpath = fileManager.join(oldpath, data["newname"])
+
+		if _verifyFileExists(target, newpath):
+			return make_response("File already exists", 404)
+
+		fileManager.move_file(target, fileManager.join(oldpath, oldname), newpath)
 
 	return NO_CONTENT
 

From 2530e9b7105143a8aaeca82f8b54f769435e8c1c Mon Sep 17 00:00:00 2001
From: Salandora <Sunpack@web.de>
Date: Sun, 4 Oct 2015 02:42:18 +0200
Subject: [PATCH 05/25] Fixed merge and moved some functions into library

---
 src/octoprint/static/js/app/client/files.js   | 62 +++++++++++++++--
 .../static/js/app/viewmodels/files.js         | 68 ++++---------------
 2 files changed, 69 insertions(+), 61 deletions(-)

diff --git a/src/octoprint/static/js/app/client/files.js b/src/octoprint/static/js/app/client/files.js
index 84d26f17..9a6b1c51 100644
--- a/src/octoprint/static/js/app/client/files.js
+++ b/src/octoprint/static/js/app/client/files.js
@@ -2,12 +2,12 @@
     'use strict';
     if (typeof define === 'function' && define.amd) {
         // Register as an anonymous AMD module:
-        define(["OctoPrint", "jquery"], factory);
+        define(["OctoPrint", "jquery", "lodash"], factory);
     } else {
         // Browser globals:
-        factory(window.OctoPrint, window.jQuery);
+        factory(window.OctoPrint, window.jQuery, window._);
     }
-})(function(OctoPrint, $) {
+})(function(OctoPrint, $, _) {
     var url = "api/files";
 
     var resourceForLocation = function(location) {
@@ -27,15 +27,32 @@
         return OctoPrint.get(resourceForFile(location, filename), opts);
     };
 
+    var preProcessList = function(response) {
+        recursiveCheck = function(element, index, list) {
+            if (!element.hasOwnProperty("parent")) element.parent = { children: list, parent: undefined };
+            if (!element.hasOwnProperty("size")) element.size = undefined;
+            if (!element.hasOwnProperty("date")) element.date = undefined;
+
+            if (element.type == "folder")
+            {
+                _.each(element.children, function(e, i, l) {
+                    e.parent = element;
+                    recursiveCheck(e, i, l);
+                });
+            }
+        };
+        _.each(response.files, recursiveCheck);
+    };
+
     OctoPrint.files = {
         get: getFile,
 
         list: function (opts) {
-            return OctoPrint.get(url, opts);
+            return OctoPrint.get(url, opts).done(preProcessList);
         },
 
         listForLocation: function (location, opts) {
-            return OctoPrint.get(resourceForLocation(location), opts);
+            return OctoPrint.get(resourceForLocation(location), opts).done(preProcessList);
         },
 
         select: function (location, filename, print, opts) {
@@ -80,6 +97,41 @@
                     deferred.reject.apply(null, arguments);
                 });
             return deferred.promise();
+        },
+
+        pathForElement: function(element) {
+            if (!element || !element.hasOwnProperty("parent") || element.parent == undefined)
+                return "";
+
+            recursivePath = function(element, path) {
+              if (element.hasOwnProperty("parent") && element.parent != undefined)
+                  return recursivePath(element.parent, element.name + "/" + path);
+
+              return path;
+            };
+
+            return recursivePath(element.parent, element.name);
+        },
+
+        elementByPath: function(location, startElement) {
+            recursiveSearch = function(location, element) {
+                if (location.length == 0)
+                    return element;
+
+                if (!element.hasOwnProperty("children"))
+                    return undefined;
+
+                var name = location.shift();
+                for(var i = 0; i < element.children.length; i++) {
+                    if (name == element.children[i].name) {
+                        return recursivePath(location, element.children[i]);
+                    }
+                }
+
+                return undefined;
+            };
+
+            return recursiveSearch(location.split("/"), startElement);
         }
     }
 });
diff --git a/src/octoprint/static/js/app/viewmodels/files.js b/src/octoprint/static/js/app/viewmodels/files.js
index 603023e9..b4d85fed 100644
--- a/src/octoprint/static/js/app/viewmodels/files.js
+++ b/src/octoprint/static/js/app/viewmodels/files.js
@@ -109,14 +109,12 @@ $(function() {
         );
 
         self.foldersOnlyList = ko.dependentObservable(function() {
-            filter = function(data) { return data["type"] && data["type"] == "folder"; };
-            var items = _.filter(self.listHelper.paginatedItems(), filter);
-            return items;
+            var filter = function(data) { return data["type"] && data["type"] == "folder"; };
+            return _.filter(self.listHelper.paginatedItems(), filter);
         });
         self.filesOnlyList = ko.dependentObservable(function() {
-            filter = function(data) { return data["type"] && data["type"] != "folder"; };
-            var items = _.filter(self.listHelper.paginatedItems(), filter);
-            return items;
+            var filter = function(data) { return data["type"] && data["type"] != "folder"; };
+            return _.filter(self.listHelper.paginatedItems(), filter);
         });
 
         self.isLoadActionPossible = ko.computed(function() {
@@ -176,20 +174,6 @@ $(function() {
 
         self.fromResponse = function(response, filenameToFocus, locationToFocus, switchToPath) {
             var files = response.files;
-            recursiveCheck = function(element, index, list) {
-                if (!element.hasOwnProperty("parent")) element.parent = { children: list, parent: undefined };
-                if (!element.hasOwnProperty("size")) element.size = undefined;
-                if (!element.hasOwnProperty("date")) element.date = undefined;
-
-                if (element.type == "folder")
-                {
-                    for (var i = 0; i < element.children.length; i++) {
-                        element.children[i].parent = element;
-                        recursiveCheck(element.children[i], i, element.children);
-                    }
-                }
-            };
-            _.each(files, recursiveCheck);
 
             self.allItems(files);
             self.currentPath("");
@@ -225,11 +209,11 @@ $(function() {
         };
 
         self.changeFolder = function(data) {
-            self.currentPath(self.pathByElement(data));
+            self.currentPath(OctoPrint.files.pathForElement(data));
             self.listHelper.updateItems(data.children);
         };
         self.changeFolderByPath = function(path) {
-            var element = self.elementByPath(path, { children: self.allItems() });
+            var element = OctoPrint.files.elementByPath(path, { children: self.allItems() });
             if (element) {
                 self.currentPath(path);
                 self.listHelper.updateItems(element.children);
@@ -240,41 +224,11 @@ $(function() {
             }
         };
 
-        self.pathByElement = function(element) {
-            if (!element || element.parent == undefined)
-                return "";
-
-            recursivePath = function(element, path) {
-              if (element.parent !== undefined)
-                  return recursivePath(element.parent, element.name + "/" + path);
-
-              return path;
-            };
-            return recursivePath(element.parent, element.name);
-        };
-        self.elementByPath = function(path, startElement) {
-            recursiveSearch = function(path, element) {
-                if (path.length == 0)
-                    return element;
-
-                var name = path.shift();
-                for(var i = 0; i< startElement.children.length; i++) {
-                    if (name == startElement.children[i].name) {
-                        return recursivePath(path, startElement.children[i]);
-                    }
-                }
-
-                return undefined;
-            };
-
-            return recursiveSearch(path.split("/"), startElement);
-        };
-
         self.loadFile = function(file, printAfterLoad) {
             if (!file) {
                 return;
             }
-            OctoPrint.files.select(file.origin, file.name)
+            OctoPrint.files.select(file.origin, OctoPrint.files.pathForElement(file))
                 .done(function() {
                     if (printAfterLoad) {
                         OctoPrint.job.start();
@@ -298,9 +252,9 @@ $(function() {
             if (fileToFocus)
                 filenameToFocus = fileToFocus.name;
             
-            OctoPrint.files.delete(file.origin, file.name)
+            OctoPrint.files.delete(file.origin, OctoPrint.files.pathForElement(file))
                 .done(function() {
-                    self.requestData(undefined, filenameToFocus, self.pathByElement(file.parent));
+                    self.requestData(undefined, filenameToFocus, OctoPrint.files.pathForElement(file.parent));
                 })
         };
 
@@ -309,7 +263,7 @@ $(function() {
                 return;
             }
 
-            self.slicing.show(file.origin, file.name, true);
+            self.slicing.show(file.origin, OctoPrint.files.pathForElement(file), true);
         };
 
         self.initSdCard = function() {
@@ -554,6 +508,8 @@ $(function() {
                     done: gcode_upload_done,
                     fail: gcode_upload_fail,
                     progressall: gcode_upload_progress
+                }).bind('fileuploadsubmit', function(e, data) {
+                    data.formData = { path: self.currentPath() };
                 });
             }
 

From b5ff8defdea1e6870915fb27962733492c8a94b4 Mon Sep 17 00:00:00 2001
From: Salandora <Sunpack@web.de>
Date: Thu, 8 Oct 2015 15:24:22 +0200
Subject: [PATCH 06/25] Added a missing function

---
 src/octoprint/filemanager/__init__.py | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/octoprint/filemanager/__init__.py b/src/octoprint/filemanager/__init__.py
index 38e23611..cb3c8deb 100644
--- a/src/octoprint/filemanager/__init__.py
+++ b/src/octoprint/filemanager/__init__.py
@@ -302,6 +302,9 @@ class FileManager(object):
 	def file_exists(self, destination, path):
 		return self._storage(destination).file_exists(path)
 
+	def folder_exists(self, destination, path):
+		return self._storage(destination).folder_exists(path)
+
 	def list_files(self, destinations=None, path=None, filter=None, recursive=None):
 		if not destinations:
 			destinations = self._storage_managers.keys()

From 05d8b0ac07924eb4d4fbd754d5178f36994f52a7 Mon Sep 17 00:00:00 2001
From: Salandora <Sunpack@web.de>
Date: Thu, 8 Oct 2015 15:26:00 +0200
Subject: [PATCH 07/25] Removed Move and Rename functions again

---
 src/octoprint/server/api/files.py | 20 +-------------------
 1 file changed, 1 insertion(+), 19 deletions(-)

diff --git a/src/octoprint/server/api/files.py b/src/octoprint/server/api/files.py
index 1980d24d..2804f5d5 100644
--- a/src/octoprint/server/api/files.py
+++ b/src/octoprint/server/api/files.py
@@ -325,9 +325,7 @@ def gcodeFileCommand(filename, target):
 	# valid file commands, dict mapping command name to mandatory parameters
 	valid_commands = {
 		"select": [],
-		"slice": [],
-		"move": ["newpath"],
-		"rename": ["newpath"],
+		"slice": []
 	}
 
 	command, data, response = get_json_command_from_request(request, valid_commands)
@@ -459,22 +457,6 @@ def gcodeFileCommand(filename, target):
 		r = make_response(jsonify(result), 202)
 		r.headers["Location"] = location
 		return r
-	elif command == "move":
-		oldpath = fileManager.path_on_disk(target, filename)
-		newpath = fileManager.path_on_disk(target, data["newpath"])
-
-		if _verifyFileExists(target, newpath):
-			return make_response("File already exists", 404)
-
-		fileManager.move_file(target, oldpath, newpath)
-	elif command == "rename":
-		oldpath, oldname = fileManager.sanitize(target, filename)
-		newpath = fileManager.join(oldpath, data["newname"])
-
-		if _verifyFileExists(target, newpath):
-			return make_response("File already exists", 404)
-
-		fileManager.move_file(target, fileManager.join(oldpath, oldname), newpath)
 
 	return NO_CONTENT
 

From 9429456c5f8e4f2201e115b65657456fc059798a Mon Sep 17 00:00:00 2001
From: Salandora <Sunpack@web.de>
Date: Thu, 8 Oct 2015 15:26:58 +0200
Subject: [PATCH 08/25] Fixed some small mistakes

---
 src/octoprint/static/js/app/client/files.js | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/src/octoprint/static/js/app/client/files.js b/src/octoprint/static/js/app/client/files.js
index 9a6b1c51..d1b5b046 100644
--- a/src/octoprint/static/js/app/client/files.js
+++ b/src/octoprint/static/js/app/client/files.js
@@ -28,13 +28,12 @@
     };
 
     var preProcessList = function(response) {
-        recursiveCheck = function(element, index, list) {
+        var recursiveCheck = function(element, index, list) {
             if (!element.hasOwnProperty("parent")) element.parent = { children: list, parent: undefined };
             if (!element.hasOwnProperty("size")) element.size = undefined;
             if (!element.hasOwnProperty("date")) element.date = undefined;
 
-            if (element.type == "folder")
-            {
+            if (element.type == "folder") {
                 _.each(element.children, function(e, i, l) {
                     e.parent = element;
                     recursiveCheck(e, i, l);
@@ -103,7 +102,7 @@
             if (!element || !element.hasOwnProperty("parent") || element.parent == undefined)
                 return "";
 
-            recursivePath = function(element, path) {
+            var recursivePath = function(element, path) {
               if (element.hasOwnProperty("parent") && element.parent != undefined)
                   return recursivePath(element.parent, element.name + "/" + path);
 
@@ -114,7 +113,7 @@
         },
 
         elementByPath: function(location, startElement) {
-            recursiveSearch = function(location, element) {
+            var recursiveSearch = function(location, element) {
                 if (location.length == 0)
                     return element;
 
@@ -124,7 +123,7 @@
                 var name = location.shift();
                 for(var i = 0; i < element.children.length; i++) {
                     if (name == element.children[i].name) {
-                        return recursivePath(location, element.children[i]);
+                        return recursiveSearch(location, element.children[i]);
                     }
                 }
 

From 7f78b331facea96451d85f4453fa1da342ca3a83 Mon Sep 17 00:00:00 2001
From: Salandora <Sunpack@web.de>
Date: Thu, 8 Oct 2015 15:29:14 +0200
Subject: [PATCH 09/25] Added possibility to send a cookie back by the
 LargeResponseHandler

---
 src/octoprint/server/util/tornado.py | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/octoprint/server/util/tornado.py b/src/octoprint/server/util/tornado.py
index ce1bdd00..69e245f9 100644
--- a/src/octoprint/server/util/tornado.py
+++ b/src/octoprint/server/util/tornado.py
@@ -789,12 +789,16 @@ class LargeResponseHandler(tornado.web.StaticFileHandler):
 			self._access_validation(self.request)
 		if self._path_validation is not None:
 			self._path_validation(path)
+
+		if "cookie" in self.request.arguments:
+			self.set_cookie(self.request.arguments["cookie"][0], "true", path="/")
+
 		result = tornado.web.StaticFileHandler.get(self, path, include_body=include_body)
 		return result
 
 	def set_extra_headers(self, path):
 		if self._as_attachment:
-			self.set_header("Content-Disposition", "attachment")
+			self.set_header("Content-Disposition", "attachment; filename=%s" % os.path.basename(path))
 
 	@classmethod
 	def get_content_version(cls, abspath):

From fd0456ed268d2bfaaa3d70f7b889a92a7658c4c8 Mon Sep 17 00:00:00 2001
From: Salandora <Sunpack@web.de>
Date: Fri, 9 Oct 2015 02:26:33 +0200
Subject: [PATCH 10/25] Some small fixes and cosmetic adjustments

---
 src/octoprint/filemanager/storage.py            | 13 ++++++++++---
 src/octoprint/static/js/app/viewmodels/files.js |  5 ++++-
 src/octoprint/templates/sidebar/files.jinja2    |  2 +-
 3 files changed, 15 insertions(+), 5 deletions(-)

diff --git a/src/octoprint/filemanager/storage.py b/src/octoprint/filemanager/storage.py
index 81e6eb60..f67ef68c 100644
--- a/src/octoprint/filemanager/storage.py
+++ b/src/octoprint/filemanager/storage.py
@@ -1150,16 +1150,23 @@ class LocalFileStorage(StorageInterface):
 				if not filter or filter(entry, entry_data):
 					def get_size(start_path):
 						total_size = 0
-						for dirpath, dirnames, filenames in os.walk(start_path):
-							for f in filenames:
-								fp = os.path.join(dirpath, f)
+						for root, dirs, files in os.walk(start_path):
+							for f in files:
+								if f is ".metadata.yaml":
+									continue
+
+								fp = os.path.join(root, f)
 								total_size += os.path.getsize(fp)
+
 						return total_size
 
 					# only add folders passing the optional filter
 					extended_entry_data = dict()
 					extended_entry_data.update(entry_data)
 					extended_entry_data["size"] = get_size(entry_path)
+					stat = os.stat(entry_path)
+					if stat:
+						extended_entry_data["date"] = int(stat.st_ctime)
 
 					result[entry] = extended_entry_data
 
diff --git a/src/octoprint/static/js/app/viewmodels/files.js b/src/octoprint/static/js/app/viewmodels/files.js
index b4d85fed..481d7c29 100644
--- a/src/octoprint/static/js/app/viewmodels/files.js
+++ b/src/octoprint/static/js/app/viewmodels/files.js
@@ -99,7 +99,10 @@ $(function() {
                     return data["type"] && (data["type"] == "model" || data["type"] == "folder");
                 },
                 "emptyFolder": function(data) {
-                    return data["type"] && data["type"] != "folder" || (data["size"] && data["size"] != 0);
+                    if (data["type"] && data["type"] != "folder")
+                        return true;
+
+                    return data.children.length != 0;
                 }
             },
             "name",
diff --git a/src/octoprint/templates/sidebar/files.jinja2 b/src/octoprint/templates/sidebar/files.jinja2
index 5b128027..1d16d1c5 100644
--- a/src/octoprint/templates/sidebar/files.jinja2
+++ b/src/octoprint/templates/sidebar/files.jinja2
@@ -3,7 +3,7 @@
 </form>
 <div class="gcode_files">
     <!-- ko if: currentPath() != "" -->
-    <div class="entry" data-bind="click: function() { var path = $root.currentPath().split('/'); path.shift(); $root.changeFolderByPath(path.join('/')); }"><i class="icon-arrow-left"></i> {{  _('Back') }}</div>
+    <div class="entry" data-bind="click: function() { var path = $root.currentPath().split('/'); path.pop(); $root.changeFolderByPath(path.join('/')); }"><i class="icon-arrow-left"></i> {{  _('Back') }}</div>
     <!-- /ko -->
 
     <!-- ko if: listStyle() == 'folders_files' -->

From c3ddbd0b1b26066037cd7896c500cb8b71efc01d Mon Sep 17 00:00:00 2001
From: Salandora <Sunpack@web.de>
Date: Fri, 9 Oct 2015 02:37:42 +0200
Subject: [PATCH 11/25] Added create and remove folder API commands

---
 src/octoprint/filemanager/__init__.py |   3 +
 src/octoprint/filemanager/storage.py  |  12 +
 src/octoprint/server/api/files.py     | 309 +++++++++++++++-----------
 3 files changed, 196 insertions(+), 128 deletions(-)

diff --git a/src/octoprint/filemanager/__init__.py b/src/octoprint/filemanager/__init__.py
index 3e2d5657..a3f0a73a 100644
--- a/src/octoprint/filemanager/__init__.py
+++ b/src/octoprint/filemanager/__init__.py
@@ -340,6 +340,9 @@ class FileManager(object):
 	def get_busy_files(self):
 		return self._slicing_jobs.keys()
 
+	def file_in_path(self, destination, path, file):
+		return self._storage(destination).file_in_path(path, file)
+
 	def file_exists(self, destination, path):
 		return self._storage(destination).file_exists(path)
 
diff --git a/src/octoprint/filemanager/storage.py b/src/octoprint/filemanager/storage.py
index f67ef68c..28c0fccb 100644
--- a/src/octoprint/filemanager/storage.py
+++ b/src/octoprint/filemanager/storage.py
@@ -34,6 +34,15 @@ class StorageInterface(object):
 		return
 		yield
 
+	def file_in_path(self, path, filepath):
+		"""
+		Returns whether the file indicated by ``file`` is inside ``path`` or not.
+		:param string path: the path to check
+		:param string filepath: path to the file
+		:return: ``True`` if the file is inside the path, ``False`` otherwise
+		"""
+		return NotImplementedError()
+
 	def file_exists(self, path):
 		"""
 		Returns whether the file indicated by ``path`` exists or not.
@@ -419,6 +428,9 @@ class LocalFileStorage(StorageInterface):
 				for sub_entry in self._analysis_backlog_generator(absolute_path):
 					yield self.join_path(entry, sub_entry[0]), sub_entry[1], sub_entry[2]
 
+	def file_in_path(self, path, filepath):
+		return filepath.startswith(path)
+
 	def file_exists(self, path):
 		path, name = self.sanitize(path)
 		file_path = os.path.join(path, name)
diff --git a/src/octoprint/server/api/files.py b/src/octoprint/server/api/files.py
index 2804f5d5..908e387e 100644
--- a/src/octoprint/server/api/files.py
+++ b/src/octoprint/server/api/files.py
@@ -157,148 +157,178 @@ def _verifyFileExists(origin, filename):
 		return fileManager.file_exists(origin, filename)
 
 
+def _verifyFolderExists(origin, foldername):
+	if origin == FileDestinations.SDCARD:
+		return False
+	else:
+		return fileManager.folder_exists(origin, foldername)
+
+
+def _verifyFolderNotBusy(target, foldername):
+	busy_files = fileManager.get_busy_files()
+	for item in busy_files:
+		if target == item[0] and fileManager.file_in_path(target, foldername, item[1]):
+			return False
+
+	return True
+
 @api.route("/files/<string:target>", methods=["POST"])
 @restricted_access
 def uploadGcodeFile(target):
-	if not target in [FileDestinations.LOCAL, FileDestinations.SDCARD]:
-		return make_response("Unknown target: %s" % target, 404)
-
 	input_name = "file"
 	input_upload_name = input_name + "." + settings().get(["server", "uploads", "nameSuffix"])
 	input_upload_path = input_name + "." + settings().get(["server", "uploads", "pathSuffix"])
 	if input_upload_name in request.values and input_upload_path in request.values:
+		if not target in [FileDestinations.LOCAL, FileDestinations.SDCARD]:
+			return make_response("Unknown target: %s" % target, 404)
+
 		upload = octoprint.filemanager.util.DiskFileWrapper(request.values[input_upload_name], request.values[input_upload_path])
-	else:
-		return make_response("No file included", 400)
 
-	# Store any additional user data the caller may have passed.
-	userdata = None
-	if "userdata" in request.values:
-		import json
+		# Store any additional user data the caller may have passed.
+		userdata = None
+		if "userdata" in request.values:
+			import json
+			try:
+				userdata = json.loads(request.values["userdata"])
+			except:
+				return make_response("userdata contains invalid JSON", 400)
+
+		if target == FileDestinations.SDCARD and not settings().getBoolean(["feature", "sdSupport"]):
+			return make_response("SD card support is disabled", 404)
+
+		sd = target == FileDestinations.SDCARD
+		selectAfterUpload = "select" in request.values.keys() and request.values["select"] in valid_boolean_trues
+		printAfterSelect = "print" in request.values.keys() and request.values["print"] in valid_boolean_trues
+
+		if sd:
+			# validate that all preconditions for SD upload are met before attempting it
+			if not (printer.is_operational() and not (printer.is_printing() or printer.is_paused())):
+				return make_response("Can not upload to SD card, printer is either not operational or already busy", 409)
+			if not printer.is_sd_ready():
+				return make_response("Can not upload to SD card, not yet initialized", 409)
+
+		# determine current job
+		currentFilename = None
+		currentFullPath = None
+		currentOrigin = None
+		currentJob = printer.get_current_job()
+		if currentJob is not None and "file" in currentJob.keys():
+			currentJobFile = currentJob["file"]
+			if currentJobFile is not None and "name" in currentJobFile.keys() and "origin" in currentJobFile.keys() and currentJobFile["name"] is not None and currentJobFile["origin"] is not None:
+				currentPath, currentFilename = fileManager.sanitize(currentJobFile["origin"], currentJobFile["name"])
+				currentFullPath = fileManager.join_path(target, currentPath, currentFilename)
+				currentOrigin = currentJobFile["origin"]
+
+		# determine future filename of file to be uploaded, abort if it can't be uploaded
 		try:
-			userdata = json.loads(request.values["userdata"])
+			futurePath, futureFilename = fileManager.sanitize(target, upload.filename)
 		except:
-			return make_response("userdata contains invalid JSON", 400)
+			futurePath = None
+			futureFilename = None
 
-	if target == FileDestinations.SDCARD and not settings().getBoolean(["feature", "sdSupport"]):
-		return make_response("SD card support is disabled", 404)
+		if futureFilename is None:
+			return make_response("Can not upload file %s, wrong format?" % upload.filename, 415)
 
-	sd = target == FileDestinations.SDCARD
-	selectAfterUpload = "select" in request.values.keys() and request.values["select"] in valid_boolean_trues
-	printAfterSelect = "print" in request.values.keys() and request.values["print"] in valid_boolean_trues
+		if "path" in request.values:
+			futurePath = fileManager.sanitize_path(target, request.values["path"])
 
-	if sd:
-		# validate that all preconditions for SD upload are met before attempting it
-		if not (printer.is_operational() and not (printer.is_printing() or printer.is_paused())):
-			return make_response("Can not upload to SD card, printer is either not operational or already busy", 409)
-		if not printer.is_sd_ready():
-			return make_response("Can not upload to SD card, not yet initialized", 409)
+		futureFullPath = fileManager.join_path(target, futurePath, futureFilename)
 
-	# determine current job
-	currentFilename = None
-	currentFullPath = None
-	currentOrigin = None
-	currentJob = printer.get_current_job()
-	if currentJob is not None and "file" in currentJob.keys():
-		currentJobFile = currentJob["file"]
-		if currentJobFile is not None and "name" in currentJobFile.keys() and "origin" in currentJobFile.keys() and currentJobFile["name"] is not None and currentJobFile["origin"] is not None:
-			currentPath, currentFilename = fileManager.sanitize(currentJobFile["origin"], currentJobFile["name"])
-			currentFullPath = fileManager.join_path(target, currentPath, currentFilename)
-			currentOrigin = currentJobFile["origin"]
+		# prohibit overwriting currently selected file while it's being printed
+		if futureFullPath == currentFullPath and target == currentOrigin and printer.is_printing() or printer.is_paused():
+			return make_response("Trying to overwrite file that is currently being printed: %s" % currentFilename, 409)
 
-	# determine future filename of file to be uploaded, abort if it can't be uploaded
-	try:
-		futurePath, futureFilename = fileManager.sanitize(target, upload.filename)
-	except:
-		futurePath = None
-		futureFilename = None
+		def fileProcessingFinished(filename, absFilename, destination):
+			"""
+			Callback for when the file processing (upload, optional slicing, addition to analysis queue) has
+			finished.
 
-	if futureFilename is None:
-		return make_response("Can not upload file %s, wrong format?" % upload.filename, 415)
+			Depending on the file's destination triggers either streaming to SD card or directly calls selectAndOrPrint.
+			"""
 
-	if "path" in request.values:
-		futurePath = fileManager.sanitize_path(target, request.values["path"])
+			if destination == FileDestinations.SDCARD and octoprint.filemanager.valid_file_type(filename, "gcode"):
+				return filename, printer.add_sd_file(filename, absFilename, selectAndOrPrint)
+			else:
+				selectAndOrPrint(filename, absFilename, destination)
+				return filename
 
-	futureFullPath = fileManager.join_path(target, futurePath, futureFilename)
+		def selectAndOrPrint(filename, absFilename, destination):
+			"""
+			Callback for when the file is ready to be selected and optionally printed. For SD file uploads this is only
+			the case after they have finished streaming to the printer, which is why this callback is also used
+			for the corresponding call to addSdFile.
 
-	# prohibit overwriting currently selected file while it's being printed
-	if futureFullPath == currentFullPath and target == currentOrigin and printer.is_printing() or printer.is_paused():
-		return make_response("Trying to overwrite file that is currently being printed: %s" % currentFilename, 409)
+			Selects the just uploaded file if either selectAfterUpload or printAfterSelect are True, or if the
+			exact file is already selected, such reloading it.
+			"""
+			if octoprint.filemanager.valid_file_type(added_file, "gcode") and (selectAfterUpload or printAfterSelect or (currentFilename == filename and currentOrigin == destination)):
+				printer.select_file(absFilename, destination == FileDestinations.SDCARD, printAfterSelect)
 
-	def fileProcessingFinished(filename, absFilename, destination):
-		"""
-		Callback for when the file processing (upload, optional slicing, addition to analysis queue) has
-		finished.
-
-		Depending on the file's destination triggers either streaming to SD card or directly calls selectAndOrPrint.
-		"""
-
-		if destination == FileDestinations.SDCARD and octoprint.filemanager.valid_file_type(filename, "gcode"):
-			return filename, printer.add_sd_file(filename, absFilename, selectAndOrPrint)
+		added_file = fileManager.add_file(FileDestinations.LOCAL, futureFullPath, upload, allow_overwrite=True)
+		if added_file is None:
+			return make_response("Could not upload the file %s" % upload.filename, 500)
+		if octoprint.filemanager.valid_file_type(added_file, "stl"):
+			filename = added_file
+			done = True
 		else:
-			selectAndOrPrint(filename, absFilename, destination)
-			return filename
+			filename = fileProcessingFinished(added_file, fileManager.path_on_disk(FileDestinations.LOCAL, added_file), target)
+			done = True
 
-	def selectAndOrPrint(filename, absFilename, destination):
-		"""
-		Callback for when the file is ready to be selected and optionally printed. For SD file uploads this is only
-		the case after they have finished streaming to the printer, which is why this callback is also used
-		for the corresponding call to addSdFile.
+		if userdata is not None:
+			# upload included userdata, add this now to the metadata
+			fileManager.set_additional_metadata(FileDestinations.LOCAL, added_file, "userdata", userdata)
 
-		Selects the just uploaded file if either selectAfterUpload or printAfterSelect are True, or if the
-		exact file is already selected, such reloading it.
-		"""
-		if octoprint.filemanager.valid_file_type(added_file, "gcode") and (selectAfterUpload or printAfterSelect or (currentFilename == filename and currentOrigin == destination)):
-			printer.select_file(absFilename, destination == FileDestinations.SDCARD, printAfterSelect)
+		sdFilename = None
+		if isinstance(filename, tuple):
+			filename, sdFilename = filename
 
-	added_file = fileManager.add_file(FileDestinations.LOCAL, futureFullPath, upload, allow_overwrite=True)
-	if added_file is None:
-		return make_response("Could not upload the file %s" % upload.filename, 500)
-	if octoprint.filemanager.valid_file_type(added_file, "stl"):
-		filename = added_file
-		done = True
-	else:
-		filename = fileProcessingFinished(added_file, fileManager.path_on_disk(FileDestinations.LOCAL, added_file), target)
-		done = True
+		eventManager.fire(Events.UPLOAD, {"file": filename, "target": target})
 
-	if userdata is not None:
-		# upload included userdata, add this now to the metadata
-		fileManager.set_additional_metadata(FileDestinations.LOCAL, added_file, "userdata", userdata)
-
-	sdFilename = None
-	if isinstance(filename, tuple):
-		filename, sdFilename = filename
-
-	eventManager.fire(Events.UPLOAD, {"file": filename, "target": target})
-
-	files = {}
-	location = url_for(".readGcodeFile", target=FileDestinations.LOCAL, filename=filename, _external=True)
-	files.update({
-		FileDestinations.LOCAL: {
-			"name": filename,
-			"origin": FileDestinations.LOCAL,
-			"refs": {
-				"resource": location,
-				"download": url_for("index", _external=True) + "downloads/files/" + FileDestinations.LOCAL + "/" + filename
-			}
-		}
-	})
-
-	if sd and sdFilename:
-		location = url_for(".readGcodeFile", target=FileDestinations.SDCARD, filename=sdFilename, _external=True)
+		files = {}
+		location = url_for(".readGcodeFile", target=FileDestinations.LOCAL, filename=filename, _external=True)
 		files.update({
-			FileDestinations.SDCARD: {
-				"name": sdFilename,
-				"origin": FileDestinations.SDCARD,
+			FileDestinations.LOCAL: {
+				"name": filename,
+				"origin": FileDestinations.LOCAL,
 				"refs": {
-					"resource": location
+					"resource": location,
+					"download": url_for("index", _external=True) + "downloads/files/" + FileDestinations.LOCAL + "/" + filename
 				}
 			}
 		})
 
-	r = make_response(jsonify(files=files, done=done), 201)
-	r.headers["Location"] = location
-	return r
+		if sd and sdFilename:
+			location = url_for(".readGcodeFile", target=FileDestinations.SDCARD, filename=sdFilename, _external=True)
+			files.update({
+				FileDestinations.SDCARD: {
+					"name": sdFilename,
+					"origin": FileDestinations.SDCARD,
+					"refs": {
+						"resource": location
+					}
+				}
+			})
+
+		r = make_response(jsonify(files=files, done=done), 201)
+		r.headers["Location"] = location
+		return r
+	else:
+		if "foldername" not in request.json:
+			return make_response("No path information or no file included", 409)
+
+		if not target in [FileDestinations.LOCAL]:
+			return make_response("Unknown target: %s" % target, 404)
+
+		futurePath, futureName = fileManager.sanitize(target, request.json["foldername"])
+		futureFullPath = fileManager.join_path(target, futurePath, futureName)
+		if octoprint.filemanager.valid_file_type(futureName):
+			return make_response("Can't create a folder named %s, please try another name" % futureName, 409)
+
+		added_folder = fileManager.add_folder(target, futureFullPath)
+		if added_folder is None:
+			return make_response("Could not create folder %s" % futureName, 500)
+
+	return NO_CONTENT
 
 
 @api.route("/files/<string:target>/<path:filename>", methods=["GET"])
@@ -464,29 +494,52 @@ def gcodeFileCommand(filename, target):
 @api.route("/files/<string:target>/<path:filename>", methods=["DELETE"])
 @restricted_access
 def deleteGcodeFile(filename, target):
-	if not target in [FileDestinations.LOCAL, FileDestinations.SDCARD]:
-		return make_response("Unknown target: %s" % target, 404)
+	if not _verifyFileExists(target, filename) and not _verifyFolderExists(target, filename):
+		return make_response("File/Folder not found on '%s': %s" % (target, filename), 404)
 
-	if not _verifyFileExists(target, filename):
-		return make_response("File not found on '%s': %s" % (target, filename), 404)
+	if _verifyFileExists(target, filename):
+		if not target in [FileDestinations.LOCAL, FileDestinations.SDCARD]:
+			return make_response("Unknown target: %s" % target, 404)
 
-	# prohibit deleting files that are currently in use
-	currentOrigin, currentFilename = _getCurrentFile()
-	if currentFilename == filename and currentOrigin == target and (printer.is_printing() or printer.is_paused()):
-		make_response("Trying to delete file that is currently being printed: %s" % filename, 409)
+		# prohibit deleting files that are currently in use
+		currentOrigin, currentFilename = _getCurrentFile()
 
-	if (target, filename) in fileManager.get_busy_files():
-		make_response("Trying to delete a file that is currently in use: %s" % filename, 409)
+		if currentFilename is not None and currentFilename == filename and currentOrigin == target and (printer.is_printing() or printer.is_paused()):
+			return make_response("Trying to delete file that is currently being printed: %s" % filename, 409)
 
-	# deselect the file if it's currently selected
-	if currentFilename is not None and filename == currentFilename:
-		printer.unselect_file()
+		if not _verifyFolderNotBusy(target, filename):
+			return make_response("Trying to delete a file that is currently in use: %s" % filename, 409)
 
-	# delete it
-	if target == FileDestinations.SDCARD:
-		printer.delete_sd_file(filename)
-	else:
-		fileManager.remove_file(target, filename)
+		# deselect the file if it's currently selected
+		if currentFilename is not None and filename == currentFilename:
+			printer.unselect_file()
+
+		# delete it
+		if target == FileDestinations.SDCARD:
+			printer.delete_sd_file(filename)
+		else:
+			fileManager.remove_file(target, filename)
+
+	elif _verifyFolderExists(target, filename):
+		if not target in [FileDestinations.LOCAL]:
+			return make_response("Unknown target: %s" % target, 404)
+
+		folderpath = filename
+		# prohibit deleting folders that are currently in use
+		currentOrigin, currentFilename = _getCurrentFile()
+
+		if currentFilename is not None and fileManager.file_in_path(target, folderpath, currentFilename) and currentOrigin == target and (printer.is_printing() or printer.is_paused()):
+			return make_response("Trying to delete a folder that contains a file that is currently being printed: %s" % folderpath, 409)
+
+		if not _verifyFolderNotBusy(target, folderpath):
+			return make_response("Trying to delete a folder that contains a file that is currently in use: %s" % folderpath, 409)
+
+		# deselect the file if it's currently selected
+		if currentFilename is not None and fileManager.file_in_path(target, folderpath, currentFilename):
+			printer.unselect_file()
+
+		# delete it
+		fileManager.remove_folder(target, folderpath)
 
 	return NO_CONTENT
 

From d719e3cdbf9d42ea31c9a5e28640b66f99bfdfe3 Mon Sep 17 00:00:00 2001
From: Salandora <Sunpack@web.de>
Date: Fri, 9 Oct 2015 02:38:40 +0200
Subject: [PATCH 12/25] Added copy and move API commands

---
 src/octoprint/server/api/files.py | 55 ++++++++++++++++++++++++++++---
 1 file changed, 51 insertions(+), 4 deletions(-)

diff --git a/src/octoprint/server/api/files.py b/src/octoprint/server/api/files.py
index 908e387e..cc00e438 100644
--- a/src/octoprint/server/api/files.py
+++ b/src/octoprint/server/api/files.py
@@ -349,13 +349,12 @@ def gcodeFileCommand(filename, target):
 	if not target in [FileDestinations.LOCAL, FileDestinations.SDCARD]:
 		return make_response("Unknown target: %s" % target, 404)
 
-	if not _verifyFileExists(target, filename):
-		return make_response("File not found on '%s': %s" % (target, filename), 404)
-
 	# valid file commands, dict mapping command name to mandatory parameters
 	valid_commands = {
 		"select": [],
-		"slice": []
+		"slice": [],
+		"copy": ["destination"],
+		"move": ["destination"]
 	}
 
 	command, data, response = get_json_command_from_request(request, valid_commands)
@@ -363,6 +362,9 @@ def gcodeFileCommand(filename, target):
 		return response
 
 	if command == "select":
+		if not _verifyFileExists(target, filename):
+			return make_response("File not found on '%s': %s" % (target, filename), 404)
+
 		# selects/loads a file
 		if not octoprint.filemanager.valid_file_type(filename, type="machinecode"):
 			return make_response("Cannot select {filename} for printing, not a machinecode file".format(**locals()), 415)
@@ -382,6 +384,9 @@ def gcodeFileCommand(filename, target):
 		printer.select_file(filenameToSelect, sd, printAfterLoading)
 
 	elif command == "slice":
+		if not _verifyFileExists(target, filename):
+			return make_response("File not found on '%s': %s" % (target, filename), 404)
+
 		try:
 			if "slicer" in data:
 				slicer = data["slicer"]
@@ -488,6 +493,48 @@ def gcodeFileCommand(filename, target):
 		r.headers["Location"] = location
 		return r
 
+	elif command == "copy" or command == "move":
+		# Copy and move are only possible on local storage
+		if not target in [FileDestinations.LOCAL]:
+			return make_response("Unknown target: %s" % target, 404)
+
+		if not _verifyFileExists(target, filename) and not _verifyFolderExists(target, filename):
+			return make_response("File/Folder not found on '%s': %s" % (target, filename), 404)
+
+		overwrite = data["overwrite"] if "overwrite" in data else False
+		destination = data["destination"]
+
+		if _verifyFolderExists(target, destination):
+			path, name = fileManager.split_path(target, filename)
+			destination = fileManager.join_path(target, destination, name)
+
+		if fileManager.file_exists(target, destination) and not overwrite:
+			return make_response("File already exists and overwrite is prohibited: %s" % filename, 409)
+
+		if command == "copy":
+			if fileManager.file_exists(target, filename):
+				fileManager.copy_file(target, filename, destination, overwrite)
+			elif fileManager.folder_exists(target, filename):
+				fileManager.copy_folder(target, filename, destination)
+		elif command == "move":
+			# prohibit deleting or moving files that are currently in use
+			currentOrigin, currentFilename = _getCurrentFile()
+
+			if currentFilename is not None and fileManager.file_in_path(target, filename, currentFilename) and currentOrigin == target and (printer.is_printing() or printer.is_paused()):
+				return make_response("Trying to delete a folder that contains a file that is currently being printed: %s" % filename, 409)
+
+			if not _verifyFolderNotBusy(target, filename):
+				return make_response("Trying to delete a folder that contains a file that is currently in use: %s" % filename, 409)
+
+			# deselect the file if it's currently selected
+			if currentFilename is not None and filename == currentFilename:
+				printer.unselect_file()
+
+			if fileManager.file_exists(target, filename):
+				fileManager.move_file(target, filename, destination, overwrite)
+			elif fileManager.folder_exists(target, filename):
+				fileManager.move_folder(target, filename, destination, overwrite)
+
 	return NO_CONTENT
 
 

From 76718317075294f16c25dd9cf6a77a7098537f2a Mon Sep 17 00:00:00 2001
From: Salandora <Sunpack@web.de>
Date: Fri, 9 Oct 2015 02:39:21 +0200
Subject: [PATCH 13/25] Added copy, move and createFolder to clientlib

---
 src/octoprint/static/js/app/client/files.js | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/src/octoprint/static/js/app/client/files.js b/src/octoprint/static/js/app/client/files.js
index d1b5b046..0d6be0f7 100644
--- a/src/octoprint/static/js/app/client/files.js
+++ b/src/octoprint/static/js/app/client/files.js
@@ -73,6 +73,23 @@
             return OctoPrint.delete(resourceForFile(location, filename), opts);
         },
 
+        copy: function(location, filename, destination, opts) {
+            return issueFileCommand(location, filename, "copy", { destination: destination }, opts);
+        },
+
+        move: function(location, filename, destination, opts) {
+            return issueFileCommand(location, filename, "move", { destination: destination }, opts);
+        },
+
+        createFolder: function (location, name, path) {
+            var data = { foldername: name };
+            if (path != undefined && path != "") {
+                data["foldername"] = path + "/" + name;
+            }
+
+            return OctoPrint.postJson(resourceForLocation(location), data);
+        },
+
         upload: function (location, file, data) {
             data = data || {};
 

From 3458f9af433ec27a0634bc17efba9b4edbd448c5 Mon Sep 17 00:00:00 2001
From: Salandora <Sunpack@web.de>
Date: Fri, 9 Oct 2015 19:51:36 +0200
Subject: [PATCH 14/25] Refactorings based on Commit comments

---
 src/octoprint/filemanager/__init__.py         |  12 +-
 src/octoprint/filemanager/storage.py          | 190 ++++++++---------
 src/octoprint/server/api/files.py             | 193 +++++++++---------
 src/octoprint/static/js/app/client/files.js   |  23 ++-
 .../static/js/app/viewmodels/files.js         |  16 +-
 src/octoprint/templates/sidebar/files.jinja2  |  38 ++--
 6 files changed, 242 insertions(+), 230 deletions(-)

diff --git a/src/octoprint/filemanager/__init__.py b/src/octoprint/filemanager/__init__.py
index a3f0a73a..795cb2c0 100644
--- a/src/octoprint/filemanager/__init__.py
+++ b/src/octoprint/filemanager/__init__.py
@@ -391,12 +391,12 @@ class FileManager(object):
 		self._storage(destination).remove_file(path)
 		eventManager().fire(Events.UPDATED_FILES, dict(type="printables"))
 
-	def copy_file(self, destination, source, dst, allow_overwrite=False):
-		self._storage(destination).copy_file(source, dst, allow_overwrite)
+	def copy_file(self, destination, source, dst):
+		self._storage(destination).copy_file(source, dst)
 		eventManager().fire(Events.UPDATED_FILES, dict(type="printables"))
 
-	def move_file(self, destination, source, dst, allow_overwrite=False):
-		self._storage(destination).move_file(source, dst, allow_overwrite)
+	def move_file(self, destination, source, dst):
+		self._storage(destination).move_file(source, dst)
 		eventManager().fire(Events.UPDATED_FILES, dict(type="printables"))
 
 	def add_folder(self, destination, path, ignore_existing=True):
@@ -412,8 +412,8 @@ class FileManager(object):
 		self._storage(destination).copy_folder(source, dst)
 		eventManager().fire(Events.UPDATED_FILES, dict(type="printables"))
 
-	def move_folder(self, destination, source, dst, allow_overwrite=False):
-		self._storage(destination).move_folder(source, dst, allow_overwrite)
+	def move_folder(self, destination, source, dst):
+		self._storage(destination).move_folder(source, dst)
 		eventManager().fire(Events.UPDATED_FILES, dict(type="printables"))
 
 	def get_metadata(self, destination, path):
diff --git a/src/octoprint/filemanager/storage.py b/src/octoprint/filemanager/storage.py
index 28c0fccb..47ba0941 100644
--- a/src/octoprint/filemanager/storage.py
+++ b/src/octoprint/filemanager/storage.py
@@ -139,7 +139,7 @@ class StorageInterface(object):
 		"""
 		raise NotImplementedError()
 
-	def move_folder(self, source, destination, allow_overwrite=False):
+	def move_folder(self, source, destination):
 		"""
 		Moves the folder ``source`` to ``destination``
 
@@ -172,7 +172,7 @@ class StorageInterface(object):
 		"""
 		raise NotImplementedError()
 
-	def copy_file(self, source, destination, allow_overwrite=False):
+	def copy_file(self, source, destination):
 		"""
 		Copys the file ``source`` to ``destination``
 
@@ -181,7 +181,7 @@ class StorageInterface(object):
 		"""
 		raise NotImplementedError()
 
-	def move_file(self, source, destination, allow_overwrite=False):
+	def move_file(self, source, destination):
 		"""
 		Moves the file ``source`` to ``destination``
 
@@ -429,6 +429,9 @@ class LocalFileStorage(StorageInterface):
 					yield self.join_path(entry, sub_entry[0]), sub_entry[1], sub_entry[2]
 
 	def file_in_path(self, path, filepath):
+		filepath = self.sanitize_path(filepath)
+		path = self.sanitize_path(path)
+
 		return filepath.startswith(path)
 
 	def file_exists(self, path):
@@ -476,45 +479,69 @@ class LocalFileStorage(StorageInterface):
 		import shutil
 		shutil.rmtree(folder_path)
 
+	def _copyMove1(self, source, destination):
+		sourcepath, sourcename = self.sanitize(source)
+		destinationpath, destinationname = self.sanitize(destination)
+
+		source_path = os.path.join(sourcepath, sourcename)
+		if not os.path.exists(source_path):
+			raise RuntimeError("{sourcename} in {sourcepath} does not exist".format(**locals()))
+
+		destination_path = os.path.join(destinationpath, destinationname)
+		if os.path.exists(destination_path):
+			raise RuntimeError("{destinationname} does already exist in {destinationpath}".format(**locals()))
+
+		sourceObj = dict(
+			path=sourcepath,
+			name=sourcename,
+			fullpath=source_path,
+		)
+		destinationObj = dict(
+			path=destinationpath,
+			name=destinationname,
+			fullpath=destination_path,
+		)
+		return sourceObj, destinationObj
+
+	def _copyMove2(self, source, destination):
+		sourceObj, destinationObj = self._copyMove1(source, destination)
+
+		if not os.path.isfile(sourceObj["fullpath"]):
+			raise RuntimeError("%s in %s is not a file" % (sourceObj["name"], sourceObj["path"]))
+
+		sourcemetadata = self._get_metadata(sourceObj["path"])
+		if not sourcemetadata:
+			sourcemetadata = dict()
+
+		destinationmetadata = self._get_metadata(destinationObj["path"])
+		if not destinationmetadata:
+			destinationmetadata = dict()
+
+		sourceObj.update(dict(metadata=sourcemetadata))
+		destinationObj.update(dict(metadata=destinationmetadata))
+		return sourceObj, destinationObj
+
 	def copy_folder(self, source, destination):
-		sourcepath, sourcename = self.sanitize(source)
-		destinationpath, destinationname = self.sanitize(destination)
+		sourceObj, destinationObj = self._copyMove1(source, destination)
 
-		sourcefolder_path = os.path.join(sourcepath, sourcename)
-		if not os.path.exists(sourcefolder_path):
-			return
-
-		if not os.path.isdir(sourcefolder_path):
-			raise RuntimeError("{name} in {path} is not a folder".format(**locals()))
-
-		destinationfolder_path = os.path.join(destinationpath, destinationname)
-		if os.path.exists(destinationfolder_path):
-			raise RuntimeError("{newname} does already exist in {newpath}".format(**locals()))
+		if not os.path.isdir(sourceObj["fullpath"]):
+			raise RuntimeError("%s in %s is not a folder" % (sourceObj["name"], sourceObj["path"]))
 
 		try:
-			shutil.copytree(sourcefolder_path, destinationfolder_path)
+			shutil.copytree(sourceObj["fullpath"], destinationObj["fullpath"])
 		except Exception as e:
-			raise RuntimeError("Could not copy {oldname} in {oldpath} to {newname} in {newpath}".format(**locals()), e)
+			raise RuntimeError("Could not copy %s in %s to %s in %s" % (sourceObj["name"], sourceObj["path"], destinationObj["name"], destinationObj["path"]), e)
 
-	def move_folder(self, source, destination, allow_overwrite=False):
-		sourcepath, sourcename = self.sanitize(source)
-		destinationpath, destinationname = self.sanitize(destination)
+	def move_folder(self, source, destination):
+		sourceObj, destinationObj = self._copyMove1(source, destination)
 
-		sourcefolder_path = os.path.join(sourcepath, sourcename)
-		if not os.path.exists(sourcefolder_path):
-			return
-
-		if not os.path.isdir(sourcefolder_path):
-			raise RuntimeError("{name} in {path} is not a folder".format(**locals()))
-
-		destinationfolder_path = os.path.join(destinationpath, destinationname)
-		if os.path.exists(destinationfolder_path) and not allow_overwrite:
-			raise RuntimeError("{newname} does already exist in {newpath} and overwriting is prohibited".format(**locals()))
+		if not os.path.isdir(sourceObj["fullpath"]):
+			raise RuntimeError("%s in %s is not a folder" % (sourceObj["name"], sourceObj["path"]))
 
 		try:
-			shutil.move(sourcefolder_path, destinationfolder_path)
+			shutil.move(sourceObj["fullpath"], destinationObj["fullpath"])
 		except Exception as e:
-			raise RuntimeError("Could not move {oldname} in {oldpath} to {newname} in {newpath}".format(**locals()), e)
+			raise RuntimeError("Could not move %s in %s to %s in %s" % (sourceObj["name"], sourceObj["path"], destinationObj["name"], destinationObj["path"]), e)
 
 	def add_file(self, path, file_object, printer_profile=None, links=None, allow_overwrite=False):
 		path, name = self.sanitize(path)
@@ -585,83 +612,41 @@ class LocalFileStorage(StorageInterface):
 					if not "links" in m:
 						continue
 					for link in m["links"]:
-						if "rel" in link and "hash" in link and (link["rel"] == "model" or link["rel"] == "machinecode") and link["hash"] == hash:
+						if "rel" in link and "hash" in link and (
+								link["rel"] == "model" or link["rel"] == "machinecode") and link["hash"] == hash:
 							m["links"].remove(link)
 			del metadata[name]
 			self._save_metadata(path, metadata)
 
-	def copy_file(self, source, destination, allow_overwrite=False):
-		sourcepath, sourcename = self.sanitize(source)
-		destinationpath, destinationname = self.sanitize(destination)
-
-		oldmetadata = self._get_metadata(sourcepath)
-		if not oldmetadata:
-			oldmetadata = dict()
-
-		newmetadata = self._get_metadata(destinationpath)
-		if not newmetadata:
-			newmetadata = dict()
-
-		sourcefile_path = os.path.join(sourcepath, sourcename)
-		if not os.path.exists(sourcefile_path):
-			return
-
-		if not os.path.isfile(sourcefile_path):
-			raise RuntimeError("{oldname} in {oldpath} is not a file".format(**locals()))
-
-		destinationfile_path = os.path.join(destinationpath, destinationname)
-		if os.path.exists(destinationfile_path) and not allow_overwrite:
-			raise RuntimeError("{newname} does already exist in {newpath} and overwriting is prohibited".format(**locals()))
+	def copy_file(self, source, destination):
+		sourceObj, destinationObj = self._copyMove2(source, destination)
 
 		try:
-			shutil.copy2(sourcefile_path, destinationfile_path)
+			shutil.copy2(sourceObj["fullpath"], destinationObj["fullpath"])
 		except Exception as e:
-			raise RuntimeError("Could not copy {oldname} in {oldpath} to {newname} in {newpath}".format(**locals()), e)
+			raise RuntimeError("Could not copy %s in %s to %s in %s" % (sourceObj["name"], sourceObj["path"], destinationObj["name"], destinationObj["path"]), e)
 
-		if sourcename in oldmetadata:
-			metadata = oldmetadata[sourcename]
-
-			newmetadata[destinationname] = metadata
-			newmetadata[destinationname]["hash"] = self._create_hash(destinationfile_path)
-			self._save_metadata(destinationpath, newmetadata)
+		if sourceObj["name"] in sourceObj["metadata"]:
+			destinationObj["metadata"][destinationObj["name"]] = sourceObj["metadata"][sourceObj["name"]]
+			destinationObj["metadata"][destinationObj["name"]]["hash"] = self._create_hash(destinationObj["fullpath"])
+			self._save_metadata(destinationObj["path"], destinationObj["metadata"])
 
 	def move_file(self, source, destination, allow_overwrite=False):
-		sourcepath, sourcename = self.sanitize(source)
-		destinationpath, destinationname = self.sanitize(destination)
-
-		oldmetadata = self._get_metadata(sourcepath)
-		if not oldmetadata:
-			oldmetadata = dict()
-
-		newmetadata = self._get_metadata(destinationpath)
-		if not newmetadata:
-			newmetadata = dict()
-
-		sourcefile_path = os.path.join(sourcepath, sourcename)
-		if not os.path.exists(sourcefile_path):
-			return
-
-		if not os.path.isfile(sourcefile_path):
-			raise RuntimeError("{oldname} in {oldpath} is not a file".format(**locals()))
-
-		destinationfile_path = os.path.join(destinationpath, destinationname)
-		if os.path.exists(destinationfile_path) and not allow_overwrite:
-			raise RuntimeError("{newname} does already exist in {newpath} and overwriting is prohibited".format(**locals()))
+		sourceObj, destinationObj = self._copyMove2(source, destination)
 
 		try:
-			shutil.move(sourcefile_path, destinationfile_path)
+			shutil.move(sourceObj["fullpath"], destinationObj["fullpath"])
 		except Exception as e:
-			raise RuntimeError("Could not move {oldname} in {oldpath} to {newname} in {newpath}".format(**locals()), e)
+			raise RuntimeError("Could not move %s in %s to %s in %s" % (sourceObj["name"], sourceObj["path"], destinationObj["name"], destinationObj["path"]), e)
 
-		if sourcename in oldmetadata:
-			metadata = oldmetadata[sourcename]
-			del oldmetadata[sourcename]
-			self._save_metadata(sourcepath, oldmetadata)
-
-			newmetadata[destinationname] = metadata
-			newmetadata[destinationname]["hash"] = self._create_hash(destinationfile_path)
-			self._save_metadata(destinationpath, newmetadata)
+		if sourceObj["name"] in sourceObj["metadata"]:
+			metadata = sourceObj["metadata"][sourceObj["name"]]
+			del sourceObj["metadata"][sourceObj["name"]]
+			self._save_metadata(sourceObj["path"], sourceObj["metadata"])
 
+			destinationObj["metadata"][destinationObj["name"]] = metadata
+			destinationObj["metadata"][destinationObj["name"]]["hash"] = self._create_hash(destinationObj["fullpath"])
+			self._save_metadata(destinationObj["path"], destinationObj["metadata"])
 
 	def get_metadata(self, path):
 		path, name = self.sanitize(path)
@@ -1160,25 +1145,18 @@ class LocalFileStorage(StorageInterface):
 				)
 
 				if not filter or filter(entry, entry_data):
-					def get_size(start_path):
+					def get_size():
 						total_size = 0
-						for root, dirs, files in os.walk(start_path):
-							for f in files:
-								if f is ".metadata.yaml":
-									continue
-
-								fp = os.path.join(root, f)
-								total_size += os.path.getsize(fp)
+						for element in entry_data["children"].itervalues():
+							if "size" in element:
+								total_size += element["size"]
 
 						return total_size
 
 					# only add folders passing the optional filter
 					extended_entry_data = dict()
 					extended_entry_data.update(entry_data)
-					extended_entry_data["size"] = get_size(entry_path)
-					stat = os.stat(entry_path)
-					if stat:
-						extended_entry_data["date"] = int(stat.st_ctime)
+					extended_entry_data["size"] = get_size()
 
 					result[entry] = extended_entry_data
 
diff --git a/src/octoprint/server/api/files.py b/src/octoprint/server/api/files.py
index cc00e438..d98c24de 100644
--- a/src/octoprint/server/api/files.py
+++ b/src/octoprint/server/api/files.py
@@ -25,13 +25,8 @@ import psutil
 
 @api.route("/files", methods=["GET"])
 def readGcodeFiles():
-	filter = None
-	recursive = False
-	if "filter" in request.values:
-		filter = request.values["filter"]
-
-	if "recursive" in request.values:
-		recursive = request.values["recursive"] == 'true'
+	filter = "filter" in request.values and request.values["recursive"] in valid_boolean_trues
+	recursive = "recursive" in request.values and request.values["recursive"] in valid_boolean_trues
 
 	files = _getFileList(FileDestinations.LOCAL, filter=filter, recursive=recursive)
 	files.extend(_getFileList(FileDestinations.SDCARD))
@@ -62,17 +57,40 @@ def _getFileDetails(origin, path):
 	files = _getFileList(origin, recursive=True)
 	path = path.split('/')
 
-	def recursive_get_filedetails(files, path):
-		for file in files:
-			if file["name"] == path[0]:
-				if len(path) > 1:
-					return recursive_get_filedetails(file["children"], path[1:])
-				else:
-					return file
+	if len(path) == 1:
+		# shortcut for files in the root folder
+		name = path[0]
+		for f in files:
+			if f["name"] == name:
+				return f
 
 		return None
 
-	return recursive_get_filedetails(files, path)
+	node = files
+	while path:
+		segment = path.pop(0)
+		for f in node:
+			if not f["name"] == segment:
+				# wrong name => next!
+				continue
+
+			if not path:
+				# no path left and name matches => found it!
+				return f
+
+			if not f["type"] == "folder":
+				# path left but not a folder => that doesn't work
+				return None
+
+			# we'll use this folder's children as the next iteration
+			node = f["children"]
+			break
+		else:
+			# nothing matched the name, we can't find it
+			return None
+
+	# nothing returned until now => not found
+	return None
 
 
 def _getFileList(origin, filter=None, recursive=False):
@@ -100,52 +118,55 @@ def _getFileList(origin, filter=None, recursive=False):
 
 		files = fileManager.list_files(origin, filter=filter_func, recursive=recursive)[origin].values()
 
-		def recursive_analysis(files, path):
+		def analyse_recursively(files, path=None):
+			if path is None:
+				path = ""
+
 			for file in files:
 				file["origin"] = FileDestinations.LOCAL
 
 				if file["type"] == "folder":
-					file["children"] = recursive_analysis(file["children"].values(), path + file["name"] + "/")
+					file["children"] = analyse_recursively(file["children"].values(), path + file["name"] + "/")
+				else:
+					if "analysis" in file and octoprint.filemanager.valid_file_type(file["name"], type="gcode"):
+						file["gcodeAnalysis"] = file["analysis"]
+						del file["analysis"]
 
-				if "analysis" in file and octoprint.filemanager.valid_file_type(file["name"], type="gcode"):
-					file["gcodeAnalysis"] = file["analysis"]
-					del file["analysis"]
-
-				if "history" in file and octoprint.filemanager.valid_file_type(file["name"], type="gcode"):
-					# convert print log
-					history = file["history"]
-					del file["history"]
-					success = 0
-					failure = 0
-					last = None
-					for entry in history:
-						success += 1 if "success" in entry and entry["success"] else 0
-						failure += 1 if "success" in entry and not entry["success"] else 0
-						if not last or ("timestamp" in entry and "timestamp" in last and entry["timestamp"] > last["timestamp"]):
-							last = entry
-					if last:
-						prints = dict(
-							success=success,
-							failure=failure,
-							last=dict(
-								success=last["success"],
-								date=last["timestamp"]
+					if "history" in file and octoprint.filemanager.valid_file_type(file["name"], type="gcode"):
+						# convert print log
+						history = file["history"]
+						del file["history"]
+						success = 0
+						failure = 0
+						last = None
+						for entry in history:
+							success += 1 if "success" in entry and entry["success"] else 0
+							failure += 1 if "success" in entry and not entry["success"] else 0
+							if not last or ("timestamp" in entry and "timestamp" in last and entry["timestamp"] > last["timestamp"]):
+								last = entry
+						if last:
+							prints = dict(
+								success=success,
+								failure=failure,
+								last=dict(
+									success=last["success"],
+									date=last["timestamp"]
+								)
 							)
-						)
-						if "printTime" in last:
-							prints["last"]["printTime"] = last["printTime"]
-						file["prints"] = prints
+							if "printTime" in last:
+								prints["last"]["printTime"] = last["printTime"]
+							file["prints"] = prints
 
-				file.update({
-					"refs": {
-						"resource": url_for(".readGcodeFile", target=FileDestinations.LOCAL, filename=path + file["name"], _external=True),
-						"download": url_for("index", _external=True) + "downloads/files/" + FileDestinations.LOCAL + "/" + path + file["name"]
-					}
-				})
+					file.update({
+						"refs": {
+							"resource": url_for(".readGcodeFile", target=FileDestinations.LOCAL, filename=path + file["name"], _external=True),
+							"download": url_for("index", _external=True) + "downloads/files/" + FileDestinations.LOCAL + "/" + path + file["name"]
+						}
+					})
 
 			return files
 
-		files = recursive_analysis(files, "")
+		analyse_recursively(files)
 
 	return files
 
@@ -164,13 +185,17 @@ def _verifyFolderExists(origin, foldername):
 		return fileManager.folder_exists(origin, foldername)
 
 
-def _verifyFolderNotBusy(target, foldername):
+def _isBusy(target, path):
+	currentOrigin, currentFilename = _getCurrentFile()
+	if currentFilename is not None and fileManager.file_in_path(target, path, currentFilename) and currentOrigin == target and (printer.is_printing() or printer.is_paused()):
+		return True
+
 	busy_files = fileManager.get_busy_files()
 	for item in busy_files:
-		if target == item[0] and fileManager.file_in_path(target, foldername, item[1]):
-			return False
+		if target == item[0] and fileManager.file_in_path(target, path, item[1]):
+			return True
 
-	return True
+	return False
 
 @api.route("/files/<string:target>", methods=["POST"])
 @restricted_access
@@ -312,14 +337,13 @@ def uploadGcodeFile(target):
 		r = make_response(jsonify(files=files, done=done), 201)
 		r.headers["Location"] = location
 		return r
-	else:
-		if "foldername" not in request.json:
-			return make_response("No path information or no file included", 409)
+	elif "foldername" in request.values:
+		foldername = request.values["foldername"]
 
 		if not target in [FileDestinations.LOCAL]:
-			return make_response("Unknown target: %s" % target, 404)
+			return make_response("Unknown target: %s" % target, 400)
 
-		futurePath, futureName = fileManager.sanitize(target, request.json["foldername"])
+		futurePath, futureName = fileManager.sanitize(target, foldername)
 		futureFullPath = fileManager.join_path(target, futurePath, futureName)
 		if octoprint.filemanager.valid_file_type(futureName):
 			return make_response("Can't create a folder named %s, please try another name" % futureName, 409)
@@ -327,6 +351,8 @@ def uploadGcodeFile(target):
 		added_folder = fileManager.add_folder(target, futureFullPath)
 		if added_folder is None:
 			return make_response("Could not create folder %s" % futureName, 500)
+	else:
+		return make_response("No file to upload and no folder to create", 400)
 
 	return NO_CONTENT
 
@@ -496,44 +522,37 @@ def gcodeFileCommand(filename, target):
 	elif command == "copy" or command == "move":
 		# Copy and move are only possible on local storage
 		if not target in [FileDestinations.LOCAL]:
-			return make_response("Unknown target: %s" % target, 404)
+			return make_response("Unsupported target for {}: {}".format(command, target), 400)
 
 		if not _verifyFileExists(target, filename) and not _verifyFolderExists(target, filename):
 			return make_response("File/Folder not found on '%s': %s" % (target, filename), 404)
 
-		overwrite = data["overwrite"] if "overwrite" in data else False
 		destination = data["destination"]
-
 		if _verifyFolderExists(target, destination):
 			path, name = fileManager.split_path(target, filename)
 			destination = fileManager.join_path(target, destination, name)
 
-		if fileManager.file_exists(target, destination) and not overwrite:
-			return make_response("File already exists and overwrite is prohibited: %s" % filename, 409)
+		if _verifyFileExists(target, destination) or _verifyFolderExists(target, destination):
+			return make_response("File/Folder already exists: %s" % filename, 409)
 
 		if command == "copy":
 			if fileManager.file_exists(target, filename):
-				fileManager.copy_file(target, filename, destination, overwrite)
+				fileManager.copy_file(target, filename, destination)
 			elif fileManager.folder_exists(target, filename):
 				fileManager.copy_folder(target, filename, destination)
 		elif command == "move":
-			# prohibit deleting or moving files that are currently in use
-			currentOrigin, currentFilename = _getCurrentFile()
-
-			if currentFilename is not None and fileManager.file_in_path(target, filename, currentFilename) and currentOrigin == target and (printer.is_printing() or printer.is_paused()):
-				return make_response("Trying to delete a folder that contains a file that is currently being printed: %s" % filename, 409)
-
-			if not _verifyFolderNotBusy(target, filename):
-				return make_response("Trying to delete a folder that contains a file that is currently in use: %s" % filename, 409)
+			if _isBusy(target, filename):
+				return make_response("Trying to move a file/folder that is currently in use: %s" % filename, 409)
 
 			# deselect the file if it's currently selected
+			currentOrigin, currentFilename = _getCurrentFile()
 			if currentFilename is not None and filename == currentFilename:
 				printer.unselect_file()
 
 			if fileManager.file_exists(target, filename):
-				fileManager.move_file(target, filename, destination, overwrite)
+				fileManager.move_file(target, filename, destination)
 			elif fileManager.folder_exists(target, filename):
-				fileManager.move_folder(target, filename, destination, overwrite)
+				fileManager.move_folder(target, filename, destination)
 
 	return NO_CONTENT
 
@@ -546,18 +565,13 @@ def deleteGcodeFile(filename, target):
 
 	if _verifyFileExists(target, filename):
 		if not target in [FileDestinations.LOCAL, FileDestinations.SDCARD]:
-			return make_response("Unknown target: %s" % target, 404)
+			return make_response("Unknown target: %s" % target, 400)
 
-		# prohibit deleting files that are currently in use
-		currentOrigin, currentFilename = _getCurrentFile()
-
-		if currentFilename is not None and currentFilename == filename and currentOrigin == target and (printer.is_printing() or printer.is_paused()):
-			return make_response("Trying to delete file that is currently being printed: %s" % filename, 409)
-
-		if not _verifyFolderNotBusy(target, filename):
+		if _isBusy(target, filename):
 			return make_response("Trying to delete a file that is currently in use: %s" % filename, 409)
 
 		# deselect the file if it's currently selected
+		currentOrigin, currentFilename = _getCurrentFile()
 		if currentFilename is not None and filename == currentFilename:
 			printer.unselect_file()
 
@@ -569,19 +583,14 @@ def deleteGcodeFile(filename, target):
 
 	elif _verifyFolderExists(target, filename):
 		if not target in [FileDestinations.LOCAL]:
-			return make_response("Unknown target: %s" % target, 404)
+			return make_response("Unknown target: %s" % target, 400)
 
 		folderpath = filename
-		# prohibit deleting folders that are currently in use
-		currentOrigin, currentFilename = _getCurrentFile()
-
-		if currentFilename is not None and fileManager.file_in_path(target, folderpath, currentFilename) and currentOrigin == target and (printer.is_printing() or printer.is_paused()):
-			return make_response("Trying to delete a folder that contains a file that is currently being printed: %s" % folderpath, 409)
-
-		if not _verifyFolderNotBusy(target, folderpath):
+		if _isBusy(target, folderpath):
 			return make_response("Trying to delete a folder that contains a file that is currently in use: %s" % folderpath, 409)
 
 		# deselect the file if it's currently selected
+		currentOrigin, currentFilename = _getCurrentFile()
 		if currentFilename is not None and fileManager.file_in_path(target, folderpath, currentFilename):
 			printer.unselect_file()
 
diff --git a/src/octoprint/static/js/app/client/files.js b/src/octoprint/static/js/app/client/files.js
index d1b5b046..50d896de 100644
--- a/src/octoprint/static/js/app/client/files.js
+++ b/src/octoprint/static/js/app/client/files.js
@@ -47,11 +47,13 @@
         get: getFile,
 
         list: function (opts) {
-            return OctoPrint.get(url, opts).done(preProcessList);
+            return OctoPrint.get(url, opts)
+                .done(preProcessList);
         },
 
         listForLocation: function (location, opts) {
-            return OctoPrint.get(resourceForLocation(location), opts).done(preProcessList);
+            return OctoPrint.get(resourceForLocation(location), opts)
+                .done(preProcessList);
         },
 
         select: function (location, filename, print, opts) {
@@ -73,6 +75,23 @@
             return OctoPrint.delete(resourceForFile(location, filename), opts);
         },
 
+        copy: function(location, filename, destination, opts) {
+            return issueFileCommand(location, filename, "copy", { destination: destination }, opts);
+        },
+
+        move: function(location, filename, destination, opts) {
+            return issueFileCommand(location, filename, "move", { destination: destination }, opts);
+        },
+
+        createFolder: function (location, name, path) {
+            var data = "foldername=" + name;
+            if (path != undefined && path != "") {
+                data = "foldername:" + path + "/" + name;
+            }
+
+            return OctoPrint.post(resourceForLocation(location), data);
+        },
+
         upload: function (location, file, data) {
             data = data || {};
 
diff --git a/src/octoprint/static/js/app/viewmodels/files.js b/src/octoprint/static/js/app/viewmodels/files.js
index 481d7c29..d94f13d5 100644
--- a/src/octoprint/static/js/app/viewmodels/files.js
+++ b/src/octoprint/static/js/app/viewmodels/files.js
@@ -99,10 +99,7 @@ $(function() {
                     return data["type"] && (data["type"] == "model" || data["type"] == "folder");
                 },
                 "emptyFolder": function(data) {
-                    if (data["type"] && data["type"] != "folder")
-                        return true;
-
-                    return data.children.length != 0;
+                    return data["type"] && (data["type"] != "folder" || data["children"].length != 0);
                 }
             },
             "name",
@@ -115,6 +112,7 @@ $(function() {
             var filter = function(data) { return data["type"] && data["type"] == "folder"; };
             return _.filter(self.listHelper.paginatedItems(), filter);
         });
+
         self.filesOnlyList = ko.dependentObservable(function() {
             var filter = function(data) { return data["type"] && data["type"] != "folder"; };
             return _.filter(self.listHelper.paginatedItems(), filter);
@@ -215,6 +213,7 @@ $(function() {
             self.currentPath(OctoPrint.files.pathForElement(data));
             self.listHelper.updateItems(data.children);
         };
+
         self.changeFolderByPath = function(path) {
             var element = OctoPrint.files.elementByPath(path, { children: self.allItems() });
             if (element) {
@@ -245,15 +244,18 @@ $(function() {
             }
             
             var index = self.listHelper.paginatedItems().indexOf(file) + 1;
-            if (index >= self.listHelper.paginatedItems().length)
+            if (index >= self.listHelper.paginatedItems().length) {
                 index = index - 2;
-            if (index < 0)
+            }
+            if (index < 0) {
                 index = 0;
+            }
 
             var filenameToFocus = undefined;
             var fileToFocus = self.listHelper.paginatedItems()[index];
-            if (fileToFocus)
+            if (fileToFocus) {
                 filenameToFocus = fileToFocus.name;
+            }
             
             OctoPrint.files.delete(file.origin, OctoPrint.files.pathForElement(file))
                 .done(function() {
diff --git a/src/octoprint/templates/sidebar/files.jinja2 b/src/octoprint/templates/sidebar/files.jinja2
index 1d16d1c5..180cea90 100644
--- a/src/octoprint/templates/sidebar/files.jinja2
+++ b/src/octoprint/templates/sidebar/files.jinja2
@@ -7,25 +7,27 @@
     <!-- /ko -->
 
     <!-- ko if: listStyle() == 'folders_files' -->
-    <!-- ko slimScrolledForeach: foldersOnlyList -->
-    <div class="entry" data-bind="attr: { id: $root.getEntryId($data) }, template: { name: $root.templateFor($data), data: $data }"></div>
-    <!-- /ko -->
-    <!-- ko slimScrolledForeach: filesOnlyList -->
-    <div class="entry" data-bind="attr: { id: $root.getEntryId($data) }, template: { name: $root.templateFor($data), data: $data }"></div>
-    <!-- /ko -->
+        <!-- ko slimScrolledForeach: foldersOnlyList -->
+             <div class="entry" data-bind="attr: { id: $root.getEntryId($data) }, template: { name: $root.templateFor($data), data: $data }"></div>
+        <!-- /ko -->
+        <!-- ko slimScrolledForeach: filesOnlyList -->
+            <div class="entry" data-bind="attr: { id: $root.getEntryId($data) }, template: { name: $root.templateFor($data), data: $data }"></div>
+        <!-- /ko -->
     <!-- /ko -->
+
     <!-- ko if: listStyle() == 'files_folders' -->
-    <!-- ko slimScrolledForeach: filesOnlyList -->
-    <div class="entry" data-bind="attr: { id: $root.getEntryId($data) }, template: { name: $root.templateFor($data), data: $data }"></div>
-    <!-- /ko -->
-    <!-- ko slimScrolledForeach: foldersOnlyList -->
-    <div class="entry" data-bind="attr: { id: $root.getEntryId($data) }, template: { name: $root.templateFor($data), data: $data }"></div>
-    <!-- /ko -->
+        <!-- ko slimScrolledForeach: filesOnlyList -->
+            <div class="entry" data-bind="attr: { id: $root.getEntryId($data) }, template: { name: $root.templateFor($data), data: $data }"></div>
+        <!-- /ko -->
+        <!-- ko slimScrolledForeach: foldersOnlyList -->
+            <div class="entry" data-bind="attr: { id: $root.getEntryId($data) }, template: { name: $root.templateFor($data), data: $data }"></div>
+        <!-- /ko -->
     <!-- /ko -->
+
     <!-- ko if: listStyle() == 'mixed' -->
-    <!-- ko slimScrolledForeach: listHelper.paginatedItems -->
-    <div class="entry" data-bind="attr: { id: $root.getEntryId($data) }, template: { name: $root.templateFor($data), data: $data }"></div>
-    <!-- /ko -->
+        <!-- ko slimScrolledForeach: listHelper.paginatedItems -->
+            <div class="entry" data-bind="attr: { id: $root.getEntryId($data) }, template: { name: $root.templateFor($data), data: $data }"></div>
+        <!-- /ko -->
     <!-- /ko -->
 
     <script type="text/html" id="files_template_machinecode">
@@ -54,8 +56,10 @@
     </script>
 
     <script type="text/html" id="files_template_folder">
-        <div class="title" data-bind="click: $root.changeFolder"><i class="icon-folder-open"></i> <span data-bind="text: name"></span></div>
-        <div class="size">{{ _('Size') }}: <span data-bind="text: formatSize(size)"></span></div>
+        <div data-bind="click: $root.changeFolder">
+            <div class="title"><i class="icon-folder-open"></i> <span data-bind="text: name"></span></div>
+            <div class="size">{{ _('Size') }}: <span data-bind="text: formatSize(size)"></span></div>
+        </div>
     </script>
 </div>
 <div class="text-right muted" data-bind="attr: {title: diskusageString}, css: {'text-error': diskusageCritical}, style: {'font-weight': diskusageCritical() || diskusageWarning() ? 'bold' : 'normal'}">

From 0dacfcdf8d60a39f680f92aaa38ab9e78738acba Mon Sep 17 00:00:00 2001
From: Salandora <Sunpack@web.de>
Date: Fri, 9 Oct 2015 21:50:34 +0200
Subject: [PATCH 15/25] Fixed Slicing. Normal behaviour is sliced gcode will be
 placed in same folder as the stl.

---
 src/octoprint/server/api/files.py              |  7 +++++++
 .../static/js/app/viewmodels/slicing.js        | 18 +++++++++++++++---
 2 files changed, 22 insertions(+), 3 deletions(-)

diff --git a/src/octoprint/server/api/files.py b/src/octoprint/server/api/files.py
index d98c24de..3723c707 100644
--- a/src/octoprint/server/api/files.py
+++ b/src/octoprint/server/api/files.py
@@ -443,6 +443,13 @@ def gcodeFileCommand(filename, target):
 			name, _ = os.path.splitext(filename)
 			gcode_name = name + ".gco"
 
+		if "path" in data and data["path"]:
+			gcode_name = fileManager.join_path(target, data["path"], gcode_name)
+		else:
+			path, _ = fileManager.split_path(target, filename)
+			if path:
+				gcode_name = fileManager.join_path(target, path, gcode_name)
+
 		# prohibit overwriting the file that is currently being printed
 		currentOrigin, currentFilename = _getCurrentFile()
 		if currentFilename == gcode_name and currentOrigin == target and (printer.is_printing() or printer.is_paused()):
diff --git a/src/octoprint/static/js/app/viewmodels/slicing.js b/src/octoprint/static/js/app/viewmodels/slicing.js
index ffbb21f9..222d243f 100644
--- a/src/octoprint/static/js/app/viewmodels/slicing.js
+++ b/src/octoprint/static/js/app/viewmodels/slicing.js
@@ -7,6 +7,7 @@ $(function() {
 
         self.target = undefined;
         self.file = undefined;
+        self.path = undefined;
         self.data = undefined;
 
         self.defaultSlicer = undefined;
@@ -34,16 +35,23 @@ $(function() {
         ];
         self.afterSlicing = ko.observable("none");
 
-        self.show = function(target, file, force) {
+        self.show = function(target, file, force, path) {
             if (!self.enableSlicingDialog() && !force) {
                 return;
             }
 
+            var filename = file.substr(0, file.lastIndexOf("."));
+            if (filename.lastIndexOf("/") != 0) {
+                path = path || filename.substr(0, filename.lastIndexOf("/"));
+                filename = filename.substr(filename.lastIndexOf("/") + 1);
+            }
+
             self.requestData();
             self.target = target;
             self.file = file;
-            self.title(_.sprintf(gettext("Slicing %(filename)s"), {filename: self.file}));
-            self.gcodeFilename(self.file.substr(0, self.file.lastIndexOf(".")));
+            self.path = path;
+            self.title(_.sprintf(gettext("Slicing %(filename)s"), {filename: filename}));
+            self.gcodeFilename(filename);
             self.printerProfile(self.printerProfiles.currentProfile());
             self.afterSlicing("none");
             $("#slicing_configuration_dialog").modal("show");
@@ -149,6 +157,10 @@ $(function() {
                 gcode: gcodeFilename
             };
 
+            if (self.path != undefined) {
+                data["path"] = self.path;
+            }
+
             if (self.afterSlicing() == "print") {
                 data["print"] = true;
             } else if (self.afterSlicing() == "select") {

From 95bcccb84c3cb354eff49d0f072d1be6115b576b Mon Sep 17 00:00:00 2001
From: Salandora <Sunpack@web.de>
Date: Mon, 12 Oct 2015 10:00:26 +0200
Subject: [PATCH 16/25] Renaming and Refactoring

---
 src/octoprint/filemanager/storage.py          | 14 +++++-----
 src/octoprint/static/js/app/main.js           |  6 ++--
 .../static/js/app/viewmodels/files.js         | 22 +++++++++++++++
 src/octoprint/templates/sidebar/files.jinja2  | 28 ++-----------------
 .../templates/sidebar/files_header.jinja2     | 12 +++++---
 5 files changed, 44 insertions(+), 38 deletions(-)

diff --git a/src/octoprint/filemanager/storage.py b/src/octoprint/filemanager/storage.py
index 47ba0941..ab34a374 100644
--- a/src/octoprint/filemanager/storage.py
+++ b/src/octoprint/filemanager/storage.py
@@ -479,7 +479,7 @@ class LocalFileStorage(StorageInterface):
 		import shutil
 		shutil.rmtree(folder_path)
 
-	def _copyMove1(self, source, destination):
+	def _copyMove(self, source, destination):
 		sourcepath, sourcename = self.sanitize(source)
 		destinationpath, destinationname = self.sanitize(destination)
 
@@ -503,8 +503,8 @@ class LocalFileStorage(StorageInterface):
 		)
 		return sourceObj, destinationObj
 
-	def _copyMove2(self, source, destination):
-		sourceObj, destinationObj = self._copyMove1(source, destination)
+	def _copyMoveWithMetadata(self, source, destination):
+		sourceObj, destinationObj = self._copyMove(source, destination)
 
 		if not os.path.isfile(sourceObj["fullpath"]):
 			raise RuntimeError("%s in %s is not a file" % (sourceObj["name"], sourceObj["path"]))
@@ -522,7 +522,7 @@ class LocalFileStorage(StorageInterface):
 		return sourceObj, destinationObj
 
 	def copy_folder(self, source, destination):
-		sourceObj, destinationObj = self._copyMove1(source, destination)
+		sourceObj, destinationObj = self._copyMove(source, destination)
 
 		if not os.path.isdir(sourceObj["fullpath"]):
 			raise RuntimeError("%s in %s is not a folder" % (sourceObj["name"], sourceObj["path"]))
@@ -533,7 +533,7 @@ class LocalFileStorage(StorageInterface):
 			raise RuntimeError("Could not copy %s in %s to %s in %s" % (sourceObj["name"], sourceObj["path"], destinationObj["name"], destinationObj["path"]), e)
 
 	def move_folder(self, source, destination):
-		sourceObj, destinationObj = self._copyMove1(source, destination)
+		sourceObj, destinationObj = self._copyMove(source, destination)
 
 		if not os.path.isdir(sourceObj["fullpath"]):
 			raise RuntimeError("%s in %s is not a folder" % (sourceObj["name"], sourceObj["path"]))
@@ -619,7 +619,7 @@ class LocalFileStorage(StorageInterface):
 			self._save_metadata(path, metadata)
 
 	def copy_file(self, source, destination):
-		sourceObj, destinationObj = self._copyMove2(source, destination)
+		sourceObj, destinationObj = self._copyMoveWithMetadata(source, destination)
 
 		try:
 			shutil.copy2(sourceObj["fullpath"], destinationObj["fullpath"])
@@ -632,7 +632,7 @@ class LocalFileStorage(StorageInterface):
 			self._save_metadata(destinationObj["path"], destinationObj["metadata"])
 
 	def move_file(self, source, destination, allow_overwrite=False):
-		sourceObj, destinationObj = self._copyMove2(source, destination)
+		sourceObj, destinationObj = self._copyMoveWithMetadata(source, destination)
 
 		try:
 			shutil.move(sourceObj["fullpath"], destinationObj["fullpath"])
diff --git a/src/octoprint/static/js/app/main.js b/src/octoprint/static/js/app/main.js
index 90d32ead..88f9ac18 100644
--- a/src/octoprint/static/js/app/main.js
+++ b/src/octoprint/static/js/app/main.js
@@ -271,10 +271,12 @@ $(function() {
             },
             update: function(element, valueAccessor, allBindings, viewModel, bindingContext) {
                 setTimeout(function() {
-                    if (element.nodeName == "#comment")
+                    if (element.nodeName == "#comment") {
+                        // foreach is bound to a virtual element
                         $(element.parentElement).slimScroll({scrollBy: 0});
-                    else
+                    } else {
                         $(element).slimScroll({scrollBy: 0});
+                    }
                 }, 10);
                 return ko.bindingHandlers.foreach.update(element, valueAccessor(), allBindings, viewModel, bindingContext);
             }
diff --git a/src/octoprint/static/js/app/viewmodels/files.js b/src/octoprint/static/js/app/viewmodels/files.js
index d94f13d5..f13a13ed 100644
--- a/src/octoprint/static/js/app/viewmodels/files.js
+++ b/src/octoprint/static/js/app/viewmodels/files.js
@@ -118,6 +118,22 @@ $(function() {
             return _.filter(self.listHelper.paginatedItems(), filter);
         });
 
+        self.filesAndFolders = ko.dependentObservable(function() {
+            var style = self.listStyle();
+            if (style == "folders_files" || style == "files_folders") {
+                var files = self.filesOnlyList();
+                var folders = self.foldersOnlyList();
+
+                if (style == "folders_files") {
+                    return folders.concat(files);
+                } else {
+                    return files.concat(folders);
+                }
+            } else {
+                return self.listHelper.paginatedItems();
+            }
+        });
+
         self.isLoadActionPossible = ko.computed(function() {
             return self.loginState.isUser() && !self.isPrinting() && !self.isPaused() && !self.isLoading();
         });
@@ -214,6 +230,12 @@ $(function() {
             self.listHelper.updateItems(data.children);
         };
 
+        self.navigateUp = function() {
+            var path = self.currentPath().split("/");
+            path.pop();
+            self.changeFolderByPath(path.join("/"));
+        };
+
         self.changeFolderByPath = function(path) {
             var element = OctoPrint.files.elementByPath(path, { children: self.allItems() });
             if (element) {
diff --git a/src/octoprint/templates/sidebar/files.jinja2 b/src/octoprint/templates/sidebar/files.jinja2
index 180cea90..31be4107 100644
--- a/src/octoprint/templates/sidebar/files.jinja2
+++ b/src/octoprint/templates/sidebar/files.jinja2
@@ -2,32 +2,10 @@
     <input type="text" class="input-block search-query" data-bind="value: searchQuery, valueUpdate: 'input'" placeholder="{{ _('Search...') }}">
 </form>
 <div class="gcode_files">
-    <!-- ko if: currentPath() != "" -->
-    <div class="entry" data-bind="click: function() { var path = $root.currentPath().split('/'); path.pop(); $root.changeFolderByPath(path.join('/')); }"><i class="icon-arrow-left"></i> {{  _('Back') }}</div>
-    <!-- /ko -->
+    <div class="entry" data-bind="visible: currentPath() != '', click: function() { $root.navigateUp(); }" style="display: none"><i class="icon-arrow-left"></i> {{  _('Back') }}</div>
 
-    <!-- ko if: listStyle() == 'folders_files' -->
-        <!-- ko slimScrolledForeach: foldersOnlyList -->
-             <div class="entry" data-bind="attr: { id: $root.getEntryId($data) }, template: { name: $root.templateFor($data), data: $data }"></div>
-        <!-- /ko -->
-        <!-- ko slimScrolledForeach: filesOnlyList -->
-            <div class="entry" data-bind="attr: { id: $root.getEntryId($data) }, template: { name: $root.templateFor($data), data: $data }"></div>
-        <!-- /ko -->
-    <!-- /ko -->
-
-    <!-- ko if: listStyle() == 'files_folders' -->
-        <!-- ko slimScrolledForeach: filesOnlyList -->
-            <div class="entry" data-bind="attr: { id: $root.getEntryId($data) }, template: { name: $root.templateFor($data), data: $data }"></div>
-        <!-- /ko -->
-        <!-- ko slimScrolledForeach: foldersOnlyList -->
-            <div class="entry" data-bind="attr: { id: $root.getEntryId($data) }, template: { name: $root.templateFor($data), data: $data }"></div>
-        <!-- /ko -->
-    <!-- /ko -->
-
-    <!-- ko if: listStyle() == 'mixed' -->
-        <!-- ko slimScrolledForeach: listHelper.paginatedItems -->
-            <div class="entry" data-bind="attr: { id: $root.getEntryId($data) }, template: { name: $root.templateFor($data), data: $data }"></div>
-        <!-- /ko -->
+    <!-- ko slimScrolledForeach: filesAndFolders -->
+    <div class="entry" data-bind="attr: { id: $root.getEntryId($data) }, template: { name: $root.templateFor($data), data: $data }"></div>
     <!-- /ko -->
 
     <script type="text/html" id="files_template_machinecode">
diff --git a/src/octoprint/templates/sidebar/files_header.jinja2 b/src/octoprint/templates/sidebar/files_header.jinja2
index 1e7eebc7..c706bfc9 100644
--- a/src/octoprint/templates/sidebar/files_header.jinja2
+++ b/src/octoprint/templates/sidebar/files_header.jinja2
@@ -3,13 +3,17 @@
         <span class="icon-wrench"></span>
     </a>
     <ul class="dropdown-menu">
-        <li><a href="#" data-bind="click: function() { $root.listStyle('folders_files'); }"><i class="icon-ok" data-bind="style: {visibility: listStyle() == 'folders_files' ? 'visible' : 'hidden'}"></i> {{ _('Sort by Folders, Files') }}</a></li>
-        <li><a href="#" data-bind="click: function() { $root.listStyle('files_folders'); }"><i class="icon-ok" data-bind="style: {visibility: listStyle() == 'files_folders' ? 'visible' : 'hidden'}"></i> {{ _('Sort by Files, Folders') }}</a></li>
-        <li><a href="#" data-bind="click: function() { $root.listStyle('mixed'); }"><i class="icon-ok" data-bind="style: {visibility: listStyle() == 'mixed' ? 'visible' : 'hidden'}"></i> {{ _('Mixed') }}</a></li>
-        <li class="divider"></li>
         <li><a href="#" data-bind="click: function() { $root.listHelper.changeSorting('name'); }"><i class="icon-ok" data-bind="style: {visibility: listHelper.currentSorting() == 'name' ? 'visible' : 'hidden'}"></i> {{ _('Sort by name') }} ({{ _('ascending') }})</a></li>
         <li><a href="#" data-bind="click: function() { $root.listHelper.changeSorting('upload'); }"><i class="icon-ok" data-bind="style: {visibility: listHelper.currentSorting() == 'upload' ? 'visible' : 'hidden'}"></i> {{ _('Sort by upload date') }} ({{ _('descending') }})</a></li>
         <li><a href="#" data-bind="click: function() { $root.listHelper.changeSorting('size'); }"><i class="icon-ok" data-bind="style: {visibility: listHelper.currentSorting() == 'size' ? 'visible' : 'hidden'}"></i> {{ _('Sort by file size') }} ({{ _('descending') }})</a></li>
+        <li class="dropdown-submenu">
+            <a href="#"><i class="icon-ok" style="visibility: hidden"></i> {{ _('Folders') }}</a>
+            <ul class="dropdown-menu">
+                <li><a href="#" data-bind="click: function() { $root.listStyle('folders_files'); }"><i class="icon-ok" data-bind="style: {visibility: listStyle() == 'folders_files' ? 'visible' : 'hidden'}"></i> {{ _('Sort by Folders, Files') }}</a></li>
+                <li><a href="#" data-bind="click: function() { $root.listStyle('files_folders'); }"><i class="icon-ok" data-bind="style: {visibility: listStyle() == 'files_folders' ? 'visible' : 'hidden'}"></i> {{ _('Sort by Files, Folders') }}</a></li>
+                <li><a href="#" data-bind="click: function() { $root.listStyle('mixed'); }"><i class="icon-ok" data-bind="style: {visibility: listStyle() == 'mixed' ? 'visible' : 'hidden'}"></i> {{ _('Mixed') }}</a></li>
+            </ul>
+        </li>
         <li class="divider"></li>
         <li><a href="#" data-bind="click: function() { $root.listHelper.toggleFilter('machinecode'); }"><i class="icon-ok" data-bind="style: {visibility: _.contains(listHelper.currentFilters(), 'machinecode') ? 'visible' : 'hidden'}"></i> {{ _('Only show GCode files') }}</a></li>
         <li><a href="#" data-bind="click: function() { $root.listHelper.toggleFilter('model'); }"><i class="icon-ok" data-bind="style: {visibility: _.contains(listHelper.currentFilters(), 'model') ? 'visible' : 'hidden'}"></i> {{ _('Only show STL files') }}</a></li>

From 46faa286e6cbe5770dbe137d9fac93872b935f75 Mon Sep 17 00:00:00 2001
From: Salandora <Sunpack@web.de>
Date: Tue, 27 Oct 2015 13:04:47 +0100
Subject: [PATCH 17/25] Little refactorings and bugfixes

---
 src/octoprint/server/api/files.py | 40 ++++++++++++++-----------------
 1 file changed, 18 insertions(+), 22 deletions(-)

diff --git a/src/octoprint/server/api/files.py b/src/octoprint/server/api/files.py
index 3723c707..d9a8b38c 100644
--- a/src/octoprint/server/api/files.py
+++ b/src/octoprint/server/api/files.py
@@ -187,15 +187,10 @@ def _verifyFolderExists(origin, foldername):
 
 def _isBusy(target, path):
 	currentOrigin, currentFilename = _getCurrentFile()
-	if currentFilename is not None and fileManager.file_in_path(target, path, currentFilename) and currentOrigin == target and (printer.is_printing() or printer.is_paused()):
+	if currentFilename is not None and currentOrigin == target and fileManager.file_in_path(FileDestinations.LOCAL, path, currentFilename) and (printer.is_printing() or printer.is_paused()):
 		return True
 
-	busy_files = fileManager.get_busy_files()
-	for item in busy_files:
-		if target == item[0] and fileManager.file_in_path(target, path, item[1]):
-			return True
-
-	return False
+	return any(target == x[0] and fileManager.file_in_path(FileDestinations.LOCAL, path, x[1]) for x in fileManager.get_busy_files())
 
 @api.route("/files/<string:target>", methods=["POST"])
 @restricted_access
@@ -233,20 +228,20 @@ def uploadGcodeFile(target):
 				return make_response("Can not upload to SD card, not yet initialized", 409)
 
 		# determine current job
+		currentPath = None
 		currentFilename = None
-		currentFullPath = None
 		currentOrigin = None
 		currentJob = printer.get_current_job()
 		if currentJob is not None and "file" in currentJob.keys():
 			currentJobFile = currentJob["file"]
 			if currentJobFile is not None and "name" in currentJobFile.keys() and "origin" in currentJobFile.keys() and currentJobFile["name"] is not None and currentJobFile["origin"] is not None:
-				currentPath, currentFilename = fileManager.sanitize(currentJobFile["origin"], currentJobFile["name"])
-				currentFullPath = fileManager.join_path(target, currentPath, currentFilename)
+				currentPath, currentFilename = fileManager.sanitize(FileDestinations.LOCAL, currentJobFile["name"])
 				currentOrigin = currentJobFile["origin"]
 
 		# determine future filename of file to be uploaded, abort if it can't be uploaded
 		try:
-			futurePath, futureFilename = fileManager.sanitize(target, upload.filename)
+			# FileDestinations.LOCAL = should normally be target, but can't because SDCard handling isn't implemented yet
+			futurePath, futureFilename = fileManager.sanitize(FileDestinations.LOCAL, upload.filename)
 		except:
 			futurePath = None
 			futureFilename = None
@@ -254,13 +249,12 @@ def uploadGcodeFile(target):
 		if futureFilename is None:
 			return make_response("Can not upload file %s, wrong format?" % upload.filename, 415)
 
-		if "path" in request.values:
-			futurePath = fileManager.sanitize_path(target, request.values["path"])
-
-		futureFullPath = fileManager.join_path(target, futurePath, futureFilename)
+		if "path" in request.values and request.values["path"]:
+			# FileDestinations.LOCAL = should normally be target, but can't because SDCard handling isn't implemented yet
+			futurePath = fileManager.sanitize_path(FileDestinations.LOCAL, request.values["path"])
 
 		# prohibit overwriting currently selected file while it's being printed
-		if futureFullPath == currentFullPath and target == currentOrigin and printer.is_printing() or printer.is_paused():
+		if futurePath == currentPath and futureFilename == currentFilename and target == currentOrigin and (printer.is_printing() or printer.is_paused()):
 			return make_response("Trying to overwrite file that is currently being printed: %s" % currentFilename, 409)
 
 		def fileProcessingFinished(filename, absFilename, destination):
@@ -289,6 +283,9 @@ def uploadGcodeFile(target):
 			if octoprint.filemanager.valid_file_type(added_file, "gcode") and (selectAfterUpload or printAfterSelect or (currentFilename == filename and currentOrigin == destination)):
 				printer.select_file(absFilename, destination == FileDestinations.SDCARD, printAfterSelect)
 
+		# FileDestinations.LOCAL = should normally be target, but can't because SDCard handling isn't implemented yet
+		futureFullPath = fileManager.join_path(FileDestinations.LOCAL, futurePath, futureFilename)
+
 		added_file = fileManager.add_file(FileDestinations.LOCAL, futureFullPath, upload, allow_overwrite=True)
 		if added_file is None:
 			return make_response("Could not upload the file %s" % upload.filename, 500)
@@ -579,7 +576,7 @@ def deleteGcodeFile(filename, target):
 
 		# deselect the file if it's currently selected
 		currentOrigin, currentFilename = _getCurrentFile()
-		if currentFilename is not None and filename == currentFilename:
+		if currentFilename is not None and currentOrigin == target and filename == currentFilename:
 			printer.unselect_file()
 
 		# delete it
@@ -592,17 +589,16 @@ def deleteGcodeFile(filename, target):
 		if not target in [FileDestinations.LOCAL]:
 			return make_response("Unknown target: %s" % target, 400)
 
-		folderpath = filename
-		if _isBusy(target, folderpath):
-			return make_response("Trying to delete a folder that contains a file that is currently in use: %s" % folderpath, 409)
+		if _isBusy(target, filename):
+			return make_response("Trying to delete a folder that contains a file that is currently in use: %s" % filename, 409)
 
 		# deselect the file if it's currently selected
 		currentOrigin, currentFilename = _getCurrentFile()
-		if currentFilename is not None and fileManager.file_in_path(target, folderpath, currentFilename):
+		if currentFilename is not None and currentOrigin == target and fileManager.file_in_path(target, filename, currentFilename):
 			printer.unselect_file()
 
 		# delete it
-		fileManager.remove_folder(target, folderpath)
+		fileManager.remove_folder(target, filename)
 
 	return NO_CONTENT
 

From 962dc490aab5ddb44a31b849c72b4f1c7cb367a6 Mon Sep 17 00:00:00 2001
From: Salandora <Sunpack@web.de>
Date: Tue, 27 Oct 2015 14:38:16 +0100
Subject: [PATCH 18/25] Forgot to include a change

---
 src/octoprint/static/js/app/viewmodels/files.js | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/octoprint/static/js/app/viewmodels/files.js b/src/octoprint/static/js/app/viewmodels/files.js
index b7462335..337ecacc 100644
--- a/src/octoprint/static/js/app/viewmodels/files.js
+++ b/src/octoprint/static/js/app/viewmodels/files.js
@@ -539,7 +539,8 @@ $(function() {
                     fail: gcode_upload_fail,
                     progressall: gcode_upload_progress
                 }).bind('fileuploadsubmit', function(e, data) {
-                    data.formData = { path: self.currentPath() };
+                    if (self.currentPath() != "")
+                        data.formData = { path: self.currentPath() };
                 });
             }
 

From 306fd164d714b6b3c8319cefaf6780cb8367e5cc Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Gina=20H=C3=A4u=C3=9Fge?= <osd@foosel.net>
Date: Wed, 18 Nov 2015 10:47:49 +0100
Subject: [PATCH 19/25] Refactoring of localstorage and added tests

  * improved internal metadata handling
  * less code duplication
  * individual locks per metadata file
  * unit tests for copy and move operations
---
 src/octoprint/filemanager/storage.py   | 299 ++++++++++++++-----------
 tests/filemanager/test_localstorage.py | 251 +++++++++++++++++----
 2 files changed, 376 insertions(+), 174 deletions(-)

diff --git a/src/octoprint/filemanager/storage.py b/src/octoprint/filemanager/storage.py
index 15386b74..4121af35 100644
--- a/src/octoprint/filemanager/storage.py
+++ b/src/octoprint/filemanager/storage.py
@@ -9,9 +9,12 @@ __copyright__ = "Copyright (C) 2014 The OctoPrint Project - Released under terms
 import logging
 import os
 import pylru
-import tempfile
 import shutil
 
+from octoprint.util import atomic_write
+from contextlib import contextmanager
+from copy import deepcopy
+
 import octoprint.filemanager
 
 class StorageInterface(object):
@@ -331,6 +334,25 @@ class StorageInterface(object):
 		raise NotImplementedError()
 
 
+class StorageError(BaseException):
+	UNKNOWN = "unknown"
+	INVALID_DIRECTORY = "invalid_directory"
+	INVALID_FILE = "invalid_file"
+	INVALID_SOURCE = "invalid_source"
+	INVALID_DESTINATION = "invalid_destination"
+	DOES_NOT_EXIST = "does_not_exist"
+	ALREADY_EXISTS = "already_exists"
+	NOT_EMPTY = "not_empty"
+
+	def __init__(self, message, code=None, cause=None):
+		BaseException.__init__(self)
+		self.message = message
+		self.cause = cause
+
+		if code is None:
+			code = StorageError.UNKNOWN
+		self.code = code
+
 
 class LocalFileStorage(StorageInterface):
 	"""
@@ -356,10 +378,11 @@ class LocalFileStorage(StorageInterface):
 		if not os.path.exists(self.basefolder) and create:
 			os.makedirs(self.basefolder)
 		if not os.path.exists(self.basefolder) or not os.path.isdir(self.basefolder):
-			raise RuntimeError("{basefolder} is not a valid directory".format(**locals()))
+			raise StorageError("{basefolder} is not a valid directory".format(**locals()), code=StorageError.INVALID_DIRECTORY)
 
 		import threading
-		self._metadata_lock = threading.Lock()
+		self._metadata_lock_mutex = threading.RLock()
+		self._metadata_locks = dict()
 
 		self._metadata_cache = pylru.lrucache(10)
 
@@ -457,7 +480,7 @@ class LocalFileStorage(StorageInterface):
 		folder_path = os.path.join(path, name)
 		if os.path.exists(folder_path):
 			if not ignore_existing:
-				raise RuntimeError("{sanitized_foldername} does already exist in {virtual_path}".format(**locals()))
+				raise StorageError("{sanitized_foldername} does already exist in {virtual_path}".format(**locals()), code=StorageError.ALREADY_EXISTS)
 		else:
 			os.mkdir(folder_path)
 
@@ -474,89 +497,69 @@ class LocalFileStorage(StorageInterface):
 		if ".metadata.yaml" in contents:
 			contents.remove(".metadata.yaml")
 		if contents and not recursive:
-			raise RuntimeError("{sanitized_foldername} in {virtual_path} is not empty".format(**locals()))
+			raise StorageError("{sanitized_foldername} in {virtual_path} is not empty".format(**locals()), code=StorageError.NOT_EMPTY)
 
 		import shutil
 		shutil.rmtree(folder_path)
 
-	def _copyMove(self, source, destination):
-		sourcepath, sourcename = self.sanitize(source)
-		destinationpath, destinationname = self.sanitize(destination)
+		self._delete_metadata(folder_path)
 
-		source_path = os.path.join(sourcepath, sourcename)
-		if not os.path.exists(source_path):
-			raise RuntimeError("{sourcename} in {sourcepath} does not exist".format(**locals()))
+	def _get_source_destination_data(self, source, destination):
+		"""Prepares data dicts about source and destination for copy/move."""
+		source_path, source_name = self.sanitize(source)
+		destination_path, destination_name = self.sanitize(destination)
 
-		destination_path = os.path.join(destinationpath, destinationname)
-		if os.path.exists(destination_path):
-			raise RuntimeError("{destinationname} does already exist in {destinationpath}".format(**locals()))
+		source_fullpath = os.path.join(source_path, source_name)
+		destination_fullpath = os.path.join(destination_path, destination_name)
 
-		sourceObj = dict(
-			path=sourcepath,
-			name=sourcename,
-			fullpath=source_path,
+		if not os.path.exists(source_fullpath):
+			raise StorageError("{} in {} does not exist".format(source_name, source_path), code=StorageError.INVALID_SOURCE)
+
+		if not os.path.isdir(destination_path):
+			raise StorageError("Destination path {} does not exist or is not a folder".format(destination_path), code=StorageError.INVALID_DESTINATION)
+		if os.path.exists(destination_fullpath):
+			raise StorageError("{} does already exist in {}".format(destination_name, destination_path), code=StorageError.INVALID_DESTINATION)
+
+		source_data = dict(
+			path=source_path,
+			name=source_name,
+			fullpath=source_fullpath,
 		)
-		destinationObj = dict(
-			path=destinationpath,
-			name=destinationname,
-			fullpath=destination_path,
+		destination_data = dict(
+			path=destination_path,
+			name=destination_name,
+			fullpath=destination_fullpath,
 		)
-		return sourceObj, destinationObj
-
-	def _copyMoveWithMetadata(self, source, destination):
-		sourceObj, destinationObj = self._copyMove(source, destination)
-
-		if not os.path.isfile(sourceObj["fullpath"]):
-			raise RuntimeError("%s in %s is not a file" % (sourceObj["name"], sourceObj["path"]))
-
-		sourcemetadata = self._get_metadata(sourceObj["path"])
-		if not sourcemetadata:
-			sourcemetadata = dict()
-
-		destinationmetadata = self._get_metadata(destinationObj["path"])
-		if not destinationmetadata:
-			destinationmetadata = dict()
-
-		sourceObj.update(dict(metadata=sourcemetadata))
-		destinationObj.update(dict(metadata=destinationmetadata))
-		return sourceObj, destinationObj
+		return source_data, destination_data
 
 	def copy_folder(self, source, destination):
-		sourceObj, destinationObj = self._copyMove(source, destination)
-
-		if not os.path.isdir(sourceObj["fullpath"]):
-			raise RuntimeError("%s in %s is not a folder" % (sourceObj["name"], sourceObj["path"]))
+		source_data, destination_data = self._get_source_destination_data(source, destination)
 
 		try:
-			shutil.copytree(sourceObj["fullpath"], destinationObj["fullpath"])
+			shutil.copytree(source_data["fullpath"], destination_data["fullpath"])
 		except Exception as e:
-			raise RuntimeError("Could not copy %s in %s to %s in %s" % (sourceObj["name"], sourceObj["path"], destinationObj["name"], destinationObj["path"]), e)
+			raise StorageError("Could not copy %s in %s to %s in %s" % (source_data["name"], source_data["path"], destination_data["name"], destination_data["path"]), cause=e)
 
 	def move_folder(self, source, destination):
-		sourceObj, destinationObj = self._copyMove(source, destination)
-
-		if not os.path.isdir(sourceObj["fullpath"]):
-			raise RuntimeError("%s in %s is not a folder" % (sourceObj["name"], sourceObj["path"]))
+		source_data, destination_data = self._get_source_destination_data(source, destination)
 
 		try:
-			shutil.move(sourceObj["fullpath"], destinationObj["fullpath"])
+			shutil.move(source_data["fullpath"], destination_data["fullpath"])
 		except Exception as e:
-			raise RuntimeError("Could not move %s in %s to %s in %s" % (sourceObj["name"], sourceObj["path"], destinationObj["name"], destinationObj["path"]), e)
+			raise StorageError("Could not move %s in %s to %s in %s" % (source_data["name"], source_data["path"], destination_data["name"], destination_data["path"]), cause=e)
+
+		self._delete_metadata(source_data["fullpath"])
 
 	def add_file(self, path, file_object, printer_profile=None, links=None, allow_overwrite=False):
 		path, name = self.sanitize(path)
 		if not octoprint.filemanager.valid_file_type(name):
-			raise RuntimeError("{name} is an unrecognized file type".format(**locals()))
-
-		metadata = self._get_metadata(path)
-		if not metadata:
-			metadata = dict()
+			raise StorageError("{name} is an unrecognized file type".format(**locals()), code=StorageError.INVALID_FILE)
 
 		file_path = os.path.join(path, name)
 		if os.path.exists(file_path) and not os.path.isfile(file_path):
-			raise RuntimeError("{name} does already exist in {path} and is not a file".format(**locals()))
+			raise StorageError("{name} does already exist in {path} and is not a file".format(**locals()), code=StorageError.ALREADY_EXISTS)
 		if os.path.exists(file_path) and not allow_overwrite:
-			raise RuntimeError("{name} does already exist in {path} and overwriting is prohibited".format(**locals()))
+			raise StorageError("{name} does already exist in {path} and overwriting is prohibited".format(**locals()), code=StorageError.ALREADY_EXISTS)
 
 		# make sure folders exist
 		if not os.path.exists(path):
@@ -567,13 +570,10 @@ class LocalFileStorage(StorageInterface):
 
 		# save the file's hash to the metadata of the folder
 		file_hash = self._create_hash(file_path)
-		if not name in metadata or not "hash" in metadata[name] or metadata[name]["hash"] != file_hash:
-			# make sure to create a new metadata entry if we've never seen that file with that content before
-			file_metadata = dict(
-				hash=file_hash
-			)
-			metadata[name] = file_metadata
-			self._save_metadata(path, metadata)
+		metadata = self._get_metadata_entry(path, name, default=dict())
+		if not "hash" in metadata or metadata["hash"] != file_hash:
+			metadata["hash"] = file_hash
+			self._update_metadata_entry(path, name, metadata)
 
 		# process any links that were also provided for adding to the file
 		if not links:
@@ -592,76 +592,50 @@ class LocalFileStorage(StorageInterface):
 	def remove_file(self, path):
 		path, name = self.sanitize(path)
 
-		metadata = self._get_metadata(path)
-
 		file_path = os.path.join(path, name)
 		if not os.path.exists(file_path):
 			return
 		if not os.path.isfile(file_path):
-			raise RuntimeError("{name} in {path} is not a file".format(**locals()))
+			raise StorageError("{name} in {path} is not a file".format(**locals()), code=StorageError.INVALID_FILE)
 
 		try:
 			os.remove(file_path)
 		except Exception as e:
-			raise RuntimeError("Could not delete {name} in {path}".format(**locals()), e)
+			raise StorageError("Could not delete {name} in {path}".format(**locals()), cause=e)
 
-		if name in metadata:
-			if "hash" in metadata[name]:
-				hash = metadata[name]["hash"]
-				for m in metadata.values():
-					if not "links" in m:
-						continue
-					for link in m["links"]:
-						if "rel" in link and "hash" in link and (
-								link["rel"] == "model" or link["rel"] == "machinecode") and link["hash"] == hash:
-							m["links"].remove(link)
-			del metadata[name]
-			self._save_metadata(path, metadata)
+		self._remove_metadata_entry(path, name)
 
 	def copy_file(self, source, destination):
-		sourceObj, destinationObj = self._copyMoveWithMetadata(source, destination)
+		source_data, destination_data = self._get_source_destination_data(source, destination)
 
 		try:
-			shutil.copy2(sourceObj["fullpath"], destinationObj["fullpath"])
+			shutil.copy2(source_data["fullpath"], destination_data["fullpath"])
 		except Exception as e:
-			raise RuntimeError("Could not copy %s in %s to %s in %s" % (sourceObj["name"], sourceObj["path"], destinationObj["name"], destinationObj["path"]), e)
+			raise StorageError("Could not copy %s in %s to %s in %s" % (source_data["name"], source_data["path"], destination_data["name"], destination_data["path"]), cause=e)
 
-		if sourceObj["name"] in sourceObj["metadata"]:
-			destinationObj["metadata"][destinationObj["name"]] = sourceObj["metadata"][sourceObj["name"]]
-			destinationObj["metadata"][destinationObj["name"]]["hash"] = self._create_hash(destinationObj["fullpath"])
-			self._save_metadata(destinationObj["path"], destinationObj["metadata"])
+		self._copy_metadata_entry(source_data["path"], source_data["name"],
+		                          destination_data["path"], destination_data["name"])
 
 	def move_file(self, source, destination, allow_overwrite=False):
-		sourceObj, destinationObj = self._copyMoveWithMetadata(source, destination)
+		source_data, destination_data = self._get_source_destination_data(source, destination)
 
 		try:
-			shutil.move(sourceObj["fullpath"], destinationObj["fullpath"])
+			shutil.move(source_data["fullpath"], destination_data["fullpath"])
 		except Exception as e:
-			raise RuntimeError("Could not move %s in %s to %s in %s" % (sourceObj["name"], sourceObj["path"], destinationObj["name"], destinationObj["path"]), e)
+			raise StorageError("Could not move %s in %s to %s in %s" % (source_data["name"], source_data["path"], destination_data["name"], destination_data["path"]), cause=e)
 
-		if sourceObj["name"] in sourceObj["metadata"]:
-			metadata = sourceObj["metadata"][sourceObj["name"]]
-			del sourceObj["metadata"][sourceObj["name"]]
-			self._save_metadata(sourceObj["path"], sourceObj["metadata"])
-
-			destinationObj["metadata"][destinationObj["name"]] = metadata
-			destinationObj["metadata"][destinationObj["name"]]["hash"] = self._create_hash(destinationObj["fullpath"])
-			self._save_metadata(destinationObj["path"], destinationObj["metadata"])
+		self._copy_metadata_entry(source_data["path"], source_data["name"],
+		                          destination_data["path"], destination_data["name"],
+		                          delete_source=True)
 
 	def get_metadata(self, path):
 		path, name = self.sanitize(path)
-
-		metadata = self._get_metadata(path)
-		if name in metadata:
-			return metadata[name]
-		else:
-			return None
+		return self._get_metadata_entry(path, name)
 
 	def get_link(self, path, rel):
 		path, name = self.sanitize(path)
 		return self._get_links(name, path, rel)
 
-
 	def add_link(self, path, rel, data):
 		path, name = self.sanitize(path)
 		self._add_links(name, path, [(rel, data)])
@@ -1154,13 +1128,53 @@ class LocalFileStorage(StorageInterface):
 
 		return hash.hexdigest()
 
-	def _get_metadata(self, path):
-		if path in self._metadata_cache:
-			return self._metadata_cache[path]
+	def _get_metadata_entry(self, path, name, default=None):
+		with self._get_metadata_lock(path):
+			metadata = self._get_metadata(path)
+			return metadata.get(name, default)
 
-		metadata_path = os.path.join(path, ".metadata.yaml")
-		if os.path.exists(metadata_path):
-			with self._metadata_lock:
+	def _remove_metadata_entry(self, path, name):
+		with self._get_metadata_lock(path):
+			metadata = self._get_metadata(path)
+			if not name in metadata:
+				return
+
+			if "hash" in metadata[name]:
+				hash = metadata[name]["hash"]
+				for m in metadata.values():
+					if not "links" in m:
+						continue
+					links_hash = lambda link: "hash" in link and link["hash"] == hash and "rel" in link and (link["rel"] == "model" or link["rel"] == "machinecode")
+					m["links"] = [link for link in m["links"] if not links_hash(link)]
+
+			del metadata[name]
+			self._save_metadata(path, metadata)
+
+	def _update_metadata_entry(self, path, name, data):
+		with self._get_metadata_lock(path):
+			metadata = self._get_metadata(path)
+			metadata[name] = data
+			self._save_metadata(path, metadata)
+
+	def _copy_metadata_entry(self, source_path, source_name, destination_path, destination_name, delete_source=False):
+		with self._get_metadata_lock(source_path):
+			source_data = self._get_metadata_entry(source_path, source_name, default=dict())
+			if not source_data:
+				return
+
+			if delete_source:
+				self._remove_metadata_entry(source_path, source_name)
+
+		with self._get_metadata_lock(destination_path):
+			self._update_metadata_entry(destination_path, destination_name, source_data)
+
+	def _get_metadata(self, path):
+		with self._get_metadata_lock(path):
+			if path in self._metadata_cache:
+				return deepcopy(self._metadata_cache[path])
+
+			metadata_path = os.path.join(path, ".metadata.yaml")
+			if os.path.exists(metadata_path):
 				with open(metadata_path) as f:
 					try:
 						import yaml
@@ -1168,30 +1182,49 @@ class LocalFileStorage(StorageInterface):
 					except:
 						self._logger.exception("Error while reading .metadata.yaml from {path}".format(**locals()))
 					else:
-						self._metadata_cache[path] = metadata
+						self._metadata_cache[path] = deepcopy(metadata)
 						return metadata
-		return dict()
+			return dict()
 
 	def _save_metadata(self, path, metadata):
-		metadata_path = os.path.join(path, ".metadata.yaml")
-
-		with self._metadata_lock:
+		with self._get_metadata_lock(path):
+			metadata_path = os.path.join(path, ".metadata.yaml")
 			try:
 				import yaml
-				import shutil
-
-				file_obj = tempfile.NamedTemporaryFile(delete=False)
-				try:
-					yaml.safe_dump(metadata, stream=file_obj, default_flow_style=False, indent="  ", allow_unicode=True)
-					file_obj.close()
-					shutil.move(file_obj.name, metadata_path)
-				finally:
-					try:
-						if os.path.exists(file_obj.name):
-							os.remove(file_obj.name)
-					except Exception as e:
-						self._logger.warn("Could not delete file {}: {}".format(file_obj.name, str(e)))
+				with atomic_write(metadata_path) as f:
+					yaml.safe_dump(metadata, stream=f, default_flow_style=False, indent="  ", allow_unicode=True)
 			except:
 				self._logger.exception("Error while writing .metadata.yaml to {path}".format(**locals()))
 			else:
-				self._metadata_cache[path] = metadata
+				self._metadata_cache[path] = deepcopy(metadata)
+
+	def _delete_metadata(self, path):
+		with self._get_metadata_lock(path):
+			metadata_path = os.path.join(path, ".metadata.yaml")
+			if os.path.exists(metadata_path):
+				try:
+					os.remove(metadata_path)
+				except:
+					self._logger.exception("Error while deleting .metadata.yaml from {path}".format(**locals()))
+			if path in self._metadata_cache:
+				del self._metadata_cache[path]
+
+	@contextmanager
+	def _get_metadata_lock(self, path):
+		with self._metadata_lock_mutex:
+			if path not in self._metadata_locks:
+				import threading
+				self._metadata_locks[path] = (0, threading.RLock())
+
+			counter, lock = self._metadata_locks[path]
+			counter += 1
+			self._metadata_locks[path] = (counter, lock)
+
+			yield lock
+
+			counter = self._metadata_locks[path][0]
+			counter -= 1
+			if counter <= 0:
+				del self._metadata_locks[path]
+			else:
+				self._metadata_locks[path] = (counter, lock)
diff --git a/tests/filemanager/test_localstorage.py b/tests/filemanager/test_localstorage.py
index 45666a01..bc38a842 100644
--- a/tests/filemanager/test_localstorage.py
+++ b/tests/filemanager/test_localstorage.py
@@ -12,7 +12,7 @@ import os.path
 
 from ddt import ddt, unpack, data
 
-import octoprint.filemanager.storage
+from octoprint.filemanager.storage import LocalFileStorage, StorageError
 
 
 class FileWrapper(object):
@@ -43,7 +43,7 @@ class LocalStorageTest(unittest.TestCase):
 	def setUp(self):
 		import tempfile
 		self.basefolder = os.path.realpath(os.path.abspath(tempfile.mkdtemp()))
-		self.storage = octoprint.filemanager.storage.LocalFileStorage(self.basefolder)
+		self.storage = LocalFileStorage(self.basefolder)
 
 		# mock file manager module
 		self.filemanager_patcher = mock.patch("octoprint.filemanager")
@@ -67,24 +67,24 @@ class LocalStorageTest(unittest.TestCase):
 		self.filemanager_patcher.stop()
 
 	def test_add_file(self):
-		self._add_file("bp_case.stl", "bp_case.stl", FILE_BP_CASE_STL)
+		self._add_and_verify_file("bp_case.stl", "bp_case.stl", FILE_BP_CASE_STL)
 
 	def test_add_file_overwrite(self):
-		self._add_file("bp_case.stl", "bp_case.stl", FILE_BP_CASE_STL)
+		self._add_and_verify_file("bp_case.stl", "bp_case.stl", FILE_BP_CASE_STL)
 
 		try:
-			self._add_file("bp_case.stl", "bp_case.stl", FILE_BP_CASE_STL, overwrite=False)
+			self._add_and_verify_file("bp_case.stl", "bp_case.stl", FILE_BP_CASE_STL, overwrite=False)
 		except:
 			pass
 
-		self._add_file("bp_case.stl", "bp_case.stl", FILE_BP_CASE_STL, overwrite=True)
+		self._add_and_verify_file("bp_case.stl", "bp_case.stl", FILE_BP_CASE_STL, overwrite=True)
 
 	def test_add_file_with_web(self):
 		import time
 		href = "http://www.example.com"
 		retrieved = time.time()
 
-		stl_name = self._add_file("bp_case.stl", "bp_case.stl", FILE_BP_CASE_STL, links=[("web", dict(href=href, retrieved=retrieved))])
+		stl_name = self._add_and_verify_file("bp_case.stl", "bp_case.stl", FILE_BP_CASE_STL, links=[("web", dict(href=href, retrieved=retrieved))])
 		stl_metadata = self.storage.get_metadata(stl_name)
 
 		self.assertIsNotNone(stl_metadata)
@@ -97,8 +97,8 @@ class LocalStorageTest(unittest.TestCase):
 		self.assertEquals(retrieved, link["retrieved"])
 
 	def test_add_file_with_association(self):
-		stl_name = self._add_file("bp_case.stl", "bp_case.stl", FILE_BP_CASE_STL)
-		gcode_name = self._add_file("bp_case.gcode", "bp_case.gcode", FILE_BP_CASE_GCODE, links=[("model", dict(name=stl_name))])
+		stl_name = self._add_and_verify_file("bp_case.stl", "bp_case.stl", FILE_BP_CASE_STL)
+		gcode_name = self._add_and_verify_file("bp_case.gcode", "bp_case.gcode", FILE_BP_CASE_GCODE, links=[("model", dict(name=stl_name))])
 
 		stl_metadata = self.storage.get_metadata(stl_name)
 		gcode_metadata = self.storage.get_metadata(gcode_name)
@@ -122,8 +122,8 @@ class LocalStorageTest(unittest.TestCase):
 		self.assertEquals(FILE_BP_CASE_GCODE.hash, link["hash"])
 
 	def test_remove_file(self):
-		stl_name = self._add_file("bp_case.stl", "bp_case.stl", FILE_BP_CASE_STL)
-		gcode_name = self._add_file("bp_case.gcode", "bp_case.gcode", FILE_BP_CASE_GCODE, links=[("model", dict(name=stl_name))])
+		stl_name = self._add_and_verify_file("bp_case.stl", "bp_case.stl", FILE_BP_CASE_STL)
+		gcode_name = self._add_and_verify_file("bp_case.gcode", "bp_case.gcode", FILE_BP_CASE_GCODE, links=[("model", dict(name=stl_name))])
 
 		stl_metadata = self.storage.get_metadata(stl_name)
 		gcode_metadata = self.storage.get_metadata(gcode_name)
@@ -142,23 +142,94 @@ class LocalStorageTest(unittest.TestCase):
 
 		self.assertEquals(0, len(gcode_metadata["links"]))
 
+	def test_copy_file(self):
+		self._add_file("bp_case.stl", FILE_BP_CASE_STL)
+		self._add_folder("test")
+
+		self.assertTrue(os.path.isfile(os.path.join(self.basefolder, "bp_case.stl")))
+		self.assertTrue(os.path.isdir(os.path.join(self.basefolder, "test")))
+
+		self.storage.copy_file("bp_case.stl", "test/copied.stl")
+
+		self.assertTrue(os.path.isfile(os.path.join(self.basefolder, "bp_case.stl")))
+		self.assertTrue(os.path.isfile(os.path.join(self.basefolder, "test", "copied.stl")))
+
+		stl_metadata = self.storage.get_metadata("bp_case.stl")
+		copied_metadata = self.storage.get_metadata("test/copied.stl")
+
+		self.assertIsNotNone(stl_metadata)
+		self.assertIsNotNone(copied_metadata)
+		self.assertDictEqual(stl_metadata, copied_metadata)
+
+	def test_move_file(self):
+		self._add_file("bp_case.stl", FILE_BP_CASE_STL)
+		self._add_folder("test")
+
+		self.assertTrue(os.path.isfile(os.path.join(self.basefolder, "bp_case.stl")))
+		self.assertTrue(os.path.isdir(os.path.join(self.basefolder, "test")))
+
+		before_stl_metadata = self.storage.get_metadata("bp_case.stl")
+
+		self.storage.move_file("bp_case.stl", "test/copied.stl")
+
+		self.assertFalse(os.path.isfile(os.path.join(self.basefolder, "bp_case.stl")))
+		self.assertTrue(os.path.isfile(os.path.join(self.basefolder, "test", "copied.stl")))
+
+		after_stl_metadata = self.storage.get_metadata("bp_case.stl")
+		copied_metadata = self.storage.get_metadata("test/copied.stl")
+
+		self.assertIsNotNone(before_stl_metadata)
+		self.assertIsNone(after_stl_metadata)
+		self.assertIsNotNone(copied_metadata)
+		self.assertDictEqual(before_stl_metadata, copied_metadata)
+
+	@data("copy_file", "move_file")
+	def test_copy_move_file_missing_source(self, operation):
+		try:
+			getattr(self.storage, operation)("bp_case.stl", "test/copied.stl")
+			self.fail("Expected an exception")
+		except StorageError as e:
+			self.assertEqual(e.code, StorageError.INVALID_SOURCE)
+
+	@data("copy_file", "move_file")
+	def test_copy_move_file_missing_destination_folder(self, operation):
+		self._add_file("bp_case.stl", FILE_BP_CASE_STL)
+
+		try:
+			getattr(self.storage, operation)("bp_case.stl", "test/copied.stl")
+			self.fail("Expected an exception")
+		except StorageError as e:
+			self.assertEqual(e.code, StorageError.INVALID_DESTINATION)
+
+	@data("copy_file", "move_file")
+	def test_copy_move_file_existing_destination_path(self, operation):
+		self._add_file("bp_case.stl", FILE_BP_CASE_STL)
+		self._add_folder("test")
+		self._add_file("test/crazyradio.stl", FILE_CRAZYRADIO_STL)
+
+		try:
+			getattr(self.storage, operation)("bp_case.stl", "test/crazyradio.stl")
+			self.fail("Expected an exception")
+		except StorageError as e:
+			self.assertEqual(e.code, StorageError.INVALID_DESTINATION)
+
 	def test_add_folder(self):
-		self._add_folder("test", "test")
+		self._add_and_verify_folder("test", "test")
 
 	def test_add_subfolder(self):
-		folder_name = self._add_folder("folder with some spaces", "folder_with_some_spaces")
-		subfolder_name = self._add_folder((folder_name, "subfolder"), folder_name + "/subfolder")
-		stl_name = self._add_file((subfolder_name, "bp_case.stl"), subfolder_name + "/bp_case.stl", FILE_BP_CASE_STL)
+		folder_name = self._add_and_verify_folder("folder with some spaces", "folder_with_some_spaces")
+		subfolder_name = self._add_and_verify_folder((folder_name, "subfolder"), folder_name + "/subfolder")
+		stl_name = self._add_and_verify_file((subfolder_name, "bp_case.stl"), subfolder_name + "/bp_case.stl", FILE_BP_CASE_STL)
 
 		self.assertTrue(os.path.exists(os.path.join(self.basefolder, folder_name)))
 		self.assertTrue(os.path.exists(os.path.join(self.basefolder, subfolder_name)))
 		self.assertTrue(os.path.exists(os.path.join(self.basefolder, stl_name)))
 
 	def test_remove_folder(self):
-		content_folder = self._add_folder("content", "content")
-		other_stl_name = self._add_file((content_folder, "crazyradio.stl"), content_folder + "/crazyradio.stl", FILE_CRAZYRADIO_STL)
+		content_folder = self._add_and_verify_folder("content", "content")
+		other_stl_name = self._add_and_verify_file((content_folder, "crazyradio.stl"), content_folder + "/crazyradio.stl", FILE_CRAZYRADIO_STL)
 
-		empty_folder = self._add_folder("empty", "empty")
+		empty_folder = self._add_and_verify_folder("empty", "empty")
 
 		try:
 			self.storage.remove_folder(content_folder, recursive=False)
@@ -177,20 +248,94 @@ class LocalStorageTest(unittest.TestCase):
 		self.assertFalse(os.path.isdir(os.path.join(self.basefolder, empty_folder)))
 
 	def test_remove_folder_with_metadata(self):
-		content_folder = self._add_folder("content", "content")
-		other_stl_name = self._add_file((content_folder, "crazyradio.stl"), content_folder + "/crazyradio.stl", FILE_CRAZYRADIO_STL)
+		content_folder = self._add_and_verify_folder("content", "content")
+		other_stl_name = self._add_and_verify_file((content_folder, "crazyradio.stl"), content_folder + "/crazyradio.stl", FILE_CRAZYRADIO_STL)
 		self.storage.remove_file(other_stl_name)
 
 		self.storage.remove_folder(content_folder, recursive=False)
 
+	def test_copy_folder(self):
+		self._add_folder("source")
+		self._add_folder("destination")
+		self._add_file("source/crazyradio.stl", FILE_CRAZYRADIO_STL)
+
+		source_metadata = self.storage.get_metadata("source/crazyradio.stl")
+		self.storage.copy_folder("source", "destination/copied")
+		copied_metadata = self.storage.get_metadata("destination/copied/crazyradio.stl")
+
+		self.assertTrue(os.path.isdir(os.path.join(self.basefolder, "source")))
+		self.assertTrue(os.path.isfile(os.path.join(self.basefolder, "source", "crazyradio.stl")))
+		self.assertTrue(os.path.isdir(os.path.join(self.basefolder, "destination")))
+		self.assertTrue(os.path.isdir(os.path.join(self.basefolder, "destination", "copied")))
+		self.assertTrue(os.path.isfile(os.path.join(self.basefolder, "destination", "copied", ".metadata.yaml")))
+		self.assertTrue(os.path.isfile(os.path.join(self.basefolder, "destination", "copied", "crazyradio.stl")))
+
+		self.assertIsNotNone(source_metadata)
+		self.assertIsNotNone(copied_metadata)
+		self.assertDictEqual(source_metadata, copied_metadata)
+
+	def test_move_folder(self):
+		self._add_folder("source")
+		self._add_folder("destination")
+		self._add_file("source/crazyradio.stl", FILE_CRAZYRADIO_STL)
+
+		before_source_metadata = self.storage.get_metadata("source/crazyradio.stl")
+		self.storage.move_folder("source", "destination/copied")
+		after_source_metadata = self.storage.get_metadata("source/crazyradio.stl")
+		copied_metadata = self.storage.get_metadata("destination/copied/crazyradio.stl")
+
+		self.assertFalse(os.path.isdir(os.path.join(self.basefolder, "source")))
+		self.assertFalse(os.path.isfile(os.path.join(self.basefolder, "source", "crazyradio.stl")))
+		self.assertTrue(os.path.isdir(os.path.join(self.basefolder, "destination")))
+		self.assertTrue(os.path.isdir(os.path.join(self.basefolder, "destination", "copied")))
+		self.assertTrue(os.path.isfile(os.path.join(self.basefolder, "destination", "copied", ".metadata.yaml")))
+		self.assertTrue(os.path.isfile(os.path.join(self.basefolder, "destination", "copied", "crazyradio.stl")))
+
+		self.assertIsNotNone(before_source_metadata)
+		self.assertIsNone(after_source_metadata)
+		self.assertIsNotNone(copied_metadata)
+		self.assertDictEqual(before_source_metadata, copied_metadata)
+
+	@data("copy_folder", "move_folder")
+	def test_copy_move_folder_missing_source(self, operation):
+		try:
+			getattr(self.storage, operation)("source", "destination/copied")
+			self.fail("Expected an exception")
+		except StorageError as e:
+			self.assertEqual(e.code, StorageError.INVALID_SOURCE)
+
+	@data("copy_folder", "move_folder")
+	def test_copy_move_folder_missing_destination_folder(self, operation):
+		self._add_folder("source")
+		self._add_file("source/crazyradio.stl", FILE_CRAZYRADIO_STL)
+
+		try:
+			getattr(self.storage, operation)("source", "destination/copied")
+			self.fail("Expected an exception")
+		except StorageError as e:
+			self.assertEqual(e.code, StorageError.INVALID_DESTINATION)
+
+	@data("copy_folder", "move_folder")
+	def test_copy_move_folder_existing_destination_path(self, operation):
+		self._add_folder("source")
+		self._add_file("source/crazyradio.stl", FILE_CRAZYRADIO_STL)
+		self._add_folder("destination")
+		self._add_folder("destination/copied")
+
+		try:
+			getattr(self.storage, operation)("source", "destination/copied")
+			self.fail("Expected an exception")
+		except StorageError as e:
+			self.assertEqual(e.code, StorageError.INVALID_DESTINATION)
+
 	def test_list(self):
-		bp_case_stl = self._add_file("bp_case.stl", "bp_case.stl", FILE_BP_CASE_STL)
-		self._add_file("bp_case.gcode", "bp_case.gcode", FILE_BP_CASE_GCODE, links=[("model", dict(name=bp_case_stl))])
+		bp_case_stl = self._add_and_verify_file("bp_case.stl", "bp_case.stl", FILE_BP_CASE_STL)
+		self._add_and_verify_file("bp_case.gcode", "bp_case.gcode", FILE_BP_CASE_GCODE, links=[("model", dict(name=bp_case_stl))])
 
-		content_folder = self._add_folder("content", "content")
-		self._add_file((content_folder, "crazyradio.stl"), content_folder + "/crazyradio.stl", FILE_CRAZYRADIO_STL)
+		content_folder = self._add_and_verify_folder("content", "content")
+		self._add_and_verify_file((content_folder, "crazyradio.stl"), content_folder + "/crazyradio.stl", FILE_CRAZYRADIO_STL)
 
-		self._add_folder("empty", "empty")
+		self._add_and_verify_folder("empty", "empty")
 
 		file_list = self.storage.list_files()
 		self.assertEquals(4, len(file_list))
@@ -215,8 +360,8 @@ class LocalStorageTest(unittest.TestCase):
 		self.assertEquals(0, len(file_list["empty"]["children"]))
 
 	def test_add_link_model(self):
-		stl_name = self._add_file("bp_case.stl", "bp_case.stl", FILE_BP_CASE_STL)
-		gcode_name = self._add_file("bp_case.gcode", "bp_case.gcode", FILE_BP_CASE_GCODE)
+		stl_name = self._add_and_verify_file("bp_case.stl", "bp_case.stl", FILE_BP_CASE_STL)
+		gcode_name = self._add_and_verify_file("bp_case.gcode", "bp_case.gcode", FILE_BP_CASE_GCODE)
 
 		self.storage.add_link(gcode_name, "model", dict(name=stl_name))
 
@@ -242,8 +387,8 @@ class LocalStorageTest(unittest.TestCase):
 		self.assertEquals(FILE_BP_CASE_GCODE.hash, link["hash"])
 
 	def test_add_link_machinecode(self):
-		stl_name = self._add_file("bp_case.stl", "bp_case.stl", FILE_BP_CASE_STL)
-		gcode_name = self._add_file("bp_case.gcode", "bp_case.gcode", FILE_BP_CASE_GCODE)
+		stl_name = self._add_and_verify_file("bp_case.stl", "bp_case.stl", FILE_BP_CASE_STL)
+		gcode_name = self._add_and_verify_file("bp_case.gcode", "bp_case.gcode", FILE_BP_CASE_GCODE)
 
 		self.storage.add_link(stl_name, "machinecode", dict(name=gcode_name))
 
@@ -269,7 +414,7 @@ class LocalStorageTest(unittest.TestCase):
 		self.assertEquals(FILE_BP_CASE_GCODE.hash, link["hash"])
 
 	def test_remove_link(self):
-		stl_name = self._add_file("bp_case.stl", "bp_case.stl", FILE_BP_CASE_STL)
+		stl_name = self._add_and_verify_file("bp_case.stl", "bp_case.stl", FILE_BP_CASE_STL)
 
 		self.storage.add_link(stl_name, "web", dict(href="http://www.example.com"))
 		self.storage.add_link(stl_name, "web", dict(href="http://www.example2.com"))
@@ -288,8 +433,8 @@ class LocalStorageTest(unittest.TestCase):
 		self.assertEquals(1, len(stl_metadata["links"]))
 
 	def test_remove_link_bidirectional(self):
-		stl_name = self._add_file("bp_case.stl", "bp_case.stl", FILE_BP_CASE_STL)
-		gcode_name = self._add_file("bp_case.gcode", "bp_case.gcode", FILE_BP_CASE_GCODE)
+		stl_name = self._add_and_verify_file("bp_case.stl", "bp_case.stl", FILE_BP_CASE_STL)
+		gcode_name = self._add_and_verify_file("bp_case.gcode", "bp_case.gcode", FILE_BP_CASE_GCODE)
 
 		self.storage.add_link(stl_name, "machinecode", dict(name=gcode_name))
 		self.storage.add_link(stl_name, "web", dict(href="http://www.example.com"))
@@ -379,8 +524,23 @@ class LocalStorageTest(unittest.TestCase):
 		self.assertEquals(expected_path, actual_path)
 		self.assertEquals(expected_name, actual_name)
 
-	def _add_file(self, path, expected_path, file_object, links=None, overwrite=False):
+	def _add_and_verify_file(self, path, expected_path, file_object, links=None, overwrite=False):
+		"""Adds a file to the storage and verifies the sanitized path."""
+		sanitized_path = self._add_file(path, file_object, links=links, overwrite=overwrite)
+		self.assertEquals(expected_path, sanitized_path)
+		return sanitized_path
+
+	def _add_file(self, path, file_object, links=None, overwrite=False):
+		"""
+		Adds a file to the storage.
+
+		Ensures file is present, metadata is present, hash and links (if applicable)
+		are populated correctly.
+
+		Returns sanitized path.
+		"""
 		sanitized_path = self.storage.add_file(path, file_object, links=links, allow_overwrite=overwrite)
+
 		split_path = sanitized_path.split("/")
 		if len(split_path) == 1:
 			file_path = os.path.join(self.basefolder, split_path[0])
@@ -389,9 +549,8 @@ class LocalStorageTest(unittest.TestCase):
 			file_path = os.path.join(self.basefolder, os.path.join(*split_path))
 			folder_path = os.path.join(self.basefolder, os.path.join(*split_path[:-1]))
 
-		self.assertEquals(expected_path, sanitized_path)
-		self.assertTrue(os.path.exists(file_path))
-		self.assertTrue(os.path.exists(os.path.join(folder_path, ".metadata.yaml")))
+		self.assertTrue(os.path.isfile(file_path))
+		self.assertTrue(os.path.isfile(os.path.join(folder_path, ".metadata.yaml")))
 
 		metadata = self.storage.get_metadata(sanitized_path)
 		self.assertIsNotNone(metadata)
@@ -406,11 +565,21 @@ class LocalStorageTest(unittest.TestCase):
 
 		return sanitized_path
 
-	def _add_folder(self, path, expected_path):
-		sanitized_path = self.storage.add_folder(path)
+	def _add_and_verify_folder(self, path, expected_path):
+		"""Adds a folder to the storage and verifies sanitized path."""
+		sanitized_path = self._add_folder(path)
 		self.assertEquals(expected_path, sanitized_path)
-		self.assertTrue(os.path.exists(os.path.join(self.basefolder, os.path.join(*sanitized_path.split("/")))))
-		self.assertTrue(os.path.isdir(os.path.join(self.basefolder, os.path.join(*sanitized_path.split("/")))))
-
+		return sanitized_path
+
+	def _add_folder(self, path):
+		"""
+		Adds a folder to the storage.
+
+		Verifies existance of folder.
+
+		Returns sanitized path.
+		"""
+		sanitized_path = self.storage.add_folder(path)
+		self.assertTrue(os.path.isdir(os.path.join(self.basefolder, os.path.join(*sanitized_path.split("/")))))
 		return sanitized_path
 

From d744c7e561dafacb3ee9f72fa5134d0281b6f222 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Gina=20H=C3=A4u=C3=9Fge?= <osd@foosel.net>
Date: Wed, 18 Nov 2015 12:12:49 +0100
Subject: [PATCH 20/25] File search now operates recursively

---
 .../static/js/app/viewmodels/files.js         | 27 ++++++++++++-------
 1 file changed, 18 insertions(+), 9 deletions(-)

diff --git a/src/octoprint/static/js/app/viewmodels/files.js b/src/octoprint/static/js/app/viewmodels/files.js
index 337ecacc..72d36695 100644
--- a/src/octoprint/static/js/app/viewmodels/files.js
+++ b/src/octoprint/static/js/app/viewmodels/files.js
@@ -197,8 +197,7 @@ $(function() {
             self.listHelper.addFilter("emptyFolder");
             if (!switchToPath) {
                 self.listHelper.updateItems(files);
-            }
-            else {
+            } else {
                 self.changeFolderByPath(switchToPath);
             }
 
@@ -241,8 +240,7 @@ $(function() {
             if (element) {
                 self.currentPath(path);
                 self.listHelper.updateItems(element.children);
-            }
-            else{
+            } else{
                 self.currentPath("");
                 self.listHelper.updateItems(self.allItems());
             }
@@ -264,7 +262,7 @@ $(function() {
             if (!file) {
                 return;
             }
-            
+
             var index = self.listHelper.paginatedItems().indexOf(file) + 1;
             if (index >= self.listHelper.paginatedItems().length) {
                 index = index - 2;
@@ -278,7 +276,7 @@ $(function() {
             if (fileToFocus) {
                 filenameToFocus = fileToFocus.name;
             }
-            
+
             OctoPrint.files.delete(file.origin, OctoPrint.files.pathForElement(file))
                 .done(function() {
                     self.requestData(undefined, filenameToFocus, OctoPrint.files.pathForElement(file.parent));
@@ -403,9 +401,20 @@ $(function() {
             var query = self.searchQuery();
             if (query !== undefined && query.trim() != "") {
                 query = query.toLocaleLowerCase();
-                self.listHelper.changeSearchFunction(function(entry) {
-                    return entry && entry["name"].toLocaleLowerCase().indexOf(query) > -1;
-                });
+
+                var recursiveSearch = function(entry) {
+                    if (entry === undefined) {
+                        return false;
+                    }
+
+                    if (entry["type"] == "folder" && entry["children"]) {
+                        return _.any(entry["children"], recursiveSearch);
+                    } else {
+                        return entry["name"].toLocaleLowerCase().indexOf(query) > -1;
+                    }
+                };
+
+                self.listHelper.changeSearchFunction(recursiveSearch);
             } else {
                 self.listHelper.resetSearch();
             }

From 66ad1150d50918e0f5de71edae7d5be99281dc79 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Gina=20H=C3=A4u=C3=9Fge?= <osd@foosel.net>
Date: Wed, 18 Nov 2015 12:20:12 +0100
Subject: [PATCH 21/25] Add toggle button to hide/show empty folders

---
 src/octoprint/templates/sidebar/files_header.jinja2 | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/octoprint/templates/sidebar/files_header.jinja2 b/src/octoprint/templates/sidebar/files_header.jinja2
index c706bfc9..22410526 100644
--- a/src/octoprint/templates/sidebar/files_header.jinja2
+++ b/src/octoprint/templates/sidebar/files_header.jinja2
@@ -23,6 +23,7 @@
             <li><a href="#" data-bind="click: function() { $root.listHelper.toggleFilter('sd'); }"><i class="icon-ok" data-bind="style: {visibility: _.contains(listHelper.currentFilters(), 'sd') ? 'visible' : 'hidden'}"></i> {{ _('Only show files stored on SD') }}</a></li>
         {% endif %}
         <li class="divider"></li>
+        <li><a href="#" data-bind="click: function() { $root.listHelper.toggleFilter('emptyFolder'); }"><i class="icon-ok" data-bind="style: {visibility: _.contains(listHelper.currentFilters(), 'emptyFolder') ? 'visible' : 'hidden'}"></i> {{ _('Hide empty folders') }}</a></li>
         <li><a href="#" data-bind="click: function() { $root.listHelper.toggleFilter('printed'); }"><i class="icon-ok" data-bind="style: {visibility: _.contains(listHelper.currentFilters(), 'printed') ? 'visible' : 'hidden'}"></i> {{ _('Hide successfully printed files') }}</a></li>
     </ul>
 </div>

From 3db21f1a707b6b6108198bd5b833f0d609b9a336 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Gina=20H=C3=A4u=C3=9Fge?= <osd@foosel.net>
Date: Wed, 18 Nov 2015 17:44:11 +0100
Subject: [PATCH 22/25] Fixed highlighting for files in folders

While at it also adjusted highlighting so that the folder containing
the currently selected file will be highlighted if the selected file is
not within the current folder but in one of its sub folders.
---
 src/octoprint/static/js/app/viewmodels/files.js | 15 +++++++++++++--
 src/octoprint/templates/sidebar/files.jinja2    |  2 +-
 2 files changed, 14 insertions(+), 3 deletions(-)

diff --git a/src/octoprint/static/js/app/viewmodels/files.js b/src/octoprint/static/js/app/viewmodels/files.js
index 72d36695..0743725f 100644
--- a/src/octoprint/static/js/app/viewmodels/files.js
+++ b/src/octoprint/static/js/app/viewmodels/files.js
@@ -146,12 +146,20 @@ $(function() {
             self.highlightFilename(newValue);
         });
 
+        self.highlightCurrentFilename = function() {
+            self.highlightFilename(self.printerState.filename());
+        };
+
         self.highlightFilename = function(filename) {
             if (filename == undefined) {
                 self.listHelper.selectNone();
             } else {
                 self.listHelper.selectItem(function(item) {
-                    return item.name == filename;
+                    if (item.type == "folder") {
+                        return _.startsWith(filename, OctoPrint.files.pathForElement(item) + "/");
+                    } else {
+                        return OctoPrint.files.pathForElement(item) == filename;
+                    }
                 });
             }
         };
@@ -195,6 +203,7 @@ $(function() {
             self.allItems(files);
             self.currentPath("");
             self.listHelper.addFilter("emptyFolder");
+
             if (!switchToPath) {
                 self.listHelper.updateItems(files);
             } else {
@@ -221,12 +230,13 @@ $(function() {
                 self.totalSpace(response.total);
             }
 
-            self.highlightFilename(self.printerState.filename());
+            self.highlightCurrentFilename();
         };
 
         self.changeFolder = function(data) {
             self.currentPath(OctoPrint.files.pathForElement(data));
             self.listHelper.updateItems(data.children);
+            self.highlightCurrentFilename();
         };
 
         self.navigateUp = function() {
@@ -244,6 +254,7 @@ $(function() {
                 self.currentPath("");
                 self.listHelper.updateItems(self.allItems());
             }
+            self.highlightCurrentFilename();
         };
 
         self.loadFile = function(file, printAfterLoad) {
diff --git a/src/octoprint/templates/sidebar/files.jinja2 b/src/octoprint/templates/sidebar/files.jinja2
index 31be4107..994d7a0a 100644
--- a/src/octoprint/templates/sidebar/files.jinja2
+++ b/src/octoprint/templates/sidebar/files.jinja2
@@ -35,7 +35,7 @@
 
     <script type="text/html" id="files_template_folder">
         <div data-bind="click: $root.changeFolder">
-            <div class="title"><i class="icon-folder-open"></i> <span data-bind="text: name"></span></div>
+            <div class="title" data-bind="style: { 'font-weight': $root.listHelper.isSelected($data) ? 'bold' : 'normal' }"><i class="icon-folder-open"></i> <span data-bind="text: name"></span></div>
             <div class="size">{{ _('Size') }}: <span data-bind="text: formatSize(size)"></span></div>
         </div>
     </script>

From 1a20665729c726d6a16ced9629854817017177bf Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Gina=20H=C3=A4u=C3=9Fge?= <osd@foosel.net>
Date: Wed, 18 Nov 2015 17:45:15 +0100
Subject: [PATCH 23/25] Minor code style corrections

---
 src/octoprint/static/js/app/client/files.js | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/src/octoprint/static/js/app/client/files.js b/src/octoprint/static/js/app/client/files.js
index 69f1d700..94b8a5f5 100644
--- a/src/octoprint/static/js/app/client/files.js
+++ b/src/octoprint/static/js/app/client/files.js
@@ -119,12 +119,14 @@
         },
 
         pathForElement: function(element) {
-            if (!element || !element.hasOwnProperty("parent") || element.parent == undefined)
+            if (!element || !element.hasOwnProperty("parent") || element.parent == undefined) {
                 return "";
+            }
 
             var recursivePath = function(element, path) {
-              if (element.hasOwnProperty("parent") && element.parent != undefined)
+              if (element.hasOwnProperty("parent") && element.parent != undefined) {
                   return recursivePath(element.parent, element.name + "/" + path);
+              }
 
               return path;
             };
@@ -134,11 +136,13 @@
 
         elementByPath: function(location, startElement) {
             var recursiveSearch = function(location, element) {
-                if (location.length == 0)
+                if (location.length == 0) {
                     return element;
+                }
 
-                if (!element.hasOwnProperty("children"))
+                if (!element.hasOwnProperty("children")) {
                     return undefined;
+                }
 
                 var name = location.shift();
                 for(var i = 0; i < element.children.length; i++) {

From da890b036f0a3425815eca008cb44f9d2b312efc Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Gina=20H=C3=A4u=C3=9Fge?= <osd@foosel.net>
Date: Wed, 18 Nov 2015 18:34:09 +0100
Subject: [PATCH 24/25] Bugfix: emptyFolder filter was always active

---
 src/octoprint/static/js/app/viewmodels/files.js | 1 -
 src/octoprint/templates/dialogs/files.jinja2    | 0
 2 files changed, 1 deletion(-)
 create mode 100644 src/octoprint/templates/dialogs/files.jinja2

diff --git a/src/octoprint/static/js/app/viewmodels/files.js b/src/octoprint/static/js/app/viewmodels/files.js
index 0743725f..d19e9bc4 100644
--- a/src/octoprint/static/js/app/viewmodels/files.js
+++ b/src/octoprint/static/js/app/viewmodels/files.js
@@ -202,7 +202,6 @@ $(function() {
 
             self.allItems(files);
             self.currentPath("");
-            self.listHelper.addFilter("emptyFolder");
 
             if (!switchToPath) {
                 self.listHelper.updateItems(files);
diff --git a/src/octoprint/templates/dialogs/files.jinja2 b/src/octoprint/templates/dialogs/files.jinja2
new file mode 100644
index 00000000..e69de29b

From f1f55036e8da3ef82a015027f91b54f873cf859c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Gina=20H=C3=A4u=C3=9Fge?= <osd@foosel.net>
Date: Wed, 18 Nov 2015 18:36:23 +0100
Subject: [PATCH 25/25] Simplistic folder add dialog

---
 .../static/js/app/viewmodels/files.js         | 27 ++++++++++++++++++-
 src/octoprint/templates/dialogs/files.jinja2  | 21 +++++++++++++++
 src/octoprint/templates/index.jinja2          |  1 +
 src/octoprint/templates/sidebar/files.jinja2  |  5 ++++
 4 files changed, 53 insertions(+), 1 deletion(-)

diff --git a/src/octoprint/static/js/app/viewmodels/files.js b/src/octoprint/static/js/app/viewmodels/files.js
index d19e9bc4..8f9c0d2a 100644
--- a/src/octoprint/static/js/app/viewmodels/files.js
+++ b/src/octoprint/static/js/app/viewmodels/files.js
@@ -55,6 +55,12 @@ $(function() {
         self.uploadButton = undefined;
         self.uploadSdButton = undefined;
 
+        self.addFolderDialog = undefined;
+        self.addFolderName = ko.observable(undefined);
+        self.enableAddFolder = ko.computed(function() {
+            return self.loginState.isUser() && self.addFolderName() && self.addFolderName().trim() != "";
+        });
+
         self.allItems = ko.observable(undefined);
         self.listStyle = ko.observable("folders_files");
         self.currentPath = ko.observable("");
@@ -256,6 +262,23 @@ $(function() {
             self.highlightCurrentFilename();
         };
 
+        self.showAddFolderDialog = function() {
+            if (self.addFolderDialog) {
+                self.addFolderDialog.modal("show");
+            }
+        };
+
+        self.addFolder = function() {
+            var name = self.addFolderName();
+
+            // "local" only for now since we only support local and sdcard,
+            // and sdcard doesn't support creating folders...
+            OctoPrint.files.createFolder("local", name, self.currentPath())
+                .done(function() {
+                    self.addFolderDialog.modal("hide");
+                });
+        };
+
         self.loadFile = function(file, printAfterLoad) {
             if (!file) {
                 return;
@@ -471,6 +494,8 @@ $(function() {
                 scrollBy: "102px"
             });
 
+            self.addFolderDialog = $("#add_folder_dialog");
+
             //~~ Gcode upload
 
             self.uploadButton = $("#gcode_upload");
@@ -656,6 +681,6 @@ $(function() {
     OCTOPRINT_VIEWMODELS.push([
         GcodeFilesViewModel,
         ["settingsViewModel", "loginStateViewModel", "printerStateViewModel", "slicingViewModel"],
-        "#files_wrapper"
+        ["#files_wrapper", "#add_folder_dialog"]
     ]);
 });
diff --git a/src/octoprint/templates/dialogs/files.jinja2 b/src/octoprint/templates/dialogs/files.jinja2
index e69de29b..6962d9bd 100644
--- a/src/octoprint/templates/dialogs/files.jinja2
+++ b/src/octoprint/templates/dialogs/files.jinja2
@@ -0,0 +1,21 @@
+<div id="add_folder_dialog" class="modal hide fade">
+    <div class="modal-header">
+        <a href="#" class="close" data-dismiss="modal" aria-hidden="true">&times;</a>
+        <h3>Create Folder</h3>
+    </div>
+    <div class="modal-body">
+        <p>{{ _('Please specify the name of the folder to create.') }}</p>
+        <form class="form-horizontal">
+            <div class="control-group">
+                <label class="control-label">{{ _('Folder name') }}</label>
+                <div class="controls">
+                    <input type="text" data-bind="value: addFolderName, valueUpdate: 'afterkeydown'">
+                </div>
+            </div>
+        </form>
+    </div>
+    <div class="modal-footer">
+        <a href="#" class="btn" data-dismiss="modal" aria-hidden="true">{{ _('Cancel') }}</a>
+        <a href="#" class="btn btn-primary" data-bind="click: function() { if ($root.enableAddFolder()) { $root.addFolder() } }, enabled: $root.enableAddFolder(), css: {disabled: !$root.enableAddFolder()}">{{ _('Create') }}</a>
+    </div>
+</div>
diff --git a/src/octoprint/templates/index.jinja2 b/src/octoprint/templates/index.jinja2
index 2a316380..cbd644c0 100644
--- a/src/octoprint/templates/index.jinja2
+++ b/src/octoprint/templates/index.jinja2
@@ -130,6 +130,7 @@
             {% include 'dialogs/usersettings.jinja2' %}
             {% include 'dialogs/wizard.jinja2' %}
             {% include 'dialogs/about.jinja2' %}
+            {% include 'dialogs/files.jinja2' %}
             <!-- End of dialogs -->
 
             <!-- Overlays -->
diff --git a/src/octoprint/templates/sidebar/files.jinja2 b/src/octoprint/templates/sidebar/files.jinja2
index 994d7a0a..983af43f 100644
--- a/src/octoprint/templates/sidebar/files.jinja2
+++ b/src/octoprint/templates/sidebar/files.jinja2
@@ -44,6 +44,11 @@
     <small>{{ _('Free') }}: <span data-bind="text: freeSpaceString"></span> / {{ _('Total') }}: <span data-bind="text: totalSpaceString"></span> <i class="icon-exclamation-sign" data-bind="visible: diskusageWarning" style="display: none"></i></small>
 </div>
 <div style="display: none;" data-bind="visible: loginState.isUser">
+    <div class="row-fluid folder-button">
+        <span class="btn addfolder-button span12" data-bind="click: function() { if ($root.loginState.isUser()) { $root.showAddFolderDialog(); } }, css: {disabled: !$root.loginState.isUser()}">
+            <i class="icon-folder-close"></i> {{ _('Create folder...') }}
+        </span>
+    </div>
     <div class="row-fluid upload-buttons">
         {% if enableSdSupport %}
             <span class="btn btn-primary fileinput-button span6" data-bind="css: {disabled: !$root.loginState.isUser()}" style="margin-bottom: 10px">