| /** | |
| * OLAT - Online Learning and Training<br> | |
| * http://www.olat.org | |
| * <p> | |
| * Licensed under the Apache License, Version 2.0 (the "License"); <br> | |
| * you may not use this file except in compliance with the License.<br> | |
| * You may obtain a copy of the License at | |
| * <p> | |
| * http://www.apache.org/licenses/LICENSE-2.0 | |
| * <p> | |
| * Unless required by applicable law or agreed to in writing,<br> | |
| * software distributed under the License is distributed on an "AS IS" BASIS, <br> | |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. <br> | |
| * See the License for the specific language governing permissions and <br> | |
| * limitations under the License. | |
| * <p> | |
| * Copyright (c) since 2004 at Multimedia- & E-Learning Services (MELS),<br> | |
| * University of Zurich, Switzerland. | |
| * <hr> | |
| * <a href="http://www.openolat.org"> | |
| * OpenOLAT - Online Learning and Training</a><br> | |
| * This file has been modified by the OpenOLAT community. Changes are licensed | |
| * under the Apache 2.0 license as the original file. | |
| * <p> | |
| */ | |
| package org.olat.core.commons.modules.bc.commands; | |
| import java.util.ArrayList; | |
| import java.util.List; | |
| import org.olat.core.commons.modules.bc.FileSelection; | |
| import org.olat.core.commons.modules.bc.FolderEvent; | |
| import org.olat.core.commons.modules.bc.components.FolderComponent; | |
| import org.olat.core.commons.services.notifications.NotificationsManager; | |
| import org.olat.core.commons.services.notifications.SubscriptionContext; | |
| import org.olat.core.commons.services.vfs.VFSRepositoryService; | |
| import org.olat.core.gui.UserRequest; | |
| import org.olat.core.gui.components.Component; | |
| import org.olat.core.gui.components.link.Link; | |
| import org.olat.core.gui.components.link.LinkFactory; | |
| import org.olat.core.gui.components.tree.MenuTree; | |
| import org.olat.core.gui.components.velocity.VelocityContainer; | |
| import org.olat.core.gui.control.Controller; | |
| import org.olat.core.gui.control.DefaultController; | |
| import org.olat.core.gui.control.Event; | |
| import org.olat.core.gui.control.WindowControl; | |
| import org.olat.core.gui.control.generic.folder.FolderTreeModel; | |
| import org.olat.core.gui.translator.Translator; | |
| import org.olat.core.util.Util; | |
| import org.olat.core.util.vfs.VFSConstants; | |
| import org.olat.core.util.vfs.VFSContainer; | |
| import org.olat.core.util.vfs.VFSItem; | |
| import org.olat.core.util.vfs.VFSLeaf; | |
| import org.olat.core.util.vfs.VFSLockApplicationType; | |
| import org.olat.core.util.vfs.VFSLockManager; | |
| import org.olat.core.util.vfs.VFSManager; | |
| import org.olat.core.util.vfs.VFSStatus; | |
| import org.olat.core.util.vfs.callbacks.VFSSecurityCallback; | |
| import org.olat.core.util.vfs.filters.VFSItemFilter; | |
| import org.springframework.beans.factory.annotation.Autowired; | |
| public class CmdMoveCopy extends DefaultController implements FolderCommand { | |
| private static final String VELOCITY_ROOT = Util.getPackageVelocityRoot(CmdMoveCopy.class); | |
| private static int status = FolderCommandStatus.STATUS_SUCCESS; | |
| private Translator translator; | |
| private MenuTree selTree; | |
| private FileSelection fileSelection; | |
| private Link selectButton, cancelButton; | |
| private FolderComponent folderComponent; | |
| private final boolean move; | |
| @Autowired | |
| private VFSLockManager vfsLockManager; | |
| @Autowired | |
| private VFSRepositoryService vfsRepositoryService; | |
| @Autowired | |
| private NotificationsManager notificationsManager; | |
| protected CmdMoveCopy(WindowControl wControl, boolean move) { | |
| super(wControl); | |
| this.move = move; | |
| } | |
| @Override | |
| public Controller execute(FolderComponent fc, UserRequest ureq, WindowControl windowControl, Translator trans) { | |
| this.folderComponent = fc; | |
| this.translator = trans; | |
| // BUG: CWE-22 Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal') | |
| // this.fileSelection = new FileSelection(ureq, fc.getCurrentContainerPath()); | |
| // FIXED: | |
| this.fileSelection = new FileSelection(ureq, fc.getCurrentContainer(), fc.getCurrentContainerPath()); | |
| VelocityContainer main = new VelocityContainer("mc", VELOCITY_ROOT + "/movecopy.html", translator, this); | |
| main.contextPut("fileselection", fileSelection); | |
| //check if command is executed on a file list containing invalid filenames or paths | |
| if(!fileSelection.getInvalidFileNames().isEmpty()) { | |
| main.contextPut("invalidFileNames", fileSelection.getInvalidFileNames()); | |
| } | |
| selTree = new MenuTree(null, "seltree", this); | |
| FolderTreeModel ftm = new FolderTreeModel(ureq.getLocale(), fc.getRootContainer(), | |
| true, false, true, fc.getRootContainer().canWrite() == VFSConstants.YES, new EditableFilter()); | |
| selTree.setTreeModel(ftm); | |
| selectButton = LinkFactory.createButton(move ? "move" : "copy", main, this); | |
| cancelButton = LinkFactory.createButton("cancel", main, this); | |
| main.put("seltree", selTree); | |
| if (move) { | |
| main.contextPut("move", Boolean.TRUE); | |
| } | |
| setInitialComponent(main); | |
| return this; | |
| } | |
| public boolean isMoved() { | |
| return move; | |
| } | |
| public FileSelection getFileSelection() { | |
| return fileSelection; | |
| } | |
| @Override | |
| public int getStatus() { | |
| return status; | |
| } | |
| @Override | |
| public boolean runsModal() { | |
| return false; | |
| } | |
| @Override | |
| public String getModalTitle() { | |
| return null; | |
| } | |
| public String getTarget() { | |
| FolderTreeModel ftm = (FolderTreeModel) selTree.getTreeModel(); | |
| return ftm.getSelectedPath(selTree.getSelectedNode()); | |
| } | |
| @Override | |
| public void event(UserRequest ureq, Component source, Event event) { | |
| if(cancelButton == source) { | |
| status = FolderCommandStatus.STATUS_CANCELED; | |
| fireEvent(ureq, FOLDERCOMMAND_FINISHED); | |
| } else if (selectButton == source) { | |
| doMove(ureq); | |
| } | |
| } | |
| private void doMove(UserRequest ureq) { | |
| FolderTreeModel ftm = (FolderTreeModel) selTree.getTreeModel(); | |
| String selectedPath = ftm.getSelectedPath(selTree.getSelectedNode()); | |
| if (selectedPath == null) { | |
| abortFailed(ureq, "failed"); | |
| return; | |
| } | |
| VFSStatus vfsStatus = VFSConstants.SUCCESS; | |
| VFSContainer rootContainer = folderComponent.getRootContainer(); | |
| VFSItem vfsItem = rootContainer.resolve(selectedPath); | |
| if (vfsItem == null || (vfsItem.canWrite() != VFSConstants.YES)) { | |
| abortFailed(ureq, "failed"); | |
| return; | |
| } | |
| // copy the files | |
| VFSContainer target = (VFSContainer)vfsItem; | |
| List<VFSItem> sources = getSanityCheckedSourceItems(target, ureq); | |
| if (sources == null) return; | |
| for (VFSItem vfsSource:sources) { | |
| VFSItem targetFile = target.resolve(vfsSource.getName()); | |
| if(vfsSource instanceof VFSLeaf && targetFile != null && targetFile.canVersion() == VFSConstants.YES) { | |
| //add a new version to the file | |
| VFSLeaf sourceLeaf = (VFSLeaf)vfsSource; | |
| vfsRepositoryService.addVersion(sourceLeaf, ureq.getIdentity(), false, "", sourceLeaf.getInputStream()); | |
| } else { | |
| vfsStatus = target.copyFrom(vfsSource, ureq.getIdentity()); | |
| } | |
| if (vfsStatus != VFSConstants.SUCCESS) { | |
| String errorKey = "failed"; | |
| if (vfsStatus == VFSConstants.ERROR_QUOTA_EXCEEDED) | |
| errorKey = "QuotaExceeded"; | |
| abortFailed(ureq, errorKey); | |
| return; | |
| } | |
| if (move) { | |
| // if move, delete the source. Note that meta source | |
| // has already been delete (i.e. moved) | |
| vfsSource.delete(); | |
| } | |
| } | |
| // after a copy or a move, notify the subscribers | |
| VFSSecurityCallback secCallback = VFSManager.findInheritedSecurityCallback(folderComponent.getCurrentContainer()); | |
| if (secCallback != null) { | |
| SubscriptionContext subsContext = secCallback.getSubscriptionContext(); | |
| if (subsContext != null) { | |
| notificationsManager.markPublisherNews(subsContext, ureq.getIdentity(), true); | |
| } | |
| } | |
| fireEvent(ureq, new FolderEvent(move ? FolderEvent.MOVE_EVENT : FolderEvent.COPY_EVENT, fileSelection.renderAsHtml())); | |
| notifyFinished(ureq); | |
| } | |
| private void notifyFinished(UserRequest ureq) { | |
| VFSContainer container = VFSManager.findInheritingSecurityCallbackContainer(folderComponent.getRootContainer()); | |
| VFSSecurityCallback secCallback = container.getLocalSecurityCallback(); | |
| if(secCallback != null) { | |
| SubscriptionContext subsContext = secCallback.getSubscriptionContext(); | |
| if (subsContext != null) { | |
| notificationsManager.markPublisherNews(subsContext, ureq.getIdentity(), true); | |
| } | |
| } | |
| fireEvent(ureq, FOLDERCOMMAND_FINISHED); | |
| } | |
| /** | |
| * Get the list of source files. Sanity check if resolveable, overlapping or | |
| * a target with the same name already exists. In such cases, set the error message, fire | |
| * the abort event and return null. | |
| * | |
| * @param target | |
| * @param ureq | |
| * @return | |
| */ | |
| private List<VFSItem> getSanityCheckedSourceItems(VFSContainer target, UserRequest ureq) { | |
| // collect all source files first | |
| List<VFSItem> sources = new ArrayList<>(); | |
| for (String sourceRelPath:fileSelection.getFiles()) { | |
| VFSItem vfsSource = folderComponent.getCurrentContainer().resolve(sourceRelPath); | |
| if (vfsSource == null) { | |
| abortFailed(ureq, "FileDoesNotExist"); | |
| return null; | |
| } | |
| if (vfsSource instanceof VFSContainer) { | |
| // if a folder... check if they are overlapping | |
| if (VFSManager.isContainerDescendantOrSelf(target, (VFSContainer)vfsSource)) { | |
| abortFailed(ureq, "OverlappingTarget"); | |
| return null; | |
| } | |
| } | |
| if (vfsLockManager.isLockedForMe(vfsSource, ureq.getIdentity(), VFSLockApplicationType.vfs, null)) { | |
| abortFailed(ureq, "lock.title"); | |
| return null; | |
| } | |
| // check for existence... this will also prevent to copy item over itself | |
| VFSItem item = target.resolve(vfsSource.getName()); | |
| if (item != null) { | |
| abortFailed(ureq, "TargetNameAlreadyUsed"); | |
| return null; | |
| } | |
| if (vfsSource.canCopy() != VFSConstants.YES) { | |
| getWindowControl().setError(translator.translate("FileMoveCopyFailed", new String[] {vfsSource.getName()})); | |
| status = FolderCommandStatus.STATUS_FAILED; | |
| fireEvent(ureq, FOLDERCOMMAND_FINISHED); | |
| return null; | |
| } | |
| sources.add(vfsSource); | |
| } | |
| return sources; | |
| } | |
| private void abortFailed(UserRequest ureq, String errorMessageKey) { | |
| getWindowControl().setError(translator.translate(errorMessageKey)); | |
| status = FolderCommandStatus.STATUS_FAILED; | |
| fireEvent(ureq, FOLDERCOMMAND_FINISHED); | |
| } | |
| @Override | |
| protected void doDispose() { | |
| // | |
| } | |
| private static final class EditableFilter implements VFSItemFilter { | |
| @Override | |
| public boolean accept(VFSItem vfsItem) { | |
| VFSSecurityCallback secCallback = vfsItem.getLocalSecurityCallback(); | |
| if(secCallback != null && !secCallback.canWrite()) { | |
| return false; | |
| } | |
| return true; | |
| } | |
| } | |
| } |