diff --git a/src/main/java/org/olat/basesecurity/BaseSecurity.java b/src/main/java/org/olat/basesecurity/BaseSecurity.java
index 49b730e08beb67b09a44b1e02092cd9199928761..4add7a97724b22b33001b95ad3f55316b156150c 100644
--- a/src/main/java/org/olat/basesecurity/BaseSecurity.java
+++ b/src/main/java/org/olat/basesecurity/BaseSecurity.java
@@ -61,6 +61,14 @@ public interface BaseSecurity {
*/
public boolean isIdentityPermittedOnResourceable(Identity identity, String permission, OLATResourceable olatResourceable);
+ /**
+ * Return the list of "allowed to..."
+ * @param identity
+ * @param olatResourceable
+ * @return
+ */
+ public List<String> getIdentityPermissionOnresourceable(Identity identity, OLATResourceable olatResourceable);
+
/**
* Get the identity's roles
*
diff --git a/src/main/java/org/olat/basesecurity/BaseSecurityManager.java b/src/main/java/org/olat/basesecurity/BaseSecurityManager.java
index 2bc66bb454b4290ef934b867bae1b595b419b0fd..404d4997c6c50390a3cafa6c8b27bf90e8444c2d 100644
--- a/src/main/java/org/olat/basesecurity/BaseSecurityManager.java
+++ b/src/main/java/org/olat/basesecurity/BaseSecurityManager.java
@@ -303,6 +303,21 @@ public class BaseSecurityManager extends BasicManager implements BaseSecurity {
return query.getResultList();
}
+ @Override
+ public List<String> getIdentityPermissionOnresourceable(Identity identity, OLATResourceable olatResourceable) {
+ Long oresid = olatResourceable.getResourceableId();
+ if (oresid == null) {
+ oresid = new Long(0);
+ }
+ List<String> permissions = dbInstance.getCurrentEntityManager()
+ .createNamedQuery("getIdentityPermissionsOnResourceableCheckType", String.class)
+ .setParameter("identitykey", identity.getKey())
+ .setParameter("resid", oresid)
+ .setParameter("resname", olatResourceable.getResourceableTypeName())
+ .getResultList();
+ return permissions;
+ }
+
public boolean isIdentityPermittedOnResourceable(Identity identity, String permission, OLATResourceable olatResourceable) {
return isIdentityPermittedOnResourceable(identity, permission, olatResourceable, true);
}
diff --git a/src/main/java/org/olat/basesecurity/PolicyImpl.hbm.xml b/src/main/java/org/olat/basesecurity/PolicyImpl.hbm.xml
index d4ce888b5daa73178ac987c84d2af5769f447f4d..2a631652e3452110c3677a762a9549ae0b6c2dd4 100644
--- a/src/main/java/org/olat/basesecurity/PolicyImpl.hbm.xml
+++ b/src/main/java/org/olat/basesecurity/PolicyImpl.hbm.xml
@@ -43,6 +43,9 @@
<query name="isIdentityPermittedOnResourceable">
<![CDATA[select count(poi) from org.olat.basesecurity.SecurityGroupMembershipImpl as sgmsi, org.olat.basesecurity.PolicyImpl as poi, org.olat.resource.OLATResourceImpl as ori where sgmsi.identity.key = :identitykey and sgmsi.securityGroup = poi.securityGroup and poi.permission = :permission and poi.olatResource = ori and (ori.resId = :resid) and ori.resName = :resname]]>
</query>
+ <query name="getIdentityPermissionsOnResourceableCheckType">
+ <![CDATA[select distinct poi.permission from org.olat.basesecurity.SecurityGroupMembershipImpl as sgmsi, org.olat.basesecurity.PolicyImpl as poi, org.olat.resource.OLATResourceImpl as ori where sgmsi.identity.key=:identitykey and sgmsi.securityGroup=poi.securityGroup and poi.olatResource=ori and (ori.resId=:resid or ori.resId=0) and ori.resName=:resname]]>
+ </query>
</hibernate-mapping>
diff --git a/src/main/java/org/olat/core/util/vfs/version/FolderVersioningConfigurator.java b/src/main/java/org/olat/core/util/vfs/version/FolderVersioningConfigurator.java
index 47e4e356b82e4ea25ceb78b061c7a1c6274a6718..97bfd3b0e4b698190caef8fcf55f6d2eabdd904a 100644
--- a/src/main/java/org/olat/core/util/vfs/version/FolderVersioningConfigurator.java
+++ b/src/main/java/org/olat/core/util/vfs/version/FolderVersioningConfigurator.java
@@ -32,6 +32,12 @@ import org.olat.core.util.vfs.VFSContainer;
* @author srosse
*/
public interface FolderVersioningConfigurator {
+
+ /**
+ * The absolut limit for this instance
+ * @return -1 for versioning without limit, 0 for no versioning, 1 - n is the maximum number of revision per file
+ */
+ public int getMaxNumOfVersionsAllowed();
/**
* @param relPath
diff --git a/src/main/java/org/olat/core/util/vfs/version/SimpleVersionConfig.java b/src/main/java/org/olat/core/util/vfs/version/SimpleVersionConfig.java
index 45559de0e7e5b2db78ba97f58b2ebfd90a888275..3b9deab164038161509af11f2c8faa65824517fd 100644
--- a/src/main/java/org/olat/core/util/vfs/version/SimpleVersionConfig.java
+++ b/src/main/java/org/olat/core/util/vfs/version/SimpleVersionConfig.java
@@ -129,6 +129,12 @@ public class SimpleVersionConfig implements GenericEventListener, FolderVersioni
}
}
+ @Override
+ public int getMaxNumOfVersionsAllowed() {
+ return getVersionAllowed();
+ }
+
+ @Override
public int versionAllowed(String relPath) {
if(StringHelper.containsNonWhitespace(relPath)) {
if(relPath.startsWith("/tmp/")//no versioning in tmp
diff --git a/src/main/java/org/olat/core/util/vfs/version/VersionsFileManager.java b/src/main/java/org/olat/core/util/vfs/version/VersionsFileManager.java
index 5483423af1a189d9a1072efa2fb94326beee6ea3..340396e2c5834e9a187857ef8ee4d333f5384d67 100644
--- a/src/main/java/org/olat/core/util/vfs/version/VersionsFileManager.java
+++ b/src/main/java/org/olat/core/util/vfs/version/VersionsFileManager.java
@@ -91,6 +91,8 @@ public class VersionsFileManager extends VersionsManager implements Initializabl
private File rootFolder;
private File rootVersionFolder;
private VFSContainer rootVersionsContainer;
+
+ private FolderVersioningConfigurator versioningConfigurator;
/**
* [spring]
@@ -98,6 +100,16 @@ public class VersionsFileManager extends VersionsManager implements Initializabl
private VersionsFileManager() {
INSTANCE = this;
}
+
+ /**
+ * [used by Spring]
+ * @param versioningConfigurator
+ */
+ public void setVersioningConfigurator(FolderVersioningConfigurator versioningConfigurator) {
+ this.versioningConfigurator = versioningConfigurator;
+ }
+
+
@Override
public Versions createVersionsFor(VFSLeaf leaf) {
@@ -543,6 +555,11 @@ public class VersionsFileManager extends VersionsManager implements Initializabl
*/
@Override
public boolean addToRevisions(Versionable currentVersion, Identity identity, String comment) {
+ int maxNumOfVersions = versioningConfigurator.getMaxNumOfVersionsAllowed();
+ if(maxNumOfVersions == 0) {
+ return true;//deactivated, return all ok
+ }
+
VFSLeaf currentFile = (VFSLeaf) currentVersion;
VFSLeaf versionFile = getCanonicalVersionXmlFile(currentFile, true);
@@ -603,6 +620,16 @@ public class VersionsFileManager extends VersionsManager implements Initializabl
if (identity != null) {
versions.setAuthor(identity.getName());
}
+
+ if(maxNumOfVersions >= 0 && versions.getRevisions().size() >= maxNumOfVersions) {
+ List<VFSRevision> revisions = versions.getRevisions();
+ int numOfVersionsToDelete = Math.min(revisions.size(), (revisions.size() - maxNumOfVersions) + 1);
+ if(numOfVersionsToDelete > 0) {
+ List<VFSRevision> versionsToDelete = revisions.subList(0, numOfVersionsToDelete);
+ deleteRevisions(currentVersion, versionsToDelete);
+ versions = (VersionsFileImpl)currentVersion.getVersions();
+ }
+ }
versions.setComment(comment);
versions.getRevisions().add(newRevision);
versions.setRevisionNr(getNextRevisionNr(versions));
diff --git a/src/main/java/org/olat/core/util/vfs/version/VersionsManager.java b/src/main/java/org/olat/core/util/vfs/version/VersionsManager.java
index 4049f5b6809d8107693ab2715119cdc52e43b199..b2c4bc35376e46c85c4db1794501544f6701381a 100644
--- a/src/main/java/org/olat/core/util/vfs/version/VersionsManager.java
+++ b/src/main/java/org/olat/core/util/vfs/version/VersionsManager.java
@@ -92,6 +92,14 @@ public abstract class VersionsManager extends BasicManager {
*/
public abstract boolean addVersion(Versionable currentVersion, Identity author, String comment, InputStream newVersion);
+ /**
+ * Add a new revision to the files. The method check the number of revisions against the absolute
+ * maximum limit for the instance.
+ * @param currentVersion
+ * @param author
+ * @param comment
+ * @return
+ */
public abstract boolean addToRevisions(Versionable currentVersion, Identity author, String comment);
/**
diff --git a/src/main/java/org/olat/core/util/vfs/version/_spring/versioningCorecontext.xml b/src/main/java/org/olat/core/util/vfs/version/_spring/versioningCorecontext.xml
index e90c113ca672285588202ae8b29227e625124fd2..1bc1f9892ada5a798dd382b82c05c31d8b766528 100644
--- a/src/main/java/org/olat/core/util/vfs/version/_spring/versioningCorecontext.xml
+++ b/src/main/java/org/olat/core/util/vfs/version/_spring/versioningCorecontext.xml
@@ -5,7 +5,9 @@
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.1.xsd">
- <bean id="versionsManager" class="org.olat.core.util.vfs.version.VersionsFileManager" init-method="init"/>
+ <bean id="versionsManager" class="org.olat.core.util.vfs.version.VersionsFileManager" init-method="init">
+ <property name="versioningConfigurator" ref="versioningConfigurator" />
+ </bean>
<bean id="versioningConfigurator" class="org.olat.core.util.vfs.version.SimpleVersionConfig"
depends-on="coordinatorManager,org.olat.core.util.WebappHelper,folderModule">
diff --git a/src/main/java/org/olat/course/PersistingCourseImpl.java b/src/main/java/org/olat/course/PersistingCourseImpl.java
index b1104e23f4ae752e521b8aa5803e6f05f68889b2..0ad03dd2920787a85450a38384a3e1bc3a62c16f 100644
--- a/src/main/java/org/olat/course/PersistingCourseImpl.java
+++ b/src/main/java/org/olat/course/PersistingCourseImpl.java
@@ -47,6 +47,8 @@ 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.callbacks.FullAccessWithQuotaCallback;
+import org.olat.core.util.vfs.version.Versionable;
+import org.olat.core.util.vfs.version.VersionsFileManager;
import org.olat.core.util.xml.XStreamHelper;
import org.olat.course.assessment.AssessmentHelper;
import org.olat.course.config.CourseConfig;
@@ -81,6 +83,8 @@ import com.thoughtworks.xstream.XStream;
*/
public class PersistingCourseImpl implements ICourse, OLATResourceable, Serializable {
+ private static final long serialVersionUID = -1022498371474445868L;
+
public static String COURSE_ROOT_DIR_NAME = "course";
private static final String EDITORTREEMODEL_XML = "editortreemodel.xml";
@@ -408,6 +412,12 @@ public class PersistingCourseImpl implements ICourse, OLATResourceable, Serializ
VFSItem vfsItem = getCourseBaseContainer().resolve(fileName);
if (vfsItem == null) {
vfsItem = getCourseBaseContainer().createChildLeaf(fileName);
+ } else if(vfsItem.exists() && vfsItem instanceof Versionable) {
+ try {
+ VersionsFileManager.getInstance().addToRevisions((Versionable)vfsItem, null, "");
+ } catch (Exception e) {
+ log.error("Cannot versioned " + fileName, e);
+ }
}
XStream xstream = CourseXStreamAliases.getWriteCourseXStream();
XStreamHelper.writeObject(xstream, (VFSLeaf)vfsItem, obj);
diff --git a/src/main/java/org/olat/course/condition/interpreter/InLearningGroupFunction.java b/src/main/java/org/olat/course/condition/interpreter/InLearningGroupFunction.java
index ae284cad23056f60d08ef144e0c59db24e567e73..ec23c4c5ed215500a664cec4a77308fb47d0c127 100644
--- a/src/main/java/org/olat/course/condition/interpreter/InLearningGroupFunction.java
+++ b/src/main/java/org/olat/course/condition/interpreter/InLearningGroupFunction.java
@@ -81,21 +81,17 @@ public class InLearningGroupFunction extends AbstractFunction {
return defaultValue();
}
- /*
- * the real function evaluation which is used during run time
- */
- Identity ident = getUserCourseEnv().getIdentityEnvironment().getIdentity();
-
- CourseGroupManager cgm = getUserCourseEnv().getCourseEnvironment().getCourseGroupManager();
- //System.out.println("todo: check if "+(ident==null? "n/a":ident.getName())+" is in group "+groupName);
-
+ //the real function evaluation which is used during run time
if(isGroupKey(groupName)) {
Long groupKey = Long.parseLong(groupName);
- return cgm.isIdentityInGroup(ident, groupKey) ? ConditionInterpreter.INT_TRUE: ConditionInterpreter.INT_FALSE;
+ return getUserCourseEnv().isIdentityInCourseGroup(groupKey) ? ConditionInterpreter.INT_TRUE: ConditionInterpreter.INT_FALSE;
+ //return cgm.isIdentityInGroup(ident, groupKey) ? ConditionInterpreter.INT_TRUE: ConditionInterpreter.INT_FALSE;
}
-
+
+ CourseGroupManager cgm = getUserCourseEnv().getCourseEnvironment().getCourseGroupManager();
List<Long> groupKeys = CoreSpringFactory.getImpl(BusinessGroupService.class).toGroupKeys(groupName, cgm.getCourseResource());
if(!groupKeys.isEmpty()) {
+ Identity ident = getUserCourseEnv().getIdentityEnvironment().getIdentity();
return cgm.isIdentityInGroup(ident, groupKeys.get(0)) ? ConditionInterpreter.INT_TRUE: ConditionInterpreter.INT_FALSE;
}
return ConditionInterpreter.INT_FALSE;
diff --git a/src/main/java/org/olat/course/condition/interpreter/IsCourseAdministratorFunction.java b/src/main/java/org/olat/course/condition/interpreter/IsCourseAdministratorFunction.java
index 1a62b862826e1f71e8ab216cfc83b3bf089c50bb..46c504c9ba97d3b0fcd5ce645ba1f80a9de47fd1 100644
--- a/src/main/java/org/olat/course/condition/interpreter/IsCourseAdministratorFunction.java
+++ b/src/main/java/org/olat/course/condition/interpreter/IsCourseAdministratorFunction.java
@@ -29,7 +29,6 @@ import org.olat.core.id.Identity;
import org.olat.core.logging.OLog;
import org.olat.core.logging.Tracing;
import org.olat.course.editor.CourseEditorEnv;
-import org.olat.course.groupsandrights.CourseGroupManager;
import org.olat.course.run.userview.UserCourseEnvironment;
/**
@@ -65,10 +64,11 @@ public class IsCourseAdministratorFunction extends AbstractFunction {
return defaultValue();
}
- Identity ident = getUserCourseEnv().getIdentityEnvironment().getIdentity();
- CourseGroupManager cgm = getUserCourseEnv().getCourseEnvironment().getCourseGroupManager();
- boolean isCourseAdmin = cgm.isIdentityCourseAdministrator(ident);
+ //Identity ident = getUserCourseEnv().getIdentityEnvironment().getIdentity();
+ //CourseGroupManager cgm = getUserCourseEnv().getCourseEnvironment().getCourseGroupManager();
+ boolean isCourseAdmin = getUserCourseEnv().isAdmin();// cgm.isIdentityCourseAdministrator(ident);
if(log.isDebug()) {
+ Identity ident = getUserCourseEnv().getIdentityEnvironment().getIdentity();
log.debug("identity "+ident.getName()+", courseadministrator:"+isCourseAdmin+", in course "+getUserCourseEnv().getCourseEnvironment().getCourseResourceableId());
}
return isCourseAdmin ? ConditionInterpreter.INT_TRUE: ConditionInterpreter.INT_FALSE;
diff --git a/src/main/java/org/olat/course/condition/interpreter/IsCourseCoachFunction.java b/src/main/java/org/olat/course/condition/interpreter/IsCourseCoachFunction.java
index 25b1970c3f7f57f6af0e2a9bf36337191bcb2e4b..eccec7280b47e795cffc367c828478a29da30f48 100644
--- a/src/main/java/org/olat/course/condition/interpreter/IsCourseCoachFunction.java
+++ b/src/main/java/org/olat/course/condition/interpreter/IsCourseCoachFunction.java
@@ -29,7 +29,6 @@ import org.olat.core.id.Identity;
import org.olat.core.logging.OLog;
import org.olat.core.logging.Tracing;
import org.olat.course.editor.CourseEditorEnv;
-import org.olat.course.groupsandrights.CourseGroupManager;
import org.olat.course.run.userview.UserCourseEnvironment;
/**
@@ -61,18 +60,16 @@ public class IsCourseCoachFunction extends AbstractFunction {
return defaultValue();
}
- Identity ident = getUserCourseEnv().getIdentityEnvironment().getIdentity();
- CourseGroupManager cgm = getUserCourseEnv().getCourseEnvironment().getCourseGroupManager();
- boolean isCourseCoach = cgm.isIdentityCourseCoach(ident);
+ //CourseGroupManager cgm = getUserCourseEnv().getCourseEnvironment().getCourseGroupManager();
+ boolean isCourseCoach = this.getUserCourseEnv().isCoach();// cgm.isIdentityCourseCoach(ident);
if (log.isDebug()) {
+ Identity ident = getUserCourseEnv().getIdentityEnvironment().getIdentity();
log.debug("identity "+ident.getName()+", coursecoach:"+isCourseCoach+", in course "+getUserCourseEnv().getCourseEnvironment().getCourseResourceableId());
}
-
return isCourseCoach ? ConditionInterpreter.INT_TRUE: ConditionInterpreter.INT_FALSE;
}
protected Object defaultValue() {
return ConditionInterpreter.INT_TRUE;
}
-
}
diff --git a/src/main/java/org/olat/course/condition/interpreter/IsCourseParticipantFunction.java b/src/main/java/org/olat/course/condition/interpreter/IsCourseParticipantFunction.java
index 62e093cf99e0d1cf6f7d86b7c9dda311ddc034b8..5822f64706c56cd2a51d0f5fb2ec0cc4ea9fe42b 100644
--- a/src/main/java/org/olat/course/condition/interpreter/IsCourseParticipantFunction.java
+++ b/src/main/java/org/olat/course/condition/interpreter/IsCourseParticipantFunction.java
@@ -25,7 +25,6 @@ import org.olat.core.id.Identity;
import org.olat.core.logging.OLog;
import org.olat.core.logging.Tracing;
import org.olat.course.editor.CourseEditorEnv;
-import org.olat.course.groupsandrights.CourseGroupManager;
import org.olat.course.run.userview.UserCourseEnvironment;
/**
@@ -63,10 +62,10 @@ public class IsCourseParticipantFunction extends AbstractFunction {
return defaultValue();
}
- Identity ident = getUserCourseEnv().getIdentityEnvironment().getIdentity();
- CourseGroupManager cgm = getUserCourseEnv().getCourseEnvironment().getCourseGroupManager();
- boolean isParticipant = cgm.isIdentityCourseParticipant(ident);
+ //CourseGroupManager cgm = getUserCourseEnv().getCourseEnvironment().getCourseGroupManager();
+ boolean isParticipant = getUserCourseEnv().isParticipant();// cgm.isIdentityCourseParticipant(ident);
if (log.isDebug()) {
+ Identity ident = getUserCourseEnv().getIdentityEnvironment().getIdentity();
log.debug("identity "+ident.getName()+", coursecoach:"+isParticipant+", in course "+getUserCourseEnv().getCourseEnvironment().getCourseResourceableId());
}
diff --git a/src/main/java/org/olat/course/config/CourseConfigManagerImpl.java b/src/main/java/org/olat/course/config/CourseConfigManagerImpl.java
index 89fec404f5b595545daa9e91c1675b96404cafdf..383883000e5fd3b5334f1e12564d20b4357883e7 100644
--- a/src/main/java/org/olat/course/config/CourseConfigManagerImpl.java
+++ b/src/main/java/org/olat/course/config/CourseConfigManagerImpl.java
@@ -25,10 +25,14 @@
package org.olat.course.config;
+import org.olat.core.logging.OLog;
+import org.olat.core.logging.Tracing;
import org.olat.core.manager.BasicManager;
import org.olat.core.util.vfs.VFSConstants;
import org.olat.core.util.vfs.VFSItem;
import org.olat.core.util.vfs.VFSLeaf;
+import org.olat.core.util.vfs.version.Versionable;
+import org.olat.core.util.vfs.version.VersionsFileManager;
import org.olat.core.util.xml.XStreamHelper;
import org.olat.course.CourseXStreamAliases;
import org.olat.course.ICourse;
@@ -44,6 +48,7 @@ import com.thoughtworks.xstream.XStream;
*/
public class CourseConfigManagerImpl extends BasicManager implements CourseConfigManager {
+ private static final OLog log = Tracing.createLoggerFor(CourseConfigManagerImpl.class);
private static final CourseConfigManagerImpl INSTANCE = new CourseConfigManagerImpl();
@@ -114,6 +119,12 @@ public class CourseConfigManagerImpl extends BasicManager implements CourseConfi
if (configFile == null) {
// create new config file
configFile = course.getCourseBaseContainer().createChildLeaf(COURSECONFIG_XML);
+ } else if(configFile.exists() && configFile instanceof Versionable) {
+ try {
+ VersionsFileManager.getInstance().addToRevisions((Versionable)configFile, null, "");
+ } catch (Exception e) {
+ log.error("Cannot versioned CourseConfig.xml", e);
+ }
}
XStreamHelper.writeObject(configFile, courseConfig);
}
diff --git a/src/main/java/org/olat/course/editor/EditorUserCourseEnvironmentImpl.java b/src/main/java/org/olat/course/editor/EditorUserCourseEnvironmentImpl.java
index fb7e38f1bbeb270b24a0363bb53af51ffc5748af..bfeea21f1d97747c1fe62644e34e88665f295ed8 100644
--- a/src/main/java/org/olat/course/editor/EditorUserCourseEnvironmentImpl.java
+++ b/src/main/java/org/olat/course/editor/EditorUserCourseEnvironmentImpl.java
@@ -25,8 +25,6 @@
package org.olat.course.editor;
-import java.util.Map;
-
import org.olat.core.id.IdentityEnvironment;
import org.olat.core.logging.AssertException;
import org.olat.course.condition.interpreter.ConditionInterpreter;
@@ -90,9 +88,24 @@ public class EditorUserCourseEnvironmentImpl implements UserCourseEnvironment {
return sa;
}
- public Map getTempMap(Class owner, String key) {
- // TODO Auto-generated method stub
- return null;
+ @Override
+ public boolean isIdentityInCourseGroup(Long groupKey) {
+ //TODO OO-502
+ return false;
+ }
+
+ @Override
+ public boolean isAdmin() {
+ return false;
}
+ @Override
+ public boolean isCoach() {
+ return false;
+ }
+
+ @Override
+ public boolean isParticipant() {
+ return false;
+ }
}
diff --git a/src/main/java/org/olat/course/groupsandrights/CourseGroupManager.java b/src/main/java/org/olat/course/groupsandrights/CourseGroupManager.java
index 3251aaf5979068f5e1950be03f7a17877148d406..ac6a05bc51f2906a9d68fc28a49271fc9c069303 100644
--- a/src/main/java/org/olat/course/groupsandrights/CourseGroupManager.java
+++ b/src/main/java/org/olat/course/groupsandrights/CourseGroupManager.java
@@ -63,6 +63,14 @@ public interface CourseGroupManager {
* @return true if user has course right, false otherwise
*/
public boolean hasRight(Identity identity, String courseRight);
+
+ /**
+ * Return the users course rights in any of the available right group context of
+ * this course
+ * @param identity
+ * @return
+ */
+ public List<String> getRights(Identity identity);
/**
* Checks if an identity is in a learning group with the given name in any
diff --git a/src/main/java/org/olat/course/groupsandrights/PersistingCourseGroupManager.java b/src/main/java/org/olat/course/groupsandrights/PersistingCourseGroupManager.java
index 34b19facfa8fef004564390624d66a0b0dc48ccc..16f84d6ccbdff68292417b550fb80d9a0ca8562f 100644
--- a/src/main/java/org/olat/course/groupsandrights/PersistingCourseGroupManager.java
+++ b/src/main/java/org/olat/course/groupsandrights/PersistingCourseGroupManager.java
@@ -120,6 +120,10 @@ public class PersistingCourseGroupManager extends BasicManager implements Course
boolean hasRight = rightManager.hasBGRight(courseRight, identity, courseResource);
return hasRight;
}
+
+ public List<String> getRights(Identity identity) {
+ return securityManager.getIdentityPermissionOnresourceable(identity, courseResource);
+ }
@Override
public boolean isIdentityInGroup(Identity identity, Long groupKey) {
diff --git a/src/main/java/org/olat/course/nodes/SPCourseNode.java b/src/main/java/org/olat/course/nodes/SPCourseNode.java
index 4434a438becd9bf4cf51234ae58694a7d1907638..774ab1b4c5fd02e869fe0a7c68448b38792f859a 100644
--- a/src/main/java/org/olat/course/nodes/SPCourseNode.java
+++ b/src/main/java/org/olat/course/nodes/SPCourseNode.java
@@ -26,7 +26,6 @@
package org.olat.course.nodes;
import java.util.List;
-import java.util.Map;
import org.olat.core.commons.modules.bc.vfs.OlatNamedContainerImpl;
import org.olat.core.commons.modules.bc.vfs.OlatRootFolderImpl;
@@ -96,13 +95,8 @@ public class SPCourseNode extends AbstractAccessableCourseNode {
UserCourseEnvironment userCourseEnv, NodeEvaluation ne, String nodecmd) {
updateModuleConfigDefaults(false);
- String nodeId = ne.getCourseNode().getIdent();
- // obtain a temporary (as long as the users visits the course) map to store
- // intermediate data
- Map tmpstoremap = userCourseEnv.getTempMap(this.getClass(), nodeId);
-
VFSContainer container = userCourseEnv.getCourseEnvironment().getCourseFolderContainer();
- SPRunController runController = new SPRunController(wControl, ureq, tmpstoremap, userCourseEnv, this, container);
+ SPRunController runController = new SPRunController(wControl, ureq, userCourseEnv, this, container);
return new NodeRunConstructionResult(runController);
}
diff --git a/src/main/java/org/olat/course/nodes/sp/SPRunController.java b/src/main/java/org/olat/course/nodes/sp/SPRunController.java
index f17306aca4cc4f2352908eb7e62a17f0ddfb524f..2beb5d45e5b86958491bf8f90383c967f5f261be 100644
--- a/src/main/java/org/olat/course/nodes/sp/SPRunController.java
+++ b/src/main/java/org/olat/course/nodes/sp/SPRunController.java
@@ -83,7 +83,6 @@ public class SPRunController extends BasicController {
private VFSContainer courseFolderContainer;
private String fileName;
- private final Map tempstorage;
private boolean hasEditRights;
private CustomLinkTreeModel linkTreeModel;
@@ -101,9 +100,8 @@ public class SPRunController extends BasicController {
* @param courseNode
* @param courseFolderPath The course folder which contains the single page html file
*/
- public SPRunController(WindowControl wControl, UserRequest ureq, Map tempstorage, UserCourseEnvironment userCourseEnv, SPCourseNode courseNode, VFSContainer courseFolderContainer) {
+ public SPRunController(WindowControl wControl, UserRequest ureq, UserCourseEnvironment userCourseEnv, SPCourseNode courseNode, VFSContainer courseFolderContainer) {
super(ureq,wControl);
- this.tempstorage = tempstorage;
this.courseNode = courseNode;
this.config = courseNode.getModuleConfiguration();
this.userCourseEnv = userCourseEnv;
@@ -153,8 +151,7 @@ public class SPRunController extends BasicController {
// refire to listening controllers
fireEvent(ureq, event);
} else if (event instanceof NewInlineUriEvent) {
- NewInlineUriEvent nue = (NewInlineUriEvent)event;
- tempstorage.put(KEY_CURRENT_URI, nue.getNewUri());
+ //do nothing
}
}
}
diff --git a/src/main/java/org/olat/course/run/RunMainController.java b/src/main/java/org/olat/course/run/RunMainController.java
index e4d879f450320f54f3564d5c3aaa3a8bb29bd5bb..f7b4e8948b0caab532fd6ce26fc7a3543a49e3ad 100644
--- a/src/main/java/org/olat/course/run/RunMainController.java
+++ b/src/main/java/org/olat/course/run/RunMainController.java
@@ -109,7 +109,6 @@ import org.olat.course.run.glossary.CourseGlossaryFactory;
import org.olat.course.run.glossary.CourseGlossaryToolLinkController;
import org.olat.course.run.navigation.NavigationHandler;
import org.olat.course.run.navigation.NodeClickedRef;
-import org.olat.course.run.userview.UserCourseEnvironment;
import org.olat.course.run.userview.UserCourseEnvironmentImpl;
import org.olat.course.statistic.StatisticMainController;
import org.olat.group.BusinessGroup;
@@ -156,7 +155,7 @@ public class RunMainController extends MainLayoutBasicController implements Gene
private StackedController all;
private NavigationHandler navHandler;
- private UserCourseEnvironment uce;
+ private UserCourseEnvironmentImpl uce;
private LayoutMain3ColsController columnLayoutCtr;
private Controller currentToolCtr;
@@ -168,9 +167,6 @@ public class RunMainController extends MainLayoutBasicController implements Gene
private Map<String, Boolean> courseRightsCache = new HashMap<String, Boolean>();
private boolean isCourseAdmin = false;
private boolean isCourseCoach = false;
- private List<BusinessGroup> ownedGroups;
- private List<BusinessGroup> participatedGroups;
- private List<BusinessGroup> waitingListGroups;
private CourseNode currentCourseNode;
private TreeModel treeModel;
@@ -236,20 +232,19 @@ public class RunMainController extends MainLayoutBasicController implements Gene
luTree.setExpandSelectedNode(false);
contentP = new Panel("building_block_content");
- // get all group memberships for this course
- initGroupMemberships(identity);
// Initialize the the users roles and right for this course
// 1) is guest flag
isGuest = ureq.getUserSession().getRoles().isGuestOnly();
- // 2) all course internal rights
- initUserRolesAndRights(identity);
-
// preload user assessment data in assessmnt properties cache to speed up
// course loading
course.getCourseEnvironment().getAssessmentManager().preloadCache(identity);
// build up the running structure for this user;
- uce = new UserCourseEnvironmentImpl(ureq.getUserSession().getIdentityEnvironment(), course.getCourseEnvironment());
+ // get all group memberships for this course
+ uce = loadUserCourseEnvironment(ureq, course);
+ // 2) all course internal rights
+ reloadUserRolesAndRights(identity);
+
// build score now
uce.getScoreAccounting().evaluateAll();
navHandler = new NavigationHandler(uce, false);
@@ -336,6 +331,15 @@ public class RunMainController extends MainLayoutBasicController implements Gene
}
}
+ private UserCourseEnvironmentImpl loadUserCourseEnvironment(UserRequest ureq, ICourse course) {
+ CourseGroupManager cgm = course.getCourseEnvironment().getCourseGroupManager();
+ List<BusinessGroup> coachedGroups = cgm.getOwnedBusinessGroups(ureq.getIdentity());
+ List<BusinessGroup> participatedGroups = cgm.getParticipatingBusinessGroups(ureq.getIdentity());
+ List<BusinessGroup> waitingLists = cgm.getWaitingListGroups(ureq.getIdentity());
+ return new UserCourseEnvironmentImpl(ureq.getUserSession().getIdentityEnvironment(), course.getCourseEnvironment(),
+ coachedGroups, participatedGroups, waitingLists, null, null, null);
+ }
+
private void setLaunchDates(final Identity identity) {
CoordinatorManager.getInstance().getCoordinator().getSyncer().doInSync(createOLATResourceableForLocking(identity), new SyncerExecutor(){
public void execute() {
@@ -365,7 +369,7 @@ public class RunMainController extends MainLayoutBasicController implements Gene
return extendedCourseTitle;
}
- private void initUserRolesAndRights(final Identity identity) {
+ private void reloadUserRolesAndRights(final Identity identity) {
CourseGroupManager cgm = course.getCourseEnvironment().getCourseGroupManager();
// 1) course admins: users who are in repository entry owner group
// if user has the role InstitutionalResourceManager and has the same institution like author
@@ -377,14 +381,16 @@ public class RunMainController extends MainLayoutBasicController implements Gene
isCourseCoach = cgm.isIdentityCourseCoach(identity);
// 3) all other rights are defined in the groupmanagement using the learning
// group rights
+ uce.setUserRoles(isCourseAdmin, isCourseCoach);
- courseRightsCache.put(CourseRights.RIGHT_GROUPMANAGEMENT, new Boolean(cgm.hasRight(identity, CourseRights.RIGHT_GROUPMANAGEMENT)));
- courseRightsCache.put(CourseRights.RIGHT_COURSEEDITOR, new Boolean(cgm.hasRight(identity, CourseRights.RIGHT_COURSEEDITOR)));
- courseRightsCache.put(CourseRights.RIGHT_ARCHIVING, new Boolean(cgm.hasRight(identity, CourseRights.RIGHT_ARCHIVING)));
- courseRightsCache.put(CourseRights.RIGHT_ASSESSMENT, new Boolean(cgm.hasRight(identity, CourseRights.RIGHT_ASSESSMENT)));
- courseRightsCache.put(CourseRights.RIGHT_GLOSSARY, new Boolean(cgm.hasRight(identity, CourseRights.RIGHT_GLOSSARY)));
- courseRightsCache.put(CourseRights.RIGHT_STATISTICS, new Boolean(cgm.hasRight(identity, CourseRights.RIGHT_STATISTICS)));
- courseRightsCache.put(CourseRights.RIGHT_DB, new Boolean(cgm.hasRight(identity, CourseRights.RIGHT_DB)));
+ List<String> rights = cgm.getRights(identity);
+ courseRightsCache.put(CourseRights.RIGHT_GROUPMANAGEMENT, new Boolean(rights.contains(CourseRights.RIGHT_GROUPMANAGEMENT)));
+ courseRightsCache.put(CourseRights.RIGHT_COURSEEDITOR, new Boolean(rights.contains(CourseRights.RIGHT_COURSEEDITOR)));
+ courseRightsCache.put(CourseRights.RIGHT_ARCHIVING, new Boolean(rights.contains(CourseRights.RIGHT_ARCHIVING)));
+ courseRightsCache.put(CourseRights.RIGHT_ASSESSMENT, new Boolean(rights.contains(CourseRights.RIGHT_ASSESSMENT)));
+ courseRightsCache.put(CourseRights.RIGHT_GLOSSARY, new Boolean(rights.contains(CourseRights.RIGHT_GLOSSARY)));
+ courseRightsCache.put(CourseRights.RIGHT_STATISTICS, new Boolean(rights.contains(CourseRights.RIGHT_STATISTICS)));
+ courseRightsCache.put(CourseRights.RIGHT_DB, new Boolean(rights.contains(CourseRights.RIGHT_DB)));
}
/**
@@ -547,7 +553,8 @@ public class RunMainController extends MainLayoutBasicController implements Gene
needsRebuildAfterPublish = false;
// rebuild up the running structure for this user, after publish;
- uce = new UserCourseEnvironmentImpl(ureq.getUserSession().getIdentityEnvironment(), CourseFactory.loadCourse(course.getResourceableId()).getCourseEnvironment());
+ course = CourseFactory.loadCourse(course.getResourceableId());
+ uce = loadUserCourseEnvironment(ureq, course);
// build score now
uce.getScoreAccounting().evaluateAll();
navHandler = new NavigationHandler(uce, false);
@@ -659,7 +666,7 @@ public class RunMainController extends MainLayoutBasicController implements Gene
logAudit("User tried to launch a group but user is not owner or participant "
+ "of group or group doesn't exist. Hacker attack or group has been changed or deleted. group key :: " + groupKey, null);
// refresh toolbox that contained wrong group
- initGroupMemberships(ureq.getIdentity());
+ reloadGroupMemberships(ureq.getIdentity());
removeAsListenerAndDispose(toolC);
toolC = initToolController(ureq.getIdentity(), ureq);
listenTo(toolC);
@@ -934,9 +941,9 @@ public class RunMainController extends MainLayoutBasicController implements Gene
// was adding or removing of the user
if (bgme.wasMyselfAdded(identity) || bgme.wasMyselfRemoved(identity)) {
// 1) reinitialize all group memberships
- initGroupMemberships(identity);
+ reloadGroupMemberships(identity);
// 2) reinitialize the users roles and rights
- initUserRolesAndRights(identity);
+ reloadUserRolesAndRights(identity);
// 3) rebuild toolboxes with link to groups and tools
removeAsListenerAndDispose(toolC);
toolC = initToolController(identity, null);
@@ -948,12 +955,12 @@ public class RunMainController extends MainLayoutBasicController implements Gene
// check if this affects a right group where the user does participate.
// if so, we need
// to rebuild the toolboxes
- if (PersistenceHelper.listContainsObjectByKey(participatedGroups, bgme.getModifiedGroupKey()) ||
- PersistenceHelper.listContainsObjectByKey(ownedGroups, bgme.getModifiedGroupKey())) {
+ if (PersistenceHelper.listContainsObjectByKey(uce.getParticipatingGroups(), bgme.getModifiedGroupKey()) ||
+ PersistenceHelper.listContainsObjectByKey(uce.getCoachedGroups(), bgme.getModifiedGroupKey())) {
// 1) reinitialize all group memberships
- initGroupMemberships(identity);
+ reloadGroupMemberships(identity);
// 2) reinitialize the users roles and rights
- initUserRolesAndRights(identity);
+ reloadUserRolesAndRights(identity);
// 3) rebuild toolboxes with link to groups and tools
removeAsListenerAndDispose(toolC);
toolC = initToolController(identity, null);
@@ -1029,25 +1036,25 @@ public class RunMainController extends MainLayoutBasicController implements Gene
}
// 2) add coached groups
- if (ownedGroups.size() > 0) {
+ if (uce.getCoachedGroups().size() > 0) {
myTool.addHeader(translate("header.tools.ownerGroups"));
- for (BusinessGroup group:ownedGroups) {
+ for (BusinessGroup group:uce.getCoachedGroups()) {
myTool.addLink(CMD_START_GROUP_PREFIX + group.getKey().toString(), group.getName());
}
}
// 3) add participating groups
- if (participatedGroups.size() > 0) {
+ if (uce.getParticipatingGroups().size() > 0) {
myTool.addHeader(translate("header.tools.participatedGroups"));
- for (BusinessGroup group: participatedGroups) {
+ for (BusinessGroup group: uce.getParticipatingGroups()) {
myTool.addLink(CMD_START_GROUP_PREFIX + group.getKey().toString(), group.getName());
}
}
// 5) add waiting-list groups
- if (waitingListGroups.size() > 0) {
+ if (uce.getWaitingLists().size() > 0) {
myTool.addHeader(translate("header.tools.waitingListGroups"));
- for (BusinessGroup group:waitingListGroups) {
+ for (BusinessGroup group:uce.getWaitingLists()) {
int pos = businessGroupService.getPositionInWaitingListFor(identity, group);
myTool.addLink(CMD_START_GROUP_PREFIX + group.getKey().toString(), group.getName() + "(" + pos + ")", group
.getKey().toString(), null);
@@ -1154,11 +1161,12 @@ public class RunMainController extends MainLayoutBasicController implements Gene
*
* @param identity
*/
- private void initGroupMemberships(Identity identity) {
+ private void reloadGroupMemberships(Identity identity) {
CourseGroupManager cgm = course.getCourseEnvironment().getCourseGroupManager();
- ownedGroups = cgm.getOwnedBusinessGroups(identity);
- participatedGroups = cgm.getParticipatingBusinessGroups(identity);
- waitingListGroups = cgm.getWaitingListGroups(identity);
+ List<BusinessGroup> coachedGroups = cgm.getOwnedBusinessGroups(identity);
+ List<BusinessGroup> participatedGroups = cgm.getParticipatingBusinessGroups(identity);
+ List<BusinessGroup> waitingLists = cgm.getWaitingListGroups(identity);
+ uce.setGroupMemberships(coachedGroups, participatedGroups, waitingLists);
}
/**
diff --git a/src/main/java/org/olat/course/run/preview/PreviewCourseGroupManager.java b/src/main/java/org/olat/course/run/preview/PreviewCourseGroupManager.java
index 0f4d51428e4d67e6a04c3aa1a00cbc6295bfed0b..028e3d8d6cb3e9d34dd9eb7fb82fa1cc556d0b2d 100644
--- a/src/main/java/org/olat/course/run/preview/PreviewCourseGroupManager.java
+++ b/src/main/java/org/olat/course/run/preview/PreviewCourseGroupManager.java
@@ -26,6 +26,7 @@
package org.olat.course.run.preview;
import java.io.File;
+import java.util.ArrayList;
import java.util.List;
import org.olat.core.id.Identity;
@@ -80,7 +81,12 @@ final class PreviewCourseGroupManager extends BasicManager implements CourseGrou
}
throw new AssertException("unsupported");
}
-
+
+ @Override
+ public List<String> getRights(Identity identity) {
+ return new ArrayList<String>(1);
+ }
+
@Override
public boolean isIdentityInGroup(Identity identity, Long groupKey) {
for(BusinessGroup group:groups) {
diff --git a/src/main/java/org/olat/course/run/userview/NodeEvaluation.java b/src/main/java/org/olat/course/run/userview/NodeEvaluation.java
index 76835b753942e5ae9788503e41a2405b01b5c574..def2ee9967b6b0a18983ed21337b7cebea40718d 100644
--- a/src/main/java/org/olat/course/run/userview/NodeEvaluation.java
+++ b/src/main/java/org/olat/course/run/userview/NodeEvaluation.java
@@ -53,7 +53,7 @@ public class NodeEvaluation extends GenericNode {
private CourseNode courseNode;
private GenericTreeNode gtn = null;
- private Map accesses = new HashMap(4);
+ private Map<String, Boolean> accesses = new HashMap<String, Boolean>(4);
private boolean visible = false;
private boolean atLeastOneAccessible = false;
@@ -105,8 +105,8 @@ public class NodeEvaluation extends GenericNode {
*/
public void build() {
// if at least one access capability is true
- for (Iterator iter = accesses.values().iterator(); iter.hasNext();) {
- Boolean entry = (Boolean) iter.next();
+ for (Iterator<Boolean> iter = accesses.values().iterator(); iter.hasNext();) {
+ Boolean entry = iter.next();
atLeastOneAccessible = atLeastOneAccessible || entry.booleanValue();
}
diff --git a/src/main/java/org/olat/course/run/userview/UserCourseEnvironment.java b/src/main/java/org/olat/course/run/userview/UserCourseEnvironment.java
index 1f79b83bcce10607b6380e19d1888125682f23e6..0e39622998ff1e45dfcf94933e6aa710e0210240 100644
--- a/src/main/java/org/olat/course/run/userview/UserCourseEnvironment.java
+++ b/src/main/java/org/olat/course/run/userview/UserCourseEnvironment.java
@@ -25,8 +25,6 @@
package org.olat.course.run.userview;
-import java.util.Map;
-
import org.olat.core.id.IdentityEnvironment;
import org.olat.course.condition.interpreter.ConditionInterpreter;
import org.olat.course.editor.CourseEditorEnv;
@@ -54,16 +52,13 @@ public interface UserCourseEnvironment {
public ScoreAccounting getScoreAccounting();
- /**
- * @return a temporary map (lives as long as the user is visiting the course)
- * @param owner the owning class
- * @param key the key
- *
- * owner's classname and the key form a composite unique key / namespace
- */
- public Map getTempMap(Class owner, String key);
-
+
+ public boolean isAdmin();
- //TODO: add a method like isCourseAdmin() to be offered in a conditioninterpreter function
+ public boolean isCoach();
+
+ public boolean isParticipant();
+ public boolean isIdentityInCourseGroup(Long groupKey);
+
}
\ No newline at end of file
diff --git a/src/main/java/org/olat/course/run/userview/UserCourseEnvironmentImpl.java b/src/main/java/org/olat/course/run/userview/UserCourseEnvironmentImpl.java
index 87843f4d1adeaa8c81c7bb05d023933357d8d985..340cc3878ccae8d0c0f92af991839c8b9f4faa6b 100644
--- a/src/main/java/org/olat/course/run/userview/UserCourseEnvironmentImpl.java
+++ b/src/main/java/org/olat/course/run/userview/UserCourseEnvironmentImpl.java
@@ -25,14 +25,16 @@
package org.olat.course.run.userview;
-import java.util.HashMap;
-import java.util.Map;
+import java.util.List;
+import org.olat.core.commons.persistence.PersistenceHelper;
import org.olat.core.id.IdentityEnvironment;
import org.olat.course.condition.interpreter.ConditionInterpreter;
import org.olat.course.editor.CourseEditorEnv;
+import org.olat.course.groupsandrights.CourseGroupManager;
import org.olat.course.run.environment.CourseEnvironment;
import org.olat.course.run.scoring.ScoreAccounting;
+import org.olat.group.BusinessGroup;
/**
* Initial Date: Feb 6, 2004
@@ -44,48 +46,130 @@ public class UserCourseEnvironmentImpl implements UserCourseEnvironment {
private CourseEnvironment courseEnvironment;
private ConditionInterpreter conditionInterpreter;
private ScoreAccounting scoreAccounting;
- private Map allTempMaps = new HashMap(4);
+
+ private List<BusinessGroup> coachedGroups;
+ private List<BusinessGroup> participatingGroups;
+ private List<BusinessGroup> waitingLists;
+
+ private Boolean coach;
+ private Boolean admin;
+ private Boolean participant;
public UserCourseEnvironmentImpl(IdentityEnvironment identityEnvironment, CourseEnvironment courseEnvironment) {
+ this(identityEnvironment, courseEnvironment, null, null, null, null, null, null);
+ }
+
+ public UserCourseEnvironmentImpl(IdentityEnvironment identityEnvironment, CourseEnvironment courseEnvironment,
+ List<BusinessGroup> coachedGroups, List<BusinessGroup> participatingGroups, List<BusinessGroup> waitingLists,
+ Boolean coach, Boolean admin, Boolean participant) {
this.courseEnvironment = courseEnvironment;
this.identityEnvironment = identityEnvironment;
this.scoreAccounting = new ScoreAccounting(this);
this.conditionInterpreter = new ConditionInterpreter(this);
+ this.coachedGroups = coachedGroups;
+ this.participatingGroups = participatingGroups;
+ this.waitingLists = waitingLists;
+ this.coach = coach;
+ this.admin = admin;
+ this.participant = participant;
}
/**
* @return Returns the courseEnvironment.
*/
+ @Override
public CourseEnvironment getCourseEnvironment() {
return courseEnvironment;
}
-
+
+ @Override
public IdentityEnvironment getIdentityEnvironment() {
return identityEnvironment;
}
+ @Override
public ConditionInterpreter getConditionInterpreter() {
return conditionInterpreter;
}
+ @Override
public ScoreAccounting getScoreAccounting() {
return scoreAccounting;
}
+ @Override
public CourseEditorEnv getCourseEditorEnv() {
// return null signalling this is real user environment
return null;
}
+
+ @Override
+ public boolean isIdentityInCourseGroup(Long groupKey) {
+ if(coachedGroups != null && participatingGroups != null) {
+ return PersistenceHelper.listContainsObjectByKey(participatingGroups, groupKey)
+ || PersistenceHelper.listContainsObjectByKey(coachedGroups, groupKey);
+ }
+ CourseGroupManager cgm = courseEnvironment.getCourseGroupManager();
+ return cgm.isIdentityInGroup(identityEnvironment.getIdentity(), groupKey);
+ }
+
+ @Override
+ public boolean isCoach() {
+ if(coach != null) {
+ return coach.booleanValue();
+ }
+ //lazy loading
+ CourseGroupManager cgm = courseEnvironment.getCourseGroupManager();
+ boolean coachLazy = cgm.isIdentityCourseCoach(identityEnvironment.getIdentity());
+ coach = new Boolean(coachLazy);
+ return coachLazy;
+ }
- public Map getTempMap(Class owner, String key) {
- // thread safe since only called by the gui dispatch thread of one user
- String compKey = owner.getName()+":"+key;
- Map m = (Map) allTempMaps.get(compKey);
- if (m == null) {
- m = new HashMap(4);
- allTempMaps.put(compKey, m);
+ @Override
+ public boolean isAdmin() {
+ if(admin != null) {
+ return admin.booleanValue();
}
- return m;
+ //lazy loading
+ CourseGroupManager cgm = courseEnvironment.getCourseGroupManager();
+ boolean admiLazy = cgm.isIdentityCourseAdministrator(identityEnvironment.getIdentity());
+ admin = new Boolean(admiLazy);
+ return admiLazy;
}
+ @Override
+ public boolean isParticipant() {
+ if(participant != null) {
+ return participant.booleanValue();
+ }
+ //lazy loading
+ CourseGroupManager cgm = courseEnvironment.getCourseGroupManager();
+ boolean partLazy = cgm.isIdentityCourseParticipant(identityEnvironment.getIdentity());
+ participant = new Boolean(partLazy);
+ return partLazy;
+ }
+
+ public List<BusinessGroup> getCoachedGroups() {
+ return coachedGroups;
+ }
+
+ public List<BusinessGroup> getParticipatingGroups() {
+ return participatingGroups;
+ }
+
+ public List<BusinessGroup> getWaitingLists() {
+ return waitingLists;
+ }
+
+ public void setGroupMemberships(List<BusinessGroup> coachedGroups, List<BusinessGroup> participatingGroups, List<BusinessGroup> waitingLists) {
+ this.coachedGroups = coachedGroups;
+ this.participatingGroups = participatingGroups;
+ this.waitingLists = waitingLists;
+ }
+
+ public void setUserRoles(boolean admin, boolean coach) {
+ this.admin = new Boolean(admin);
+ this.coach = new Boolean(coach);
+ this.participant = null;//reset it
+ }
}
diff --git a/src/main/java/org/olat/group/ui/main/AbstractBusinessGroupListController.java b/src/main/java/org/olat/group/ui/main/AbstractBusinessGroupListController.java
index ff6a582ed294b144303fb2839f0bc3b82adfff49..22f5a9043ff361b9821d234869f0f02c7064b832 100644
--- a/src/main/java/org/olat/group/ui/main/AbstractBusinessGroupListController.java
+++ b/src/main/java/org/olat/group/ui/main/AbstractBusinessGroupListController.java
@@ -201,6 +201,12 @@ public abstract class AbstractBusinessGroupListController extends BasicControlle
return admin;
}
+ protected boolean isEmpty() {
+ return groupListCtr == null ? true :
+ (groupListCtr.getTableDataModel() == null ? true :
+ groupListCtr.getTableDataModel().getRowCount() == 0);
+ }
+
@Override
protected void doDispose() {
//
diff --git a/src/main/java/org/olat/group/ui/main/OverviewBusinessGroupListController.java b/src/main/java/org/olat/group/ui/main/OverviewBusinessGroupListController.java
index 44a956cda85b438e610bd97aa11428f853be6fa9..bae424fc2738520d54f4a3515d1f4a5f51b47c01 100644
--- a/src/main/java/org/olat/group/ui/main/OverviewBusinessGroupListController.java
+++ b/src/main/java/org/olat/group/ui/main/OverviewBusinessGroupListController.java
@@ -65,8 +65,8 @@ public class OverviewBusinessGroupListController extends BasicController impleme
mainVC = createVelocityContainer("group_list_overview");
- boolean marked = updateMarkedGroups(ureq).updateMarkedGroups();
- if(!marked) {
+ boolean markedEmpty = updateMarkedGroups(ureq).isEmpty();
+ if(markedEmpty) {
updateAllGroups(ureq);
}
@@ -74,10 +74,10 @@ public class OverviewBusinessGroupListController extends BasicController impleme
segmentView = SegmentViewFactory.createSegmentView("segments", mainVC, this);
markedGroupsLink = LinkFactory.createLink("marked.groups", mainVC, this);
markedGroupsLink.setElementCssClass("o_sel_group_bookmarked_groups_seg");
- segmentView.addSegment(markedGroupsLink, marked);
+ segmentView.addSegment(markedGroupsLink, !markedEmpty);
allGroupsLink = LinkFactory.createLink("opengroups.all", mainVC, this);
allGroupsLink.setElementCssClass("o_sel_group_all_groups_seg");
- segmentView.addSegment(allGroupsLink, !marked);
+ segmentView.addSegment(allGroupsLink, markedEmpty);
ownedGroupsLink = LinkFactory.createLink("owned.groups", mainVC, this);
ownedGroupsLink.setElementCssClass("o_sel_group_owned_groups_seg");
segmentView.addSegment(ownedGroupsLink, false);
diff --git a/src/main/java/org/olat/repository/RepositoryManager.java b/src/main/java/org/olat/repository/RepositoryManager.java
index 47e57856b056351760826a5b87b4f23ee500d232..175946a3358cebbb6be29e45e0327c8aa76b0afd 100644
--- a/src/main/java/org/olat/repository/RepositoryManager.java
+++ b/src/main/java/org/olat/repository/RepositoryManager.java
@@ -600,6 +600,10 @@ public class RepositoryManager extends BasicManager {
* @throws AssertException if the softkey could not be found (strict=true)
*/
public RepositoryEntry lookupRepositoryEntryBySoftkey(String softkey, boolean strict) {
+ if(softkey == null || "sf.notconfigured".equals(softkey)) {
+ return null;
+ }
+
StringBuilder sb = new StringBuilder();
sb.append("select v from ").append(RepositoryEntry.class.getName()).append(" v")
.append(" inner join fetch v.olatResource as ores ")
diff --git a/src/main/java/org/olat/repository/controllers/RepositoryDetailsController.java b/src/main/java/org/olat/repository/controllers/RepositoryDetailsController.java
index 56f42b2a3f96ac8f16801bda295b5753221dca83..1f6868e018d9105e9603f7244c0a0e58a08f1d31 100644
--- a/src/main/java/org/olat/repository/controllers/RepositoryDetailsController.java
+++ b/src/main/java/org/olat/repository/controllers/RepositoryDetailsController.java
@@ -582,9 +582,9 @@ public class RepositoryDetailsController extends BasicController implements Gene
doCloseDetailView(ureq);
return;
} else if (sourceLink == downloadButton){
- doDownload(ureq, false);
+ doDownload(ureq, repositoryEntry, false);
} else if (sourceLink == launchButton){
- doLaunch(ureq);
+ doLaunch(ureq, repositoryEntry);
} else if (sourceLink == loginLink){
DispatcherAction.redirectToDefaultDispatcher(ureq.getHttpResp());
} else if (sourceLink.getUserObject() instanceof IdentityShort) {
@@ -617,7 +617,7 @@ public class RepositoryDetailsController extends BasicController implements Gene
private void doCloseDetailView(UserRequest ureq) {
// REVIEW:pb:note:handles jumps from Catalog and Course
if (jumpfromcourse && repositoryEntry.getCanLaunch()) {
- doLaunch(ureq);
+ doLaunch(ureq, repositoryEntry);
} else {
fireEvent(ureq, Event.DONE_EVENT);
}
@@ -654,28 +654,28 @@ public class RepositoryDetailsController extends BasicController implements Gene
*
* @param ureq
*/
- boolean doLaunch(UserRequest ureq) {
- RepositoryHandler typeToLaunch = RepositoryHandlerFactory.getInstance().getRepositoryHandler(repositoryEntry);
+ boolean doLaunch(UserRequest ureq, RepositoryEntry re) {
+ RepositoryHandler typeToLaunch = RepositoryHandlerFactory.getInstance().getRepositoryHandler(re);
if (typeToLaunch == null){
StringBuilder sb = new StringBuilder(translate("error.launch"));
sb.append(": No launcher for repository entry: ");
- sb.append(repositoryEntry.getKey());
+ sb.append(re.getKey());
throw new OLATRuntimeException(RepositoryDetailsController.class,sb.toString(), null);
}
- if (RepositoryManager.getInstance().lookupRepositoryEntry(repositoryEntry.getKey()) == null) {
+ if (RepositoryManager.getInstance().lookupRepositoryEntry(re.getKey()) == null) {
showInfo("info.entry.deleted");
return false;
}
try {
- String businessPath = "[RepositoryEntry:" + repositoryEntry.getKey() + "]";
+ String businessPath = "[RepositoryEntry:" + re.getKey() + "]";
boolean ok = NewControllerFactory.getInstance().launch(businessPath, ureq, getWindowControl());
if(ok) {
fireEvent(ureq, LAUNCHED_EVENT);
}
return ok;
} catch (CorruptedCourseException e) {
- logError("Corrupted course: " + repositoryEntry, e);
+ logError("Corrupted course: " + re, e);
return false;
}
}
@@ -721,16 +721,16 @@ public class RepositoryDetailsController extends BasicController implements Gene
*
* @param ureq
*/
- void doDownload(UserRequest ureq, boolean backwardsCompatible) {
- RepositoryHandler typeToDownload = RepositoryHandlerFactory.getInstance().getRepositoryHandler(repositoryEntry);
+ void doDownload(UserRequest ureq, RepositoryEntry re, boolean backwardsCompatible) {
+ RepositoryHandler typeToDownload = RepositoryHandlerFactory.getInstance().getRepositoryHandler(re);
if (typeToDownload == null){
StringBuilder sb = new StringBuilder(translate("error.download"));
sb.append(": No download handler for repository entry: ");
- sb.append(repositoryEntry.getKey());
+ sb.append(re.getKey());
throw new OLATRuntimeException(RepositoryDetailsController.class, sb.toString(), null);
}
- OLATResource ores = OLATResourceManager.getInstance().findResourceable(repositoryEntry.getOlatResource());
+ OLATResource ores = OLATResourceManager.getInstance().findResourceable(re.getOlatResource());
if (ores == null) {
showError("error.download");
return;
@@ -741,7 +741,7 @@ public class RepositoryDetailsController extends BasicController implements Gene
if(lockResult==null || (lockResult!=null && lockResult.isSuccess() && !isAlreadyLocked)) {
MediaResource mr = typeToDownload.getAsMediaResource(ores, backwardsCompatible);
if(mr!=null) {
- RepositoryManager.getInstance().incrementDownloadCounter(repositoryEntry);
+ RepositoryManager.getInstance().incrementDownloadCounter(re);
ureq.getDispatchResult().setResultingMediaResource(mr);
} else {
showError("error.export");
@@ -866,12 +866,12 @@ public class RepositoryDetailsController extends BasicController implements Gene
//
} else if (source == detailsToolC) {
if (cmd.equals(ACTION_DOWNLOAD)) { // download
- doDownload(ureq, false);
+ doDownload(ureq, repositoryEntry, false);
return;
} else if (cmd.equals(ACTION_DOWNLOAD_BACKWARD_COMPAT)) {
- doDownload(ureq, true);
+ doDownload(ureq, repositoryEntry, true);
} else if (cmd.equals(ACTION_LAUNCH)) { // launch resource
- doLaunch(ureq);
+ doLaunch(ureq, repositoryEntry);
return;
} else if (cmd.equals(ACTION_EDIT)) { // start editor
doEdit(ureq);
diff --git a/src/main/java/org/olat/repository/controllers/RepositoryMainController.java b/src/main/java/org/olat/repository/controllers/RepositoryMainController.java
index 658283d6c4b8a401f711875bdb4e24bba7bd271a..243e44d3a6a8d4cd52279a8ca5f6ca058c18cb43 100644
--- a/src/main/java/org/olat/repository/controllers/RepositoryMainController.java
+++ b/src/main/java/org/olat/repository/controllers/RepositoryMainController.java
@@ -70,6 +70,7 @@ import org.olat.fileresource.types.PodcastFileResource;
import org.olat.fileresource.types.ScormCPFileResource;
import org.olat.fileresource.types.SharedFolderFileResource;
import org.olat.fileresource.types.WikiResource;
+import org.olat.group.BusinessGroupService;
import org.olat.ims.qti.fileresource.SurveyFileResource;
import org.olat.ims.qti.fileresource.TestFileResource;
import org.olat.portfolio.EPTemplateMapResource;
@@ -146,6 +147,7 @@ public class RepositoryMainController extends MainLayoutBasicController implemen
private RepositoryAddChooseStepsController chooseStepsController;
private Controller creationWizardController;
private final PortfolioModule portfolioModule;
+ private final BusinessGroupService businessGroupService;
/**
* The check for author rights is executed on construction time and then
@@ -160,6 +162,7 @@ public class RepositoryMainController extends MainLayoutBasicController implemen
if (log.isDebug()) {
log.debug("Constructing ReposityMainController for user::" + ureq.getIdentity());
}
+ businessGroupService = CoreSpringFactory.getImpl(BusinessGroupService.class);
portfolioModule = (PortfolioModule) CoreSpringFactory.getBean("portfolioModule");
// use i18n from RepositoryManager level
@@ -540,8 +543,9 @@ public class RepositoryMainController extends MainLayoutBasicController implemen
if (event.equals(Event.CHANGED_EVENT)) {
getWindowControl().pop();
removeAsListenerAndDispose(creationWizardController);
- detailsController.setEntry(chooseStepsController.getCourseRepositoryEntry(), urequest, false);
- detailsController.doLaunch(urequest);
+ RepositoryEntry re = chooseStepsController.getCourseRepositoryEntry();
+ detailsController.setEntry(re, urequest, false);
+ detailsController.doLaunch(urequest, re);
} else if (event.equals(Event.CANCELLED_EVENT)) {
// delete entry when the wizard was cancelled
detailsController.deleteRepositoryEntry(urequest, getWindowControl(), (RepositoryEntry) chooseStepsController.getCourseRepositoryEntry());
@@ -603,17 +607,19 @@ public class RepositoryMainController extends MainLayoutBasicController implemen
if (event.getCommand().equals(RepositoryTableModel.TABLE_ACTION_SELECT_ENTRY)) {
// entry has been selected to be launched in the
// searchController
- ToolController toolC = detailsController.setEntry(selectedEntry, urequest, false);
+
if (selectedEntry.getCanLaunch()) {
- if(!detailsController.doLaunch(urequest)) {
+ if(!detailsController.doLaunch(urequest, selectedEntry)) {
//cannot launch -> open details
+ ToolController toolC = detailsController.setEntry(selectedEntry, urequest, false);
Component toolComp = (toolC == null ? null : toolC.getInitialComponent());
columnsLayoutCtr.setCol2(toolComp);
mainPanel.setContent(detailsController.getInitialComponent());
}
} else if (selectedEntry.getCanDownload()) {
- detailsController.doDownload(urequest, false);
+ detailsController.doDownload(urequest, selectedEntry, false);
} else { // offer details view
+ ToolController toolC = detailsController.setEntry(selectedEntry, urequest, false);
Component toolComp = (toolC == null ? null : toolC.getInitialComponent());
columnsLayoutCtr.setCol2(toolComp);
mainPanel.setContent(detailsController.getInitialComponent());
@@ -629,25 +635,19 @@ public class RepositoryMainController extends MainLayoutBasicController implemen
}
} else if (source == detailsController) { // back from details
//fxdiff FXOLAT-128: back/resume function
- if (event.equals(Event.DONE_EVENT) || event.equals(RepositoryDetailsController.LAUNCHED_EVENT)) {
+ if (event.equals(Event.DONE_EVENT)) {
if (backtocatalog) {
backtocatalog = false;
ToolController toolC = catalogCntrllrOld.createCatalogToolController();
Component toolComp = (toolC == null ? null : toolC.getInitialComponent());
columnsLayoutCtr.setCol2(toolComp);
mainPanel.setContent(catalogCntrllrOld.getInitialComponent());
- //fxdiff BAKS-7 Resume function
- if(!event.equals(RepositoryDetailsController.LAUNCHED_EVENT)) {
- catalogCntrllrOld.updateHistory(urequest);
- }
+ catalogCntrllrOld.updateHistory(urequest);
} else {
Component toolComp = (mainToolC == null ? null : mainToolC.getInitialComponent());
columnsLayoutCtr.setCol2(toolComp);
mainPanel.setContent(main);
- //fxdiff BAKS-7 Resume function
- if(!event.equals(RepositoryDetailsController.LAUNCHED_EVENT)) {
- addToHistory(urequest, searchWindowControl);
- }
+ addToHistory(urequest, searchWindowControl);
}
} else if (event instanceof EntryChangedEvent) {
Component toolComp = (mainToolC == null ? null : mainToolC.getInitialComponent());
diff --git a/src/test/java/org/olat/basesecurity/BaseSecurityManagerTest.java b/src/test/java/org/olat/basesecurity/BaseSecurityManagerTest.java
index 5fd8a64d088fc25ab3ceed921550db2d7e8c9bfb..6d878821719751b6f1bfb2f4778cee9fc8689ab0 100644
--- a/src/test/java/org/olat/basesecurity/BaseSecurityManagerTest.java
+++ b/src/test/java/org/olat/basesecurity/BaseSecurityManagerTest.java
@@ -760,4 +760,75 @@ public class BaseSecurityManagerTest extends OlatTestCase {
Assert.assertTrue(policies_3.contains(policy_3_3));
Assert.assertFalse(policies_3.contains(policy_1_3));
}
+
+ @Test
+ public void isIdentityPermittedOnResourceable_checkType() {
+ //create an identity, a security group, a resource and give the identity some
+ //permissions on the resource
+ SecurityGroup secGroup = securityManager.createAndPersistSecurityGroup();
+ OLATResource resource = JunitTestHelper.createRandomResource();
+ Identity id = JunitTestHelper.createAndPersistIdentityAsUser("test-ipor-1-" + UUID.randomUUID().toString());
+ securityManager.addIdentityToSecurityGroup(id, secGroup);
+ securityManager.createAndPersistPolicy(secGroup, "test.ipor-1_1", resource);
+ securityManager.createAndPersistPolicy(secGroup, "test.ipor-1_2", resource);
+ dbInstance.commitAndCloseSession();
+
+ //check
+ boolean hasIpor_1_1 = securityManager.isIdentityPermittedOnResourceable(id, "test.ipor-1_1", resource);
+ Assert.assertTrue(hasIpor_1_1);
+ boolean hasIpor_1_2 = securityManager.isIdentityPermittedOnResourceable(id, "test.ipor-1_2", resource);
+ Assert.assertTrue(hasIpor_1_2);
+ boolean hasIpor_1_3 = securityManager.isIdentityPermittedOnResourceable(id, "test.ipor-1_3", resource);
+ Assert.assertFalse(hasIpor_1_3);
+
+ //check type
+ boolean hasIpor_1_1_ct = securityManager.isIdentityPermittedOnResourceable(id, "test.ipor-1_1", resource, true);
+ Assert.assertTrue(hasIpor_1_1_ct);
+ boolean hasIpor_1_2_ct = securityManager.isIdentityPermittedOnResourceable(id, "test.ipor-1_2", resource, true);
+ Assert.assertTrue(hasIpor_1_2_ct);
+ boolean hasIpor_1_3_ct = securityManager.isIdentityPermittedOnResourceable(id, "test.ipor-1_3", resource, true);
+ Assert.assertFalse(hasIpor_1_3_ct);
+ }
+
+ @Test
+ public void isIdentityPermittedOnResourceable_noCheckType() {
+ //create an identity, a security group, a resource and give the identity some
+ //permissions on the resource
+ SecurityGroup secGroup = securityManager.createAndPersistSecurityGroup();
+ OLATResource resource = JunitTestHelper.createRandomResource();
+ Identity id = JunitTestHelper.createAndPersistIdentityAsUser("test-ipornc-1-" + UUID.randomUUID().toString());
+ securityManager.addIdentityToSecurityGroup(id, secGroup);
+ securityManager.createAndPersistPolicy(secGroup, "test.ipornc-1_1", resource);
+ securityManager.createAndPersistPolicy(secGroup, "test.ipornc-1_2", resource);
+ dbInstance.commitAndCloseSession();
+
+ //check
+ boolean hasIpor_1_1 = securityManager.isIdentityPermittedOnResourceable(id, "test.ipornc-1_1", resource, false);
+ Assert.assertTrue(hasIpor_1_1);
+ boolean hasIpor_1_2 = securityManager.isIdentityPermittedOnResourceable(id, "test.ipornc-1_2", resource, false);
+ Assert.assertTrue(hasIpor_1_2);
+ boolean hasIpor_1_3 = securityManager.isIdentityPermittedOnResourceable(id, "test.ipornc-1_3", resource, false);
+ Assert.assertFalse(hasIpor_1_3);
+ }
+
+ @Test
+ public void getIdentityPermissionsOnResourceable() {
+ //create an identity, a security group, a resource and give the identity some
+ //permissions on the resource
+ SecurityGroup secGroup = securityManager.createAndPersistSecurityGroup();
+ OLATResource resource = JunitTestHelper.createRandomResource();
+ Identity id = JunitTestHelper.createAndPersistIdentityAsUser("test-gpor-1-" + UUID.randomUUID().toString());
+ securityManager.addIdentityToSecurityGroup(id, secGroup);
+ securityManager.createAndPersistPolicy(secGroup, "test.gpor-1_1", resource);
+ securityManager.createAndPersistPolicy(secGroup, "test.gpor-1_2", resource);
+ dbInstance.commitAndCloseSession();
+
+ //check
+ List<String> permissions = securityManager.getIdentityPermissionOnresourceable(id, resource);
+ Assert.assertNotNull(permissions);
+ Assert.assertTrue(permissions.size() >= 2);
+ Assert.assertTrue(permissions.contains("test.gpor-1_1"));
+ Assert.assertTrue(permissions.contains("test.gpor-1_2"));
+ Assert.assertFalse(permissions.contains("test.gpor-1_3"));
+ }
}
diff --git a/src/test/java/org/olat/basesecurity/BaseSecurityTest.java b/src/test/java/org/olat/basesecurity/BaseSecurityTest.java
index a40b8aee7b765e0138d7199eb4f5321703fba50e..7ee5f0a4faa0206584b8367869e4018e9a62d323 100644
--- a/src/test/java/org/olat/basesecurity/BaseSecurityTest.java
+++ b/src/test/java/org/olat/basesecurity/BaseSecurityTest.java
@@ -27,29 +27,26 @@
package org.olat.basesecurity;
import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
-import java.util.Iterator;
import java.util.List;
import java.util.Map;
-import org.hibernate.PropertyValueException;
+import junit.framework.Assert;
+
import org.junit.After;
import org.junit.Test;
import org.olat.core.commons.persistence.DBFactory;
import org.olat.core.id.Identity;
-import org.olat.core.id.OLATResourceable;
import org.olat.core.id.Roles;
import org.olat.core.id.User;
import org.olat.core.id.UserConstants;
-import org.olat.core.logging.DBRuntimeException;
+import org.olat.core.logging.OLog;
+import org.olat.core.logging.Tracing;
import org.olat.core.util.Encoder;
-import org.olat.core.util.resource.OresHelper;
import org.olat.test.JunitTestHelper;
import org.olat.test.OlatTestCase;
import org.olat.user.UserManager;
@@ -62,16 +59,20 @@ import org.springframework.beans.factory.annotation.Autowired;
*/
public class BaseSecurityTest extends OlatTestCase {
+ private static final OLog log = Tracing.createLoggerFor(BaseSecurityTest.class);
+
@Autowired
private BaseSecurity baseSecurityManager;
- @Test public void testGetIdentitiesByPowerSearch() {
+ @Test
+ public void testGetIdentitiesByPowerSearch() {
System.out.println("start testGetIdentitiesByPowerSearch");
try {
Identity ident = getOrCreateIdentity("anIdentity");
Identity ident2 = getOrCreateTestIdentity("extremegroovy");
+ Assert.assertNotNull(ident2);
Identity deletedIdent = getOrCreateTestIdentity("delete");
deletedIdent = baseSecurityManager.saveIdentityStatus(deletedIdent, Identity.STATUS_DELETED);
@@ -202,11 +203,9 @@ public class BaseSecurityTest extends OlatTestCase {
// basic query to find all system users without restrictions
List<Identity> results = baseSecurityManager.getIdentitiesByPowerSearch(null, null, true, null, null, null, null, null, null, null, null);
assertTrue(results.size()>0);
- int numberOfAllUsers = results.size();
results = baseSecurityManager.getIdentitiesByPowerSearch(null, null, true, null, null, null, null, null, null, null, Identity.STATUS_DELETED);
assertTrue(results.size() >0);
- int numberOfDeletedUsers = results.size();
results = baseSecurityManager.getIdentitiesByPowerSearch(null, null, true, groups1, null, null, null, null, null, null, null);
assertTrue(results.size() >0);
@@ -240,7 +239,7 @@ public class BaseSecurityTest extends OlatTestCase {
// policy search test
DBFactory.getInstance().closeSession();
- List policies = baseSecurityManager.getPoliciesOfSecurityGroup(admins);
+ List<Policy> policies = baseSecurityManager.getPoliciesOfSecurityGroup(admins);
PermissionOnResourceable[] adminPermissions = convertPoliciesListToPermissionOnResourceArray(policies);
policies = baseSecurityManager.getPoliciesOfSecurityGroup(anonymous);
PermissionOnResourceable[] anonymousPermissions = convertPoliciesListToPermissionOnResourceArray(policies);
@@ -484,22 +483,22 @@ public class BaseSecurityTest extends OlatTestCase {
User onePropUser = UserManager.getInstance().createUser("onepropuser", "onepropuser", "onepropuser@lustig.com");
onePropUser.setProperty(UserConstants.FIRSTNAME, "one");
Identity onePropeIdentity = baseSecurityManager.createAndPersistIdentityAndUser("onePropUser", onePropUser, BaseSecurityModule.getDefaultAuthProviderIdentifier(), "onepropuser", Encoder.encrypt("ppp"));
+ Assert.assertNotNull(onePropeIdentity);
User twoPropUser = UserManager.getInstance().createUser("twopropuser", "twopropuser", "twopropuser@lustig.com");
twoPropUser.setProperty(UserConstants.FIRSTNAME, "two");
twoPropUser.setProperty(UserConstants.LASTNAME, "prop");
-
Identity twoPropeIdentity = baseSecurityManager.createAndPersistIdentityAndUser("twopropuser", twoPropUser, BaseSecurityModule.getDefaultAuthProviderIdentifier(), "twopropuser", Encoder.encrypt("ppp"));
+ Assert.assertNotNull(twoPropeIdentity);
// commit
DBFactory.getInstance().closeSession();
HashMap<String, String> userProperties;
- List results;
-
+
// find first
userProperties = new HashMap<String, String>();
userProperties.put(UserConstants.FIRSTNAME, "one");
- results = baseSecurityManager.getIdentitiesByPowerSearch(null, userProperties, true, null, null, null, null, null, null, null, null);
+ List<Identity> results = baseSecurityManager.getIdentitiesByPowerSearch(null, userProperties, true, null, null, null, null, null, null, null, null);
assertTrue(results.size() == 1);
// no intersection - all properties optional
@@ -577,16 +576,16 @@ public class BaseSecurityTest extends OlatTestCase {
multiPropUser.setProperty(UserConstants.INSTITUTIONALUSERIDENTIFIER, "multiinst");
multiPropUser.setProperty(UserConstants.CITY, "züri");
Identity onePropeIdentity = baseSecurityManager.createAndPersistIdentityAndUser("multiPropUser", multiPropUser, BaseSecurityModule.getDefaultAuthProviderIdentifier(), "multipropuser", Encoder.encrypt("ppp"));
-
+ Assert.assertNotNull(onePropeIdentity);
+
// commit
DBFactory.getInstance().closeSession();
HashMap<String, String> userProperties;
- List results;
-
+
userProperties = new HashMap<String, String>();
userProperties.put(UserConstants.FIRSTNAME, "multi");
- results = baseSecurityManager.getIdentitiesByPowerSearch(null, userProperties, true, null, null, null, null, null, null, null, null);
+ List<Identity> results = baseSecurityManager.getIdentitiesByPowerSearch(null, userProperties, true, null, null, null, null, null, null, null, null);
sysoutResults(results);
assertTrue(results.size() == 1);
@@ -758,10 +757,10 @@ public class BaseSecurityTest extends OlatTestCase {
}
}
- private PermissionOnResourceable[] convertPoliciesListToPermissionOnResourceArray(List policies) {
+ private PermissionOnResourceable[] convertPoliciesListToPermissionOnResourceArray(List<Policy> policies) {
PermissionOnResourceable[] array = new PermissionOnResourceable[policies.size()];
for (int i = 0; i < policies.size() ; i++) {
- Policy policy = (Policy) policies.get(i);
+ Policy policy = policies.get(i);
PermissionOnResourceable por = new PermissionOnResourceable(policy.getPermission(), policy.getOlatResource());
array[i] = por;
}
@@ -772,28 +771,25 @@ public class BaseSecurityTest extends OlatTestCase {
/*
* Only for debugging to see identities result list.
*/
- private void sysoutResults(List results) {
- System.out.println("TEST results.size()=" + results.size());
- for (Iterator iterator = results.iterator(); iterator.hasNext();) {
- Identity identity = (Identity) iterator.next();
- System.out.println("TEST ident=" + identity);
+ private void sysoutResults(List<Identity> results) {
+ log.info("TEST results.size()=" + results.size());
+ for (Identity identity:results) {
+ log.debug("TEST ident=" + identity);
}
}
// check Helper Methoden
////////////////////////
- private void checkIdentitiesHasPermissions(List results, PermissionOnResourceable[] adminPermissions) {
- for (Iterator iterator = results.iterator(); iterator.hasNext();) {
- Identity resultIdentity = (Identity) iterator.next();
+ private void checkIdentitiesHasPermissions(List<Identity> results, PermissionOnResourceable[] adminPermissions) {
+ for (Identity resultIdentity: results) {
for (int i = 0; i < adminPermissions.length; i++) {
assertTrue( baseSecurityManager.isIdentityPermittedOnResourceable(resultIdentity, adminPermissions[i].getPermission(), adminPermissions[i].getOlatResourceable() ) );
}
}
}
- private void checkIdentitiesHasAuthProvider(List results, String[] authProviders) {
- for (Iterator iterator = results.iterator(); iterator.hasNext();) {
- Identity resultIdentity = (Identity) iterator.next();
+ private void checkIdentitiesHasAuthProvider(List<Identity> results, String[] authProviders) {
+ for (Identity resultIdentity : results) {
boolean foundIdentityWithAuth = false;
for (int i = 0; i < authProviders.length; i++) {
Authentication authentication = baseSecurityManager.findAuthentication(resultIdentity, authProviders[i]);
@@ -805,9 +801,8 @@ public class BaseSecurityTest extends OlatTestCase {
}
}
- private void checkIdentitiesAreInGroups(List results, SecurityGroup[] groups1) {
- for (Iterator iterator = results.iterator(); iterator.hasNext();) {
- Identity resultIdentity = (Identity) iterator.next();
+ private void checkIdentitiesAreInGroups(List<Identity> results, SecurityGroup[] groups1) {
+ for (Identity resultIdentity:results) {
boolean foundIdentityInSecGroup = false;
for (int i = 0; i < groups1.length; i++) {
if (baseSecurityManager.isIdentityInSecurityGroup(resultIdentity, groups1[i]) ) {
@@ -819,14 +814,11 @@ public class BaseSecurityTest extends OlatTestCase {
}
private void checkIdentitiesHasRoles(List<Identity> results, boolean checkIsAuthor) {
- for (Iterator iterator = results.iterator(); iterator.hasNext();) {
- Identity resultIdentity = (Identity) iterator.next();
+ for (Identity resultIdentity: results) {
Roles roles = baseSecurityManager.getRoles(resultIdentity);
if (checkIsAuthor) {
assertTrue("Identity has not roles author, identity=" + resultIdentity, roles.isAuthor());
}
}
}
-
-
}
\ No newline at end of file
diff --git a/src/test/java/org/olat/core/util/vfs/version/VersionManagerTest.java b/src/test/java/org/olat/core/util/vfs/version/VersionManagerTest.java
index af8b716334b1afd23aa8b617b03e88886f05c849..c5b474c79a2fb39425854e979a4a67d9e130ddbe 100644
--- a/src/test/java/org/olat/core/util/vfs/version/VersionManagerTest.java
+++ b/src/test/java/org/olat/core/util/vfs/version/VersionManagerTest.java
@@ -35,6 +35,7 @@ import java.util.UUID;
import junit.framework.Assert;
import org.apache.commons.io.IOUtils;
+import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.olat.core.CoreSpringFactory;
@@ -67,6 +68,8 @@ public class VersionManagerTest extends OlatTestCase {
@Autowired
private VersionsFileManager versionManager;
+ @Autowired
+ private SimpleVersionConfig versioningConfigurator;
@Before
public void setUp() throws Exception {
@@ -82,6 +85,12 @@ public class VersionManagerTest extends OlatTestCase {
setuped = true;
}
+ @After
+ public void resetMaxVersions() {
+ versioningConfigurator.setMaxNumberOfVersionsProperty(new Long(10));
+ versioningConfigurator.getMaxNumberOfVersionsProperty();
+ }
+
@Test
public void testVersionManager() throws IOException {
//create a file
@@ -136,6 +145,72 @@ public class VersionManagerTest extends OlatTestCase {
assertEquals("Version 3", versions.getComment());
}
+ @Test
+ public void testOverflow_lowLevel() throws IOException {
+ versioningConfigurator.setMaxNumberOfVersionsProperty(new Long(3));
+
+ //create a file
+ OlatRootFolderImpl rootTest = new OlatRootFolderImpl("/test_" + UUID.randomUUID(), null);
+ String filename = getRandomName();
+ VFSLeaf file = rootTest.createChildLeaf(filename);
+ OutputStream out = file.getOutputStream(false);
+ InputStream in = VersionManagerTest.class.getResourceAsStream("test.txt");
+ int byteCopied = IOUtils.copy(in, out);
+ IOUtils.closeQuietly(in);
+ assertFalse(byteCopied == 0);
+ assertTrue(file instanceof Versionable);
+
+ //save a first version
+ for(int i=0; i<5; i++) {
+ Versionable versionedFile = (Versionable)file;
+ InputStream inv = new ByteArrayInputStream(("Hello version " + i).getBytes());
+ versionedFile.getVersions().addVersion(id2, "Version " + (1 +i), inv);
+ IOUtils.closeQuietly(inv);
+ }
+
+ VFSItem retrievedFile = rootTest.resolve(filename);
+ Versions versions = VersionsFileManager.getInstance().createVersionsFor((VFSLeaf)retrievedFile);
+ List<VFSRevision> revisions = versions.getRevisions();
+ assertNotNull(revisions);
+ assertEquals(3, revisions.size());
+ assertEquals("3", revisions.get(0).getRevisionNr());
+ assertEquals("4", revisions.get(1).getRevisionNr());
+ assertEquals("5", revisions.get(2).getRevisionNr());
+
+ assertEquals("Version 5", versions.getComment());
+ assertEquals(id2.getName(), revisions.get(2).getAuthor());
+ }
+
+ @Test
+ public void testOverflow_lowLevel_deactivated() throws IOException {
+ versioningConfigurator.setMaxNumberOfVersionsProperty(new Long(0));
+
+ //create a file
+ OlatRootFolderImpl rootTest = new OlatRootFolderImpl("/test_" + UUID.randomUUID(), null);
+ String filename = getRandomName();
+ VFSLeaf file = rootTest.createChildLeaf(filename);
+ OutputStream out = file.getOutputStream(false);
+ InputStream in = VersionManagerTest.class.getResourceAsStream("test.txt");
+ int byteCopied = IOUtils.copy(in, out);
+ IOUtils.closeQuietly(in);
+ assertFalse(byteCopied == 0);
+ assertTrue(file instanceof Versionable);
+
+ //save a first version
+ for(int i=0; i<5; i++) {
+ Versionable versionedFile = (Versionable)file;
+ InputStream inv = new ByteArrayInputStream(("Hello version " + i).getBytes());
+ versionedFile.getVersions().addVersion(id2, "Version " + (1 +i), inv);
+ IOUtils.closeQuietly(inv);
+ }
+
+ VFSItem retrievedFile = rootTest.resolve(filename);
+ Versions versions = VersionsFileManager.getInstance().createVersionsFor((VFSLeaf)retrievedFile);
+ List<VFSRevision> revisions = versions.getRevisions();
+ assertNotNull(revisions);
+ assertTrue(revisions.isEmpty());
+ }
+
@Test
public void testVersionChecksum() throws IOException {
OlatRootFolderImpl rootTest = new OlatRootFolderImpl("/ver-" + UUID.randomUUID(), null);