Skip to content
Snippets Groups Projects
Commit 75d87408 authored by srosse's avatar srosse
Browse files

OO-3558: lazy load the _courseelementdata of the course storage folder 

and the single participant folders
parent 3d1be942
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
Showing
with 633 additions and 395 deletions
src/main/java/org/olat/core/util/vfs/MergeSource.java
+ 6
− 10
View file @ 75d87408
...@@ -36,12 +36,8 @@ import org.olat.core.util.vfs.callbacks.VFSSecurityCallback; ...@@ -36,12 +36,8 @@ import org.olat.core.util.vfs.callbacks.VFSSecurityCallback;
import org.olat.core.util.vfs.filters.VFSItemFilter; import org.olat.core.util.vfs.filters.VFSItemFilter;
/** /**
* Description: <br> * Initial Date: 23.06.2005 <br>
* TODO: Felix Jost Class Description for MultiSource * @author Felix Jost
* <P>
*
* Initial Date: 23.06.2005 <br>
* @author Felix Jost
*/ */
public class MergeSource extends AbstractVirtualContainer { public class MergeSource extends AbstractVirtualContainer {
...@@ -57,16 +53,16 @@ public class MergeSource extends AbstractVirtualContainer { ...@@ -57,16 +53,16 @@ public class MergeSource extends AbstractVirtualContainer {
public MergeSource(VFSContainer parentContainer, String name) { public MergeSource(VFSContainer parentContainer, String name) {
super(name); super(name);
this.parentContainer = parentContainer; this.parentContainer = parentContainer;
mergedContainers = new ArrayList<VFSContainer>(); mergedContainers = new ArrayList<>();
mergedContainersChildren = new ArrayList<VFSContainer>(); mergedContainersChildren = new ArrayList<>();
} }
protected void init() { protected void init() {
if(mergedContainers == null) { if(mergedContainers == null) {
mergedContainers = new ArrayList<VFSContainer>(); mergedContainers = new ArrayList<>();
} }
if(mergedContainersChildren == null) { if(mergedContainersChildren == null) {
mergedContainersChildren = new ArrayList<VFSContainer>(2); mergedContainersChildren = new ArrayList<>(2);
} }
} }
......
src/main/java/org/olat/course/MergedCourseContainer.java
+ 3
− 382
View file @ 75d87408
...@@ -19,37 +19,18 @@ ...@@ -19,37 +19,18 @@
*/ */
package org.olat.course; package org.olat.course;
import org.olat.admin.quota.QuotaConstants;
import org.olat.core.CoreSpringFactory; import org.olat.core.CoreSpringFactory;
import org.olat.core.commons.modules.bc.vfs.OlatRootFolderImpl; import org.olat.core.commons.modules.bc.vfs.OlatRootFolderImpl;
import org.olat.core.commons.services.notifications.SubscriptionContext;
import org.olat.core.commons.services.webdav.servlets.RequestUtil;
import org.olat.core.gui.components.tree.GenericTreeModel;
import org.olat.core.gui.components.tree.TreeNode;
import org.olat.core.id.IdentityEnvironment; import org.olat.core.id.IdentityEnvironment;
import org.olat.core.logging.OLog; import org.olat.core.logging.OLog;
import org.olat.core.logging.Tracing; import org.olat.core.logging.Tracing;
import org.olat.core.util.StringHelper; import org.olat.core.util.StringHelper;
import org.olat.core.util.vfs.MergeSource; import org.olat.core.util.vfs.MergeSource;
import org.olat.core.util.vfs.NamedContainerImpl; import org.olat.core.util.vfs.NamedContainerImpl;
import org.olat.core.util.vfs.Quota;
import org.olat.core.util.vfs.QuotaManager;
import org.olat.core.util.vfs.VFSContainer; import org.olat.core.util.vfs.VFSContainer;
import org.olat.core.util.vfs.VFSManager;
import org.olat.core.util.vfs.callbacks.ReadOnlyCallback; import org.olat.core.util.vfs.callbacks.ReadOnlyCallback;
import org.olat.core.util.vfs.callbacks.VFSSecurityCallback;
import org.olat.course.config.CourseConfig; import org.olat.course.config.CourseConfig;
import org.olat.course.nodes.BCCourseNode; import org.olat.course.folder.MergedCourseElementDataContainer;
import org.olat.course.nodes.CourseNode;
import org.olat.course.nodes.PFCourseNode;
import org.olat.course.nodes.bc.BCCourseNodeEditController;
import org.olat.course.nodes.bc.FolderNodeCallback;
import org.olat.course.nodes.pf.manager.PFManager;
import org.olat.course.run.userview.NodeEvaluation;
import org.olat.course.run.userview.TreeEvaluation;
import org.olat.course.run.userview.UserCourseEnvironment;
import org.olat.course.run.userview.UserCourseEnvironmentImpl;
import org.olat.course.run.userview.VisibleTreeFilter;
import org.olat.modules.sharedfolder.SharedFolderManager; import org.olat.modules.sharedfolder.SharedFolderManager;
import org.olat.repository.RepositoryEntry; import org.olat.repository.RepositoryEntry;
import org.olat.repository.RepositoryManager; import org.olat.repository.RepositoryManager;
...@@ -124,22 +105,8 @@ public class MergedCourseContainer extends MergeSource { ...@@ -124,22 +105,8 @@ public class MergedCourseContainer extends MergeSource {
initSharedFolder(persistingCourse); initSharedFolder(persistingCourse);
// add all course building blocks of type BC to a virtual folder // add all course building blocks of type BC to a virtual folder
MergeSource nodesContainer = new MergeSource(null, "_courseelementdata"); MergedCourseElementDataContainer nodesContainer = new MergedCourseElementDataContainer(courseId, identityEnv);
if(identityEnv == null) { if (!nodesContainer.isEmpty()) {
CourseNode rootNode = persistingCourse.getRunStructure().getRootNode();
addFoldersForAdmin(persistingCourse, nodesContainer, rootNode);
} else {
TreeEvaluation treeEval = new TreeEvaluation();
GenericTreeModel treeModel = new GenericTreeModel();
UserCourseEnvironment userCourseEnv = new UserCourseEnvironmentImpl(identityEnv, persistingCourse.getCourseEnvironment());
CourseNode rootCn = userCourseEnv.getCourseEnvironment().getRunStructure().getRootNode();
NodeEvaluation rootNodeEval = rootCn.eval(userCourseEnv.getConditionInterpreter(), treeEval, new VisibleTreeFilter());
TreeNode treeRoot = rootNodeEval.getTreeNode();
treeModel.setRootNode(treeRoot);
addFolders(persistingCourse, nodesContainer, treeRoot);
}
if (nodesContainer.getItems().size() > 0) {
addContainer(nodesContainer); addContainer(nodesContainer);
} }
} }
...@@ -171,218 +138,6 @@ public class MergedCourseContainer extends MergeSource { ...@@ -171,218 +138,6 @@ public class MergedCourseContainer extends MergeSource {
} }
} }
} }
private void addFolders(PersistingCourseImpl course, MergeSource nodesContainer, TreeNode courseNode) {
if(courseNode == null) return;
for (int i = 0; i < courseNode.getChildCount(); i++) {
TreeNode child = (TreeNode)courseNode.getChildAt(i);
NodeEvaluation nodeEval;
if(child.getUserObject() instanceof NodeEvaluation) {
nodeEval = (NodeEvaluation)child.getUserObject();
} else {
continue;
}
if(nodeEval != null && nodeEval.getCourseNode() != null) {
CourseNode courseNodeChild = nodeEval.getCourseNode();
String folderName = RequestUtil.normalizeFilename(courseNodeChild.getShortTitle());
if (courseNodeChild instanceof BCCourseNode) {
final BCCourseNode bcNode = (BCCourseNode) courseNodeChild;
// add folder not to merge source. Use name and node id to have unique name
VFSContainer rootFolder = getBCContainer(course, bcNode, nodeEval, false);
boolean canDownload = nodeEval.isCapabilityAccessible("download");
if(canDownload && rootFolder != null) {
if(courseReadOnly) {
rootFolder.setLocalSecurityCallback(new ReadOnlyCallback());
} else if(nodeEval.isCapabilityAccessible("upload")) {
//inherit the security callback from the course as for author
} else {
rootFolder.setLocalSecurityCallback(new ReadOnlyCallback());
}
folderName = getFolderName(nodesContainer, bcNode, folderName);
// Create a container for this node content and wrap it with a merge source which is attached to tree
VFSContainer nodeContentContainer = new NamedContainerImpl(folderName, rootFolder);
MergeSource courseNodeContainer = new MergeSource(nodesContainer, folderName);
courseNodeContainer.addContainersChildren(nodeContentContainer, true);
nodesContainer.addContainer(courseNodeContainer);
// Do recursion for all children
addFolders(course, courseNodeContainer, child);
} else {
// For non-folder course nodes, add merge source (no files to show) ...
MergeSource courseNodeContainer = new MergeSource(null, folderName);
// , then do recursion for all children ...
addFolders(course, courseNodeContainer, child);
// ... but only add this container if it contains any children with at least one BC course node
if (courseNodeContainer.getItems().size() > 0) {
nodesContainer.addContainer(courseNodeContainer);
}
}
} else if (courseNodeChild instanceof PFCourseNode) {
final PFCourseNode pfNode = (PFCourseNode) courseNodeChild;
// add folder not to merge source. Use name and node id to have unique name
PFManager pfManager = CoreSpringFactory.getImpl(PFManager.class);
folderName = getFolderName(nodesContainer, pfNode, folderName);
MergeSource courseNodeContainer = new MergeSource(nodesContainer, folderName);
UserCourseEnvironment userCourseEnv = new UserCourseEnvironmentImpl(identityEnv, course.getCourseEnvironment());
VFSContainer rootFolder = pfManager.provideCoachOrParticipantContainer(pfNode, userCourseEnv,
identityEnv.getIdentity(), courseReadOnly);
VFSContainer nodeContentContainer = new NamedContainerImpl(folderName, rootFolder);
courseNodeContainer.addContainersChildren(nodeContentContainer, true);
addFolders(course, courseNodeContainer, child);
nodesContainer.addContainer(courseNodeContainer);
} else {
// For non-folder course nodes, add merge source (no files to show) ...
MergeSource courseNodeContainer = new MergeSource(null, folderName);
// , then do recursion for all children ...
addFolders(course, courseNodeContainer, child);
// ... but only add this container if it contains any children with at least one BC course node
if (courseNodeContainer.getItems().size() > 0) {
nodesContainer.addContainer(courseNodeContainer);
}
}
}
}
}
/**
* Internal method to recursively add all course building blocks of type
* BC to a given VFS container. This should only be used for an author view,
* it does not test for security.
*
* @param course
* @param nodesContainer
* @param courseNode
* @return container for the current course node
*/
private void addFoldersForAdmin(PersistingCourseImpl course, MergeSource nodesContainer, CourseNode courseNode) {
for (int i = 0; i < courseNode.getChildCount(); i++) {
CourseNode child = (CourseNode) courseNode.getChildAt(i);
String folderName = RequestUtil.normalizeFilename(child.getShortTitle());
if (child instanceof BCCourseNode) {
final BCCourseNode bcNode = (BCCourseNode) child;
// add folder not to merge source. Use name and node id to have unique name
VFSContainer rootFolder = getBCContainer(course, bcNode, null, true);
if(courseReadOnly) {
rootFolder.setLocalSecurityCallback(new ReadOnlyCallback());
}
folderName = getFolderName(nodesContainer, bcNode, folderName);
if(rootFolder != null) {
// Create a container for this node content and wrap it with a merge source which is attached to tree
VFSContainer nodeContentContainer = new NamedContainerImpl(folderName, rootFolder);
MergeSource courseNodeContainer = new MergeSource(nodesContainer, folderName);
courseNodeContainer.addContainersChildren(nodeContentContainer, true);
nodesContainer.addContainer(courseNodeContainer);
// Do recursion for all children
addFoldersForAdmin(course, courseNodeContainer, child);
}
} else if (child instanceof PFCourseNode) {
final PFCourseNode pfNode = (PFCourseNode) child;
// add folder not to merge source. Use name and node id to have unique name
PFManager pfManager = CoreSpringFactory.getImpl(PFManager.class);
folderName = getFolderName(nodesContainer, pfNode, folderName);
MergeSource courseNodeContainer = new MergeSource(nodesContainer, folderName);
VFSContainer rootFolder = pfManager.provideAdminContainer(pfNode, course.getCourseEnvironment());
VFSContainer nodeContentContainer = new NamedContainerImpl(folderName, rootFolder);
courseNodeContainer.addContainersChildren(nodeContentContainer, true);
nodesContainer.addContainer(courseNodeContainer);
// Do recursion for all children
addFoldersForAdmin(course, courseNodeContainer, child);
} else {
// For non-folder course nodes, add merge source (no files to show) ...
MergeSource courseNodeContainer = new MergeSource(null, folderName);
// , then do recursion for all children ...
addFoldersForAdmin(course, courseNodeContainer, child);
// ... but only add this container if it contains any children with at least one BC course node
if (!courseNodeContainer.getItems().isEmpty()) {
nodesContainer.addContainer(courseNodeContainer);
}
}
}
}
/**
* Add node ident if multiple files have same name
*
* @param nodesContainer
* @param bcNode
* @param folderName
* @return
*/
private String getFolderName(MergeSource nodesContainer, CourseNode bcNode, String folderName) {
// add node ident if multiple files have same name
if (!nodesContainer.getItems(vfsItem -> vfsItem.getName().equals(RequestUtil.normalizeFilename(bcNode.getShortTitle()))).isEmpty()) {
folderName = folderName + " (" + bcNode.getIdent() + ")";
}
return folderName;
}
private VFSContainer getBCContainer(ICourse course, BCCourseNode bcNode, NodeEvaluation nodeEval, boolean isOlatAdmin) {
bcNode.updateModuleConfigDefaults(false);
// add folder not to merge source. Use name and node id to have unique name
VFSContainer rootFolder = null;
String subpath = bcNode.getModuleConfiguration().getStringValue(BCCourseNodeEditController.CONFIG_SUBPATH);
if(StringHelper.containsNonWhitespace(subpath)){
if(bcNode.isSharedFolder()){
// grab any shared folder that is configured
OlatRootFolderImpl sharedFolder = null;
String sfSoftkey = course.getCourseConfig().getSharedFolderSoftkey();
if (StringHelper.containsNonWhitespace(sfSoftkey) && !CourseConfig.VALUE_EMPTY_SHAREDFOLDER_SOFTKEY.equals(sfSoftkey)) {
RepositoryManager rm = RepositoryManager.getInstance();
RepositoryEntry re = rm.lookupRepositoryEntryBySoftkey(sfSoftkey, false);
if (re != null) {
sharedFolder = SharedFolderManager.getInstance().getSharedFolder(re.getOlatResource());
VFSContainer courseBase = sharedFolder;
subpath = subpath.replaceFirst("/_sharedfolder", "");
rootFolder = (VFSContainer) courseBase.resolve(subpath);
if(rootFolder != null) {
if(course.getCourseConfig().isSharedFolderReadOnlyMount() || courseReadOnly) {
rootFolder.setLocalSecurityCallback(new ReadOnlyCallback());
} else if(rootFolder.getLocalSecurityCallback() != null) {
SubscriptionContext subContext = CourseModule.createSubscriptionContext(course.getCourseEnvironment(), bcNode);
rootFolder.setLocalSecurityCallback(new OverrideSubscriptionSecurityCallback(rootFolder.getLocalSecurityCallback(), subContext));
}
}
}
}
} else {
VFSContainer courseBase = course.getCourseBaseContainer();
rootFolder = (VFSContainer) courseBase.resolve("/coursefolder" + subpath);
if(rootFolder != null && rootFolder.getLocalSecurityCallback() != null) {
SubscriptionContext subContext = CourseModule.createSubscriptionContext(course.getCourseEnvironment(), bcNode);
rootFolder.setLocalSecurityCallback(new OverrideSubscriptionSecurityCallback(rootFolder.getLocalSecurityCallback(), subContext));
}
}
}
if(bcNode.getModuleConfiguration().getBooleanSafe(BCCourseNodeEditController.CONFIG_AUTO_FOLDER)){
String path = BCCourseNode.getFoldernodePathRelToFolderBase(course.getCourseEnvironment(), bcNode);
rootFolder = new OlatRootFolderImpl(path, null);
if(nodeEval != null) {
SubscriptionContext subContext = CourseModule.createSubscriptionContext(course.getCourseEnvironment(), bcNode);
rootFolder.setLocalSecurityCallback(new FolderNodeCallback(path, nodeEval, isOlatAdmin, false, subContext));
} else {
VFSSecurityCallback secCallback = VFSManager.findInheritedSecurityCallback(this);
if(secCallback != null) {
SubscriptionContext subContext = CourseModule.createSubscriptionContext(course.getCourseEnvironment(), bcNode);
rootFolder.setLocalSecurityCallback(new OverrideQuotaSecurityCallback(path, secCallback, subContext));
}
}
}
return rootFolder;
}
private Object readResolve() { private Object readResolve() {
try { try {
...@@ -393,138 +148,4 @@ public class MergedCourseContainer extends MergeSource { ...@@ -393,138 +148,4 @@ public class MergedCourseContainer extends MergeSource {
return null; return null;
} }
} }
private static class OverrideQuotaSecurityCallback implements VFSSecurityCallback {
private final String relPath;
private Quota overridenQuota;
private final SubscriptionContext subContext;
private final VFSSecurityCallback secCallback;
public OverrideQuotaSecurityCallback(String relPath, VFSSecurityCallback secCallback, SubscriptionContext subContext) {
this.relPath = relPath;
this.subContext = subContext;
this.secCallback = secCallback;
}
@Override
public boolean canRead() {
return secCallback.canRead();
}
@Override
public boolean canWrite() {
return secCallback.canWrite();
}
@Override
public boolean canCreateFolder() {
return secCallback.canCreateFolder();
}
@Override
public boolean canDelete() {
return secCallback.canDelete();
}
@Override
public boolean canList() {
return secCallback.canList();
}
@Override
public boolean canCopy() {
return secCallback.canCopy();
}
@Override
public boolean canDeleteRevisionsPermanently() {
return secCallback.canDeleteRevisionsPermanently();
}
@Override
public Quota getQuota() {
if(overridenQuota == null) {
QuotaManager qm = QuotaManager.getInstance();
overridenQuota = qm.getCustomQuota(relPath);
if (overridenQuota == null) {
Quota defQuota = qm.getDefaultQuota(QuotaConstants.IDENTIFIER_DEFAULT_NODES);
overridenQuota = qm.createQuota(relPath, defQuota.getQuotaKB(), defQuota.getUlLimitKB());
}
}
return overridenQuota;
}
@Override
public void setQuota(Quota quota) {
//
}
@Override
public SubscriptionContext getSubscriptionContext() {
return subContext == null ? secCallback.getSubscriptionContext() : subContext;
}
}
private static class OverrideSubscriptionSecurityCallback implements VFSSecurityCallback {
private final SubscriptionContext subContext;
private final VFSSecurityCallback secCallback;
public OverrideSubscriptionSecurityCallback(VFSSecurityCallback secCallback, SubscriptionContext subContext) {
this.subContext = subContext;
this.secCallback = secCallback;
}
@Override
public boolean canRead() {
return secCallback.canRead();
}
@Override
public boolean canWrite() {
return secCallback.canWrite();
}
@Override
public boolean canCreateFolder() {
return secCallback.canCreateFolder();
}
@Override
public boolean canDelete() {
return secCallback.canDelete();
}
@Override
public boolean canList() {
return secCallback.canList();
}
@Override
public boolean canCopy() {
return secCallback.canCopy();
}
@Override
public boolean canDeleteRevisionsPermanently() {
return secCallback.canDeleteRevisionsPermanently();
}
@Override
public Quota getQuota() {
return secCallback.getQuota();
}
@Override
public void setQuota(Quota quota) {
//
}
@Override
public SubscriptionContext getSubscriptionContext() {
return subContext == null ? secCallback.getSubscriptionContext() : subContext;
}
}
} }
src/main/java/org/olat/course/folder/MergedCourseElementDataContainer.java 0 → 100644
+ 516
− 0
View file @ 75d87408
/**
* <a href="http://www.openolat.org">
* OpenOLAT - Online Learning and Training</a><br>
* <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 the
* <a href="http://www.apache.org/licenses/LICENSE-2.0">Apache homepage</a>
* <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>
* Initial code contributed and copyrighted by<br>
* frentix GmbH, http://www.frentix.com
* <p>
*/
package org.olat.course.folder;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
import org.olat.admin.quota.QuotaConstants;
import org.olat.core.commons.modules.bc.vfs.OlatRootFolderImpl;
import org.olat.core.commons.services.notifications.SubscriptionContext;
import org.olat.core.commons.services.webdav.servlets.RequestUtil;
import org.olat.core.gui.components.tree.TreeNode;
import org.olat.core.id.IdentityEnvironment;
import org.olat.core.logging.OLog;
import org.olat.core.logging.Tracing;
import org.olat.core.util.StringHelper;
import org.olat.core.util.nodes.INode;
import org.olat.core.util.tree.TreeVisitor;
import org.olat.core.util.tree.Visitor;
import org.olat.core.util.vfs.MergeSource;
import org.olat.core.util.vfs.NamedContainerImpl;
import org.olat.core.util.vfs.Quota;
import org.olat.core.util.vfs.QuotaManager;
import org.olat.core.util.vfs.VFSContainer;
import org.olat.core.util.vfs.VFSItem;
import org.olat.core.util.vfs.VFSManager;
import org.olat.core.util.vfs.callbacks.ReadOnlyCallback;
import org.olat.core.util.vfs.callbacks.VFSSecurityCallback;
import org.olat.core.util.vfs.filters.VFSItemFilter;
import org.olat.course.CourseFactory;
import org.olat.course.CourseModule;
import org.olat.course.ICourse;
import org.olat.course.PersistingCourseImpl;
import org.olat.course.config.CourseConfig;
import org.olat.course.nodes.BCCourseNode;
import org.olat.course.nodes.CourseNode;
import org.olat.course.nodes.PFCourseNode;
import org.olat.course.nodes.bc.BCCourseNodeEditController;
import org.olat.course.nodes.bc.FolderNodeCallback;
import org.olat.course.run.userview.NodeEvaluation;
import org.olat.course.run.userview.TreeEvaluation;
import org.olat.course.run.userview.UserCourseEnvironment;
import org.olat.course.run.userview.UserCourseEnvironmentImpl;
import org.olat.course.run.userview.VisibleTreeFilter;
import org.olat.modules.sharedfolder.SharedFolderManager;
import org.olat.repository.RepositoryEntry;
import org.olat.repository.RepositoryManager;
/**
*
* Initial date: 28 juin 2018<br>
* @author srosse, stephane.rosse@frentix.com, http://www.frentix.com
*
*/
public class MergedCourseElementDataContainer extends MergeSource {
private static final OLog log = Tracing.createLoggerFor(MergedCourseElementDataContainer.class);
private final Long courseId;
private boolean initialized = false;
private boolean courseReadOnly = false;
private final IdentityEnvironment identityEnv;
public MergedCourseElementDataContainer(Long courseId, IdentityEnvironment identityEnv) {
super(null, "_courseelementdata");
this.courseId = courseId;
this.identityEnv = identityEnv;
}
public boolean isEmpty() {
if(initialized) {
return getItems().isEmpty();
}
ICourse course = CourseFactory.loadCourse(courseId);
AtomicInteger count = new AtomicInteger(0);
if(identityEnv == null) {
new TreeVisitor(new Visitor() {
@Override
public void visit(INode node) {
if(node instanceof PFCourseNode || node instanceof BCCourseNode) {
count.incrementAndGet();
}
}
}, course.getRunStructure().getRootNode(), true).visitAll();
} else if(course instanceof PersistingCourseImpl) {
TreeEvaluation treeEval = new TreeEvaluation();
PersistingCourseImpl persistingCourse = (PersistingCourseImpl)course;
UserCourseEnvironment userCourseEnv = new UserCourseEnvironmentImpl(identityEnv, persistingCourse.getCourseEnvironment());
CourseNode rootCn = userCourseEnv.getCourseEnvironment().getRunStructure().getRootNode();
NodeEvaluation rootNodeEval = rootCn.eval(userCourseEnv.getConditionInterpreter(), treeEval, new VisibleTreeFilter());
new TreeVisitor(new Visitor() {
@Override
public void visit(INode node) {
if(node instanceof TreeNode) {
if(((TreeNode)node).getUserObject() instanceof NodeEvaluation) {
NodeEvaluation nodeEval = (NodeEvaluation)((TreeNode)node).getUserObject();
if(nodeEval != null
&& (nodeEval.getCourseNode() instanceof PFCourseNode || nodeEval.getCourseNode() instanceof BCCourseNode)) {
count.incrementAndGet();
}
}
}
}
}, rootNodeEval.getTreeNode(), true).visitAll();
}
return count.get() == 0;
}
@Override
public List<VFSItem> getItems(VFSItemFilter filter) {
if(!initialized) {
init();
}
return super.getItems(filter);
}
@Override
public VFSItem resolve(String path) {
if(!initialized) {
init();
}
return super.resolve(path);
}
@Override
protected void init() {
if(initialized) return;
ICourse course = CourseFactory.loadCourse(courseId);
if(course instanceof PersistingCourseImpl) {
initialized = true;
init((PersistingCourseImpl)course);
}
}
protected void init(PersistingCourseImpl persistingCourse) {
if(identityEnv == null) {
CourseNode rootNode = persistingCourse.getRunStructure().getRootNode();
addFoldersForAdmin(persistingCourse, this, rootNode);
} else {
TreeEvaluation treeEval = new TreeEvaluation();
UserCourseEnvironment userCourseEnv = new UserCourseEnvironmentImpl(identityEnv, persistingCourse.getCourseEnvironment());
CourseNode rootCn = userCourseEnv.getCourseEnvironment().getRunStructure().getRootNode();
NodeEvaluation rootNodeEval = rootCn.eval(userCourseEnv.getConditionInterpreter(), treeEval, new VisibleTreeFilter());
TreeNode treeRoot = rootNodeEval.getTreeNode();
addFolders(persistingCourse, this, treeRoot);
}
}
private void addFolders(PersistingCourseImpl course, MergeSource nodesContainer, TreeNode courseNode) {
if(courseNode == null) return;
for (int i = 0; i < courseNode.getChildCount(); i++) {
TreeNode child = (TreeNode)courseNode.getChildAt(i);
NodeEvaluation nodeEval;
if(child.getUserObject() instanceof NodeEvaluation) {
nodeEval = (NodeEvaluation)child.getUserObject();
} else {
continue;
}
if(nodeEval != null && nodeEval.getCourseNode() != null) {
CourseNode courseNodeChild = nodeEval.getCourseNode();
String folderName = RequestUtil.normalizeFilename(courseNodeChild.getShortTitle());
if (courseNodeChild instanceof BCCourseNode) {
final BCCourseNode bcNode = (BCCourseNode) courseNodeChild;
// add folder not to merge source. Use name and node id to have unique name
VFSContainer rootFolder = getBCContainer(course, bcNode, nodeEval, false);
boolean canDownload = nodeEval.isCapabilityAccessible("download");
if(canDownload && rootFolder != null) {
if(courseReadOnly) {
rootFolder.setLocalSecurityCallback(new ReadOnlyCallback());
} else if(nodeEval.isCapabilityAccessible("upload")) {
//inherit the security callback from the course as for author
} else {
rootFolder.setLocalSecurityCallback(new ReadOnlyCallback());
}
folderName = getFolderName(nodesContainer, bcNode, folderName);
// Create a container for this node content and wrap it with a merge source which is attached to tree
VFSContainer nodeContentContainer = new NamedContainerImpl(folderName, rootFolder);
MergeSource courseNodeContainer = new MergeSource(nodesContainer, folderName);
courseNodeContainer.addContainersChildren(nodeContentContainer, true);
nodesContainer.addContainer(courseNodeContainer);
// Do recursion for all children
addFolders(course, courseNodeContainer, child);
} else {
// For non-folder course nodes, add merge source (no files to show) ...
MergeSource courseNodeContainer = new MergeSource(null, folderName);
// , then do recursion for all children ...
addFolders(course, courseNodeContainer, child);
// ... but only add this container if it contains any children with at least one BC course node
if (courseNodeContainer.getItems().size() > 0) {
nodesContainer.addContainer(courseNodeContainer);
}
}
} else if (courseNodeChild instanceof PFCourseNode) {
PFCourseNode pfNode = (PFCourseNode) courseNodeChild;
// add folder not to merge source. Use name and node id to have unique name
folderName = getFolderName(nodesContainer, pfNode, folderName);
MergedPFCourseNodeContainer courseNodeContainer = new MergedPFCourseNodeContainer(nodesContainer, folderName,
courseId, pfNode, identityEnv, courseReadOnly, false);
addFolders(course, courseNodeContainer, child);
nodesContainer.addContainer(courseNodeContainer);
} else {
// For non-folder course nodes, add merge source (no files to show) ...
MergeSource courseNodeContainer = new MergeSource(null, folderName);
// , then do recursion for all children ...
addFolders(course, courseNodeContainer, child);
// ... but only add this container if it contains any children with at least one BC course node
if (courseNodeContainer.getItems().size() > 0) {
nodesContainer.addContainer(courseNodeContainer);
}
}
}
}
}
/**
* Internal method to recursively add all course building blocks of type
* BC to a given VFS container. This should only be used for an author view,
* it does not test for security.
*
* @param course
* @param nodesContainer
* @param courseNode
* @return container for the current course node
*/
private void addFoldersForAdmin(PersistingCourseImpl course, MergeSource nodesContainer, CourseNode courseNode) {
for (int i = 0; i < courseNode.getChildCount(); i++) {
CourseNode child = (CourseNode) courseNode.getChildAt(i);
String folderName = RequestUtil.normalizeFilename(child.getShortTitle());
if (child instanceof BCCourseNode) {
final BCCourseNode bcNode = (BCCourseNode) child;
// add folder not to merge source. Use name and node id to have unique name
VFSContainer rootFolder = getBCContainer(course, bcNode, null, true);
if(courseReadOnly) {
rootFolder.setLocalSecurityCallback(new ReadOnlyCallback());
}
folderName = getFolderName(nodesContainer, bcNode, folderName);
if(rootFolder != null) {
// Create a container for this node content and wrap it with a merge source which is attached to tree
VFSContainer nodeContentContainer = new NamedContainerImpl(folderName, rootFolder);
MergeSource courseNodeContainer = new MergeSource(nodesContainer, folderName);
courseNodeContainer.addContainersChildren(nodeContentContainer, true);
nodesContainer.addContainer(courseNodeContainer);
// Do recursion for all children
addFoldersForAdmin(course, courseNodeContainer, child);
}
} else if (child instanceof PFCourseNode) {
final PFCourseNode pfNode = (PFCourseNode) child;
// add folder not to merge source. Use name and node id to have unique name
folderName = getFolderName(nodesContainer, pfNode, folderName);
MergedPFCourseNodeContainer courseNodeContainer = new MergedPFCourseNodeContainer(nodesContainer, folderName,
courseId, pfNode, identityEnv, courseReadOnly, true);
nodesContainer.addContainer(courseNodeContainer);
// Do recursion for all children
addFoldersForAdmin(course, courseNodeContainer, child);
} else {
// For non-folder course nodes, add merge source (no files to show) ...
MergeSource courseNodeContainer = new MergeSource(null, folderName);
// , then do recursion for all children ...
addFoldersForAdmin(course, courseNodeContainer, child);
// ... but only add this container if it contains any children with at least one BC course node
if (!courseNodeContainer.getItems().isEmpty()) {
nodesContainer.addContainer(courseNodeContainer);
}
}
}
}
/**
* Add node ident if multiple files have same name
*
* @param nodesContainer
* @param bcNode
* @param folderName
* @return
*/
private String getFolderName(MergeSource nodesContainer, CourseNode bcNode, String folderName) {
// add node ident if multiple files have same name
if (!nodesContainer.getItems(vfsItem -> vfsItem.getName().equals(RequestUtil.normalizeFilename(bcNode.getShortTitle()))).isEmpty()) {
folderName = folderName + " (" + bcNode.getIdent() + ")";
}
return folderName;
}
private VFSContainer getBCContainer(ICourse course, BCCourseNode bcNode, NodeEvaluation nodeEval, boolean isOlatAdmin) {
bcNode.updateModuleConfigDefaults(false);
// add folder not to merge source. Use name and node id to have unique name
VFSContainer rootFolder = null;
String subpath = bcNode.getModuleConfiguration().getStringValue(BCCourseNodeEditController.CONFIG_SUBPATH);
if(StringHelper.containsNonWhitespace(subpath)){
if(bcNode.isSharedFolder()){
// grab any shared folder that is configured
OlatRootFolderImpl sharedFolder = null;
String sfSoftkey = course.getCourseConfig().getSharedFolderSoftkey();
if (StringHelper.containsNonWhitespace(sfSoftkey) && !CourseConfig.VALUE_EMPTY_SHAREDFOLDER_SOFTKEY.equals(sfSoftkey)) {
RepositoryManager rm = RepositoryManager.getInstance();
RepositoryEntry re = rm.lookupRepositoryEntryBySoftkey(sfSoftkey, false);
if (re != null) {
sharedFolder = SharedFolderManager.getInstance().getSharedFolder(re.getOlatResource());
VFSContainer courseBase = sharedFolder;
subpath = subpath.replaceFirst("/_sharedfolder", "");
rootFolder = (VFSContainer) courseBase.resolve(subpath);
if(rootFolder != null) {
if(course.getCourseConfig().isSharedFolderReadOnlyMount() || courseReadOnly) {
rootFolder.setLocalSecurityCallback(new ReadOnlyCallback());
} else if(rootFolder.getLocalSecurityCallback() != null) {
SubscriptionContext subContext = CourseModule.createSubscriptionContext(course.getCourseEnvironment(), bcNode);
rootFolder.setLocalSecurityCallback(new OverrideSubscriptionSecurityCallback(rootFolder.getLocalSecurityCallback(), subContext));
}
}
}
}
} else {
VFSContainer courseBase = course.getCourseBaseContainer();
rootFolder = (VFSContainer) courseBase.resolve("/coursefolder" + subpath);
if(rootFolder != null && rootFolder.getLocalSecurityCallback() != null) {
SubscriptionContext subContext = CourseModule.createSubscriptionContext(course.getCourseEnvironment(), bcNode);
rootFolder.setLocalSecurityCallback(new OverrideSubscriptionSecurityCallback(rootFolder.getLocalSecurityCallback(), subContext));
}
}
}
if(bcNode.getModuleConfiguration().getBooleanSafe(BCCourseNodeEditController.CONFIG_AUTO_FOLDER)){
String path = BCCourseNode.getFoldernodePathRelToFolderBase(course.getCourseEnvironment(), bcNode);
rootFolder = new OlatRootFolderImpl(path, null);
if(nodeEval != null) {
SubscriptionContext subContext = CourseModule.createSubscriptionContext(course.getCourseEnvironment(), bcNode);
rootFolder.setLocalSecurityCallback(new FolderNodeCallback(path, nodeEval, isOlatAdmin, false, subContext));
} else {
VFSSecurityCallback secCallback = VFSManager.findInheritedSecurityCallback(this);
if(secCallback != null) {
SubscriptionContext subContext = CourseModule.createSubscriptionContext(course.getCourseEnvironment(), bcNode);
rootFolder.setLocalSecurityCallback(new OverrideQuotaSecurityCallback(path, secCallback, subContext));
}
}
}
return rootFolder;
}
private Object readResolve() {
try {
init();
return this;
} catch (Exception e) {
log.error("Cannot init the merged container of a course after deserialization", e);
return null;
}
}
private static class OverrideQuotaSecurityCallback implements VFSSecurityCallback {
private final String relPath;
private Quota overridenQuota;
private final SubscriptionContext subContext;
private final VFSSecurityCallback secCallback;
public OverrideQuotaSecurityCallback(String relPath, VFSSecurityCallback secCallback, SubscriptionContext subContext) {
this.relPath = relPath;
this.subContext = subContext;
this.secCallback = secCallback;
}
@Override
public boolean canRead() {
return secCallback.canRead();
}
@Override
public boolean canWrite() {
return secCallback.canWrite();
}
@Override
public boolean canCreateFolder() {
return secCallback.canCreateFolder();
}
@Override
public boolean canDelete() {
return secCallback.canDelete();
}
@Override
public boolean canList() {
return secCallback.canList();
}
@Override
public boolean canCopy() {
return secCallback.canCopy();
}
@Override
public boolean canDeleteRevisionsPermanently() {
return secCallback.canDeleteRevisionsPermanently();
}
@Override
public Quota getQuota() {
if(overridenQuota == null) {
QuotaManager qm = QuotaManager.getInstance();
overridenQuota = qm.getCustomQuota(relPath);
if (overridenQuota == null) {
Quota defQuota = qm.getDefaultQuota(QuotaConstants.IDENTIFIER_DEFAULT_NODES);
overridenQuota = qm.createQuota(relPath, defQuota.getQuotaKB(), defQuota.getUlLimitKB());
}
}
return overridenQuota;
}
@Override
public void setQuota(Quota quota) {
//
}
@Override
public SubscriptionContext getSubscriptionContext() {
return subContext == null ? secCallback.getSubscriptionContext() : subContext;
}
}
private static class OverrideSubscriptionSecurityCallback implements VFSSecurityCallback {
private final SubscriptionContext subContext;
private final VFSSecurityCallback secCallback;
public OverrideSubscriptionSecurityCallback(VFSSecurityCallback secCallback, SubscriptionContext subContext) {
this.subContext = subContext;
this.secCallback = secCallback;
}
@Override
public boolean canRead() {
return secCallback.canRead();
}
@Override
public boolean canWrite() {
return secCallback.canWrite();
}
@Override
public boolean canCreateFolder() {
return secCallback.canCreateFolder();
}
@Override
public boolean canDelete() {
return secCallback.canDelete();
}
@Override
public boolean canList() {
return secCallback.canList();
}
@Override
public boolean canCopy() {
return secCallback.canCopy();
}
@Override
public boolean canDeleteRevisionsPermanently() {
return secCallback.canDeleteRevisionsPermanently();
}
@Override
public Quota getQuota() {
return secCallback.getQuota();
}
@Override
public void setQuota(Quota quota) {
//
}
@Override
public SubscriptionContext getSubscriptionContext() {
return subContext == null ? secCallback.getSubscriptionContext() : subContext;
}
}
}
src/main/java/org/olat/course/folder/MergedPFCourseNodeContainer.java 0 → 100644
+ 104
− 0
View file @ 75d87408
/**
* <a href="http://www.openolat.org">
* OpenOLAT - Online Learning and Training</a><br>
* <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 the
* <a href="http://www.apache.org/licenses/LICENSE-2.0">Apache homepage</a>
* <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>
* Initial code contributed and copyrighted by<br>
* frentix GmbH, http://www.frentix.com
* <p>
*/
package org.olat.course.folder;
import java.util.List;
import org.olat.core.CoreSpringFactory;
import org.olat.core.id.IdentityEnvironment;
import org.olat.core.util.vfs.MergeSource;
import org.olat.core.util.vfs.NamedContainerImpl;
import org.olat.core.util.vfs.VFSContainer;
import org.olat.core.util.vfs.VFSItem;
import org.olat.core.util.vfs.filters.VFSItemFilter;
import org.olat.course.CourseFactory;
import org.olat.course.ICourse;
import org.olat.course.nodes.PFCourseNode;
import org.olat.course.nodes.pf.manager.PFManager;
import org.olat.course.run.userview.UserCourseEnvironment;
import org.olat.course.run.userview.UserCourseEnvironmentImpl;
/**
*
* This container lazy load the participant folders.
*
* Initial date: 29 juin 2018<br>
* @author srosse, stephane.rosse@frentix.com, http://www.frentix.com
*
*/
public class MergedPFCourseNodeContainer extends MergeSource {
private boolean initialized = false;
private final Long courseId;
private final PFCourseNode pfNode;
private final boolean admin;
private final boolean courseReadOnly;
private final IdentityEnvironment identityEnv;
public MergedPFCourseNodeContainer(VFSContainer parentContainer, String folderName,
Long courseId, PFCourseNode pfNode,
IdentityEnvironment identityEnv, boolean courseReadOnly, boolean admin) {
super(parentContainer, folderName);
this.courseId = courseId;
this.pfNode = pfNode;
this.admin = admin;
this.courseReadOnly = courseReadOnly;
this.identityEnv = identityEnv;
}
@Override
protected void init() {
if(initialized) return;
PFManager pfManager = CoreSpringFactory.getImpl(PFManager.class);
ICourse course = CourseFactory.loadCourse(courseId);
if(admin) {
VFSContainer rootFolder = pfManager.provideAdminContainer(pfNode, course.getCourseEnvironment());
VFSContainer nodeContentContainer = new NamedContainerImpl(getName(), rootFolder);
addContainersChildren(nodeContentContainer, true);
} else {
UserCourseEnvironment userCourseEnv = new UserCourseEnvironmentImpl(identityEnv, course.getCourseEnvironment());
VFSContainer rootFolder = pfManager.provideCoachOrParticipantContainer(pfNode, userCourseEnv,
identityEnv.getIdentity(), courseReadOnly);
VFSContainer nodeContentContainer = new NamedContainerImpl(getName(), rootFolder);
addContainersChildren(nodeContentContainer, true);
}
super.init();
}
@Override
public List<VFSItem> getItems(VFSItemFilter filter) {
if(!initialized) {
init();
initialized = true;
}
return super.getItems(filter);
}
@Override
public VFSItem resolve(String path) {
if(!initialized) {
init();
}
return super.resolve(path);
}
}
src/main/java/org/olat/course/nodes/bc/BCCourseNodeRunController.java
+ 3
− 2
View file @ 75d87408
...@@ -119,7 +119,8 @@ public class BCCourseNodeRunController extends DefaultController implements Acti ...@@ -119,7 +119,8 @@ public class BCCourseNodeRunController extends DefaultController implements Acti
} else{ } else{
//create folder automatically if not found //create folder automatically if not found
String subPath = courseNode.getModuleConfiguration().getStringValue(BCCourseNodeEditController.CONFIG_SUBPATH); String subPath = courseNode.getModuleConfiguration().getStringValue(BCCourseNodeEditController.CONFIG_SUBPATH);
VFSContainer item = VFSManager.resolveOrCreateContainerFromPath(courseEnv.getCourseFolderContainer(), subPath); VFSContainer courseContainer = courseEnv.getCourseFolderContainer();
VFSContainer item = VFSManager.resolveOrCreateContainerFromPath(courseContainer, subPath);
String relPath; String relPath;
if(item == null) { if(item == null) {
...@@ -135,7 +136,7 @@ public class BCCourseNodeRunController extends DefaultController implements Acti ...@@ -135,7 +136,7 @@ public class BCCourseNodeRunController extends DefaultController implements Acti
&& inheritingContainer.getLocalSecurityCallback() .getQuota() != null) { && inheritingContainer.getLocalSecurityCallback() .getQuota() != null) {
relPath = inheritingContainer.getLocalSecurityCallback().getQuota().getPath(); relPath = inheritingContainer.getLocalSecurityCallback().getQuota().getPath();
} else { } else {
relPath = VFSManager.getRelativeItemPath(target, courseEnv.getCourseFolderContainer(), null); relPath = VFSManager.getRelativeItemPath(target, courseContainer, null);
} }
scallback = new FolderNodeCallback(relPath, ne, isOlatAdmin, isGuestOnly, nodefolderSubContext); scallback = new FolderNodeCallback(relPath, ne, isOlatAdmin, isGuestOnly, nodefolderSubContext);
} }
......
src/main/java/org/olat/course/nodes/iq/QTI21AssessmentRunController.java
+ 1
− 1
View file @ 75d87408
...@@ -193,9 +193,9 @@ public class QTI21AssessmentRunController extends BasicController implements Gen ...@@ -193,9 +193,9 @@ public class QTI21AssessmentRunController extends BasicController implements Gen
// fetch disclaimer file // fetch disclaimer file
String sDisclaimer = config.getStringValue(IQEditController.CONFIG_KEY_DISCLAIMER); String sDisclaimer = config.getStringValue(IQEditController.CONFIG_KEY_DISCLAIMER);
if (sDisclaimer != null) { if (sDisclaimer != null) {
VFSContainer baseContainer = userCourseEnv.getCourseEnvironment().getCourseFolderContainer();
int lastSlash = sDisclaimer.lastIndexOf('/'); int lastSlash = sDisclaimer.lastIndexOf('/');
if (lastSlash != -1) { if (lastSlash != -1) {
VFSContainer baseContainer = userCourseEnv.getCourseEnvironment().getCourseFolderContainer();
baseContainer = (VFSContainer)baseContainer.resolve(sDisclaimer.substring(0, lastSlash)); baseContainer = (VFSContainer)baseContainer.resolve(sDisclaimer.substring(0, lastSlash));
sDisclaimer = sDisclaimer.substring(lastSlash); sDisclaimer = sDisclaimer.substring(lastSlash);
// first check if disclaimer exists on filesystem // first check if disclaimer exists on filesystem
......
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment