diff --git a/src/main/java/org/olat/course/CourseFactory.java b/src/main/java/org/olat/course/CourseFactory.java
index fa7a5685a5167744124c7253b1d811d62f6f85f6..dc69b0e7cd660b1ad07a1e4406d73ad96123847e 100644
--- a/src/main/java/org/olat/course/CourseFactory.java
+++ b/src/main/java/org/olat/course/CourseFactory.java
@@ -109,7 +109,6 @@ import org.olat.course.editor.PublishSetInformations;
 import org.olat.course.editor.StatusDescription;
 import org.olat.course.groupsandrights.CourseGroupManager;
 import org.olat.course.groupsandrights.PersistingCourseGroupManager;
-import org.olat.course.nodes.AssessableCourseNode;
 import org.olat.course.nodes.BCCourseNode;
 import org.olat.course.nodes.CourseNode;
 import org.olat.course.nodes.STCourseNode;
@@ -684,7 +683,7 @@ public class CourseFactory {
 	public static void archiveCourse(Identity archiveOnBehalfOf, ICourse course, String charset, Locale locale, File exportDirectory, boolean isAdministrator, boolean... oresRights) {
 		// archive course results overview
 		List<Identity> users = ScoreAccountingHelper.loadUsers(course.getCourseEnvironment());
-		List<AssessableCourseNode> nodes = ScoreAccountingHelper.loadAssessableNodes(course.getCourseEnvironment());
+		List<CourseNode> nodes = ScoreAccountingHelper.loadAssessableNodes(course.getCourseEnvironment());
 		
 		String fileName = ExportUtil.createFileNameWithTimeStamp(course.getCourseTitle(), "zip");
 		try(OutputStream out = new FileOutputStream(new File(exportDirectory, fileName));
@@ -807,6 +806,7 @@ public class CourseFactory {
 		if(theCourse!=null) {
 			//o_clusterOK by: ld (although the course is locked for editing, we still have to insure that load course is synchronized)
 			CoordinatorManager.getInstance().getCoordinator().getSyncer().doInSync(theCourse, new SyncerExecutor(){
+				@Override
 				public void execute() {
 					final PersistingCourseImpl course = getCourseEditSession(resourceableId);
 					if(course!=null && course.isReadAndWrite()) {
@@ -918,6 +918,7 @@ public class CourseFactory {
 		if(theCourse!=null) {
 			//o_clusterOK by: ld (although the course is locked for editing, we still have to insure that load course is synchronized)
 			CoordinatorManager.getInstance().getCoordinator().getSyncer().doInSync(theCourse, new SyncerExecutor(){
+				@Override
 				public void execute() {
 					PersistingCourseImpl course = getCourseEditSession(resourceableId);
 					if(course!=null) {
@@ -1050,6 +1051,7 @@ public class CourseFactory {
 		 *
 		 * @see org.olat.core.util.tree.Visitor#visit(org.olat.core.util.nodes.INode)
 		 */
+		@Override
 		public void visit(INode node) {
 			CourseNode cNode = (CourseNode) node;
 			cNode.cleanupOnDelete(course);
diff --git a/src/main/java/org/olat/course/CourseXStreamAliases.java b/src/main/java/org/olat/course/CourseXStreamAliases.java
index 1d5fc03d61c25676a73aa9913ebf8dff2030a966..719199bffd6182204a5b77930e3704a1f4544335 100644
--- a/src/main/java/org/olat/course/CourseXStreamAliases.java
+++ b/src/main/java/org/olat/course/CourseXStreamAliases.java
@@ -37,7 +37,6 @@ import org.olat.course.condition.operators.LowerThanEqualsOperator;
 import org.olat.course.condition.operators.LowerThanOperator;
 import org.olat.course.config.CourseConfig;
 import org.olat.course.nodes.AdobeConnectCourseNode;
-import org.olat.course.nodes.AssessableCourseNode;
 import org.olat.course.nodes.BCCourseNode;
 import org.olat.course.nodes.BasicLTICourseNode;
 import org.olat.course.nodes.BlogCourseNode;
@@ -109,7 +108,7 @@ public class CourseXStreamAliases {
 		readXstream.alias("CourseEditorTreeModel", CourseEditorTreeModel.class);
 		readXstream.alias("CourseEditorTreeNode", CourseEditorTreeNode.class);
 		readXstream.alias("Structure", Structure.class);
-		readXstream.alias("AssessableCourseNode", AssessableCourseNode.class);
+		readXstream.alias("AssessableCourseNode", CourseNode.class);
 		readXstream.alias("BasicLTICourseNode", BasicLTICourseNode.class);
 		readXstream.alias("BCCourseNode", BCCourseNode.class);
 		readXstream.alias("BlogCourseNode", BlogCourseNode.class);
diff --git a/src/main/java/org/olat/course/archiver/ScoreAccountingArchiveController.java b/src/main/java/org/olat/course/archiver/ScoreAccountingArchiveController.java
index 5e4d368f7ef60b0ea140429b2c42f783ef3d72a3..33340f51d1f80c36d9435cae688c02507baa14f3 100644
--- a/src/main/java/org/olat/course/archiver/ScoreAccountingArchiveController.java
+++ b/src/main/java/org/olat/course/archiver/ScoreAccountingArchiveController.java
@@ -48,7 +48,7 @@ import org.olat.core.id.OLATResourceable;
 import org.olat.core.util.ExportUtil;
 import org.olat.course.CourseFactory;
 import org.olat.course.ICourse;
-import org.olat.course.nodes.AssessableCourseNode;
+import org.olat.course.nodes.CourseNode;
 
 /**
  * Description: Course-Results-Archiver using ScoreAccountingHelper.class
@@ -97,7 +97,7 @@ public class ScoreAccountingArchiveController extends BasicController {
 	private void doStartExport() {
 		ICourse course = CourseFactory.loadCourse(ores);
 		List<Identity> users = ScoreAccountingHelper.loadUsers(course.getCourseEnvironment());
-		List<AssessableCourseNode> nodes = ScoreAccountingHelper.loadAssessableNodes(course.getCourseEnvironment());
+		List<CourseNode> nodes = ScoreAccountingHelper.loadAssessableNodes(course.getCourseEnvironment());
 		
 		String courseTitle = course.getCourseTitle();
 		String fileName = ExportUtil.createFileNameWithTimeStamp(courseTitle, "zip");
diff --git a/src/main/java/org/olat/course/archiver/ScoreAccountingHelper.java b/src/main/java/org/olat/course/archiver/ScoreAccountingHelper.java
index 3f73b45ebbf34df060e1c49bd812aba0ad9e4d94..81325742936cf014dfc4306d536615e5728f0ce9 100644
--- a/src/main/java/org/olat/course/archiver/ScoreAccountingHelper.java
+++ b/src/main/java/org/olat/course/archiver/ScoreAccountingHelper.java
@@ -66,7 +66,6 @@ import org.olat.course.assessment.handler.AssessmentConfig;
 import org.olat.course.assessment.manager.UserCourseInformationsManager;
 import org.olat.course.groupsandrights.CourseGroupManager;
 import org.olat.course.nodes.ArchiveOptions;
-import org.olat.course.nodes.AssessableCourseNode;
 import org.olat.course.nodes.CourseNode;
 import org.olat.course.nodes.IQTESTCourseNode;
 import org.olat.course.nodes.MSCourseNode;
@@ -92,7 +91,7 @@ public class ScoreAccountingHelper {
 	
 	private static final Logger log = Tracing.createLoggerFor(ScoreAccountingHelper.class);
 	
-	public static void createCourseResultsOverview(List<Identity> identities, List<AssessableCourseNode> nodes, ICourse course, Locale locale, ZipOutputStream zout) {
+	public static void createCourseResultsOverview(List<Identity> identities, List<CourseNode> nodes, ICourse course, Locale locale, ZipOutputStream zout) {
 		try(OutputStream out = new ShieldOutputStream(zout)) {
 			zout.putNextEntry(new ZipEntry("Course_results.xlsx"));
 			createCourseResultsOverviewXMLTable(identities, nodes, course, locale, out);
@@ -101,7 +100,7 @@ public class ScoreAccountingHelper {
 			log.error("", e);
 		}
 
-		for(AssessableCourseNode node:nodes) {
+		for(CourseNode node:nodes) {
 			String dir = "Assessment_documents/" + StringHelper.transformDisplayNameToFileSystemName(node.getShortName());
 			if(node instanceof IQTESTCourseNode
 					|| node.getModuleConfiguration().getBooleanSafe(MSCourseNode.CONFIG_KEY_HAS_INDIVIDUAL_ASSESSMENT_DOCS, false)) {
@@ -134,7 +133,7 @@ public class ScoreAccountingHelper {
 	 * @param locale The locale.
 	 * @param bos The output stream (which will be closed at the end, if you use a zip stream don't forget to shield it).
 	 */
-	public static void createCourseResultsOverviewXMLTable(List<Identity> identities, List<AssessableCourseNode> myNodes, ICourse course, Locale locale, OutputStream bos) {
+	public static void createCourseResultsOverviewXMLTable(List<Identity> identities, List<CourseNode> myNodes, ICourse course, Locale locale, OutputStream bos) {
 		CourseAssessmentService courseAssessmentService = CoreSpringFactory.getImpl(CourseAssessmentService.class);
 		OpenXMLWorkbook workbook = new OpenXMLWorkbook(bos, 1);
 		OpenXMLWorksheet sheet = workbook.nextWorksheet();
@@ -174,7 +173,7 @@ public class ScoreAccountingHelper {
 		}
 		
 		int header1ColCnt = headerColCnt;
-		for(AssessableCourseNode acNode:myNodes) {
+		for(CourseNode acNode:myNodes) {
 			headerRow1.addCell(header1ColCnt++, acNode.getShortTitle());
 			header1ColCnt += acNode.getType().equals("ita") ? 1 : 0;
 			
@@ -196,7 +195,7 @@ public class ScoreAccountingHelper {
 
 		int header2ColCnt = headerColCnt;
 		Row headerRow2 = sheet.newRow();
-		for(AssessableCourseNode acNode:myNodes) {
+		for(CourseNode acNode:myNodes) {
 			if (acNode.getType().equals("ita")) {
 				headerRow2.addCell(header2ColCnt++, submitted);
 			}
@@ -263,7 +262,7 @@ public class ScoreAccountingHelper {
 			scoreAccount.evaluateAll();
 			AssessmentManager am = course.getCourseEnvironment().getAssessmentManager();
 
-			for (AssessableCourseNode acnode:myNodes) {
+			for (CourseNode acnode:myNodes) {
 				AssessmentConfig assessmentConfig = courseAssessmentService.getAssessmentConfig(acnode);
 				boolean scoreOk = assessmentConfig.hasScore();
 				boolean passedOk = assessmentConfig.hasPassed();
@@ -353,7 +352,7 @@ public class ScoreAccountingHelper {
 
 		//min. max. informations
 		boolean first = true;
-		for (AssessableCourseNode acnode:myNodes) {
+		for (CourseNode acnode:myNodes) {
 			AssessmentConfig assessmentConfig = courseAssessmentService.getAssessmentConfig(acnode);
 			if (!assessmentConfig.hasScore()) {
 				// only show min/max/cut legend when score configured
@@ -458,9 +457,9 @@ public class ScoreAccountingHelper {
 	 * @param courseEnv
 	 * @return The list of assessable nodes from this course
 	 */
-	public static List<AssessableCourseNode> loadAssessableNodes(CourseEnvironment courseEnv) {
+	public static List<CourseNode> loadAssessableNodes(CourseEnvironment courseEnv) {
 		CourseNode rootNode = courseEnv.getRunStructure().getRootNode();
-		List<AssessableCourseNode> nodeList = new ArrayList<>();
+		List<CourseNode> nodeList = new ArrayList<>();
 		collectAssessableCourseNodes(rootNode, nodeList);
 		return nodeList;
 	}
@@ -471,9 +470,10 @@ public class ScoreAccountingHelper {
 	 * @param node
 	 * @param nodeList
 	 */
-	private static void collectAssessableCourseNodes(CourseNode node, List<AssessableCourseNode> nodeList) {
-		if (node instanceof AssessableCourseNode) {
-			nodeList.add((AssessableCourseNode)node);
+	private static void collectAssessableCourseNodes(CourseNode node, List<CourseNode> nodeList) {
+		CourseAssessmentService courseAssessmentService = CoreSpringFactory.getImpl(CourseAssessmentService.class);
+		if (courseAssessmentService.getAssessmentConfig(node).isAssessable()) {
+			nodeList.add(node);
 		}
 		int count = node.getChildCount();
 		for (int i = 0; i < count; i++) {
diff --git a/src/main/java/org/olat/course/assessment/AssessmentHelper.java b/src/main/java/org/olat/course/assessment/AssessmentHelper.java
index 2dbc5f8b4f87c748141cf19643e5ec4d778c6206..a4ce0ed874297c14c239f9cc8f10a3a2a917d375 100644
--- a/src/main/java/org/olat/course/assessment/AssessmentHelper.java
+++ b/src/main/java/org/olat/course/assessment/AssessmentHelper.java
@@ -51,7 +51,6 @@ import org.olat.course.ICourse;
 import org.olat.course.assessment.handler.AssessmentConfig;
 import org.olat.course.assessment.model.AssessmentNodeData;
 import org.olat.course.assessment.model.AssessmentNodesLastModified;
-import org.olat.course.nodes.AssessableCourseNode;
 import org.olat.course.nodes.CourseNode;
 import org.olat.course.nodes.CourseNodeConfiguration;
 import org.olat.course.nodes.CourseNodeFactory;
@@ -159,25 +158,20 @@ public class AssessmentHelper {
 	 * @return
 	 */
 	public static boolean checkIfNodeIsAssessable(CourseNode node) {
-		//TODO uh refactoring
-		if (node instanceof AssessableCourseNode) {
-			if (node instanceof STCourseNode) {
-				CourseAssessmentService courseAssessmentService = CoreSpringFactory.getImpl(CourseAssessmentService.class);
-				AssessmentConfig assessmentConfig = courseAssessmentService.getAssessmentConfig(node);
-				if (assessmentConfig.hasPassed() || assessmentConfig.hasScore()) {
-					return true;
-				}
-			} else if (node instanceof ScormCourseNode) {
-				CourseAssessmentService courseAssessmentService = CoreSpringFactory.getImpl(CourseAssessmentService.class);
-				AssessmentConfig assessmentConfig = courseAssessmentService.getAssessmentConfig(node);
-				if (assessmentConfig.hasPassed() || assessmentConfig.hasScore()) {
-					return true;
-				}
-			} else if (node instanceof ProjectBrokerCourseNode) {
-				return false;//no assessment-tool in V1.0 return always false
-			} else {
+		CourseAssessmentService courseAssessmentService = CoreSpringFactory.getImpl(CourseAssessmentService.class);
+		AssessmentConfig assessmentConfig = courseAssessmentService.getAssessmentConfig(node);
+		if (node instanceof STCourseNode) {
+			if (assessmentConfig.hasPassed() || assessmentConfig.hasScore()) {
+				return true;
+			}
+		} else if (node instanceof ScormCourseNode) {
+			if (assessmentConfig.hasPassed() || assessmentConfig.hasScore()) {
 				return true;
 			}
+		} else if (node instanceof ProjectBrokerCourseNode) {
+			return false;//no assessment-tool in V1.0 return always false
+		} else if (assessmentConfig.isAssessable()) {
+			return true;
 		}
 		return false;
 	}
@@ -334,20 +328,14 @@ public class AssessmentHelper {
 	}
 	
 	private static boolean isAssessable(CourseNode courseNode) {
-		boolean assessable = false;
-		if (courseNode instanceof AssessableCourseNode && !(courseNode instanceof ProjectBrokerCourseNode)) {
-			CourseAssessmentService courseAssessmentService = CoreSpringFactory.getImpl(CourseAssessmentService.class);
-			AssessmentConfig assessmentConfig = courseAssessmentService.getAssessmentConfig(courseNode);
-			if (assessmentConfig.hasEditableDetails()
+		CourseAssessmentService courseAssessmentService = CoreSpringFactory.getImpl(CourseAssessmentService.class);
+		AssessmentConfig assessmentConfig = courseAssessmentService.getAssessmentConfig(courseNode);
+		return assessmentConfig.isAssessable() &&
+				(  assessmentConfig.hasEditableDetails()
 				|| assessmentConfig.hasAttempts()
 				|| assessmentConfig.hasScore()
 				|| assessmentConfig.hasPassed()
-				|| assessmentConfig.hasComment()) {
-
-				assessable = true;
-			}
-		}
-		return assessable;
+				|| assessmentConfig.hasComment());
 	}
 	
 
@@ -426,15 +414,14 @@ public class AssessmentHelper {
 		// - it is of an assessable course node type
 		boolean hasDisplayableValuesConfigured = false;
 		boolean hasDisplayableUserValues = false;
-		if (numOfChildren > 0 || courseNode instanceof AssessableCourseNode) {
+		CourseAssessmentService courseAssessmentService = CoreSpringFactory.getImpl(CourseAssessmentService.class);
+		AssessmentConfig assessmentConfig = courseAssessmentService.getAssessmentConfig(courseNode);
+		if (numOfChildren > 0 || assessmentConfig.isAssessable()) {
 			if(courseNode instanceof ProjectBrokerCourseNode) {
 				//ProjectBroker : no assessment-tool in V1.0 , remove project broker completely form assessment-tool gui
 				assessmentNodeData.setSelectable(false);
-			} else if (courseNode instanceof AssessableCourseNode) {
-				AssessableCourseNode assessableCourseNode = (AssessableCourseNode) courseNode;
-				CourseAssessmentService courseAssessmentService = CoreSpringFactory.getImpl(CourseAssessmentService.class);
-				AssessmentConfig assessmentConfig = courseAssessmentService.getAssessmentConfig(courseNode);
-				AssessmentEvaluation scoreEvaluation = scoreAccounting.evalCourseNode(assessableCourseNode);
+			} else if (assessmentConfig.isAssessable()) {
+				AssessmentEvaluation scoreEvaluation = scoreAccounting.evalCourseNode(courseNode);
 				assessmentNodeData.setAssessmentStatus(scoreEvaluation.getAssessmentStatus());
 				assessmentNodeData.setNumOfAssessmentDocs(scoreEvaluation.getNumOfAssessmentDocs());
 				assessmentNodeData.setUserVisibility(scoreEvaluation.getUserVisible());
@@ -469,7 +456,7 @@ public class AssessmentHelper {
 							assessmentNodeData.setScore(score);
 							hasDisplayableUserValues = true;
 						}
-						if(!(assessableCourseNode instanceof STCourseNode)) {
+						if(!(courseNode instanceof STCourseNode)) {
 							assessmentNodeData.setMaxScore(assessmentConfig.getMaxScore());
 							assessmentNodeData.setMinScore(assessmentConfig.getMinScore());
 						}
@@ -498,7 +485,7 @@ public class AssessmentHelper {
 				  // comments are invisible in the table but if configured the node must be in the list
 					// for the efficiency statement this can be ignored, this is the case when discardComments is true
 					hasDisplayableValuesConfigured = true;
-					if (courseAssessmentService.getUserComment(assessableCourseNode, userCourseEnv) != null) {
+					if (courseAssessmentService.getUserComment(courseNode, userCourseEnv) != null) {
 						hasDisplayableUserValues = true;
 					}
 				}
diff --git a/src/main/java/org/olat/course/assessment/bulk/BulkAssessmentOverviewController.java b/src/main/java/org/olat/course/assessment/bulk/BulkAssessmentOverviewController.java
index e95073297a1bda1a6ec1ba2e88c12c666643e637..a559ac93a17be03193243e9a61ef7a5114cbb67f 100644
--- a/src/main/java/org/olat/course/assessment/bulk/BulkAssessmentOverviewController.java
+++ b/src/main/java/org/olat/course/assessment/bulk/BulkAssessmentOverviewController.java
@@ -60,7 +60,6 @@ import org.olat.course.assessment.bulk.TaskDataModel.Cols;
 import org.olat.course.assessment.manager.BulkAssessmentTask;
 import org.olat.course.assessment.model.BulkAssessmentDatas;
 import org.olat.course.assessment.model.BulkAssessmentFeedback;
-import org.olat.course.nodes.AssessableCourseNode;
 import org.olat.course.nodes.CourseNode;
 import org.olat.repository.RepositoryEntry;
 import org.olat.user.UserManager;
@@ -138,7 +137,7 @@ public class BulkAssessmentOverviewController extends FormBasicController {
 				fullName = userManager.getUserDisplayName(task.getCreator());
 			}
 			BulkAssessmentTask runnable = taskManager.getPersistedRunnableTask(task, BulkAssessmentTask.class);
-			AssessableCourseNode courseNode = (AssessableCourseNode)structure.getNode(runnable.getCourseNodeIdent());
+			CourseNode courseNode = structure.getNode(runnable.getCourseNodeIdent());
 			taskDatas.add(new TaskData(task, runnable, courseNode, fullName));
 		}
 		taskModel.setObjects(taskDatas);
@@ -247,9 +246,9 @@ public class BulkAssessmentOverviewController extends FormBasicController {
 	private void doNewBulkAssessment(UserRequest ureq) {
 		removeAsListenerAndDispose(bulkAssessmentCtrl);
 		
-		List<AssessableCourseNode> nodes = new ArrayList<>();
+		List<CourseNode> nodes = new ArrayList<>();
 		ICourse course = CourseFactory.loadCourse(courseEntry);
-		collectBulkAssessableCourseNode(course.getRunStructure().getRootNode(), nodes);
+		collectBulkCourseNode(course.getRunStructure().getRootNode(), nodes);
 
 		Step start;
 		if(nodes.size() > 1) {
@@ -265,7 +264,7 @@ public class BulkAssessmentOverviewController extends FormBasicController {
 			@Override
 			public Step execute(UserRequest uureq, WindowControl wControl, StepsRunContext runContext) {
 				Date scheduledDate = (Date)runContext.get("scheduledDate");
-				AssessableCourseNode courseNode = (AssessableCourseNode)runContext.get("courseNode");
+				CourseNode courseNode = (CourseNode)runContext.get("courseNode");
 				BulkAssessmentDatas datas = (BulkAssessmentDatas)runContext.get("datas");
 				Feedback feedback = doBulkAssessment(courseNode, scheduledDate, datas);
 				runContext.put("feedback", feedback);
@@ -285,7 +284,7 @@ public class BulkAssessmentOverviewController extends FormBasicController {
 			taskManager.returnTaskAfterEdition(editedTask, null);
 		}
 
-		AssessableCourseNode courseNode = data.getCourseNode();
+		CourseNode courseNode = data.getCourseNode();
 		final Task editableTask = taskManager.pickTaskForEdition(data.getTask());
 		editedTask = editableTask;
 		if(editableTask == null) {
@@ -300,7 +299,7 @@ public class BulkAssessmentOverviewController extends FormBasicController {
 				public Step execute(UserRequest uureq, WindowControl wControl, StepsRunContext runContext) {
 					Task task = (Task)runContext.get("task");
 					Date scheduledDate = (Date)runContext.get("scheduledDate");
-					AssessableCourseNode assessableCourseNode = (AssessableCourseNode)runContext.get("courseNode");
+					CourseNode assessableCourseNode = (CourseNode)runContext.get("courseNode");
 					BulkAssessmentDatas bulkDatas = (BulkAssessmentDatas)runContext.get("datas");
 					Feedback feedback = doUpdateBulkAssessment(task, assessableCourseNode, scheduledDate, bulkDatas);
 					runContext.put("feedback", feedback);
@@ -325,17 +324,17 @@ public class BulkAssessmentOverviewController extends FormBasicController {
 		}
 	}
 	
-	private void collectBulkAssessableCourseNode(CourseNode courseNode, List<AssessableCourseNode> nodes) {
+	private void collectBulkCourseNode(CourseNode courseNode, List<CourseNode> nodes) {
 		for (int i=courseNode.getChildCount(); i-->0; ) {
-			collectBulkAssessableCourseNode((CourseNode)courseNode.getChildAt(i), nodes);
+			collectBulkCourseNode((CourseNode)courseNode.getChildAt(i), nodes);
 		}
 		
 		if(BulkAssessmentTask.isBulkAssessable(courseNode)) {
-			nodes.add((AssessableCourseNode)courseNode);
+			nodes.add(courseNode);
 		}
 	}
 	
-	private Feedback doUpdateBulkAssessment(Task task, AssessableCourseNode node, Date scheduledDate, BulkAssessmentDatas datas) {
+	private Feedback doUpdateBulkAssessment(Task task, CourseNode node, Date scheduledDate, BulkAssessmentDatas datas) {
 		BulkAssessmentTask runnable = new BulkAssessmentTask(courseEntry.getOlatResource(), node, datas, getIdentity().getKey());
 		Feedback feedback;
 		if(scheduledDate == null) {
@@ -351,7 +350,7 @@ public class BulkAssessmentOverviewController extends FormBasicController {
 		return feedback;
 	}
 	
-	private Feedback doBulkAssessment(AssessableCourseNode node, Date scheduledDate, BulkAssessmentDatas datas) {
+	private Feedback doBulkAssessment(CourseNode node, Date scheduledDate, BulkAssessmentDatas datas) {
 		BulkAssessmentTask task = new BulkAssessmentTask(courseEntry.getOlatResource(), node, datas, getIdentity().getKey());
 		Feedback feedback;
 		if(scheduledDate == null) {
diff --git a/src/main/java/org/olat/course/assessment/bulk/BulkAssessmentToolController.java b/src/main/java/org/olat/course/assessment/bulk/BulkAssessmentToolController.java
index e4f5957210cb79eb465ad444051b2af81e924c2a..faf24d983a640604b7f784f5e12343e94ceb794a 100644
--- a/src/main/java/org/olat/course/assessment/bulk/BulkAssessmentToolController.java
+++ b/src/main/java/org/olat/course/assessment/bulk/BulkAssessmentToolController.java
@@ -40,7 +40,7 @@ import org.olat.core.gui.control.generic.wizard.StepsMainRunController;
 import org.olat.course.assessment.manager.BulkAssessmentTask;
 import org.olat.course.assessment.model.BulkAssessmentDatas;
 import org.olat.course.assessment.model.BulkAssessmentFeedback;
-import org.olat.course.nodes.AssessableCourseNode;
+import org.olat.course.nodes.CourseNode;
 import org.olat.course.run.environment.CourseEnvironment;
 import org.olat.resource.OLATResource;
 
@@ -52,14 +52,14 @@ import org.olat.resource.OLATResource;
 public class BulkAssessmentToolController extends BasicController {
 	
 	private final Link startButton;
-	private final AssessableCourseNode courseNode;
+	private final CourseNode courseNode;
 
 	private DialogBoxController errorCtrl;
 	private StepsMainRunController bulkAssessmentCtrl;
 	private final TaskExecutorManager taskManager;
 	private final OLATResource courseOres;
 	
-	public BulkAssessmentToolController(UserRequest ureq, WindowControl wControl, CourseEnvironment courseEnv, AssessableCourseNode courseNode) {
+	public BulkAssessmentToolController(UserRequest ureq, WindowControl wControl, CourseEnvironment courseEnv, CourseNode courseNode) {
 		super(ureq, wControl);
 		this.courseNode = courseNode;
 		taskManager = CoreSpringFactory.getImpl(TaskExecutorManager.class);
diff --git a/src/main/java/org/olat/course/assessment/bulk/BulkAssessment_2_DatasStep.java b/src/main/java/org/olat/course/assessment/bulk/BulkAssessment_2_DatasStep.java
index c638a3142dafdfea4ec46279f0b78b7ada80333f..ebd8a0e692d349c83e2fbd90291736baa0a29289 100644
--- a/src/main/java/org/olat/course/assessment/bulk/BulkAssessment_2_DatasStep.java
+++ b/src/main/java/org/olat/course/assessment/bulk/BulkAssessment_2_DatasStep.java
@@ -28,7 +28,7 @@ import org.olat.core.gui.control.generic.wizard.PrevNextFinishConfig;
 import org.olat.core.gui.control.generic.wizard.StepFormController;
 import org.olat.core.gui.control.generic.wizard.StepsRunContext;
 import org.olat.course.assessment.model.BulkAssessmentDatas;
-import org.olat.course.nodes.AssessableCourseNode;
+import org.olat.course.nodes.CourseNode;
 
 /**
  * 
@@ -40,14 +40,14 @@ public class BulkAssessment_2_DatasStep extends BasicStep {
 	
 	private final Task task;
 	private final BulkAssessmentDatas savedDatas;
-	private final AssessableCourseNode courseNode;
+	private final CourseNode courseNode;
 	private boolean hasPreviousStep = true;
 
 	public BulkAssessment_2_DatasStep(UserRequest ureq) {
 		this(ureq, null, null, null);
 	}
 	
-	public BulkAssessment_2_DatasStep(UserRequest ureq, AssessableCourseNode courseNode) {
+	public BulkAssessment_2_DatasStep(UserRequest ureq, CourseNode courseNode) {
 		this(ureq, courseNode, null, null);
 	}
 	
@@ -57,7 +57,7 @@ public class BulkAssessment_2_DatasStep extends BasicStep {
 	 * @param courseNode
 	 * @param datas
 	 */
-	public BulkAssessment_2_DatasStep(UserRequest ureq, AssessableCourseNode courseNode,
+	public BulkAssessment_2_DatasStep(UserRequest ureq, CourseNode courseNode,
 			BulkAssessmentDatas savedDatas, Task task) {
 		super(ureq);
 		this.task = task;
diff --git a/src/main/java/org/olat/course/assessment/bulk/BulkAssessment_2b_ChooseColumnsStep.java b/src/main/java/org/olat/course/assessment/bulk/BulkAssessment_2b_ChooseColumnsStep.java
index 67def1b744837dbde8bfdafb1742ed6bd0977743..d301105fe51d04cd1f5b389a71926bbb1c3fba11 100644
--- a/src/main/java/org/olat/course/assessment/bulk/BulkAssessment_2b_ChooseColumnsStep.java
+++ b/src/main/java/org/olat/course/assessment/bulk/BulkAssessment_2b_ChooseColumnsStep.java
@@ -28,7 +28,7 @@ import org.olat.core.gui.control.generic.wizard.StepFormController;
 import org.olat.core.gui.control.generic.wizard.StepsRunContext;
 import org.olat.course.assessment.model.BulkAssessmentColumnSettings;
 import org.olat.course.assessment.model.BulkAssessmentSettings;
-import org.olat.course.nodes.AssessableCourseNode;
+import org.olat.course.nodes.CourseNode;
 
 /**
  * 
@@ -71,14 +71,11 @@ public class BulkAssessment_2b_ChooseColumnsStep extends BasicStep {
 	@Override
 	public StepFormController getStepController(UserRequest ureq, WindowControl wControl, StepsRunContext context, Form form) {
 		// Skip this step if it has only return files
-		AssessableCourseNode courseNode = (AssessableCourseNode)context.get("courseNode");
+		CourseNode courseNode = (CourseNode)context.get("courseNode");
 		BulkAssessmentSettings settings = new BulkAssessmentSettings(courseNode);
 		boolean onlyReturnFiles = (!settings.isHasScore() && !settings.isHasPassed() && !settings.isHasUserComment());
-		if (onlyReturnFiles) {
-			return new ChooseColumnsStepSkipForm(ureq, wControl, context, form);						
-		} else {
-			return new ChooseColumnsStepForm(ureq, wControl, savedColumnsSettings, context, form);			
-		}
-
+		return onlyReturnFiles
+				? new ChooseColumnsStepSkipForm(ureq, wControl, context, form)
+				: new ChooseColumnsStepForm(ureq, wControl, savedColumnsSettings, context, form);
 	}
 }
diff --git a/src/main/java/org/olat/course/assessment/bulk/ChooseColumnsStepForm.java b/src/main/java/org/olat/course/assessment/bulk/ChooseColumnsStepForm.java
index b4fb25da24225ec9f94e595de2431358faeb65d4..96f0d414b35cc48485611611411738f98885c90a 100644
--- a/src/main/java/org/olat/course/assessment/bulk/ChooseColumnsStepForm.java
+++ b/src/main/java/org/olat/course/assessment/bulk/ChooseColumnsStepForm.java
@@ -45,7 +45,7 @@ import org.olat.course.assessment.model.BulkAssessmentColumnSettings;
 import org.olat.course.assessment.model.BulkAssessmentDatas;
 import org.olat.course.assessment.model.BulkAssessmentRow;
 import org.olat.course.assessment.model.BulkAssessmentSettings;
-import org.olat.course.nodes.AssessableCourseNode;
+import org.olat.course.nodes.CourseNode;
 
 /**
  *
@@ -91,7 +91,7 @@ public class ChooseColumnsStepForm extends StepFormBasicController {
 		setFormDescription("chooseColumns.description");
 		setFormContextHelp("Using Course Tools#bulkassessment_map");
 
-		AssessableCourseNode courseNode = (AssessableCourseNode)getFromRunContext("courseNode");
+		CourseNode courseNode = (CourseNode)getFromRunContext("courseNode");
 		BulkAssessmentSettings settings = new BulkAssessmentSettings(courseNode);
 
 		String[] usernameKeys = new String[numOfColumns];
diff --git a/src/main/java/org/olat/course/assessment/bulk/DataStepForm.java b/src/main/java/org/olat/course/assessment/bulk/DataStepForm.java
index 63c629e4f1c84056a844b92669d17f052ede347b..98209eb667e43336c73d61ec46e6bbafe72fe426 100644
--- a/src/main/java/org/olat/course/assessment/bulk/DataStepForm.java
+++ b/src/main/java/org/olat/course/assessment/bulk/DataStepForm.java
@@ -61,7 +61,7 @@ import org.olat.core.util.vfs.VFSManager;
 import org.olat.course.assessment.model.BulkAssessmentDatas;
 import org.olat.course.assessment.model.BulkAssessmentRow;
 import org.olat.course.assessment.model.BulkAssessmentSettings;
-import org.olat.course.nodes.AssessableCourseNode;
+import org.olat.course.nodes.CourseNode;
 import org.olat.course.nodes.GTACourseNode;
 import org.olat.modules.assessment.model.AssessmentEntryStatus;
 
@@ -87,18 +87,18 @@ public class DataStepForm extends StepFormBasicController {
 
 	private VFSLeaf targetArchive;
 	private BulkAssessmentDatas savedDatas;
-	private final AssessableCourseNode courseNode;
+	private final CourseNode courseNode;
 	private VFSContainer bulkAssessmentTmpDir;
 
 	public DataStepForm(UserRequest ureq, WindowControl wControl, StepsRunContext runContext, Form rootForm) {
 		super(ureq, wControl, rootForm, runContext, LAYOUT_VERTICAL, null);
 
-		courseNode = (AssessableCourseNode)getFromRunContext("courseNode");
+		courseNode = (CourseNode)getFromRunContext("courseNode");
 
 		initForm(ureq);
 	}
 
-	public DataStepForm(UserRequest ureq, WindowControl wControl, AssessableCourseNode courseNode, BulkAssessmentDatas savedDatas,
+	public DataStepForm(UserRequest ureq, WindowControl wControl, CourseNode courseNode, BulkAssessmentDatas savedDatas,
 			StepsRunContext runContext, Form rootForm) {
 		super(ureq, wControl, rootForm, runContext, LAYOUT_VERTICAL, null);
 
diff --git a/src/main/java/org/olat/course/assessment/bulk/TaskData.java b/src/main/java/org/olat/course/assessment/bulk/TaskData.java
index f93ed4753a1a90bddad62a6fd5611eccb15c1e46..f44383c873bab0034fd221c2ed0e5849746dbb45 100644
--- a/src/main/java/org/olat/course/assessment/bulk/TaskData.java
+++ b/src/main/java/org/olat/course/assessment/bulk/TaskData.java
@@ -21,7 +21,7 @@ package org.olat.course.assessment.bulk;
 
 import org.olat.core.commons.services.taskexecutor.Task;
 import org.olat.course.assessment.manager.BulkAssessmentTask;
-import org.olat.course.nodes.AssessableCourseNode;
+import org.olat.course.nodes.CourseNode;
 
 /**
  * 
@@ -33,7 +33,7 @@ public class TaskData {
 	
 	private final Task task;
 	private final String ownerFullName;
-	private final AssessableCourseNode courseNode;
+	private final CourseNode courseNode;
 	
 	private boolean hasScore;
 	private boolean hasPassed;
@@ -41,7 +41,7 @@ public class TaskData {
 	private boolean hasReturnFiles;
 	private int numOfAssessedIds;
 	
-	public TaskData(Task task, BulkAssessmentTask runnable, AssessableCourseNode courseNode, String ownerFullName) {
+	public TaskData(Task task, BulkAssessmentTask runnable, CourseNode courseNode, String ownerFullName) {
 		this.task = task;
 		this.courseNode = courseNode;
 		this.ownerFullName = ownerFullName;
@@ -77,7 +77,7 @@ public class TaskData {
 		return numOfAssessedIds;
 	}
 
-	public AssessableCourseNode getCourseNode() {
+	public CourseNode getCourseNode() {
 		return courseNode;
 	}
 	
diff --git a/src/main/java/org/olat/course/assessment/bulk/ValidationStepForm.java b/src/main/java/org/olat/course/assessment/bulk/ValidationStepForm.java
index 848d53c7463196fad95bd9cea04b3cfe0716726a..8f5e07fd0b9243a0feee8b94520784b9a06b1187 100644
--- a/src/main/java/org/olat/course/assessment/bulk/ValidationStepForm.java
+++ b/src/main/java/org/olat/course/assessment/bulk/ValidationStepForm.java
@@ -46,7 +46,7 @@ import org.olat.core.id.UserConstants;
 import org.olat.course.assessment.model.BulkAssessmentDatas;
 import org.olat.course.assessment.model.BulkAssessmentRow;
 import org.olat.course.assessment.model.BulkAssessmentSettings;
-import org.olat.course.nodes.AssessableCourseNode;
+import org.olat.course.nodes.CourseNode;
 import org.olat.user.UserManager;
 
 /**
@@ -78,7 +78,7 @@ public class ValidationStepForm extends StepFormBasicController {
 	
 	@Override
 	protected void initForm(FormItemContainer formLayout, Controller listener, UserRequest ureq) {
-		AssessableCourseNode courseNode = (AssessableCourseNode)getFromRunContext("courseNode");
+		CourseNode courseNode = (CourseNode)getFromRunContext("courseNode");
 		BulkAssessmentSettings settings = new BulkAssessmentSettings(courseNode);
 		FlexiTableColumnModel tableColumnModel = FlexiTableDataModelFactory.createFlexiTableColumnModel();
 		tableColumnModel.addFlexiColumnModel(new DefaultFlexiColumnModel("table.header.identifier", Cols.identifier.ordinal()));
diff --git a/src/main/java/org/olat/course/assessment/handler/AssessmentConfig.java b/src/main/java/org/olat/course/assessment/handler/AssessmentConfig.java
index 667ba7d83fd05053db82e1adffc31eca2a50f008..7e35c0b4da1a42d8b1f57a82c815f0e3e8481970 100644
--- a/src/main/java/org/olat/course/assessment/handler/AssessmentConfig.java
+++ b/src/main/java/org/olat/course/assessment/handler/AssessmentConfig.java
@@ -27,6 +27,13 @@ package org.olat.course.assessment.handler;
  */
 public interface AssessmentConfig {
 	
+	/**
+	 * Real assessments are in efficiency statements and are shown in the assessment tool.
+	 * 
+	 * @return true if it is a real assessment.
+	 */
+	public boolean isAssessable();
+	
 	/**
 	 * @return true if the score evaluation is persisted
 	 */
diff --git a/src/main/java/org/olat/course/assessment/handler/ModuleAssessmentConfig.java b/src/main/java/org/olat/course/assessment/handler/ModuleAssessmentConfig.java
index 4d8c4101962373960e12ec330a046064429d2bb6..c7ee34a9a671cea305cc0ef397c865405cef4f5f 100644
--- a/src/main/java/org/olat/course/assessment/handler/ModuleAssessmentConfig.java
+++ b/src/main/java/org/olat/course/assessment/handler/ModuleAssessmentConfig.java
@@ -37,6 +37,11 @@ public abstract class ModuleAssessmentConfig implements AssessmentConfig {
 		this.config = config;
 	}
 
+	@Override
+	public boolean isAssessable() {
+		return true;
+	}
+
 	@Override
 	public boolean isScoreEvaluationPersisted() {
 		return true;
diff --git a/src/main/java/org/olat/course/assessment/handler/NonAssessmentConfig.java b/src/main/java/org/olat/course/assessment/handler/NonAssessmentConfig.java
index 7fd1f591000aa543df904b049c2cfcb901a94205..3b44d38c0e3c97761b0a1984c7e39c1467be0159 100644
--- a/src/main/java/org/olat/course/assessment/handler/NonAssessmentConfig.java
+++ b/src/main/java/org/olat/course/assessment/handler/NonAssessmentConfig.java
@@ -33,6 +33,11 @@ public class NonAssessmentConfig implements AssessmentConfig {
 		return INSATNCE;
 	}
 
+	@Override
+	public boolean isAssessable() {
+		return false;
+	}
+
 	@Override
 	public boolean isScoreEvaluationPersisted() {
 		return false;
diff --git a/src/main/java/org/olat/course/assessment/manager/AssessmentNotificationsHandler.java b/src/main/java/org/olat/course/assessment/manager/AssessmentNotificationsHandler.java
index 674a817e8201a9d9f9762c66c3607744e6e6f76b..ddba9d33580a8a5f032ec4f35d9fd77f6801b9ce 100644
--- a/src/main/java/org/olat/course/assessment/manager/AssessmentNotificationsHandler.java
+++ b/src/main/java/org/olat/course/assessment/manager/AssessmentNotificationsHandler.java
@@ -37,6 +37,7 @@ import org.apache.logging.log4j.Logger;
 import org.olat.basesecurity.GroupRoles;
 import org.olat.basesecurity.OrganisationRoles;
 import org.olat.basesecurity.OrganisationService;
+import org.olat.core.CoreSpringFactory;
 import org.olat.core.commons.services.notifications.NotificationHelper;
 import org.olat.core.commons.services.notifications.NotificationsHandler;
 import org.olat.core.commons.services.notifications.NotificationsManager;
@@ -61,9 +62,10 @@ import org.olat.course.ICourse;
 import org.olat.course.Structure;
 import org.olat.course.assessment.AssessmentHelper;
 import org.olat.course.assessment.AssessmentManager;
+import org.olat.course.assessment.CourseAssessmentService;
+import org.olat.course.assessment.handler.AssessmentConfig;
 import org.olat.course.groupsandrights.CourseGroupManager;
 import org.olat.course.groupsandrights.CourseRights;
-import org.olat.course.nodes.AssessableCourseNode;
 import org.olat.course.nodes.CourseNode;
 import org.olat.course.nodes.CourseNodeFactory;
 import org.olat.course.nodes.STCourseNode;
@@ -250,8 +252,9 @@ public class AssessmentNotificationsHandler implements NotificationsHandler {
 	 * <code>AssessableCourseNode</code>
 	 * </ul>
 	 */
-	private List<AssessableCourseNode> getCourseTestNodes(ICourse course) {
-		List<AssessableCourseNode> assessableNodes = new ArrayList<>();
+	//TODO uh CourseNodeSelector as well
+	private List<CourseNode> getCourseTestNodes(ICourse course) {
+		List<CourseNode> assessableNodes = new ArrayList<>();
 
 		Structure courseStruct = course.getRunStructure();
 		CourseNode rootNode = courseStruct.getRootNode();
@@ -272,10 +275,13 @@ public class AssessmentNotificationsHandler implements NotificationsHandler {
 	 * 
 	 * @see #getCourseTestNodes(ICourse)
 	 */
-	private void getCourseTestNodes(INode node, List<AssessableCourseNode> result) {
+	private void getCourseTestNodes(INode node, List<CourseNode> result) {
 		if (node != null) {
-			if (node instanceof AssessableCourseNode && !(node instanceof STCourseNode)) {
-				result.add((AssessableCourseNode) node);
+			CourseNode courseNode = (CourseNode)node;
+			CourseAssessmentService courseAssessmentService = CoreSpringFactory.getImpl(CourseAssessmentService.class);
+			AssessmentConfig assessmentConfig = courseAssessmentService.getAssessmentConfig(courseNode);
+			if (assessmentConfig.isAssessable() && !(node instanceof STCourseNode)) {
+				result.add(courseNode);
 			}
 
 			for (int i = 0; i < node.getChildCount(); i++) {
@@ -322,9 +328,9 @@ public class AssessmentNotificationsHandler implements NotificationsHandler {
 						coachedUsers.addAll(coachedIdentites);
 					}
 
-					List<AssessableCourseNode> testNodes = getCourseTestNodes(course);
+					List<CourseNode> testNodes = getCourseTestNodes(course);
 					Translator translator = Util.createPackageTranslator(AssessmentManager.class, locale);
-					for (AssessableCourseNode test:testNodes) {
+					for (CourseNode test:testNodes) {
 						List<AssessmentEntry> assessments = courseNodeAssessmentDao.loadAssessmentEntryBySubIdent(cgm.getCourseEntry(), test.getIdent());
 						for(AssessmentEntry assessment:assessments) {
 							Date modDate = assessment.getLastModified();
diff --git a/src/main/java/org/olat/course/assessment/manager/BulkAssessmentTask.java b/src/main/java/org/olat/course/assessment/manager/BulkAssessmentTask.java
index eaa91edc799d71620cd62926f56fc2c436f5b15e..963c8ab2b4b41d86bcc0dcdbf3ae9ee7dbcdf3a5 100644
--- a/src/main/java/org/olat/course/assessment/manager/BulkAssessmentTask.java
+++ b/src/main/java/org/olat/course/assessment/manager/BulkAssessmentTask.java
@@ -79,7 +79,6 @@ import org.olat.course.assessment.model.BulkAssessmentDatas;
 import org.olat.course.assessment.model.BulkAssessmentFeedback;
 import org.olat.course.assessment.model.BulkAssessmentRow;
 import org.olat.course.assessment.model.BulkAssessmentSettings;
-import org.olat.course.nodes.AssessableCourseNode;
 import org.olat.course.nodes.CourseNode;
 import org.olat.course.nodes.GTACourseNode;
 import org.olat.course.nodes.MSCourseNode;
@@ -121,8 +120,8 @@ public class BulkAssessmentTask implements LongRunnable, TaskAwareRunnable, Sequ
 	private transient Task task;
 	private transient File unzipped;
 
-	public BulkAssessmentTask(OLATResourceable courseRes, AssessableCourseNode courseNode,
-			BulkAssessmentDatas datas, Long coachedIdentity) {
+	public BulkAssessmentTask(OLATResourceable courseRes, CourseNode courseNode, BulkAssessmentDatas datas,
+			Long coachedIdentity) {
 		this.courseRes = OresHelper.clone(courseRes);
 		this.courseNodeIdent = courseNode.getIdent();
 		this.settings = new BulkAssessmentSettings(courseNode);
@@ -199,7 +198,7 @@ public class BulkAssessmentTask implements LongRunnable, TaskAwareRunnable, Sequ
 		}
 		return feedbacks;
 	}
-
+	
 	private void cleanup() {
 		if(StringHelper.containsNonWhitespace(datas.getDataBackupFile())) {
 			File backupFile = VFSManager.olatRootFile(datas.getDataBackupFile());
@@ -284,26 +283,23 @@ public class BulkAssessmentTask implements LongRunnable, TaskAwareRunnable, Sequ
 	
 	public static boolean isBulkAssessable(CourseNode courseNode) {
 		boolean bulkAssessability = false;
+		//TODO uh move to config
 		if (courseNode instanceof MSCourseNode
 				|| courseNode instanceof TACourseNode
 				|| courseNode instanceof GTACourseNode
 				|| courseNode instanceof ProjectBrokerCourseNode) {
 			// now a more fine granular check on bulk features. only show wizard for nodes that have at least one
-			BulkAssessmentSettings settings = new BulkAssessmentSettings((AssessableCourseNode)courseNode);
+			BulkAssessmentSettings settings = new BulkAssessmentSettings(courseNode);
 			if (settings.isHasPassed() || settings.isHasScore() || settings.isHasUserComment() || settings.isHasReturnFiles()) {
-				bulkAssessability = true;				
+				bulkAssessability = true;
 			}
 		}
 		return bulkAssessability;
 	}
 
-	private AssessableCourseNode getCourseNode() {
+	private CourseNode getCourseNode() {
 		ICourse course = CourseFactory.loadCourse(courseRes);
-		CourseNode node = course.getRunStructure().getNode(courseNodeIdent);
-		if(node instanceof AssessableCourseNode) {
-			return (AssessableCourseNode)node;
-		}
-		return null;
+		return course.getRunStructure().getNode(courseNodeIdent);
 	}
 	
 	private void doProcess(List<BulkAssessmentFeedback> feedbacks) {
@@ -312,7 +308,7 @@ public class BulkAssessmentTask implements LongRunnable, TaskAwareRunnable, Sequ
 		final CourseAssessmentService courseAssessmentService = CoreSpringFactory.getImpl(CourseAssessmentService.class);
 		final Identity coachIdentity = securityManager.loadIdentityByKey(coachedIdentity);
 		final ICourse course = CourseFactory.loadCourse(courseRes);
-		final AssessableCourseNode courseNode = getCourseNode();
+		final CourseNode courseNode = getCourseNode();
 		final AssessmentConfig assessmentConfig = courseAssessmentService.getAssessmentConfig(courseNode);
 		
 		final boolean hasUserComment = assessmentConfig.hasComment();
@@ -481,7 +477,7 @@ public class BulkAssessmentTask implements LongRunnable, TaskAwareRunnable, Sequ
 		}
 	}
 	
-	private void processReturnFile(AssessableCourseNode courseNode, BulkAssessmentRow row, UserCourseEnvironment uce, File assessedFolder) {
+	private void processReturnFile(CourseNode courseNode, BulkAssessmentRow row, UserCourseEnvironment uce, File assessedFolder) {
 		String assessedId = row.getAssessedId();
 		Identity identity = uce.getIdentityEnvironment().getIdentity();
 		VFSContainer returnBox = getReturnBox(uce, courseNode, identity);
diff --git a/src/main/java/org/olat/course/assessment/manager/CourseAssessmentManagerImpl.java b/src/main/java/org/olat/course/assessment/manager/CourseAssessmentManagerImpl.java
index 3fec0a3ef3fd3263161aea500759dffb5d01f1d8..059b7b23d2e1b9fce86d6d35d402fb70bc7a309a 100644
--- a/src/main/java/org/olat/course/assessment/manager/CourseAssessmentManagerImpl.java
+++ b/src/main/java/org/olat/course/assessment/manager/CourseAssessmentManagerImpl.java
@@ -51,6 +51,8 @@ import org.olat.course.assessment.AssessmentChangedEvent;
 import org.olat.course.assessment.AssessmentHelper;
 import org.olat.course.assessment.AssessmentLoggingAction;
 import org.olat.course.assessment.AssessmentManager;
+import org.olat.course.assessment.CourseAssessmentService;
+import org.olat.course.assessment.handler.AssessmentConfig;
 import org.olat.course.assessment.model.AssessmentNodeData;
 import org.olat.course.assessment.model.AssessmentNodesLastModified;
 import org.olat.course.auditing.UserNodeAuditManager;
@@ -59,7 +61,6 @@ import org.olat.course.certificate.CertificatesManager;
 import org.olat.course.certificate.model.CertificateConfig;
 import org.olat.course.certificate.model.CertificateInfos;
 import org.olat.course.groupsandrights.CourseGroupManager;
-import org.olat.course.nodes.AssessableCourseNode;
 import org.olat.course.nodes.CourseNode;
 import org.olat.course.run.environment.CourseEnvironment;
 import org.olat.course.run.scoring.AssessmentEvaluation;
@@ -95,12 +96,15 @@ public class CourseAssessmentManagerImpl implements AssessmentManager {
 	private final AssessmentService assessmentService;
 	private final CertificatesManager certificatesManager;
 	private final EfficiencyStatementManager efficiencyStatementManager;
+	private final CourseAssessmentService courseAssessmentService;
+
 	
 	public CourseAssessmentManagerImpl(CourseGroupManager cgm) {
 		this.cgm = cgm;
 		assessmentService = CoreSpringFactory.getImpl(AssessmentService.class);
 		certificatesManager = CoreSpringFactory.getImpl(CertificatesManager.class);
 		efficiencyStatementManager = CoreSpringFactory.getImpl(EfficiencyStatementManager.class);
+		courseAssessmentService = CoreSpringFactory.getImpl(CourseAssessmentService.class);
 	}
 
 	private AssessmentEntry getOrCreate(Identity assessedIdentity, CourseNode courseNode) {
@@ -337,8 +341,9 @@ public class CourseAssessmentManagerImpl implements AssessmentManager {
 		DBFactory.getInstance().commit();
 		userCourseEnv.getScoreAccounting().evaluateAll(true);
 		DBFactory.getInstance().commit();
-		if(courseNode instanceof AssessableCourseNode) {
-			// Update users efficiency statement
+		
+		AssessmentConfig assessmentConfig = courseAssessmentService.getAssessmentConfig(courseNode);
+		if(assessmentConfig.isAssessable()) {
 			efficiencyStatementManager.updateUserEfficiencyStatement(userCourseEnv);
 		}
 		
@@ -361,8 +366,9 @@ public class CourseAssessmentManagerImpl implements AssessmentManager {
 		int attempts = nodeAssessment.getAttempts() == null ? 1 :nodeAssessment.getAttempts().intValue() + 1;
 		nodeAssessment.setAttempts(attempts);
 		assessmentService.updateAssessmentEntry(nodeAssessment);
-		if(courseNode instanceof AssessableCourseNode) {
-			// Update users efficiency statement
+		
+		AssessmentConfig assessmentConfig = courseAssessmentService.getAssessmentConfig(courseNode);
+		if(assessmentConfig.isAssessable()) {
 			efficiencyStatementManager.updateUserEfficiencyStatement(userCourseEnv);
 		}
 		
@@ -381,9 +387,10 @@ public class CourseAssessmentManagerImpl implements AssessmentManager {
 		}
 		assessmentService.updateAssessmentEntry(nodeAssessment);
 		DBFactory.getInstance().commit();
+		
 		userCourseEnv.getScoreAccounting().evaluateAll(true);
-		if(courseNode instanceof AssessableCourseNode) {
-			// Update users efficiency statement
+		AssessmentConfig assessmentConfig = courseAssessmentService.getAssessmentConfig(courseNode);
+		if(assessmentConfig.isAssessable()) {
 			efficiencyStatementManager.updateUserEfficiencyStatement(userCourseEnv);
 		}
 	}
@@ -514,7 +521,7 @@ public class CourseAssessmentManagerImpl implements AssessmentManager {
 
 		if(course.getCourseConfig().isAutomaticCertificationEnabled()) {
 			CourseNode rootNode = courseEnv.getRunStructure().getRootNode();
-			ScoreEvaluation rootEval = scoreAccounting.evalCourseNode((AssessableCourseNode)rootNode);
+			ScoreEvaluation rootEval = scoreAccounting.evalCourseNode(rootNode);
 			if(rootEval != null && rootEval.getPassed() != null && rootEval.getPassed().booleanValue()
 					&& certificatesManager.isCertificationAllowed(assessedIdentity, cgm.getCourseEntry())) {
 				CertificateTemplate template = null;
diff --git a/src/main/java/org/olat/course/assessment/model/BulkAssessmentSettings.java b/src/main/java/org/olat/course/assessment/model/BulkAssessmentSettings.java
index 23bc3d3fb1ea8dc3a4c35f38f24bfcb08c84c36a..d772a3305f6357aff0ce04ab994f8c8ffa74e427 100644
--- a/src/main/java/org/olat/course/assessment/model/BulkAssessmentSettings.java
+++ b/src/main/java/org/olat/course/assessment/model/BulkAssessmentSettings.java
@@ -25,7 +25,7 @@ import java.io.Serializable;
 import org.olat.core.CoreSpringFactory;
 import org.olat.course.assessment.CourseAssessmentService;
 import org.olat.course.assessment.handler.AssessmentConfig;
-import org.olat.course.nodes.AssessableCourseNode;
+import org.olat.course.nodes.CourseNode;
 import org.olat.course.nodes.GTACourseNode;
 import org.olat.course.nodes.ProjectBrokerCourseNode;
 import org.olat.course.nodes.TACourseNode;
@@ -49,7 +49,7 @@ public class BulkAssessmentSettings implements Serializable {
 	private final Float max;
 	private final Float cut;
 
-	public BulkAssessmentSettings(AssessableCourseNode courseNode) {
+	public BulkAssessmentSettings(CourseNode courseNode) {
 		CourseAssessmentService courseAssessmentService = CoreSpringFactory.getImpl(CourseAssessmentService.class);
 		AssessmentConfig assessmentConfig = courseAssessmentService.getAssessmentConfig(courseNode);
 		hasUserComment = assessmentConfig.hasComment();
diff --git a/src/main/java/org/olat/course/assessment/ui/tool/AssessedBusinessGroupCourseNodeListController.java b/src/main/java/org/olat/course/assessment/ui/tool/AssessedBusinessGroupCourseNodeListController.java
index e0a32380d3dc25d24b1d3e60c538969cb2e1bad2..3df34fb6164faf67d2d4b866fe8a71278a6142dd 100644
--- a/src/main/java/org/olat/course/assessment/ui/tool/AssessedBusinessGroupCourseNodeListController.java
+++ b/src/main/java/org/olat/course/assessment/ui/tool/AssessedBusinessGroupCourseNodeListController.java
@@ -57,7 +57,6 @@ import org.olat.course.assessment.model.AssessedBusinessGroup;
 import org.olat.course.assessment.model.SearchAssessedIdentityParams;
 import org.olat.course.assessment.ui.tool.AssessedBusinessGroupTableModel.ABGCols;
 import org.olat.course.assessment.ui.tool.event.CourseNodeEvent;
-import org.olat.course.nodes.AssessableCourseNode;
 import org.olat.course.nodes.CourseNode;
 import org.olat.course.nodes.CourseNodeFactory;
 import org.olat.course.run.environment.CourseEnvironment;
@@ -119,17 +118,14 @@ public class AssessedBusinessGroupCourseNodeListController extends FormBasicCont
 		columnsModel.addFlexiColumnModel(new DefaultFlexiColumnModel(false, ABGCols.key, "select"));
 		columnsModel.addFlexiColumnModel(new DefaultFlexiColumnModel(ABGCols.name, "select"));
 		
-		if(courseNode instanceof AssessableCourseNode) {
-			AssessableCourseNode aNode = (AssessableCourseNode)courseNode;
-			AssessmentConfig assessmentConfig = courseAssessmentService.getAssessmentConfig(courseNode);
-			if(assessmentConfig.hasPassed()) {
-				columnsModel.addFlexiColumnModel(new DefaultFlexiColumnModel(ABGCols.countPassed,
-						new ProgressRenderer(false, getTranslator())));
-			}
-			if(assessmentConfig.hasScore()) {
-				columnsModel.addFlexiColumnModel(new DefaultFlexiColumnModel(ABGCols.averageScore,
-						new ScoreCellRenderer()));
-			}
+		AssessmentConfig assessmentConfig = courseAssessmentService.getAssessmentConfig(courseNode);
+		if(assessmentConfig.hasPassed()) {
+			columnsModel.addFlexiColumnModel(new DefaultFlexiColumnModel(ABGCols.countPassed,
+					new ProgressRenderer(false, getTranslator())));
+		}
+		if(assessmentConfig.hasScore()) {
+			columnsModel.addFlexiColumnModel(new DefaultFlexiColumnModel(ABGCols.averageScore,
+					new ScoreCellRenderer()));
 		}
 		
 		tableModel = new AssessedBusinessGroupTableModel(columnsModel, getLocale()); 
diff --git a/src/main/java/org/olat/course/assessment/ui/tool/AssessmentCourseTreeController.java b/src/main/java/org/olat/course/assessment/ui/tool/AssessmentCourseTreeController.java
index fa589b51d0fff51344e7104e12d7b93a1982b55c..2a5cdf70cac93ade2af2af5f87f9aa3c7392d338 100644
--- a/src/main/java/org/olat/course/assessment/ui/tool/AssessmentCourseTreeController.java
+++ b/src/main/java/org/olat/course/assessment/ui/tool/AssessmentCourseTreeController.java
@@ -47,7 +47,6 @@ import org.olat.course.assessment.AssessmentHelper;
 import org.olat.course.assessment.CourseAssessmentService;
 import org.olat.course.assessment.handler.AssessmentConfig;
 import org.olat.course.assessment.ui.tool.event.CourseNodeEvent;
-import org.olat.course.nodes.AssessableCourseNode;
 import org.olat.course.nodes.CourseNode;
 import org.olat.course.nodes.GTACourseNode;
 import org.olat.course.run.environment.CourseEnvironment;
@@ -315,7 +314,7 @@ public class AssessmentCourseTreeController extends BasicController implements A
 		OLATResourceable oresNode = OresHelper.createOLATResourceableInstance("Node", Long.valueOf(courseNode.getIdent()));
 		WindowControl bbwControl = BusinessControlFactory.getInstance().createBusinessWindowControl(oresNode, null, bwControl);
 		AssessmentConfig assessmentConfig = courseAssessmentService.getAssessmentConfig(courseNode);
-		if(courseNode instanceof AssessableCourseNode && assessmentConfig.isAssessedBusinessGroups()) {
+		if(assessmentConfig.isAssessedBusinessGroups()) {
 			if(courseNode instanceof GTACourseNode) {
 				CourseEnvironment courseEnv = CourseFactory.loadCourse(courseEntry).getCourseEnvironment();
 				
diff --git a/src/main/java/org/olat/course/assessment/ui/tool/AssessmentForm.java b/src/main/java/org/olat/course/assessment/ui/tool/AssessmentForm.java
index 773589b890a5d712026866816ee6ac8027a5e051..eac4fb566bde4ed21e3c525cb6cabba45eef4711 100644
--- a/src/main/java/org/olat/course/assessment/ui/tool/AssessmentForm.java
+++ b/src/main/java/org/olat/course/assessment/ui/tool/AssessmentForm.java
@@ -61,7 +61,7 @@ import org.olat.course.assessment.AssessmentHelper;
 import org.olat.course.assessment.AssessmentModule;
 import org.olat.course.assessment.CourseAssessmentService;
 import org.olat.course.assessment.handler.AssessmentConfig;
-import org.olat.course.nodes.AssessableCourseNode;
+import org.olat.course.nodes.CourseNode;
 import org.olat.course.run.scoring.ScoreAccounting;
 import org.olat.course.run.scoring.ScoreEvaluation;
 import org.olat.course.run.userview.UserCourseEnvironment;
@@ -102,7 +102,7 @@ public class AssessmentForm extends FormBasicController {
 
 	private final UserCourseEnvironment coachCourseEnv;
 	private final UserCourseEnvironment assessedUserCourseEnv;
-	private final AssessableCourseNode assessableCourseNode;
+	private final CourseNode courseNode;
 	
 	private int counter = 0;
 
@@ -118,16 +118,16 @@ public class AssessmentForm extends FormBasicController {
 	 * Constructor for an assessment detail form. The form will be configured according
 	 * to the assessable course node parameters
 	 * @param name The form name
-	 * @param assessableCourseNode The course node
+	 * @param courseNode The course node
 	 * @param assessedIdentityWrapper The wrapped identity
 	 * @param trans The package translator
 	 */
-	public AssessmentForm(UserRequest ureq, WindowControl wControl, AssessableCourseNode assessableCourseNode,
+	public AssessmentForm(UserRequest ureq, WindowControl wControl, CourseNode courseNode,
 			UserCourseEnvironment coachCourseEnv, UserCourseEnvironment assessedUserCourseEnv) {
 		super(ureq, wControl);
 		setTranslator(Util.createPackageTranslator(AssessmentModule.class, getLocale(), getTranslator()));
 		
-		AssessmentConfig assessmentConfig = courseAssessmentService.getAssessmentConfig(assessableCourseNode);
+		AssessmentConfig assessmentConfig = courseAssessmentService.getAssessmentConfig(courseNode);
 		hasAttempts = assessmentConfig.hasAttempts();
 		hasScore = assessmentConfig.hasScore();
 		hasPassed = assessmentConfig.hasPassed();
@@ -136,7 +136,7 @@ public class AssessmentForm extends FormBasicController {
 		
 		this.coachCourseEnv = coachCourseEnv;
 		this.assessedUserCourseEnv = assessedUserCourseEnv;
-		this.assessableCourseNode = assessableCourseNode;
+		this.courseNode = courseNode;
 
 		initForm(ureq);
 	}
@@ -245,7 +245,7 @@ public class AssessmentForm extends FormBasicController {
 			fireEvent(ureq, new AssessmentFormEvent(AssessmentFormEvent.ASSESSMENT_REOPEN, false));
 		} else if(uploadDocsEl == source) {
 			if(uploadDocsEl.getUploadFile() != null && StringHelper.containsNonWhitespace(uploadDocsEl.getUploadFileName())) {
-				courseAssessmentService.addIndividualAssessmentDocument(assessableCourseNode,
+				courseAssessmentService.addIndividualAssessmentDocument(courseNode,
 						uploadDocsEl.getUploadFile(), uploadDocsEl.getUploadFileName(), assessedUserCourseEnv,
 						getIdentity());
 				reloadAssessmentDocs();
@@ -331,12 +331,12 @@ public class AssessmentForm extends FormBasicController {
 	}
 	
 	private void doReopen() {
-		ScoreEvaluation scoreEval = assessedUserCourseEnv.getScoreAccounting().evalCourseNode(assessableCourseNode);
+		ScoreEvaluation scoreEval = assessedUserCourseEnv.getScoreAccounting().evalCourseNode(courseNode);
 		if (scoreEval != null) {
 			ScoreEvaluation reopenedEval = new ScoreEvaluation(scoreEval.getScore(), scoreEval.getPassed(),
 					AssessmentEntryStatus.inReview, scoreEval.getUserVisible(), scoreEval.getFullyAssessed(),
 					scoreEval.getCurrentRunCompletion(), scoreEval.getCurrentRunStatus(), scoreEval.getAssessmentID());
-			courseAssessmentService.updateScoreEvaluation(assessableCourseNode, reopenedEval, assessedUserCourseEnv,
+			courseAssessmentService.updateScoreEvaluation(courseNode, reopenedEval, assessedUserCourseEnv,
 					getIdentity(), false, Role.coach);
 			updateStatus(reopenedEval);
 		}
@@ -351,7 +351,7 @@ public class AssessmentForm extends FormBasicController {
 	}
 	
 	private void doDeleteAssessmentDocument(File document) {
-		courseAssessmentService.removeIndividualAssessmentDocument(assessableCourseNode, document,
+		courseAssessmentService.removeIndividualAssessmentDocument(courseNode, document,
 				assessedUserCourseEnv, getIdentity());
 	}
 	
@@ -360,7 +360,7 @@ public class AssessmentForm extends FormBasicController {
 		Boolean updatedPassed = null;
 
 		if (isHasAttempts() && isAttemptsDirty()) {
-			courseAssessmentService.updateAttempts(assessableCourseNode, new Integer(getAttempts()),
+			courseAssessmentService.updateAttempts(courseNode, new Integer(getAttempts()),
 					assessedUserCourseEnv, getIdentity(), Role.coach);
 		}
 
@@ -392,17 +392,17 @@ public class AssessmentForm extends FormBasicController {
 		} else {
 			scoreEval = new ScoreEvaluation(updatedScore, updatedPassed, null, visibility, null, null, null, null);
 		}
-		courseAssessmentService.updateScoreEvaluation(assessableCourseNode, scoreEval, assessedUserCourseEnv,
+		courseAssessmentService.updateScoreEvaluation(courseNode, scoreEval, assessedUserCourseEnv,
 				getIdentity(), false, Role.coach);
 
 		if (isHasComment() && isUserCommentDirty()) {
 			String newComment = getUserComment().getValue();
-			courseAssessmentService.updatedUserComment(assessableCourseNode, newComment, assessedUserCourseEnv, getIdentity());
+			courseAssessmentService.updatedUserComment(courseNode, newComment, assessedUserCourseEnv, getIdentity());
 		}
 
 		if (isCoachCommentDirty()) {
 			String newCoachComment = getCoachComment().getValue();
-			courseAssessmentService.updateCoachComment(assessableCourseNode, newCoachComment, assessedUserCourseEnv);
+			courseAssessmentService.updateCoachComment(courseNode, newCoachComment, assessedUserCourseEnv);
 		}
 	}
 	
@@ -413,11 +413,11 @@ public class AssessmentForm extends FormBasicController {
 	public void reloadData() {
 		ScoreAccounting scoreAccounting = assessedUserCourseEnv.getScoreAccounting();
 		scoreAccounting.evaluateAll(true);
-		ScoreEvaluation scoreEval = scoreAccounting.evalCourseNode(assessableCourseNode);
+		ScoreEvaluation scoreEval = scoreAccounting.evalCourseNode(courseNode);
 		if (scoreEval == null) scoreEval = new ScoreEvaluation(null, null);
 		
 		if (hasAttempts) {
-			attemptsValue = courseAssessmentService.getAttempts(assessableCourseNode, assessedUserCourseEnv);
+			attemptsValue = courseAssessmentService.getAttempts(courseNode, assessedUserCourseEnv);
 			attempts.setIntValue(attemptsValue == null ? 0 : attemptsValue.intValue());
 		}
 		
@@ -436,7 +436,7 @@ public class AssessmentForm extends FormBasicController {
 		}
 		
 		if(hasComment) {
-			userCommentValue = courseAssessmentService.getUserComment(assessableCourseNode, assessedUserCourseEnv);
+			userCommentValue = courseAssessmentService.getUserComment(courseNode, assessedUserCourseEnv);
 			userComment.setValue(userCommentValue);
 		}
 		
@@ -447,7 +447,7 @@ public class AssessmentForm extends FormBasicController {
 	private void reloadAssessmentDocs() {
 		if(docsLayoutCont == null) return;
 		
-		List<File> documents = courseAssessmentService.getIndividualAssessmentDocuments(assessableCourseNode,
+		List<File> documents = courseAssessmentService.getIndividualAssessmentDocuments(courseNode,
 				assessedUserCourseEnv);
 		List<DocumentWrapper> wrappers = new ArrayList<>(documents.size());
 		for (File document : documents) {
@@ -508,15 +508,15 @@ public class AssessmentForm extends FormBasicController {
 		setFormTitle("form.title", null);
 		formLayout.setElementCssClass("o_sel_assessment_form");
 		
-		AssessmentConfig assessmentConfig = courseAssessmentService.getAssessmentConfig(assessableCourseNode);
+		AssessmentConfig assessmentConfig = courseAssessmentService.getAssessmentConfig(courseNode);
 		
-		ScoreEvaluation scoreEval = assessedUserCourseEnv.getScoreAccounting().evalCourseNode(assessableCourseNode);
+		ScoreEvaluation scoreEval = assessedUserCourseEnv.getScoreAccounting().evalCourseNode(courseNode);
 		if (scoreEval == null) {
 			scoreEval = ScoreEvaluation.EMPTY_EVALUATION;
 		}
 
 		if (hasAttempts) {
-			attemptsValue = courseAssessmentService.getAttempts(assessableCourseNode, assessedUserCourseEnv);
+			attemptsValue = courseAssessmentService.getAttempts(courseNode, assessedUserCourseEnv);
 			if(attemptsValue == null) {
 				attemptsValue = new Integer(0);
 			}
@@ -578,7 +578,7 @@ public class AssessmentForm extends FormBasicController {
 		}
 
 		if (hasComment) {
-			userCommentValue = courseAssessmentService.getUserComment(assessableCourseNode, assessedUserCourseEnv);
+			userCommentValue = courseAssessmentService.getUserComment(courseNode, assessedUserCourseEnv);
 			userComment = uifactory.addTextAreaElement("usercomment", "form.usercomment", 2500, 5, 40, true, false, userCommentValue, formLayout);
 			userComment.setNotLongerThanCheck(2500, "input.toolong");
 		}
@@ -595,7 +595,7 @@ public class AssessmentForm extends FormBasicController {
 			uploadDocsEl.addActionListener(FormEvent.ONCHANGE);
 		}
 		
-		coachCommentValue = courseAssessmentService.getCoachComment(assessableCourseNode, assessedUserCourseEnv);
+		coachCommentValue = courseAssessmentService.getCoachComment(courseNode, assessedUserCourseEnv);
 		coachComment = uifactory.addTextAreaElement("coachcomment", "form.coachcomment", 2500, 5, 40, true, false, coachCommentValue, formLayout);
 		coachComment.setNotLongerThanCheck(2500, "input.toolong");
 		
diff --git a/src/main/java/org/olat/course/assessment/ui/tool/AssessmentIdentityCourseController.java b/src/main/java/org/olat/course/assessment/ui/tool/AssessmentIdentityCourseController.java
index 46cfe08a34a8816dd88707c2372d551be9dd75d9..9127aa1a008473c5954a18f4a59db27388cc4348 100644
--- a/src/main/java/org/olat/course/assessment/ui/tool/AssessmentIdentityCourseController.java
+++ b/src/main/java/org/olat/course/assessment/ui/tool/AssessmentIdentityCourseController.java
@@ -47,9 +47,10 @@ import org.olat.core.id.context.StateEntry;
 import org.olat.core.util.FileUtils;
 import org.olat.course.CourseFactory;
 import org.olat.course.ICourse;
+import org.olat.course.assessment.CourseAssessmentService;
+import org.olat.course.assessment.handler.AssessmentConfig;
 import org.olat.course.assessment.ui.tool.event.CourseNodeEvent;
 import org.olat.course.config.CourseConfig;
-import org.olat.course.nodes.AssessableCourseNode;
 import org.olat.course.nodes.CourseNode;
 import org.olat.course.nodes.CourseNodeFactory;
 import org.olat.course.nodes.STCourseNode;
@@ -86,6 +87,8 @@ public class AssessmentIdentityCourseController extends BasicController
 	private final RepositoryEntry courseEntry;
 	private final UserCourseEnvironment coachCourseEnv;
 	
+	@Autowired
+	private CourseAssessmentService courseAssessmentService;
 	@Autowired
 	private BaseSecurity securityManager;
 	@Autowired
@@ -314,7 +317,8 @@ public class AssessmentIdentityCourseController extends BasicController
 		if(index > 0 && index <= numOfNodes) {
 			for(int i=index; i-->0; ) {
 				CourseNode previousNode = treeOverviewCtrl.getNode(i);
-				if(previousNode instanceof AssessableCourseNode && !(previousNode instanceof STCourseNode)) {
+				AssessmentConfig previousConfig = courseAssessmentService.getAssessmentConfig(previousNode);
+				if(previousConfig.isAssessable() && !(previousNode instanceof STCourseNode)) {
 					return true;
 				}
 			}
diff --git a/src/main/java/org/olat/course/assessment/ui/tool/AssessmentIdentityCourseNodeController.java b/src/main/java/org/olat/course/assessment/ui/tool/AssessmentIdentityCourseNodeController.java
index 15b6f35c01f5059b2b3901324918a5ce615a5f4d..e9159b750da7515fcadaf36801f9c37f141e7c71 100644
--- a/src/main/java/org/olat/course/assessment/ui/tool/AssessmentIdentityCourseNodeController.java
+++ b/src/main/java/org/olat/course/assessment/ui/tool/AssessmentIdentityCourseNodeController.java
@@ -48,7 +48,6 @@ import org.olat.course.assessment.AssessmentModule;
 import org.olat.course.assessment.CourseAssessmentService;
 import org.olat.course.assessment.OpenSubDetailsEvent;
 import org.olat.course.assessment.handler.AssessmentConfig;
-import org.olat.course.nodes.AssessableCourseNode;
 import org.olat.course.nodes.CourseNode;
 import org.olat.course.nodes.CourseNodeFactory;
 import org.olat.course.nodes.MSCourseNode;
@@ -118,9 +117,7 @@ public class AssessmentIdentityCourseNodeController extends BasicController impl
 			alreadyLockedDialogController = DialogBoxUIFactory.createResourceLockedMessage(ureq, wControl, lockEntry, "assessmentLock", getTranslator());
 			listenTo(alreadyLockedDialogController);
 			alreadyLockedDialogController.activate();
-		} else if(courseNode instanceof AssessableCourseNode) {
-			AssessableCourseNode aCourseNode = (AssessableCourseNode)courseNode;
-			
+		} else {
 			identityInfosCtrl = new AssessedIdentityLargeInfosController(ureq, wControl, assessedIdentity, course);
 			listenTo(identityInfosCtrl);
 			identityAssessmentVC.put("identityInfos", identityInfosCtrl.getInitialComponent());
@@ -134,7 +131,7 @@ public class AssessmentIdentityCourseNodeController extends BasicController impl
 				identityAssessmentVC.put("details", detailsEditController.getInitialComponent());
 			}
 			
-			assessmentForm = new AssessmentForm(ureq, wControl, aCourseNode, coachCourseEnv, assessedUserCourseEnvironment);
+			assessmentForm = new AssessmentForm(ureq, wControl, courseNode, coachCourseEnv, assessedUserCourseEnvironment);
 			listenTo(assessmentForm);
 			identityAssessmentVC.put("assessmentForm", assessmentForm.getInitialComponent());
 			
diff --git a/src/main/java/org/olat/course/assessment/ui/tool/AssessmentModeOverviewListController.java b/src/main/java/org/olat/course/assessment/ui/tool/AssessmentModeOverviewListController.java
index d8a697a24181b563d9a44bce6a9654fda6e2b174..de10c5169afd877ad47d741c8f60be5f71b35990 100644
--- a/src/main/java/org/olat/course/assessment/ui/tool/AssessmentModeOverviewListController.java
+++ b/src/main/java/org/olat/course/assessment/ui/tool/AssessmentModeOverviewListController.java
@@ -55,6 +55,8 @@ import org.olat.course.ICourse;
 import org.olat.course.assessment.AssessmentMode;
 import org.olat.course.assessment.AssessmentModeCoordinationService;
 import org.olat.course.assessment.AssessmentModeManager;
+import org.olat.course.assessment.CourseAssessmentService;
+import org.olat.course.assessment.handler.AssessmentConfig;
 import org.olat.course.assessment.ui.mode.AssessmentModeHelper;
 import org.olat.course.assessment.ui.mode.AssessmentModeListController;
 import org.olat.course.assessment.ui.mode.ModeStatusCellRenderer;
@@ -62,7 +64,6 @@ import org.olat.course.assessment.ui.mode.TimeCellRenderer;
 import org.olat.course.assessment.ui.tool.AssessmentModeOverviewListTableModel.ModeCols;
 import org.olat.course.assessment.ui.tool.event.AssessmentModeStatusEvent;
 import org.olat.course.assessment.ui.tool.event.CourseNodeEvent;
-import org.olat.course.nodes.AssessableCourseNode;
 import org.olat.course.nodes.CourseNode;
 import org.olat.course.nodes.CourseNodeConfiguration;
 import org.olat.course.nodes.CourseNodeFactory;
@@ -103,6 +104,8 @@ public class AssessmentModeOverviewListController extends FormBasicController im
 	private AssessmentModeManager asssessmentModeManager;
 	@Autowired
 	private AssessmentModeCoordinationService assessmentModeCoordinationService;
+	@Autowired
+	private CourseAssessmentService courseAssessmentService;
 	
 	public AssessmentModeOverviewListController(UserRequest ureq, WindowControl wControl,
 			RepositoryEntry courseEntry, AssessmentToolSecurityCallback assessmentCallback) {
@@ -215,7 +218,8 @@ public class AssessmentModeOverviewListController extends FormBasicController im
 			ICourse course = CourseFactory.loadCourse(courseEntry);
 			for(String element:elements.split("[,]")) {
 				CourseNode node = course.getRunStructure().getNode(element);
-				if(node instanceof AssessableCourseNode && !(node instanceof STCourseNode) && !(node instanceof PortfolioCourseNode)) {
+				AssessmentConfig assessmentConfig = courseAssessmentService.getAssessmentConfig(node);
+				if(assessmentConfig.isAssessable() && !(node instanceof STCourseNode) && !(node instanceof PortfolioCourseNode)) {
 					String id = "element_" + (++count);
 					FormLink elementButton = uifactory.addFormLink(id, "element", node.getShortTitle(), null, flc, Link.LINK | Link.NONTRANSLATED);
 					elementButton.setDomReplacementWrapperRequired(false);
diff --git a/src/main/java/org/olat/course/assessment/ui/tool/CourseNodeSelectionController.java b/src/main/java/org/olat/course/assessment/ui/tool/CourseNodeSelectionController.java
index 64478f027ac14f8eaa063d34112657ae612b20bc..55a9cbc0ff050412ca34eb73615a9fb60ae5a7bf 100644
--- a/src/main/java/org/olat/course/assessment/ui/tool/CourseNodeSelectionController.java
+++ b/src/main/java/org/olat/course/assessment/ui/tool/CourseNodeSelectionController.java
@@ -33,11 +33,12 @@ import org.olat.core.util.tree.TreeHelper;
 import org.olat.course.CourseFactory;
 import org.olat.course.ICourse;
 import org.olat.course.assessment.AssessmentHelper;
+import org.olat.course.assessment.CourseAssessmentService;
+import org.olat.course.assessment.handler.AssessmentConfig;
 import org.olat.course.assessment.ui.tool.event.CourseNodeEvent;
-import org.olat.course.nodes.AssessableCourseNode;
 import org.olat.course.nodes.CourseNode;
-import org.olat.course.nodes.STCourseNode;
 import org.olat.repository.RepositoryEntry;
+import org.springframework.beans.factory.annotation.Autowired;
 
 /**
  * 
@@ -49,6 +50,9 @@ public class CourseNodeSelectionController extends BasicController {
 	
 	private final MenuTree menuTree;
 	
+	@Autowired
+	private CourseAssessmentService courseAssessmentService;
+	
 	public CourseNodeSelectionController(UserRequest ureq, WindowControl wControl, RepositoryEntry courseEntry) {
 		super(ureq, wControl);
 	
@@ -88,18 +92,24 @@ public class CourseNodeSelectionController extends BasicController {
 					Object uo = menuTree.getSelectedNode().getUserObject();
 					if(menuTree.getSelectedNode() == menuTree.getTreeModel().getRootNode()) {
 						//do nothing
-					} else if(uo instanceof AssessableCourseNode && !(uo instanceof STCourseNode)) {
-						AssessableCourseNode selectedNode = (AssessableCourseNode)uo;
-						fireEvent(ureq, new CourseNodeEvent(CourseNodeEvent.SELECT_COURSE_NODE, selectedNode.getIdent()));
+					} else {
+						CourseNode selectedNode = (CourseNode)uo;
+						AssessmentConfig assessmentConfig = courseAssessmentService.getAssessmentConfig(selectedNode);
+						if (assessmentConfig.isAssessable() && assessmentConfig.isEditable()) {
+							fireEvent(ureq, new CourseNodeEvent(CourseNodeEvent.SELECT_COURSE_NODE, selectedNode.getIdent()));
+						}
 					}
 				} else if (event.getCommand().equals(MenuTree.COMMAND_TREENODE_CLICKED)) {
 					Object uo = menuTree.getSelectedNode().getUserObject();
 					if(menuTree.getSelectedNode() == menuTree.getTreeModel().getRootNode()) {
 						CourseNode rootNode = (CourseNode)uo;
 						fireEvent(ureq, new CourseNodeEvent(CourseNodeEvent.SELECT_COURSE_NODE, rootNode.getIdent()));
-					} else if(uo instanceof AssessableCourseNode && !(uo instanceof STCourseNode)) {
-						AssessableCourseNode selectedNode = (AssessableCourseNode)uo;
-						fireEvent(ureq, new CourseNodeEvent(CourseNodeEvent.SELECT_COURSE_NODE, selectedNode.getIdent()));
+					} else {
+						CourseNode selectedNode = (CourseNode)uo;
+						AssessmentConfig assessmentConfig = courseAssessmentService.getAssessmentConfig(selectedNode);
+						if (assessmentConfig.isAssessable() && assessmentConfig.isEditable()) {
+							fireEvent(ureq, new CourseNodeEvent(CourseNodeEvent.SELECT_COURSE_NODE, selectedNode.getIdent()));
+						}
 					}
 				}
 			}
diff --git a/src/main/java/org/olat/course/assessment/ui/tool/IdentityAssessmentOverviewController.java b/src/main/java/org/olat/course/assessment/ui/tool/IdentityAssessmentOverviewController.java
index ac6eb53e4e0a10a387e37603b17bc2e5a0485236..8f2571dd6b8bab4e0dbfd0d373731b327857edff 100644
--- a/src/main/java/org/olat/course/assessment/ui/tool/IdentityAssessmentOverviewController.java
+++ b/src/main/java/org/olat/course/assessment/ui/tool/IdentityAssessmentOverviewController.java
@@ -56,7 +56,6 @@ import org.olat.course.assessment.IndentedNodeRenderer;
 import org.olat.course.assessment.bulk.PassedCellRenderer;
 import org.olat.course.assessment.model.AssessmentNodeData;
 import org.olat.course.assessment.ui.tool.IdentityAssessmentOverviewTableModel.NodeCols;
-import org.olat.course.nodes.AssessableCourseNode;
 import org.olat.course.nodes.CourseNode;
 import org.olat.course.run.userview.UserCourseEnvironment;
 import org.olat.modules.assessment.ui.AssessedIdentityListState;
@@ -90,7 +89,7 @@ public class IdentityAssessmentOverviewController extends FormBasicController im
 
 	private boolean loadNodesFromCourse;
 	private final boolean followUserResultsVisibility;
-	private AssessableCourseNode selectedCourseNode;
+	private CourseNode selectedCourseNode;
 	private List<AssessmentNodeData> preloadedNodesList;
 	private UserCourseEnvironment userCourseEnvironment;
 
@@ -211,11 +210,11 @@ public class IdentityAssessmentOverviewController extends FormBasicController im
 	}
 	
 	/**
-	 * Returns the selected assessable course node. Call this method after getting the EVENT_NODE_SELECTED
+	 * Returns the selected course node. Call this method after getting the EVENT_NODE_SELECTED
 	 * to get the selected node
 	 * @return AssessableCourseNode
 	 */
-	public AssessableCourseNode getSelectedCourseNode() {
+	public CourseNode getSelectedCourseNode() {
 		if (selectedCourseNode == null) {
 			throw new AssertException("Selected course node was null. Maybe getSelectedCourseNode called prior to EVENT_NODE_SELECTED has been fired?");
 		}
@@ -313,8 +312,7 @@ public class IdentityAssessmentOverviewController extends FormBasicController im
 				String cmd = se.getCommand();
 				AssessmentNodeData nodeData = tableModel.getObject(se.getIndex());
 				if(CMD_SELECT_NODE.equals(cmd)) {
-					CourseNode node = runStructure.getNode(nodeData.getIdent());
-					selectedCourseNode = (AssessableCourseNode)node;
+					selectedCourseNode = runStructure.getNode(nodeData.getIdent());
 					fireEvent(ureq, EVENT_NODE_SELECTED);
 				}
 			}
diff --git a/src/main/java/org/olat/course/assessment/ui/tool/IdentityCertificatesController.java b/src/main/java/org/olat/course/assessment/ui/tool/IdentityCertificatesController.java
index 0f9cd99921c7d6c47d42e2289ee33086f3d9e13a..e6adba3a3a7e9678d904e6ccd0b7ef5ccea2bc71 100644
--- a/src/main/java/org/olat/course/assessment/ui/tool/IdentityCertificatesController.java
+++ b/src/main/java/org/olat/course/assessment/ui/tool/IdentityCertificatesController.java
@@ -53,7 +53,6 @@ import org.olat.course.certificate.model.CertificateConfig;
 import org.olat.course.certificate.model.CertificateInfos;
 import org.olat.course.certificate.ui.DownloadCertificateCellRenderer;
 import org.olat.course.config.CourseConfig;
-import org.olat.course.nodes.AssessableCourseNode;
 import org.olat.course.nodes.CourseNode;
 import org.olat.course.run.scoring.ScoreAccounting;
 import org.olat.course.run.scoring.ScoreEvaluation;
@@ -226,7 +225,7 @@ public class IdentityCertificatesController extends BasicController implements G
 		UserCourseEnvironment assessedUserCourseEnv = new UserCourseEnvironmentImpl(identityEnv, course.getCourseEnvironment());
 		ScoreAccounting scoreAccounting = assessedUserCourseEnv.getScoreAccounting();
 		scoreAccounting.evaluateAll();
-		ScoreEvaluation scoreEval = scoreAccounting.evalCourseNode((AssessableCourseNode)rootNode);
+		ScoreEvaluation scoreEval = scoreAccounting.evalCourseNode(rootNode);
 
 		CertificateTemplate template = null;
 		Long templateKey = course.getCourseConfig().getCertificateTemplate();
diff --git a/src/main/java/org/olat/course/assessment/ui/tool/IdentityListCourseNodeController.java b/src/main/java/org/olat/course/assessment/ui/tool/IdentityListCourseNodeController.java
index 488af4ef6ded521d22d830fed3e38fdb311472be..ec03574b731ebd8e4379b9c387486fa7ddaea291 100644
--- a/src/main/java/org/olat/course/assessment/ui/tool/IdentityListCourseNodeController.java
+++ b/src/main/java/org/olat/course/assessment/ui/tool/IdentityListCourseNodeController.java
@@ -79,7 +79,6 @@ import org.olat.course.assessment.handler.AssessmentConfig;
 import org.olat.course.assessment.model.SearchAssessedIdentityParams;
 import org.olat.course.assessment.ui.tool.IdentityListCourseNodeTableModel.IdentityCourseElementCols;
 import org.olat.course.assessment.ui.tool.event.ShowDetailsEvent;
-import org.olat.course.nodes.AssessableCourseNode;
 import org.olat.course.nodes.CourseNode;
 import org.olat.course.nodes.CourseNodeFactory;
 import org.olat.course.nodes.STCourseNode;
@@ -275,13 +274,13 @@ public class IdentityListCourseNodeController extends FormBasicController
 			colIndex++;
 		}
 		
-		initAssessmentColumns(columnsModel);
+		AssessmentConfig assessmentConfig = courseAssessmentService.getAssessmentConfig(courseNode);
+		initAssessmentColumns(columnsModel, assessmentConfig);
 		initStatusColumns(columnsModel);
 		initModificationDatesColumns(columnsModel);
-		initCalloutColumns(columnsModel);
+		initCalloutColumns(columnsModel, assessmentConfig);
 
-		AssessableCourseNode assessableNode = courseNode instanceof AssessableCourseNode ? (AssessableCourseNode)courseNode : null;
-		usersTableModel = new IdentityListCourseNodeTableModel(columnsModel, assessableNode, getLocale()); 
+		usersTableModel = new IdentityListCourseNodeTableModel(columnsModel, courseNode, getLocale()); 
 		tableEl = uifactory.addTableElement(getWindowControl(), "table", usersTableModel, 20, false, getTranslator(), formLayout);
 		tableEl.setExportEnabled(true);
 		tableEl.setSearchEnabled(new AssessedIdentityListProvider(getIdentity(), courseEntry, referenceEntry, courseNode.getIdent(), assessmentCallback), ureq.getUserSession());
@@ -354,11 +353,8 @@ public class IdentityListCourseNodeController extends FormBasicController
 		return "assessment-tool-identity-list";
 	}
 	
-	protected void initAssessmentColumns(FlexiTableColumnModel columnsModel) {
-		if(courseNode instanceof AssessableCourseNode) {
-			AssessableCourseNode assessableNode = (AssessableCourseNode)courseNode;
-			AssessmentConfig assessmentConfig = courseAssessmentService.getAssessmentConfig(courseNode);
-			
+	protected void initAssessmentColumns(FlexiTableColumnModel columnsModel, AssessmentConfig assessmentConfig) {
+		if(assessmentConfig.isAssessable()) {
 			if(assessmentConfig.hasAttempts()) {
 				columnsModel.addFlexiColumnModel(new DefaultFlexiColumnModel(IdentityCourseElementCols.attempts));
 			}
@@ -367,7 +363,7 @@ public class IdentityListCourseNodeController extends FormBasicController
 						new UserVisibilityCellRenderer(getTranslator())));
 			}
 			if(assessmentConfig.hasScore()) {
-				if(!(assessableNode instanceof STCourseNode)) {
+				if(!(courseNode instanceof STCourseNode)) {
 					if(assessmentConfig.getMinScore() != null) {
 						columnsModel.addFlexiColumnModel(new DefaultFlexiColumnModel(IdentityCourseElementCols.min, new ScoreCellRenderer()));
 					}
@@ -404,8 +400,8 @@ public class IdentityListCourseNodeController extends FormBasicController
 		columnsModel.addFlexiColumnModel(new DefaultFlexiColumnModel(false, IdentityCourseElementCols.lastCoachModified, select));
 	}
 	
-	protected void initCalloutColumns(FlexiTableColumnModel columnsModel) {
-		if(courseNode instanceof AssessableCourseNode) {
+	protected void initCalloutColumns(FlexiTableColumnModel columnsModel, AssessmentConfig assessmentConfig) {
+		if(assessmentConfig.isAssessable()) {
 			DefaultFlexiColumnModel toolsCol = new DefaultFlexiColumnModel(IdentityCourseElementCols.tools);
 			toolsCol.setExportable(false);
 			columnsModel.addFlexiColumnModel(toolsCol);
@@ -417,11 +413,11 @@ public class IdentityListCourseNodeController extends FormBasicController
 	}
 	
 	protected boolean isSelectable() {
-		return courseNode instanceof AssessableCourseNode;
+		return courseAssessmentService.getAssessmentConfig(courseNode).isAssessable();
 	}
 	
 	protected void initMultiSelectionTools(@SuppressWarnings("unused") UserRequest ureq, FormLayoutContainer formLayout) {
-		if(courseNode instanceof AssessableCourseNode) {
+		if(courseAssessmentService.getAssessmentConfig(courseNode).isAssessable()) {
 			bulkDoneButton = uifactory.addFormLink("bulk.done", formLayout, Link.BUTTON);
 			bulkDoneButton.setElementCssClass("o_sel_assessment_bulk_done");
 			bulkDoneButton.setVisible(!coachCourseEnv.isCourseReadOnly());
@@ -727,8 +723,8 @@ public class IdentityListCourseNodeController extends FormBasicController
 	}
 	
 	protected Controller createCalloutController(UserRequest ureq, Identity assessedIdentity) {
-		return new IdentityListCourseNodeToolsController(ureq, getWindowControl(),
-				(AssessableCourseNode)courseNode, assessedIdentity, coachCourseEnv);
+		return new IdentityListCourseNodeToolsController(ureq, getWindowControl(), courseNode, assessedIdentity,
+				coachCourseEnv);
 	}
 	
 	private void doNext(UserRequest ureq) {
@@ -833,7 +829,6 @@ public class IdentityListCourseNodeController extends FormBasicController
 	
 	private void doSetVisibility(UserRequest ureq, Boolean visibility, List<AssessedIdentityElementRow> rows) {
 		ICourse course = CourseFactory.loadCourse(courseEntry);
-		AssessableCourseNode assessableCourseNode = (AssessableCourseNode)courseNode;
 		
 		for(AssessedIdentityElementRow row:rows) {
 			Identity assessedIdentity = securityManager.loadIdentityByKey(row.getIdentityKey());
@@ -848,8 +843,8 @@ public class IdentityListCourseNodeController extends FormBasicController
 			ScoreEvaluation doneEval = new ScoreEvaluation(scoreEval.getScore(), scoreEval.getPassed(),
 					scoreEval.getAssessmentStatus(), visibility, scoreEval.getFullyAssessed(),
 					scoreEval.getCurrentRunCompletion(), scoreEval.getCurrentRunStatus(), scoreEval.getAssessmentID());
-			courseAssessmentService.updateScoreEvaluation(assessableCourseNode, doneEval, assessedUserCourseEnv,
-					getIdentity(), false, Role.coach);
+			courseAssessmentService.updateScoreEvaluation(courseNode, doneEval, assessedUserCourseEnv, getIdentity(),
+					false, Role.coach);
 		}
 		loadModel(ureq);
 	}
@@ -866,18 +861,17 @@ public class IdentityListCourseNodeController extends FormBasicController
 
 		if(rows.isEmpty()) {
 			showWarning("warning.bulk.done");
-		} else if(courseNode instanceof AssessableCourseNode) {
+		} else if(courseAssessmentService.getAssessmentConfig(courseNode).isAssessable()) {
 			ICourse course = CourseFactory.loadCourse(courseEntry);
-			AssessableCourseNode assessableCourseNode = (AssessableCourseNode)courseNode;
 			for(AssessedIdentityElementRow row:rows) {
 				Identity assessedIdentity = securityManager.loadIdentityByKey(row.getIdentityKey());
-				doSetDone(assessedIdentity, assessableCourseNode, course);
+				doSetDone(assessedIdentity, courseNode, course);
 			}
 			loadModel(ureq);
 		}
 	}
 	
-	protected void doSetDone(Identity assessedIdentity, AssessableCourseNode assessableCourseNode, ICourse course) {
+	protected void doSetDone(Identity assessedIdentity, CourseNode courseNode, ICourse course) {
 		Roles roles = securityManager.getRoles(assessedIdentity);
 		
 		IdentityEnvironment identityEnv = new IdentityEnvironment(assessedIdentity, roles);
@@ -888,7 +882,7 @@ public class IdentityListCourseNodeController extends FormBasicController
 		ScoreEvaluation doneEval = new ScoreEvaluation(scoreEval.getScore(), scoreEval.getPassed(),
 				AssessmentEntryStatus.done, null, scoreEval.getFullyAssessed(),
 				scoreEval.getCurrentRunCompletion(), scoreEval.getCurrentRunStatus(), scoreEval.getAssessmentID());
-		courseAssessmentService.updateScoreEvaluation(assessableCourseNode, doneEval, assessedUserCourseEnv,
+		courseAssessmentService.updateScoreEvaluation(courseNode, doneEval, assessedUserCourseEnv,
 				getIdentity(), false, Role.coach);
 		
 	}
diff --git a/src/main/java/org/olat/course/assessment/ui/tool/IdentityListCourseNodeTableModel.java b/src/main/java/org/olat/course/assessment/ui/tool/IdentityListCourseNodeTableModel.java
index b782cf7aaf8e31c4c18398109eaa1b9d66f8b2c5..7764d63125995853dfc9dc556adf08ecdcf31f03 100644
--- a/src/main/java/org/olat/course/assessment/ui/tool/IdentityListCourseNodeTableModel.java
+++ b/src/main/java/org/olat/course/assessment/ui/tool/IdentityListCourseNodeTableModel.java
@@ -38,7 +38,7 @@ import org.olat.core.util.StringHelper;
 import org.olat.course.assessment.CourseAssessmentService;
 import org.olat.course.assessment.handler.AssessmentConfig;
 import org.olat.course.certificate.CertificateLight;
-import org.olat.course.nodes.AssessableCourseNode;
+import org.olat.course.nodes.CourseNode;
 import org.olat.course.nodes.STCourseNode;
 import org.olat.modules.assessment.model.AssessmentEntryStatus;
 import org.olat.modules.assessment.ui.AssessedIdentityElementRow;
@@ -59,11 +59,11 @@ public class IdentityListCourseNodeTableModel extends DefaultFlexiTableDataModel
 	private Float minScore;
 	private Float maxScore;
 	private Float cutValue;
-	private final AssessableCourseNode courseNode;
+	private final CourseNode courseNode;
 	private List<AssessedIdentityElementRow> backups;
 	private ConcurrentMap<Long, CertificateLight> certificateMap;
 	
-	public IdentityListCourseNodeTableModel(FlexiTableColumnModel columnModel, AssessableCourseNode courseNode, Locale locale) {
+	public IdentityListCourseNodeTableModel(FlexiTableColumnModel columnModel, CourseNode courseNode, Locale locale) {
 		super(columnModel);
 		this.locale = locale;
 		this.courseNode = courseNode;
diff --git a/src/main/java/org/olat/course/assessment/ui/tool/IdentityListCourseNodeToolsController.java b/src/main/java/org/olat/course/assessment/ui/tool/IdentityListCourseNodeToolsController.java
index 4b8a33b6effa8271ba9d1b596b05f364b965e2de..8dbca415069cb19eb521fb879ab58b4596dbdbe1 100644
--- a/src/main/java/org/olat/course/assessment/ui/tool/IdentityListCourseNodeToolsController.java
+++ b/src/main/java/org/olat/course/assessment/ui/tool/IdentityListCourseNodeToolsController.java
@@ -23,7 +23,7 @@ import org.olat.core.gui.UserRequest;
 import org.olat.core.gui.control.WindowControl;
 import org.olat.core.id.Identity;
 import org.olat.course.assessment.ui.tool.tools.AbstractToolsController;
-import org.olat.course.nodes.AssessableCourseNode;
+import org.olat.course.nodes.CourseNode;
 import org.olat.course.run.userview.UserCourseEnvironment;
 
 /**
@@ -34,8 +34,8 @@ import org.olat.course.run.userview.UserCourseEnvironment;
  */
 public class IdentityListCourseNodeToolsController extends AbstractToolsController {
 	
-	public IdentityListCourseNodeToolsController(UserRequest ureq, WindowControl wControl,
-			AssessableCourseNode courseNode, Identity assessedIdentity, UserCourseEnvironment coachCourseEnv) {
+	public IdentityListCourseNodeToolsController(UserRequest ureq, WindowControl wControl, CourseNode courseNode,
+			Identity assessedIdentity, UserCourseEnvironment coachCourseEnv) {
 		super(ureq, wControl, courseNode, assessedIdentity, coachCourseEnv);
 		
 		initTools();
diff --git a/src/main/java/org/olat/course/assessment/ui/tool/event/ShowDetailsEvent.java b/src/main/java/org/olat/course/assessment/ui/tool/event/ShowDetailsEvent.java
index 4dca27c5e351c09fb3005388b482dcce4c2e382c..109836e220bdd66ce354a5f65242b6eabc875015 100644
--- a/src/main/java/org/olat/course/assessment/ui/tool/event/ShowDetailsEvent.java
+++ b/src/main/java/org/olat/course/assessment/ui/tool/event/ShowDetailsEvent.java
@@ -21,7 +21,7 @@ package org.olat.course.assessment.ui.tool.event;
 
 import org.olat.core.gui.control.Event;
 import org.olat.core.id.Identity;
-import org.olat.course.nodes.AssessableCourseNode;
+import org.olat.course.nodes.CourseNode;
 
 /**
  * 
@@ -35,9 +35,9 @@ public class ShowDetailsEvent extends Event {
 	public static final String SHOW_DETAILS = "show-details";
 	
 	private final Identity assessedIdentity;
-	private final AssessableCourseNode courseNode;
+	private final CourseNode courseNode;
 	
-	public ShowDetailsEvent(AssessableCourseNode courseNode, Identity assessedIdentity) {
+	public ShowDetailsEvent(CourseNode courseNode, Identity assessedIdentity) {
 		super(SHOW_DETAILS);
 		this.assessedIdentity = assessedIdentity;
 		this.courseNode = courseNode;
@@ -47,7 +47,7 @@ public class ShowDetailsEvent extends Event {
 		return assessedIdentity;
 	}
 
-	public AssessableCourseNode getCourseNode() {
+	public CourseNode getCourseNode() {
 		return courseNode;
 	}
 }
diff --git a/src/main/java/org/olat/course/assessment/ui/tool/tools/AbstractToolsController.java b/src/main/java/org/olat/course/assessment/ui/tool/tools/AbstractToolsController.java
index eba2882a11b4ec0345abd6c6458d669ec035f79d..281c7d5fbb197b58d32d2d1cb1e5adfc05931d3a 100644
--- a/src/main/java/org/olat/course/assessment/ui/tool/tools/AbstractToolsController.java
+++ b/src/main/java/org/olat/course/assessment/ui/tool/tools/AbstractToolsController.java
@@ -39,7 +39,7 @@ import org.olat.course.assessment.AssessmentHelper;
 import org.olat.course.assessment.CourseAssessmentService;
 import org.olat.course.assessment.ui.tool.IdentityListCourseNodeController;
 import org.olat.course.assessment.ui.tool.event.ShowDetailsEvent;
-import org.olat.course.nodes.AssessableCourseNode;
+import org.olat.course.nodes.CourseNode;
 import org.olat.course.run.scoring.AssessmentEvaluation;
 import org.olat.course.run.scoring.ScoreEvaluation;
 import org.olat.course.run.userview.UserCourseEnvironment;
@@ -76,14 +76,14 @@ public abstract class AbstractToolsController extends BasicController {
 	protected final Identity assessedIdentity;
 	private final RepositoryEntry courseEntry;
 	private final AssessmentEvaluation scoreEval;
-	protected final AssessableCourseNode courseNode;
+	protected final CourseNode courseNode;
 	protected final UserCourseEnvironment assessedUserCourseEnv;
 	
 	@Autowired
 	private CourseAssessmentService courseAssessmentService;
 	
-	public AbstractToolsController(UserRequest ureq, WindowControl wControl,
-			AssessableCourseNode courseNode, Identity assessedIdentity, UserCourseEnvironment coachCourseEnv) {
+	public AbstractToolsController(UserRequest ureq, WindowControl wControl, CourseNode courseNode,
+			Identity assessedIdentity, UserCourseEnvironment coachCourseEnv) {
 		super(ureq, wControl);
 		
 		setTranslator(Util.createPackageTranslator(IdentityListCourseNodeController.class, getLocale(), getTranslator()));
diff --git a/src/main/java/org/olat/course/assessment/ui/tool/tools/ResetAttemptsConfirmationController.java b/src/main/java/org/olat/course/assessment/ui/tool/tools/ResetAttemptsConfirmationController.java
index 1f6a8eb0c43a112439ae13b0cc782e7f97aab5b8..001308bb16ea8f0b849163855475942726a550a7 100644
--- a/src/main/java/org/olat/course/assessment/ui/tool/tools/ResetAttemptsConfirmationController.java
+++ b/src/main/java/org/olat/course/assessment/ui/tool/tools/ResetAttemptsConfirmationController.java
@@ -30,7 +30,7 @@ import org.olat.core.util.Util;
 import org.olat.course.assessment.AssessmentHelper;
 import org.olat.course.assessment.CourseAssessmentService;
 import org.olat.course.assessment.ui.tool.IdentityListCourseNodeController;
-import org.olat.course.nodes.AssessableCourseNode;
+import org.olat.course.nodes.CourseNode;
 import org.olat.course.run.environment.CourseEnvironment;
 import org.olat.course.run.userview.UserCourseEnvironment;
 import org.olat.modules.assessment.Role;
@@ -46,13 +46,13 @@ public class ResetAttemptsConfirmationController extends FormBasicController {
 	
 	private final Identity assessedIdentity;
 	private final CourseEnvironment courseEnv;
-	private final AssessableCourseNode courseNode;
+	private final CourseNode courseNode;
 	
 	@Autowired
 	private CourseAssessmentService courseAssessmentService;
 	
 	public ResetAttemptsConfirmationController(UserRequest ureq, WindowControl wControl,
-			CourseEnvironment courseEnv, AssessableCourseNode courseNode, Identity assessedIdentity) {
+			CourseEnvironment courseEnv, CourseNode courseNode, Identity assessedIdentity) {
 		super(ureq, wControl, "reset_attempts", Util.createPackageTranslator(IdentityListCourseNodeController.class, ureq.getLocale()));
 		this.courseEnv = courseEnv;
 		this.courseNode = courseNode;
diff --git a/src/main/java/org/olat/course/nodes/AssessableCourseNode.java b/src/main/java/org/olat/course/nodes/AssessableCourseNode.java
deleted file mode 100644
index e9eb7a564d9343e88e41d99b5a5392b6660969a5..0000000000000000000000000000000000000000
--- a/src/main/java/org/olat/course/nodes/AssessableCourseNode.java
+++ /dev/null
@@ -1,40 +0,0 @@
-/**
-
-* OLAT - Online Learning and Training<br>
-* http://www.olat.org
-* <p>
-* Licensed under the Apache License, Version 2.0 (the "License"); <br>
-* you may not use this file except in compliance with the License.<br>
-* You may obtain a copy of the License at
-* <p>
-* http://www.apache.org/licenses/LICENSE-2.0
-* <p>
-* Unless required by applicable law or agreed to in writing,<br>
-* software distributed under the License is distributed on an "AS IS" BASIS, <br>
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. <br>
-* See the License for the specific language governing permissions and <br>
-* limitations under the License.
-* <p>
-* Copyright (c) since 2004 at Multimedia- & E-Learning Services (MELS),<br>
-* University of Zurich, Switzerland.
-* <hr>
-* <a href="http://www.openolat.org">
-* OpenOLAT - Online Learning and Training</a><br>
-* This file has been modified by the OpenOLAT community. Changes are licensed
-* under the Apache 2.0 license as the original file.
-*/
-
-package org.olat.course.nodes;
-
-/**
- * Initial Date:  Jun 18, 2004
- * @author gnaegi
- *
- * Comment: 
- * All course nodes that are of an assessement type must implement this 
- * interface so that the assessment results can be managed by the assessment
- * tool.
- */
-public interface AssessableCourseNode extends CourseNode {
-
-}
diff --git a/src/main/java/org/olat/course/nodes/BasicLTICourseNode.java b/src/main/java/org/olat/course/nodes/BasicLTICourseNode.java
index 555f33e8a3fcbe02824df60d5fe019556e33ff59..282cfbb594d445a28c48f43eb7b13110eed644d1 100644
--- a/src/main/java/org/olat/course/nodes/BasicLTICourseNode.java
+++ b/src/main/java/org/olat/course/nodes/BasicLTICourseNode.java
@@ -59,7 +59,7 @@ import org.olat.resource.OLATResource;
  * @author guido
  * @author Charles Severance
  */
-public class BasicLTICourseNode extends AbstractAccessableCourseNode implements AssessableCourseNode {
+public class BasicLTICourseNode extends AbstractAccessableCourseNode implements CourseNode {
 
 	private static final long serialVersionUID = 2210572148308757127L;
 	private static final String translatorPackage = Util.getPackageName(LTIEditController.class);
diff --git a/src/main/java/org/olat/course/nodes/CheckListCourseNode.java b/src/main/java/org/olat/course/nodes/CheckListCourseNode.java
index cc1fbd2388b61bc591fde604c289c489de5e1aa3..9b632239b49c6439cd6186c2d0dd548e1847fe31 100644
--- a/src/main/java/org/olat/course/nodes/CheckListCourseNode.java
+++ b/src/main/java/org/olat/course/nodes/CheckListCourseNode.java
@@ -87,7 +87,7 @@ import org.olat.repository.RepositoryEntry;
  * @author srosse, stephane.rosse@frentix.com, http://www.frentix.com
  *
  */
-public class CheckListCourseNode extends AbstractAccessableCourseNode implements AssessableCourseNode {
+public class CheckListCourseNode extends AbstractAccessableCourseNode implements CourseNode {
 	
 	private static final String PACKAGE_CL = Util.getPackageName(CheckListEditController.class);
 	private static final long serialVersionUID = -7460670977531082040L;
diff --git a/src/main/java/org/olat/course/nodes/GTACourseNode.java b/src/main/java/org/olat/course/nodes/GTACourseNode.java
index 319bb12471e775b7847cfd61d4139ec539448bd1..8a716e0283d8aaef7f4da8ec5898f435cc7e162a 100644
--- a/src/main/java/org/olat/course/nodes/GTACourseNode.java
+++ b/src/main/java/org/olat/course/nodes/GTACourseNode.java
@@ -91,7 +91,7 @@ import org.olat.user.UserManager;
  * @author srosse, stephane.rosse@frentix.com, http://www.frentix.com
  *
  */
-public class GTACourseNode extends AbstractAccessableCourseNode implements AssessableCourseNode {
+public class GTACourseNode extends AbstractAccessableCourseNode implements CourseNode {
 	
 	private static final Logger log = Tracing.createLoggerFor(GTACourseNode.class);
 	private static final String PACKAGE_GTA = Util.getPackageName(GTAEditController.class);
@@ -535,7 +535,7 @@ public class GTACourseNode extends AbstractAccessableCourseNode implements Asses
 			
 			String courseTitle = course.getCourseTitle();
 			String fileName = ExportUtil.createFileNameWithTimeStamp(courseTitle, "xlsx");
-			List<AssessableCourseNode> nodes = Collections.singletonList(this);
+			List<CourseNode> nodes = Collections.singletonList(this);
 			try(OutputStream out = new ShieldOutputStream(exportStream)) {
 				exportStream.putNextEntry(new ZipEntry(dirName + "/" + fileName));
 				ScoreAccountingHelper.createCourseResultsOverviewXMLTable(users, nodes, course, locale, out);
diff --git a/src/main/java/org/olat/course/nodes/IQTESTCourseNode.java b/src/main/java/org/olat/course/nodes/IQTESTCourseNode.java
index 509cdfcd94056e7f9cd7f5291e8f6d60b31763df..5393dfd58f4fff219c9f5c4d42a5869d44af98b1 100644
--- a/src/main/java/org/olat/course/nodes/IQTESTCourseNode.java
+++ b/src/main/java/org/olat/course/nodes/IQTESTCourseNode.java
@@ -122,7 +122,7 @@ import uk.ac.ed.ph.jqtiplus.resolution.ResolvedAssessmentTest;
  * @author Mike Stock Comment:
  * @author BPS (<a href="http://www.bps-system.de/">BPS Bildungsportal Sachsen GmbH</a>)
  */
-public class IQTESTCourseNode extends AbstractAccessableCourseNode implements AssessableCourseNode, QTICourseNode {
+public class IQTESTCourseNode extends AbstractAccessableCourseNode implements CourseNode, QTICourseNode {
 	private static final long serialVersionUID = 5806292895738005387L;
 	private static final Logger log = Tracing.createLoggerFor(IQTESTCourseNode.class);
 	private static final String translatorStr = Util.getPackageName(IQEditController.class);
diff --git a/src/main/java/org/olat/course/nodes/MSCourseNode.java b/src/main/java/org/olat/course/nodes/MSCourseNode.java
index 4b07c728307fb63a40db0e0e9f586b54ae0e3c1a..3efe06cefb7c17d4e87be8d2bd301e77af8df3e2 100644
--- a/src/main/java/org/olat/course/nodes/MSCourseNode.java
+++ b/src/main/java/org/olat/course/nodes/MSCourseNode.java
@@ -85,7 +85,7 @@ import org.olat.resource.OLATResource;
  * @author gnaegi
  * @author BPS (<a href="http://www.bps-system.de/">BPS Bildungsportal Sachsen GmbH</a>)
  */
-public class MSCourseNode extends AbstractAccessableCourseNode implements AssessableCourseNode {
+public class MSCourseNode extends AbstractAccessableCourseNode implements CourseNode {
 	
 	private static final long serialVersionUID = -7741172700015384397L;
 	
diff --git a/src/main/java/org/olat/course/nodes/PortfolioCourseNode.java b/src/main/java/org/olat/course/nodes/PortfolioCourseNode.java
index 9f0de6b4d39980282504d9955af70dabcd97402e..63ad3b6b9d6b4d63103cecf0f57400832f1286c9 100644
--- a/src/main/java/org/olat/course/nodes/PortfolioCourseNode.java
+++ b/src/main/java/org/olat/course/nodes/PortfolioCourseNode.java
@@ -78,7 +78,7 @@ import org.olat.repository.handlers.RepositoryHandlerFactory;
  * Initial Date:  6 oct. 2010 <br>
  * @author srosse, stephane.rosse@frentix.com, http://www.frentix.com
  */
-public class PortfolioCourseNode extends AbstractAccessableCourseNode implements AssessableCourseNode {
+public class PortfolioCourseNode extends AbstractAccessableCourseNode implements CourseNode {
 	
 	private static final Logger log = Tracing.createLoggerFor(PortfolioCourseNode.class);
 	private static final int CURRENT_CONFIG_VERSION = 2;
diff --git a/src/main/java/org/olat/course/nodes/ProjectBrokerCourseNode.java b/src/main/java/org/olat/course/nodes/ProjectBrokerCourseNode.java
index 1ce4d540116c2a9b823db2f47282ecbe0c748d20..d009b370c54ff1e56d46bb0a22c4132474895d87 100644
--- a/src/main/java/org/olat/course/nodes/ProjectBrokerCourseNode.java
+++ b/src/main/java/org/olat/course/nodes/ProjectBrokerCourseNode.java
@@ -115,7 +115,7 @@ import com.thoughtworks.xstream.XStream;
  *   @author Christian Guretzki
  */
 
-public class ProjectBrokerCourseNode extends GenericCourseNode implements AssessableCourseNode {
+public class ProjectBrokerCourseNode extends GenericCourseNode implements CourseNode {
 
 	private static final long serialVersionUID = -8177448874150049173L;
 	private static final Logger log = Tracing.createLoggerFor(ProjectBrokerCourseNode.class);
diff --git a/src/main/java/org/olat/course/nodes/STCourseNode.java b/src/main/java/org/olat/course/nodes/STCourseNode.java
index 18eeeb0ac3d54aab70bf286ef5072df8aa9f7d04..a66fd80f9134def8e1a6736196b994e3edb8e731 100644
--- a/src/main/java/org/olat/course/nodes/STCourseNode.java
+++ b/src/main/java/org/olat/course/nodes/STCourseNode.java
@@ -93,7 +93,7 @@ import org.olat.util.logging.activity.LoggingResourceable;
  * @author Mike Stock
  * @author BPS (<a href="http://www.bps-system.de/">BPS Bildungsportal Sachsen GmbH</a>)
  */
-public class STCourseNode extends AbstractAccessableCourseNode implements AssessableCourseNode {
+public class STCourseNode extends AbstractAccessableCourseNode implements CourseNode {
 	
 	private static final Logger log = Tracing.createLoggerFor(STCourseNode.class);
 
diff --git a/src/main/java/org/olat/course/nodes/ScormCourseNode.java b/src/main/java/org/olat/course/nodes/ScormCourseNode.java
index fab1348a4ce72a8b2dac3f32fb413c0a0bb5f289..8068c22c032c6faf5345600b6702b588b6e8b5b0 100644
--- a/src/main/java/org/olat/course/nodes/ScormCourseNode.java
+++ b/src/main/java/org/olat/course/nodes/ScormCourseNode.java
@@ -76,7 +76,7 @@ import org.olat.repository.handlers.RepositoryHandlerFactory;
  * @author Felix Jost
  * @author BPS (<a href="http://www.bps-system.de/">BPS Bildungsportal Sachsen GmbH</a>)
  */
-public class ScormCourseNode extends AbstractAccessableCourseNode implements AssessableCourseNode {
+public class ScormCourseNode extends AbstractAccessableCourseNode implements CourseNode {
 	
 	private static final Logger log = Tracing.createLoggerFor(ScormCourseNode.class);
 	private static final long serialVersionUID = 2970594874787761801L;
diff --git a/src/main/java/org/olat/course/nodes/TACourseNode.java b/src/main/java/org/olat/course/nodes/TACourseNode.java
index d56b310129bc16006a52747d6c7a11d857cc52d0..f64fc45260dcb7826d359e6221ecb1f928a217d9 100644
--- a/src/main/java/org/olat/course/nodes/TACourseNode.java
+++ b/src/main/java/org/olat/course/nodes/TACourseNode.java
@@ -101,7 +101,7 @@ import org.olat.resource.OLATResource;
  * 	 @author BPS (<a href="http://www.bps-system.de/">BPS Bildungsportal Sachsen GmbH</a>)
  */
 
-public class TACourseNode extends GenericCourseNode implements AssessableCourseNode {
+public class TACourseNode extends GenericCourseNode implements CourseNode {
 	
 	private static final long serialVersionUID = -7266553843441305310L;
 
@@ -505,7 +505,7 @@ public class TACourseNode extends GenericCourseNode implements AssessableCourseN
 			
 			String courseTitle = course.getCourseTitle();
 			String fileName = ExportUtil.createFileNameWithTimeStamp(courseTitle, "xlsx");
-			List<AssessableCourseNode> nodes = Collections.singletonList(this);
+			List<CourseNode> nodes = Collections.singletonList(this);
 			// write course results overview table to filesystem
 			try(OutputStream out = new ShieldOutputStream(exportStream)) {
 				exportStream.putNextEntry(new ZipEntry(dirName + "/" + fileName));
diff --git a/src/main/java/org/olat/course/nodes/basiclti/LTIAssessmentConfig.java b/src/main/java/org/olat/course/nodes/basiclti/LTIAssessmentConfig.java
index 05d79b05c1aa527163115751dd689ee65879249d..30c2a555edf165f212bde5180a211dae53c0297d 100644
--- a/src/main/java/org/olat/course/nodes/basiclti/LTIAssessmentConfig.java
+++ b/src/main/java/org/olat/course/nodes/basiclti/LTIAssessmentConfig.java
@@ -39,6 +39,11 @@ public class LTIAssessmentConfig implements AssessmentConfig {
 		this.config = config;
 	}
 
+	@Override
+	public boolean isAssessable() {
+		return true;
+	}
+
 	@Override
 	public boolean isScoreEvaluationPersisted() {
 		return true;
diff --git a/src/main/java/org/olat/course/nodes/gta/ui/GTAIdentityListCourseNodeController.java b/src/main/java/org/olat/course/nodes/gta/ui/GTAIdentityListCourseNodeController.java
index 8178165c5cc368eeb20644e85ccb7ebfc1cc8f39..d66ecae36200cbfbdefc040fb07d68ede85ac2b6 100644
--- a/src/main/java/org/olat/course/nodes/gta/ui/GTAIdentityListCourseNodeController.java
+++ b/src/main/java/org/olat/course/nodes/gta/ui/GTAIdentityListCourseNodeController.java
@@ -44,7 +44,6 @@ import org.olat.course.assessment.bulk.BulkAssessmentToolController;
 import org.olat.course.assessment.ui.tool.IdentityListCourseNodeController;
 import org.olat.course.assessment.ui.tool.IdentityListCourseNodeTableModel.IdentityCourseElementCols;
 import org.olat.course.nodes.ArchiveOptions;
-import org.olat.course.nodes.AssessableCourseNode;
 import org.olat.course.nodes.CourseNode;
 import org.olat.course.nodes.GTACourseNode;
 import org.olat.course.nodes.gta.GTAManager;
@@ -140,8 +139,8 @@ public class GTAIdentityListCourseNodeController extends IdentityListCourseNodeC
 	private void initBulkAsssessmentTool(UserRequest ureq, FormLayoutContainer formLayout) {
 		removeAsListenerAndDispose(bulkAssessmentToolCtrl);
 		
-		bulkAssessmentToolCtrl = new BulkAssessmentToolController(ureq, getWindowControl(),
-				getCourseEnvironment(), (AssessableCourseNode)courseNode);
+		bulkAssessmentToolCtrl = new BulkAssessmentToolController(ureq, getWindowControl(), getCourseEnvironment(),
+				courseNode);
 		listenTo(bulkAssessmentToolCtrl);
 		formLayout.put("bulk.assessment", bulkAssessmentToolCtrl.getInitialComponent());	
 	}
@@ -216,12 +215,12 @@ public class GTAIdentityListCourseNodeController extends IdentityListCourseNodeC
 	
 	@Override
 	protected Controller createCalloutController(UserRequest ureq, Identity assessedIdentity) {
-		return new GTAIdentityListCourseNodeToolsController(ureq, getWindowControl(),
-				(AssessableCourseNode)courseNode, assessedIdentity, coachCourseEnv);
+		return new GTAIdentityListCourseNodeToolsController(ureq, getWindowControl(), courseNode, assessedIdentity,
+				coachCourseEnv);
 	}
 
 	@Override
-	protected void doSetDone(Identity assessedIdentity, AssessableCourseNode assessableCourseNode, ICourse course) {
+	protected void doSetDone(Identity assessedIdentity, CourseNode assessableCourseNode, ICourse course) {
 		super.doSetDone(assessedIdentity, assessableCourseNode, course);
 		
 		TaskList taskList = gtaManager.getTaskList(getCourseRepositoryEntry(), (GTACourseNode)assessableCourseNode);
diff --git a/src/main/java/org/olat/course/nodes/gta/ui/GTAIdentityListCourseNodeToolsController.java b/src/main/java/org/olat/course/nodes/gta/ui/GTAIdentityListCourseNodeToolsController.java
index 5a3c6abf42f2dadf9a36e2984422cf623407991f..d962cc5a77c7854ef149124d18e7a5522119d932 100644
--- a/src/main/java/org/olat/course/nodes/gta/ui/GTAIdentityListCourseNodeToolsController.java
+++ b/src/main/java/org/olat/course/nodes/gta/ui/GTAIdentityListCourseNodeToolsController.java
@@ -23,7 +23,7 @@ import org.olat.core.gui.UserRequest;
 import org.olat.core.gui.control.WindowControl;
 import org.olat.core.id.Identity;
 import org.olat.course.assessment.ui.tool.tools.AbstractToolsController;
-import org.olat.course.nodes.AssessableCourseNode;
+import org.olat.course.nodes.CourseNode;
 import org.olat.course.nodes.GTACourseNode;
 import org.olat.course.nodes.gta.GTAManager;
 import org.olat.course.nodes.gta.Task;
@@ -45,7 +45,7 @@ public class GTAIdentityListCourseNodeToolsController extends AbstractToolsContr
 	private GTAManager gtaManager;
 	
 	public GTAIdentityListCourseNodeToolsController(UserRequest ureq, WindowControl wControl,
-			AssessableCourseNode courseNode, Identity assessedIdentity, UserCourseEnvironment coachCourseEnv) {
+			CourseNode courseNode, Identity assessedIdentity, UserCourseEnvironment coachCourseEnv) {
 		super(ureq, wControl, courseNode, assessedIdentity, coachCourseEnv);
 		
 		initTools();
diff --git a/src/main/java/org/olat/course/nodes/gta/ui/GroupBulkDownloadResource.java b/src/main/java/org/olat/course/nodes/gta/ui/GroupBulkDownloadResource.java
index 986cabb473cebd298bd38f5abfe43366cfc7aa58..03322226b7b5b33c919d5595d8459ed408883cd3 100644
--- a/src/main/java/org/olat/course/nodes/gta/ui/GroupBulkDownloadResource.java
+++ b/src/main/java/org/olat/course/nodes/gta/ui/GroupBulkDownloadResource.java
@@ -45,7 +45,7 @@ import org.olat.core.util.io.ShieldOutputStream;
 import org.olat.course.CourseFactory;
 import org.olat.course.ICourse;
 import org.olat.course.archiver.ScoreAccountingHelper;
-import org.olat.course.nodes.AssessableCourseNode;
+import org.olat.course.nodes.CourseNode;
 import org.olat.course.nodes.GTACourseNode;
 import org.olat.course.nodes.gta.GTAManager;
 import org.olat.course.nodes.gta.TaskList;
@@ -130,7 +130,7 @@ public class GroupBulkDownloadResource implements MediaResource {
 						.getMembers(groups, GroupRoles.participant.name());
 				String courseTitle = course.getCourseTitle();
 				String fileName = ExportUtil.createFileNameWithTimeStamp(courseTitle, "xlsx");
-				List<AssessableCourseNode> nodes = Collections.singletonList(courseNode);
+				List<CourseNode> nodes = Collections.singletonList(courseNode);
 				try(OutputStream out = new ShieldOutputStream(zout)) {
 					zout.putNextEntry(new ZipEntry(fileName));
 					ScoreAccountingHelper.createCourseResultsOverviewXMLTable(assessableIdentities, nodes, course, locale, out);
diff --git a/src/main/java/org/olat/course/nodes/iq/IQTESTAssessmentConfig.java b/src/main/java/org/olat/course/nodes/iq/IQTESTAssessmentConfig.java
index eeae3a7e3034af59cbf0a74d994834f3d6d4815d..9d7fd0a40f896801cb5e4725ffa2b460fadcf084 100644
--- a/src/main/java/org/olat/course/nodes/iq/IQTESTAssessmentConfig.java
+++ b/src/main/java/org/olat/course/nodes/iq/IQTESTAssessmentConfig.java
@@ -41,6 +41,11 @@ public class IQTESTAssessmentConfig implements AssessmentConfig {
 		this.courseNode = courseNode;
 	}
 
+	@Override
+	public boolean isAssessable() {
+		return true;
+	}
+
 	@Override
 	public boolean isScoreEvaluationPersisted() {
 		return true;
diff --git a/src/main/java/org/olat/course/nodes/iq/QTI21AssessmentRunController.java b/src/main/java/org/olat/course/nodes/iq/QTI21AssessmentRunController.java
index 1ceccc2a5f86090fc15332b616c6196e4fa649fe..c1d117e87c90670f56839f15c3616f595ba8d003 100644
--- a/src/main/java/org/olat/course/nodes/iq/QTI21AssessmentRunController.java
+++ b/src/main/java/org/olat/course/nodes/iq/QTI21AssessmentRunController.java
@@ -66,7 +66,6 @@ import org.olat.course.assessment.handler.AssessmentConfig;
 import org.olat.course.assessment.manager.AssessmentNotificationsHandler;
 import org.olat.course.auditing.UserNodeAuditManager;
 import org.olat.course.highscore.ui.HighScoreRunController;
-import org.olat.course.nodes.AssessableCourseNode;
 import org.olat.course.nodes.CourseNode;
 import org.olat.course.nodes.IQSELFCourseNode;
 import org.olat.course.nodes.IQTESTCourseNode;
@@ -243,13 +242,13 @@ public class QTI21AssessmentRunController extends BasicController implements Gen
 			mainVC.contextPut("timeLimit", Formatter.formatHourAndSeconds(timeLimit.longValue() * 1000l));
 		}
 
-		if (courseNode instanceof AssessableCourseNode) {
-			AssessmentConfig assessmentConfig = courseAssessmentService.getAssessmentConfig(courseNode);
+		AssessmentConfig assessmentConfig = courseAssessmentService.getAssessmentConfig(courseNode);
+		if (assessmentConfig.isAssessable()) {
 			if (assessmentConfig.hasScore() || userCourseEnv.isCoach()){
 				HighScoreRunController highScoreCtr = new HighScoreRunController(ureq, getWindowControl(), userCourseEnv, courseNode);
 				if (highScoreCtr.isViewHighscore()) {
 					Component highScoreComponent = highScoreCtr.getInitialComponent();
-					mainVC.put("highScore", highScoreComponent);							
+					mainVC.put("highScore", highScoreComponent);
 				}
 			}
 		}
@@ -298,7 +297,6 @@ public class QTI21AssessmentRunController extends BasicController implements Gen
 				mainVC.contextPut("hasPassedValue", (passed == null ? Boolean.FALSE : Boolean.TRUE));
 				mainVC.contextPut("passed", passed);
 				if(resultsVisible) {
-					AssessmentConfig assessmentConfig = courseAssessmentService.getAssessmentConfig(courseNode);
 					if(assessmentConfig.hasComment()) {
 						StringBuilder comment = Formatter.stripTabsAndReturns(
 								courseAssessmentService.getUserComment(testCourseNode, userCourseEnv));
diff --git a/src/main/java/org/olat/course/nodes/ms/MSCourseNodeRunController.java b/src/main/java/org/olat/course/nodes/ms/MSCourseNodeRunController.java
index 8bdd719accf162ac1eedbc5c5ae89a33a6ddaddf..4dc467bd1d87fb37539efde84c7d31b17820de6d 100644
--- a/src/main/java/org/olat/course/nodes/ms/MSCourseNodeRunController.java
+++ b/src/main/java/org/olat/course/nodes/ms/MSCourseNodeRunController.java
@@ -50,7 +50,6 @@ import org.olat.course.assessment.CourseAssessmentService;
 import org.olat.course.assessment.handler.AssessmentConfig;
 import org.olat.course.auditing.UserNodeAuditManager;
 import org.olat.course.highscore.ui.HighScoreRunController;
-import org.olat.course.nodes.AssessableCourseNode;
 import org.olat.course.nodes.CourseNode;
 import org.olat.course.nodes.MSCourseNode;
 import org.olat.course.nodes.ObjectivesHelper;
@@ -74,7 +73,7 @@ public class MSCourseNodeRunController extends BasicController implements Activa
 	private boolean hasScore, hasPassed, hasComment;
 	private final UserCourseEnvironment userCourseEnv;
 	private final boolean overrideUserResultsVisiblity;
-	private final AssessableCourseNode courseNode;
+	private final CourseNode courseNode;
 	
 	@Autowired
 	private CourseModule courseModule;
@@ -87,12 +86,12 @@ public class MSCourseNodeRunController extends BasicController implements Activa
 	 * @param ureq The user request
 	 * @param wControl The window control
 	 * @param userCourseEnv The user course environment
-	 * @param msCourseNode An assessable course node
+	 * @param msCourseNode An course node
 	 * @param displayNodeInfo If true, the node title and learning objectives will be displayed
 	 * @param showLog If true, the change log will be displayed
 	 */
 	public MSCourseNodeRunController(UserRequest ureq, WindowControl wControl, UserCourseEnvironment userCourseEnv,
-			AssessableCourseNode courseNode, boolean displayNodeInfo, boolean showLog) {
+			CourseNode courseNode, boolean displayNodeInfo, boolean showLog) {
 		this(ureq, wControl, userCourseEnv, courseNode, displayNodeInfo, showLog, false);
 	}
 	
@@ -102,14 +101,13 @@ public class MSCourseNodeRunController extends BasicController implements Activa
 	 * @param ureq The user request
 	 * @param wControl The window control
 	 * @param userCourseEnv The user course environment
-	 * @param courseNode An assessable course element
+	 * @param courseNode An course element
 	 * @param displayNodeInfo If true, the node title and learning objectives will be displayed
 	 * @param showLog If true, the change log will be displayed
 	 * @param overrideUserResultsVisiblity If the controller can override the user visiblity of the score evaluation
 	 */
-	public MSCourseNodeRunController(UserRequest ureq, WindowControl wControl,
-			UserCourseEnvironment userCourseEnv, AssessableCourseNode courseNode,
-			boolean displayNodeInfo, boolean showLog, boolean overrideUserResultsVisiblity) {
+	public MSCourseNodeRunController(UserRequest ureq, WindowControl wControl, UserCourseEnvironment userCourseEnv,
+			CourseNode courseNode, boolean displayNodeInfo, boolean showLog, boolean overrideUserResultsVisiblity) {
 		super(ureq, wControl, Util.createPackageTranslator(CourseNode.class, ureq.getLocale()));
 		
 		this.showLog = showLog;
diff --git a/src/main/java/org/olat/course/nodes/projectbroker/ProjectBrokerAssessmentConfig.java b/src/main/java/org/olat/course/nodes/projectbroker/ProjectBrokerAssessmentConfig.java
index e6a80de70eec00d940f54f68eccf4ea108c27463..9491c2642c85dd6c294c297aa02fc91dac48db34 100644
--- a/src/main/java/org/olat/course/nodes/projectbroker/ProjectBrokerAssessmentConfig.java
+++ b/src/main/java/org/olat/course/nodes/projectbroker/ProjectBrokerAssessmentConfig.java
@@ -34,6 +34,11 @@ public class ProjectBrokerAssessmentConfig extends ModuleAssessmentConfig {
 	public ProjectBrokerAssessmentConfig(ModuleConfiguration config) {
 		super(config);
 	}
+
+	@Override
+	public boolean isAssessable() {
+		return true;
+	}
 	
 	@Override
 	public boolean hasScore() {
diff --git a/src/main/java/org/olat/course/nodes/scorm/ScormAssessmentConfig.java b/src/main/java/org/olat/course/nodes/scorm/ScormAssessmentConfig.java
index 5c2326f1c589834a223f39b9a7ca3bbc9379b584..652c886081254c73378a25ab3a07c591bca1ce21 100644
--- a/src/main/java/org/olat/course/nodes/scorm/ScormAssessmentConfig.java
+++ b/src/main/java/org/olat/course/nodes/scorm/ScormAssessmentConfig.java
@@ -36,6 +36,11 @@ public class ScormAssessmentConfig implements AssessmentConfig {
 		this.config = config;
 	}
 
+	@Override
+	public boolean isAssessable() {
+		return true;
+	}
+
 	@Override
 	public boolean isScoreEvaluationPersisted() {
 		return true;
diff --git a/src/main/java/org/olat/course/nodes/st/STAssessmentConfig.java b/src/main/java/org/olat/course/nodes/st/STAssessmentConfig.java
index 32e14710f5e7068ecca93cc04d50045917134c0b..c78df5cdec799c7d61f67cf6d680a66ef5820eac 100644
--- a/src/main/java/org/olat/course/nodes/st/STAssessmentConfig.java
+++ b/src/main/java/org/olat/course/nodes/st/STAssessmentConfig.java
@@ -38,6 +38,11 @@ public class STAssessmentConfig implements AssessmentConfig {
 		this.scoreCalculator = scoreCalculator;
 	}
 
+	@Override
+	public boolean isAssessable() {
+		return true;
+	}
+
 	@Override
 	public boolean isScoreEvaluationPersisted() {
 		return true;
diff --git a/src/main/java/org/olat/course/nodes/st/STIdentityListCourseNodeController.java b/src/main/java/org/olat/course/nodes/st/STIdentityListCourseNodeController.java
index a48ae3fe9c710538d1cc955bc64325d9b3202d71..eeed8113435539784378acc828900308c05b42ff 100644
--- a/src/main/java/org/olat/course/nodes/st/STIdentityListCourseNodeController.java
+++ b/src/main/java/org/olat/course/nodes/st/STIdentityListCourseNodeController.java
@@ -45,6 +45,7 @@ import org.olat.core.gui.media.MediaResource;
 import org.olat.core.util.FileUtils;
 import org.olat.course.CourseFactory;
 import org.olat.course.ICourse;
+import org.olat.course.assessment.handler.AssessmentConfig;
 import org.olat.course.assessment.manager.UserCourseInformationsManager;
 import org.olat.course.assessment.ui.tool.AssessmentIdentiesPrintController;
 import org.olat.course.assessment.ui.tool.IdentityListCourseNodeController;
@@ -103,7 +104,7 @@ public class STIdentityListCourseNodeController extends IdentityListCourseNodeCo
 	}
 
 	@Override
-	protected void initCalloutColumns(FlexiTableColumnModel columnsModel) {
+	protected void initCalloutColumns(FlexiTableColumnModel columnsModel, AssessmentConfig assessmentConfig) {
 		ICourse course = CourseFactory.loadCourse(getCourseRepositoryEntry());
 		if(course.getCourseConfig().isCertificateEnabled()) {
 			columnsModel.addFlexiColumnModel(new DefaultFlexiColumnModel(IdentityCourseElementCols.certificate, new DownloadCertificateCellRenderer(getLocale())));
diff --git a/src/main/java/org/olat/course/nodes/ta/DropboxScoringViewController.java b/src/main/java/org/olat/course/nodes/ta/DropboxScoringViewController.java
index ad830009b86f8c9cec067fb3807d2c61ecf5d7b1..7cde92b24f8ea7f66f8f996a467ece2b1f5b84f3 100644
--- a/src/main/java/org/olat/course/nodes/ta/DropboxScoringViewController.java
+++ b/src/main/java/org/olat/course/nodes/ta/DropboxScoringViewController.java
@@ -75,7 +75,6 @@ import org.olat.core.util.vfs.callbacks.VFSSecurityCallback;
 import org.olat.course.assessment.CourseAssessmentService;
 import org.olat.course.assessment.handler.AssessmentConfig;
 import org.olat.course.auditing.UserNodeAuditManager;
-import org.olat.course.nodes.AssessableCourseNode;
 import org.olat.course.nodes.CourseNode;
 import org.olat.course.nodes.TACourseNode;
 import org.olat.course.properties.CoursePropertyManager;
@@ -306,12 +305,11 @@ public class DropboxScoringViewController extends BasicController {
 					Identity coach = ureq.getIdentity();
 					Identity student = userCourseEnv.getIdentityEnvironment().getIdentity();
 					
-					if(node instanceof AssessableCourseNode) {
-						AssessableCourseNode acn = (AssessableCourseNode)node;
+					if(courseAssessmentService.getAssessmentConfig(node).isAssessable()) {
 						AssessmentEvaluation eval = courseAssessmentService.getAssessmentEvaluation(node, userCourseEnv);
 						if(eval.getAssessmentStatus() == null || eval.getAssessmentStatus() == AssessmentEntryStatus.notStarted) {
 							eval = new AssessmentEvaluation(eval, AssessmentEntryStatus.inProgress);
-							courseAssessmentService.updateScoreEvaluation(acn, eval, userCourseEnv, coach, false, Role.coach);
+							courseAssessmentService.updateScoreEvaluation(node, eval, userCourseEnv, coach, false, Role.coach);
 						}
 					}
 
@@ -342,15 +340,14 @@ public class DropboxScoringViewController extends BasicController {
 					}
 				}
 			} else if(FolderCommand.FOLDERCOMMAND_FINISHED == event) {
-				if(node instanceof AssessableCourseNode) {
-					AssessableCourseNode acn = (AssessableCourseNode)node;
+				if(courseAssessmentService.getAssessmentConfig(node).isAssessable()) {
 					AssessmentEvaluation eval = courseAssessmentService.getAssessmentEvaluation(node, userCourseEnv);
 					if (eval == null) {
 						eval = AssessmentEvaluation.EMPTY_EVAL;
 					}
 					if(eval.getAssessmentStatus() == null || eval.getAssessmentStatus() == AssessmentEntryStatus.notStarted) {
 						eval = new AssessmentEvaluation(eval, AssessmentEntryStatus.inProgress);
-						courseAssessmentService.updateScoreEvaluation(acn, eval, userCourseEnv, getIdentity(), false, Role.coach);
+						courseAssessmentService.updateScoreEvaluation(node, eval, userCourseEnv, getIdentity(), false, Role.coach);
 						fireEvent(ureq, Event.CHANGED_EVENT);
 					}
 				}
diff --git a/src/main/java/org/olat/course/reminder/ui/AttemptsRuleEditor.java b/src/main/java/org/olat/course/reminder/ui/AttemptsRuleEditor.java
index caaed2a21b4000fe02b7e42dcb0e7bba747135f5..a750b4f01a99db7e255943b4efb5410d2527dd20 100644
--- a/src/main/java/org/olat/course/reminder/ui/AttemptsRuleEditor.java
+++ b/src/main/java/org/olat/course/reminder/ui/AttemptsRuleEditor.java
@@ -37,7 +37,6 @@ import org.olat.course.CourseFactory;
 import org.olat.course.ICourse;
 import org.olat.course.assessment.CourseAssessmentService;
 import org.olat.course.assessment.handler.AssessmentConfig;
-import org.olat.course.nodes.AssessableCourseNode;
 import org.olat.course.nodes.CourseNode;
 import org.olat.course.nodes.QTICourseNode;
 import org.olat.course.reminder.rule.AttemptsRuleSPI;
@@ -146,12 +145,10 @@ public class AttemptsRuleEditor extends RuleEditorFragment {
 	}
 	
 	private void searchAttemptableNodes(CourseNode courseNode, List<CourseNode> nodes) {
-		if (courseNode instanceof AssessableCourseNode) {
-			CourseAssessmentService courseAssessmentService = CoreSpringFactory.getImpl(CourseAssessmentService.class);
-			AssessmentConfig assessmentConfig = courseAssessmentService.getAssessmentConfig(courseNode);
-			if (assessmentConfig.hasAttempts()) {
-				nodes.add(courseNode);
-			}
+		CourseAssessmentService courseAssessmentService = CoreSpringFactory.getImpl(CourseAssessmentService.class);
+		AssessmentConfig assessmentConfig = courseAssessmentService.getAssessmentConfig(courseNode);
+		if (assessmentConfig.hasAttempts()) {
+			nodes.add(courseNode);
 		} else if (courseNode instanceof QTICourseNode) {
 			QTICourseNode assessableCourseNode = (QTICourseNode) courseNode;
 			if (assessableCourseNode.hasAttemptsConfigured()) {
diff --git a/src/main/java/org/olat/course/reminder/ui/InitialAttemptsRuleEditor.java b/src/main/java/org/olat/course/reminder/ui/InitialAttemptsRuleEditor.java
index df082ee2ec35e85ae3ede3e7882b3fb8346ffc01..c375b5389057c659f846c069a35c382a44103597 100644
--- a/src/main/java/org/olat/course/reminder/ui/InitialAttemptsRuleEditor.java
+++ b/src/main/java/org/olat/course/reminder/ui/InitialAttemptsRuleEditor.java
@@ -38,7 +38,6 @@ import org.olat.course.CourseFactory;
 import org.olat.course.ICourse;
 import org.olat.course.assessment.CourseAssessmentService;
 import org.olat.course.assessment.handler.AssessmentConfig;
-import org.olat.course.nodes.AssessableCourseNode;
 import org.olat.course.nodes.CourseNode;
 import org.olat.course.reminder.rule.InitialAttemptsRuleSPI;
 import org.olat.modules.reminder.ReminderRule;
@@ -155,12 +154,10 @@ public class InitialAttemptsRuleEditor extends RuleEditorFragment {
 	}
 	
 	private void searchAttemptableNodes(CourseNode courseNode, List<CourseNode> nodes) {
-		if (courseNode instanceof AssessableCourseNode) {
-			CourseAssessmentService courseAssessmentService = CoreSpringFactory.getImpl(CourseAssessmentService.class);
-			AssessmentConfig assessmentConfig = courseAssessmentService.getAssessmentConfig(courseNode);
-			if (assessmentConfig.hasAttempts()) {
-				nodes.add(courseNode);
-			}
+		CourseAssessmentService courseAssessmentService = CoreSpringFactory.getImpl(CourseAssessmentService.class);
+		AssessmentConfig assessmentConfig = courseAssessmentService.getAssessmentConfig(courseNode);
+		if (assessmentConfig.hasAttempts()) {
+			nodes.add(courseNode);
 		}
 		
 		for(int i=0; i<courseNode.getChildCount(); i++) {
diff --git a/src/main/java/org/olat/course/reminder/ui/PassedRuleEditor.java b/src/main/java/org/olat/course/reminder/ui/PassedRuleEditor.java
index d48b04ac3448dbebd38895079fd5baaedd206f30..fbd90e9c32bad49a4f606033217a0d2c9d17e210 100644
--- a/src/main/java/org/olat/course/reminder/ui/PassedRuleEditor.java
+++ b/src/main/java/org/olat/course/reminder/ui/PassedRuleEditor.java
@@ -37,7 +37,6 @@ import org.olat.course.CourseFactory;
 import org.olat.course.ICourse;
 import org.olat.course.assessment.CourseAssessmentService;
 import org.olat.course.assessment.handler.AssessmentConfig;
-import org.olat.course.nodes.AssessableCourseNode;
 import org.olat.course.nodes.CourseNode;
 import org.olat.course.reminder.rule.PassedRuleSPI;
 import org.olat.modules.reminder.ReminderRule;
@@ -141,12 +140,10 @@ public class PassedRuleEditor extends RuleEditorFragment {
 	}
 	
 	private void searchPassedNodes(CourseNode courseNode, List<CourseNode> nodes) {
-		if (courseNode instanceof AssessableCourseNode) {
-			CourseAssessmentService courseAssessmentService = CoreSpringFactory.getImpl(CourseAssessmentService.class);
-			AssessmentConfig assessmentConfig = courseAssessmentService.getAssessmentConfig(courseNode);
-			if (assessmentConfig.hasPassed()) {
-				nodes.add(courseNode);
-			}
+		CourseAssessmentService courseAssessmentService = CoreSpringFactory.getImpl(CourseAssessmentService.class);
+		AssessmentConfig assessmentConfig = courseAssessmentService.getAssessmentConfig(courseNode);
+		if (assessmentConfig.hasPassed()) {
+			nodes.add(courseNode);
 		}
 		
 		for(int i=0; i<courseNode.getChildCount(); i++) {
diff --git a/src/main/java/org/olat/course/reminder/ui/ScoreRuleEditor.java b/src/main/java/org/olat/course/reminder/ui/ScoreRuleEditor.java
index 2dc4749c0cc8adb9af1c54707e377dde68869e4b..b67e30bd666783d2d1d64cb0a7e1702e913bb4ed 100644
--- a/src/main/java/org/olat/course/reminder/ui/ScoreRuleEditor.java
+++ b/src/main/java/org/olat/course/reminder/ui/ScoreRuleEditor.java
@@ -37,7 +37,6 @@ import org.olat.course.CourseFactory;
 import org.olat.course.ICourse;
 import org.olat.course.assessment.CourseAssessmentService;
 import org.olat.course.assessment.handler.AssessmentConfig;
-import org.olat.course.nodes.AssessableCourseNode;
 import org.olat.course.nodes.CourseNode;
 import org.olat.course.reminder.rule.ScoreRuleSPI;
 import org.olat.modules.reminder.ReminderRule;
@@ -144,12 +143,10 @@ public class ScoreRuleEditor extends RuleEditorFragment {
 	}
 	
 	private void searchScoreableNodes(CourseNode courseNode, List<CourseNode> nodes) {
-		if (courseNode instanceof AssessableCourseNode) {
-			CourseAssessmentService courseAssessmentService = CoreSpringFactory.getImpl(CourseAssessmentService.class);
-			AssessmentConfig assessmentConfig = courseAssessmentService.getAssessmentConfig(courseNode);
-			if (assessmentConfig.hasScore()) {
-				nodes.add(courseNode);
-			}
+		CourseAssessmentService courseAssessmentService = CoreSpringFactory.getImpl(CourseAssessmentService.class);
+		AssessmentConfig assessmentConfig = courseAssessmentService.getAssessmentConfig(courseNode);
+		if (assessmentConfig.hasScore()) {
+			nodes.add(courseNode);
 		}
 		
 		for(int i=0; i<courseNode.getChildCount(); i++) {
diff --git a/src/main/java/org/olat/course/run/scoring/ScoreAccounting.java b/src/main/java/org/olat/course/run/scoring/ScoreAccounting.java
index 278d0e1d603fedf666efa2ad7d6ec5ac20ce98a9..1a6d481ee6512ebcb5be33ebbe8aeb16e11b414a 100644
--- a/src/main/java/org/olat/course/run/scoring/ScoreAccounting.java
+++ b/src/main/java/org/olat/course/run/scoring/ScoreAccounting.java
@@ -44,7 +44,6 @@ import org.olat.course.assessment.CourseAssessmentService;
 import org.olat.course.assessment.handler.AssessmentConfig;
 import org.olat.course.condition.interpreter.ConditionInterpreter;
 import org.olat.course.groupsandrights.CourseGroupManager;
-import org.olat.course.nodes.AssessableCourseNode;
 import org.olat.course.nodes.CourseNode;
 import org.olat.course.run.userview.UserCourseEnvironment;
 import org.olat.modules.assessment.AssessmentEntry;
@@ -69,7 +68,7 @@ public class ScoreAccounting {
 
 	private boolean error;
 	private final UserCourseEnvironment userCourseEnvironment;
-	private final Map<AssessableCourseNode, AssessmentEvaluation> cachedScoreEvals = new HashMap<>();
+	private final Map<CourseNode, AssessmentEvaluation> cachedScoreEvals = new HashMap<>();
 	
 	@Autowired
 	private CourseAssessmentService courseAssessmentService;
@@ -108,11 +107,8 @@ public class ScoreAccounting {
 		for(AssessmentEntry entry:entries) {
 			String nodeIdent = entry.getSubIdent();
 			CourseNode courseNode = userCourseEnvironment.getCourseEnvironment().getRunStructure().getNode(nodeIdent);
-			if(courseNode instanceof AssessableCourseNode) {
-				AssessableCourseNode acn = (AssessableCourseNode)courseNode;
-				AssessmentEvaluation se = courseAssessmentService.toAssessmentEvaluation(entry, courseNode);
-				cachedScoreEvals.put(acn, se);
-			}
+			AssessmentEvaluation se = courseAssessmentService.toAssessmentEvaluation(entry, courseNode);
+			cachedScoreEvals.put(courseNode, se);
 		}
 		
 		TreeVisitor tv = new TreeVisitor(visitor, root, true); // true=depth first
@@ -148,13 +144,10 @@ public class ScoreAccounting {
 
 		@Override
 		public void visit(INode node) {
-			CourseNode cn = (CourseNode) node;
-			if (cn instanceof AssessableCourseNode) {
-				evalCourseNode((AssessableCourseNode)cn);
-			}
+			evalCourseNode((CourseNode)node);
 		}
 		
-		public AssessmentEvaluation evalCourseNode(AssessableCourseNode cn) {
+		public AssessmentEvaluation evalCourseNode(CourseNode cn) {
 			// make sure we have no circular calculations
 			recursionLevel++;
 			AssessmentEvaluation se = null;
@@ -372,7 +365,7 @@ public class ScoreAccounting {
 	 * @param cn
 	 * @return ScoreEvaluation
 	 */
-	public AssessmentEvaluation evalCourseNode(AssessableCourseNode cn) {
+	public AssessmentEvaluation evalCourseNode(CourseNode cn) {
 		AssessmentEvaluation se = cachedScoreEvals.get(cn);
 		if (se == null) { // result of this node has not been calculated yet, do it
 			se = getScoreEvaluation(cn);
@@ -393,9 +386,8 @@ public class ScoreAccounting {
 		CourseNode foundNode = findChildByID(childId);
 		
 		Float score = null;
-		if (foundNode instanceof AssessableCourseNode) {
-			AssessableCourseNode acn = (AssessableCourseNode) foundNode;
-			ScoreEvaluation se = evalCourseNode(acn);
+		if (foundNode != null) {
+			ScoreEvaluation se = evalCourseNode(foundNode);
 			if(se != null) {
 				// the node could not provide any sensible information on scoring. e.g. a STNode with no calculating rules
 				if(se.getUserVisible() == null || se.getUserVisible().booleanValue()) {
@@ -429,9 +421,8 @@ public class ScoreAccounting {
 		for (String childId : childIds) {
 			CourseNode foundNode = findChildByID(childId);
 			Float score = null;
-			if (foundNode instanceof AssessableCourseNode) {
-				AssessableCourseNode acn = (AssessableCourseNode) foundNode;
-				ScoreEvaluation se = evalCourseNode(acn);
+			if (foundNode != null) {
+				ScoreEvaluation se = evalCourseNode(foundNode);
 				if(se != null) {
 					// the node could not provide any sensible information on scoring. e.g. a STNode with no calculating rules
 					if(se.getUserVisible() == null || se.getUserVisible().booleanValue()) {
@@ -463,14 +454,9 @@ public class ScoreAccounting {
 			error = true;
 			return Boolean.FALSE;
 		}
-		if (!(foundNode instanceof AssessableCourseNode)) {
-			error = true;
-			return Boolean.FALSE;
-		}
-		AssessableCourseNode acn = (AssessableCourseNode) foundNode;
-		ScoreEvaluation se = evalCourseNode(acn);
+		ScoreEvaluation se = evalCourseNode(foundNode);
 		if (se == null) { // the node could not provide any sensible information on scoring. e.g. a STNode with no calculating rules
-			log.error("could not evaluate node '{}' ({},{})", acn.getShortTitle(), acn.getClass().getName(), childId);
+			log.error("could not evaluate node '{}' ({},{})", foundNode.getShortTitle(), foundNode.getClass().getName(), childId);
 			return Boolean.FALSE;
 		}
 		// check if the results are visible
@@ -490,14 +476,9 @@ public class ScoreAccounting {
 			error = true;
 			return Boolean.FALSE;
 		}
-		if (!(foundNode instanceof AssessableCourseNode)) {
-			error = true;
-			return Boolean.FALSE;
-		}
-		AssessableCourseNode acn = (AssessableCourseNode) foundNode;
-		ScoreEvaluation se = evalCourseNode(acn);
+		ScoreEvaluation se = evalCourseNode(foundNode);
 		if (se == null) { // the node could not provide any sensible information on scoring. e.g. a STNode with no calculating rules
-			log.error("could not evaluate node '{}' ({},{})", acn.getShortTitle(), acn.getClass().getName(), childId);
+			log.error("could not evaluate node '{}' ({},{})", foundNode.getShortTitle(), foundNode.getClass().getName(), childId);
 			return Boolean.FALSE;
 		}
 		// check if the results are visible
diff --git a/src/main/java/org/olat/ims/qti/QTI12ResultDetailsController.java b/src/main/java/org/olat/ims/qti/QTI12ResultDetailsController.java
index 4c7b30705b928cd7e9b53dbcc4bd64b20d12aa5d..21388ee51b45cc3da417614d4cc686f747664cb9 100644
--- a/src/main/java/org/olat/ims/qti/QTI12ResultDetailsController.java
+++ b/src/main/java/org/olat/ims/qti/QTI12ResultDetailsController.java
@@ -52,7 +52,7 @@ import org.olat.course.ICourse;
 import org.olat.course.assessment.AssessmentHelper;
 import org.olat.course.assessment.CourseAssessmentService;
 import org.olat.course.assessment.OpenSubDetailsEvent;
-import org.olat.course.nodes.AssessableCourseNode;
+import org.olat.course.nodes.CourseNode;
 import org.olat.course.run.scoring.ScoreEvaluation;
 import org.olat.course.run.userview.UserCourseEnvironment;
 import org.olat.ims.qti.container.AssessmentContext;
@@ -248,7 +248,7 @@ public class QTI12ResultDetailsController extends BasicController {
 	 */
 	private void doRetrieveTest() {
 		ICourse course = CourseFactory.loadCourse(courseResourceableId);
-		AssessableCourseNode testNode = (AssessableCourseNode)course.getRunStructure().getNode(nodeIdent);
+		CourseNode testNode = course.getRunStructure().getNode(nodeIdent);
 		ModuleConfiguration modConfig = testNode.getModuleConfiguration();
 
 		String resourcePathInfo = courseResourceableId + File.separator + nodeIdent;
diff --git a/src/main/java/org/olat/ims/qti21/manager/archive/QTI21ArchiveFormat.java b/src/main/java/org/olat/ims/qti21/manager/archive/QTI21ArchiveFormat.java
index 24052767f0425eefa623f8db5598ab85aacbdc69..0e62fe4de7937d065c65369af16a32ffa0b35da7 100644
--- a/src/main/java/org/olat/ims/qti21/manager/archive/QTI21ArchiveFormat.java
+++ b/src/main/java/org/olat/ims/qti21/manager/archive/QTI21ArchiveFormat.java
@@ -57,7 +57,6 @@ import org.olat.course.ICourse;
 import org.olat.course.archiver.ExportFormat;
 import org.olat.course.assessment.CourseAssessmentService;
 import org.olat.course.assessment.handler.AssessmentConfig;
-import org.olat.course.nodes.AssessableCourseNode;
 import org.olat.course.nodes.CourseNode;
 import org.olat.fileresource.FileResourceManager;
 import org.olat.ims.qti.export.QTIArchiver;
@@ -157,6 +156,7 @@ public class QTI21ArchiveFormat {
 	private final UserManager userManager;
 	private final AssessmentResponseDAO responseDao;
 	private final AssessmentTestSessionDAO testSessionDao;
+	private final CourseAssessmentService courseAssessmentService;
 	
 	public QTI21ArchiveFormat(Locale locale, QTI21StatisticSearchParams searchParams) {
 		this.searchParams = searchParams;
@@ -170,6 +170,7 @@ public class QTI21ArchiveFormat {
 		qtiService = CoreSpringFactory.getImpl(QTI21ServiceImpl.class);
 		responseDao = CoreSpringFactory.getImpl(AssessmentResponseDAO.class);
 		testSessionDao = CoreSpringFactory.getImpl(AssessmentTestSessionDAO.class);
+		courseAssessmentService = CoreSpringFactory.getImpl(CourseAssessmentService.class);
 		
 		userPropertyHandlers = userManager.getUserPropertyHandlersFor(QTIArchiver.TEST_USER_PROPERTIES, true);
 		
@@ -324,19 +325,16 @@ public class QTI21ArchiveFormat {
 		}
 
 		// course node points and passed
-		if(courseNode instanceof AssessableCourseNode) {
-			CourseAssessmentService courseAssessmentService = CoreSpringFactory.getImpl(CourseAssessmentService.class);
-			AssessmentConfig assessmentConfig = courseAssessmentService.getAssessmentConfig(courseNode);
+		AssessmentConfig assessmentConfig = courseAssessmentService.getAssessmentConfig(courseNode);
+		if(assessmentConfig.hasScore()) {
+			header1Row.addCell(col++, translator.translate("archive.table.header.node"), headerStyle);
+		}
+		if(assessmentConfig.hasPassed()) {
 			if(assessmentConfig.hasScore()) {
+				col++;
+			} else {
 				header1Row.addCell(col++, translator.translate("archive.table.header.node"), headerStyle);
 			}
-			if(assessmentConfig.hasPassed()) {
-				if(assessmentConfig.hasScore()) {
-					col++;
-				} else {
-					header1Row.addCell(col++, translator.translate("archive.table.header.node"), headerStyle);
-				}
-			}
 		}
 
 		// test points, passed and dates
@@ -403,15 +401,12 @@ public class QTI21ArchiveFormat {
 		}
 
 		// course node points and passed
-		if(courseNode instanceof AssessableCourseNode) {
-			CourseAssessmentService courseAssessmentService = CoreSpringFactory.getImpl(CourseAssessmentService.class);
-			AssessmentConfig assessmentConfig = courseAssessmentService.getAssessmentConfig(courseNode);
-			if(assessmentConfig.hasScore()) {
-				header2Row.addCell(col++, translator.translate("archive.table.header.node.points"), headerStyle);
-			}
-			if(assessmentConfig.hasPassed()) {
-				header2Row.addCell(col++, translator.translate("archive.table.header.node.passed"), headerStyle);
-			}
+		AssessmentConfig assessmentConfig = courseAssessmentService.getAssessmentConfig(courseNode);
+		if(assessmentConfig.hasScore()) {
+			header2Row.addCell(col++, translator.translate("archive.table.header.node.points"), headerStyle);
+		}
+		if(assessmentConfig.hasPassed()) {
+			header2Row.addCell(col++, translator.translate("archive.table.header.node.passed"), headerStyle);
 		}
 		
 		header2Row.addCell(col++, translator.translate("archive.table.header.points"), headerStyle);
@@ -537,22 +532,19 @@ public class QTI21ArchiveFormat {
 		}
 		
 		// course node points and passed
-		if(courseNode instanceof AssessableCourseNode) {
-			CourseAssessmentService courseAssessmentService = CoreSpringFactory.getImpl(CourseAssessmentService.class);
-			AssessmentConfig assessmentConfig = courseAssessmentService.getAssessmentConfig(courseNode);
-			if(assessmentConfig.hasScore()) {
-				if(entry.getScore() != null) {
-					dataRow.addCell(col++, entry.getScore(), null);
-				} else {
-					col++;
-				}
+		AssessmentConfig assessmentConfig = courseAssessmentService.getAssessmentConfig(courseNode);
+		if(assessmentConfig.hasScore()) {
+			if(entry.getScore() != null) {
+				dataRow.addCell(col++, entry.getScore(), null);
+			} else {
+				col++;
 			}
-			if(assessmentConfig.hasPassed()) {
-				if(entry.getPassed() != null) {
-					dataRow.addCell(col++, entry.getPassed().toString(), null);
-				} else {
-					col++;
-				}
+		}
+		if(assessmentConfig.hasPassed()) {
+			if(entry.getPassed() != null) {
+				dataRow.addCell(col++, entry.getPassed().toString(), null);
+			} else {
+				col++;
 			}
 		}
 		
diff --git a/src/main/java/org/olat/restapi/repository/course/CourseAssessmentWebService.java b/src/main/java/org/olat/restapi/repository/course/CourseAssessmentWebService.java
index 1dff4c79268fd0a5e8aaf4cc250c653129982b05..f8adbd73f2ab953baa292e1f8dcd8a1694be0582 100644
--- a/src/main/java/org/olat/restapi/repository/course/CourseAssessmentWebService.java
+++ b/src/main/java/org/olat/restapi/repository/course/CourseAssessmentWebService.java
@@ -58,7 +58,6 @@ import org.olat.course.assessment.AssessmentManager;
 import org.olat.course.assessment.CourseAssessmentService;
 import org.olat.course.groupsandrights.CourseGroupManager;
 import org.olat.course.groupsandrights.CourseRights;
-import org.olat.course.nodes.AssessableCourseNode;
 import org.olat.course.nodes.CourseNode;
 import org.olat.course.nodes.IQTESTCourseNode;
 import org.olat.course.run.environment.CourseEnvironment;
@@ -317,8 +316,6 @@ public class CourseAssessmentWebService {
 	
 	private void attachAssessableResults(ICourse course, String nodeKey, Identity requestIdentity, AssessableResultsVO resultsVO) {
 		CourseNode node = getParentNode(course, nodeKey);
-		if (!(node instanceof AssessableCourseNode)) { throw new IllegalArgumentException(
-				"The supplied node key does not refer to an AssessableCourseNode"); }
 		Identity userIdentity = securityManager.loadIdentityByKey(resultsVO.getIdentityKey());
 
 		// create an identenv with no roles, no attributes, no locale
@@ -423,11 +420,10 @@ public class CourseAssessmentWebService {
 				Float score = ac.getScore();
 				Boolean passed = ac.isPassed();
 				ScoreEvaluation sceval = new ScoreEvaluation(score, passed, passed, Long.valueOf(nodeKey));//perhaps don't pass this key directly
-				AssessableCourseNode acn = (AssessableCourseNode) courseNode;
 				// assessment nodes are assessable
 				boolean incrementUserAttempts = true;
 				CourseAssessmentService courseAssessmentService = CoreSpringFactory.getImpl(CourseAssessmentService.class);
-				courseAssessmentService.updateScoreEvaluation(acn, sceval, userCourseEnv, identity, incrementUserAttempts, Role.coach);
+				courseAssessmentService.updateScoreEvaluation(courseNode, sceval, userCourseEnv, identity, incrementUserAttempts, Role.coach);
 			} else {
 				log.error("Result set already saved");
 			}
@@ -522,13 +518,10 @@ public class CourseAssessmentWebService {
 		ScoreAccounting scoreAccounting = userCourseEnvironment.getScoreAccounting();
 		scoreAccounting.evaluateAll();
 		
-		if(courseNode instanceof AssessableCourseNode) {
-			AssessableCourseNode assessableRootNode = (AssessableCourseNode)courseNode;
-			ScoreEvaluation scoreEval = scoreAccounting.evalCourseNode(assessableRootNode);
-			results.setScore(scoreEval.getScore());
-			results.setPassed(scoreEval.getPassed());
-			results.setLastModifiedDate(getLastModificationDate(identity, course, courseNode));
-		}
+		ScoreEvaluation scoreEval = scoreAccounting.evalCourseNode(courseNode);
+		results.setScore(scoreEval.getScore());
+		results.setPassed(scoreEval.getPassed());
+		results.setLastModifiedDate(getLastModificationDate(identity, course, courseNode));
 		
 		return results;
 	}
diff --git a/src/main/java/org/olat/upgrade/OLATUpgrade_11_0_0.java b/src/main/java/org/olat/upgrade/OLATUpgrade_11_0_0.java
index 2e3eed4af4ba847912d1d7ca0563b097efa84377..9bf635a86757d8e0e4ca7da3032517544a51ccc5 100644
--- a/src/main/java/org/olat/upgrade/OLATUpgrade_11_0_0.java
+++ b/src/main/java/org/olat/upgrade/OLATUpgrade_11_0_0.java
@@ -47,6 +47,7 @@ import org.apache.logging.log4j.Logger;
 import org.olat.admin.user.imp.TransientIdentity;
 import org.olat.basesecurity.GroupRoles;
 import org.olat.basesecurity.IdentityRef;
+import org.olat.core.CoreSpringFactory;
 import org.olat.core.commons.persistence.DB;
 import org.olat.core.gui.translator.Translator;
 import org.olat.core.id.Identity;
@@ -70,8 +71,9 @@ import org.olat.course.CorruptedCourseException;
 import org.olat.course.CourseFactory;
 import org.olat.course.CourseModule;
 import org.olat.course.ICourse;
+import org.olat.course.assessment.CourseAssessmentService;
+import org.olat.course.assessment.handler.AssessmentConfig;
 import org.olat.course.assessment.model.UserEfficiencyStatementLight;
-import org.olat.course.nodes.AssessableCourseNode;
 import org.olat.course.nodes.BasicLTICourseNode;
 import org.olat.course.nodes.CourseNode;
 import org.olat.course.nodes.GTACourseNode;
@@ -408,11 +410,12 @@ public class OLATUpgrade_11_0_0 extends OLATUpgrade {
 			
 			//check the transient qti ser
 			CourseNode rootNode = course.getRunStructure().getRootNode();
+			CourseAssessmentService courseAssessmentService = CoreSpringFactory.getImpl(CourseAssessmentService.class);
 			new TreeVisitor(new Visitor() {
 				@Override
 				public void visit(INode node) {
-					if(node instanceof AssessableCourseNode) {
-						processNonPropertiesStates(assessableIdentities, (AssessableCourseNode)node, course, courseEntry,
+					if(node instanceof CourseNode) {
+						processNonPropertiesStates(assessableIdentities, (CourseNode)node, course, courseEntry,
 								nodeAssessmentMap, curentNodeAssessmentMap);
 					}
 				}
@@ -452,7 +455,7 @@ public class OLATUpgrade_11_0_0 extends OLATUpgrade {
 		return allOk;
 	}
 	
-	private void processNonPropertiesStates(List<Identity> assessableIdentities, AssessableCourseNode cNode,
+	private void processNonPropertiesStates(List<Identity> assessableIdentities, CourseNode cNode,
 			ICourse course, RepositoryEntry courseEntry, Map<AssessmentDataKey,AssessmentEntryImpl> nodeAssessmentMap,
 			Map<AssessmentDataKey,AssessmentEntryImpl> curentNodeAssessmentMap) {
 		
@@ -683,7 +686,10 @@ public class OLATUpgrade_11_0_0 extends OLATUpgrade {
 		}
 		
 		boolean allOk = true;
-		if(node instanceof AssessableCourseNode && !(node instanceof STCourseNode)) {
+		
+		CourseAssessmentService courseAssessmentService = CoreSpringFactory.getImpl(CourseAssessmentService.class);
+		AssessmentConfig assessmentConfig = courseAssessmentService.getAssessmentConfig(node);
+		if(assessmentConfig.isAssessable() && !(node instanceof STCourseNode)) {
 			Identity assessedIdentity = entry.getIdentity();
 			
 			Integer attempts = assessmentManager.getNodeAttempts(node, assessedIdentity);
@@ -822,7 +828,7 @@ public class OLATUpgrade_11_0_0 extends OLATUpgrade {
 			} else if(courseNode instanceof ScormCourseNode) {
 				String username = assessedIdentity.getName();
 				Map<Date, List<CmiData>> rawDatas = ScormAssessmentManager.getInstance()
-						.visitScoDatasMultiResults(username, course.getCourseEnvironment(), (ScormCourseNode)courseNode);
+						.visitScoDatasMultiResults(username, course.getCourseEnvironment(), courseNode);
 				if(rawDatas != null && rawDatas.size() > 0) {
 					entry.setAssessmentStatus(AssessmentEntryStatus.inProgress);
 				} else {
diff --git a/src/main/java/org/olat/upgrade/legacy/NewCachePersistingAssessmentManager.java b/src/main/java/org/olat/upgrade/legacy/NewCachePersistingAssessmentManager.java
index 19986be71a511dd0fa775a9d6070505fe1194dd6..8736281a9f09595a0a457544e50a32c48b0ce51c 100644
--- a/src/main/java/org/olat/upgrade/legacy/NewCachePersistingAssessmentManager.java
+++ b/src/main/java/org/olat/upgrade/legacy/NewCachePersistingAssessmentManager.java
@@ -36,12 +36,12 @@ import java.util.Map;
 
 import javax.persistence.TypedQuery;
 
+import org.apache.logging.log4j.Logger;
 import org.olat.core.CoreSpringFactory;
 import org.olat.core.commons.persistence.DBFactory;
 import org.olat.core.commons.persistence.PersistenceHelper;
 import org.olat.core.id.Identity;
 import org.olat.core.id.OLATResourceable;
-import org.apache.logging.log4j.Logger;
 import org.olat.core.logging.Tracing;
 import org.olat.core.logging.activity.StringResourceableType;
 import org.olat.core.logging.activity.ThreadLocalUserActivityLogger;
@@ -57,13 +57,14 @@ import org.olat.course.ICourse;
 import org.olat.course.assessment.AssessmentChangedEvent;
 import org.olat.course.assessment.AssessmentLoggingAction;
 import org.olat.course.assessment.AssessmentManager;
+import org.olat.course.assessment.CourseAssessmentService;
+import org.olat.course.assessment.handler.AssessmentConfig;
 import org.olat.course.assessment.manager.EfficiencyStatementManager;
 import org.olat.course.auditing.UserNodeAuditManager;
 import org.olat.course.certificate.CertificateTemplate;
 import org.olat.course.certificate.CertificatesManager;
 import org.olat.course.certificate.model.CertificateConfig;
 import org.olat.course.certificate.model.CertificateInfos;
-import org.olat.course.nodes.AssessableCourseNode;
 import org.olat.course.nodes.CourseNode;
 import org.olat.course.properties.CoursePropertyManager;
 import org.olat.course.run.scoring.ScoreEvaluation;
@@ -583,10 +584,11 @@ public class NewCachePersistingAssessmentManager {
 			@Override
 			public Long execute() {
 				long attempts = incrementNodeAttemptsProperty(courseNode, identity, cpm);
-				if(courseNode instanceof AssessableCourseNode) {
-          // Update users efficiency statement
-				  EfficiencyStatementManager esm =	CoreSpringFactory.getImpl(EfficiencyStatementManager.class);
-				  esm.updateUserEfficiencyStatement(userCourseEnv);
+				CourseAssessmentService courseAssessmentService = CoreSpringFactory.getImpl(CourseAssessmentService.class);
+				AssessmentConfig assessmentConfig = courseAssessmentService.getAssessmentConfig(courseNode);
+				if(assessmentConfig.isAssessable()) {
+					EfficiencyStatementManager esm =	CoreSpringFactory.getImpl(EfficiencyStatementManager.class);
+					esm.updateUserEfficiencyStatement(userCourseEnv);
 				}
 				return attempts;
 			}
@@ -878,11 +880,13 @@ public class NewCachePersistingAssessmentManager {
 				if(incrementUserAttempts) {
 					attempts = incrementNodeAttemptsProperty(courseNode, assessedIdentity, cpm);
 				}
-				if(courseNode instanceof AssessableCourseNode) {
-				  userCourseEnv.getScoreAccounting().evaluateAll();
-				  // Update users efficiency statement
-				  EfficiencyStatementManager esm =	CoreSpringFactory.getImpl(EfficiencyStatementManager.class);
-				  esm.updateUserEfficiencyStatement(userCourseEnv);
+				CourseAssessmentService courseAssessmentService = CoreSpringFactory.getImpl(CourseAssessmentService.class);
+				AssessmentConfig assessmentConfig = courseAssessmentService.getAssessmentConfig(courseNode);
+				if(assessmentConfig.isAssessable()) {
+					userCourseEnv.getScoreAccounting().evaluateAll();
+					// Update users efficiency statement
+					EfficiencyStatementManager esm = CoreSpringFactory.getImpl(EfficiencyStatementManager.class);
+					esm.updateUserEfficiencyStatement(userCourseEnv);
 				}
 				
 				if(passed != null && passed.booleanValue() && course.getCourseConfig().isAutomaticCertificationEnabled()) {
@@ -978,7 +982,10 @@ public class NewCachePersistingAssessmentManager {
 		saveNodeFullyAssessed(courseNode, identity, assessedIdentity, scoreEvaluation.getFullyAssessed(), cpm);
 		log.debug("successfully saved node fullyAssessed : " + scoreEvaluation.getFullyAssessed());
 		DBFactory.getInstance().commitAndCloseSession();
-		if (courseNode instanceof AssessableCourseNode) {
+
+		CourseAssessmentService courseAssessmentService = CoreSpringFactory.getImpl(CourseAssessmentService.class);
+		AssessmentConfig assessmentConfig = courseAssessmentService.getAssessmentConfig(courseNode);
+		if(assessmentConfig.isAssessable()) {
 			userCourseEnv.getScoreAccounting().evaluateAll();
 			EfficiencyStatementManager esm = CoreSpringFactory.getImpl(EfficiencyStatementManager.class);
 			esm.updateUserEfficiencyStatement(userCourseEnv);
diff --git a/src/test/java/org/olat/course/assessment/AssessmentManagerTest.java b/src/test/java/org/olat/course/assessment/AssessmentManagerTest.java
index a57bbc45f0213c80250c11c5bbea90e6f74f696d..7b9ea78797bcd2ea61918ff30431171e40278771 100644
--- a/src/test/java/org/olat/course/assessment/AssessmentManagerTest.java
+++ b/src/test/java/org/olat/course/assessment/AssessmentManagerTest.java
@@ -54,7 +54,6 @@ import org.olat.course.CourseModule;
 import org.olat.course.ICourse;
 import org.olat.course.assessment.manager.EfficiencyStatementManager;
 import org.olat.course.config.CourseConfig;
-import org.olat.course.nodes.AssessableCourseNode;
 import org.olat.course.nodes.CourseNode;
 import org.olat.course.run.scoring.ScoreEvaluation;
 import org.olat.course.run.userview.UserCourseEnvironment;
@@ -82,7 +81,7 @@ public class AssessmentManagerTest extends OlatTestCase  {
 	
 	private AssessmentManager assessmentManager;	
 	private ICourse course;
-	private AssessableCourseNode assessableCourseNode;
+	private CourseNode assessableCourseNode;
 	private Identity tutor;
 	private Identity student;
 	private final Float score = new Float(10);
@@ -138,13 +137,11 @@ public class AssessmentManagerTest extends OlatTestCase  {
 		boolean testNodeFound = false; 
 		while(nodesIterator.hasNext()) {
 			CourseNode currentNode = nodesIterator.next();			
-			if(currentNode instanceof AssessableCourseNode) {
-				if (currentNode.getType().equalsIgnoreCase("iqtest")) {
-					log.info("Yes, we found a test node! - currentNode.getType(): " + currentNode.getType());
-					assessableCourseNode = (AssessableCourseNode)currentNode;
-					testNodeFound = true;
-					break;
-				}
+			if (currentNode.getType().equalsIgnoreCase("iqtest")) {
+				log.info("Yes, we found a test node! - currentNode.getType(): " + currentNode.getType());
+				assessableCourseNode = currentNode;
+				testNodeFound = true;
+				break;
 			}
 		}
 		assertTrue("found no test-node of type 'iqtest' (hint: add one to DemoCourse) ",testNodeFound);
diff --git a/src/test/java/org/olat/modules/reminder/manager/ReminderRuleEngineTest.java b/src/test/java/org/olat/modules/reminder/manager/ReminderRuleEngineTest.java
index bf32c11fb58d390dcd070fd816d9c818aca05c9f..31ea995da86c870df832a2dc829f3655aaa46a73 100644
--- a/src/test/java/org/olat/modules/reminder/manager/ReminderRuleEngineTest.java
+++ b/src/test/java/org/olat/modules/reminder/manager/ReminderRuleEngineTest.java
@@ -45,7 +45,6 @@ import org.olat.course.assessment.CourseAssessmentService;
 import org.olat.course.assessment.handler.AssessmentConfig;
 import org.olat.course.assessment.manager.UserCourseInformationsManager;
 import org.olat.course.assessment.model.UserCourseInfosImpl;
-import org.olat.course.nodes.AssessableCourseNode;
 import org.olat.course.nodes.CourseNode;
 import org.olat.course.reminder.rule.AttemptsRuleSPI;
 import org.olat.course.reminder.rule.InitialAttemptsRuleSPI;
@@ -1080,13 +1079,11 @@ public class ReminderRuleEngineTest extends OlatTestCase {
 		//create user course infos
 		ICourse course = CourseFactory.loadCourse(re);
 		List<CourseNode> assessableNodeList = AssessmentHelper.getAssessableNodes(course.getEditorTreeModel(), null);
-		AssessableCourseNode testNode = null; 
+		CourseNode testNode = null; 
 		for(CourseNode currentNode: assessableNodeList) {	
-			if(currentNode instanceof AssessableCourseNode) {
-				if (currentNode.getType().equalsIgnoreCase("iqtest")) {
-					testNode = (AssessableCourseNode)currentNode;
-					break;
-				}
+			if (currentNode.getType().equalsIgnoreCase("iqtest")) {
+				testNode = currentNode;
+				break;
 			}
 		}
 		Assert.assertNotNull(testNode);