OO-4766: view number of participants waiting an assessment

src/main/java/org/olat/core/gui/components/progressbar/ProgressBarItem.java

@@ -88,6 +88,10 @@ public class ProgressBarItem extends FormItemImpl {
 		component.setCssClass(cssClass);
 	}
 	
+	public void setPercentagesEnabled(boolean enabled) {
+		component.setPercentagesEnabled(enabled);
+	}
+	
 	public void setInfo(String info) {
 		component.setInfo(info);
 	}

src/main/java/org/olat/course/assessment/AssessmentModeCoordinationService.java

@@ -21,7 +21,10 @@ package org.olat.course.assessment;
 
 import java.util.Date;
 
+import org.olat.basesecurity.IdentityRef;
 import org.olat.course.assessment.AssessmentMode.Status;
+import org.olat.course.assessment.model.AssessmentModeStatistics;
+import org.olat.course.assessment.model.TransientAssessmentMode;
 import org.olat.repository.RepositoryEntry;
 
 /**
@@ -55,5 +58,13 @@ public interface AssessmentModeCoordinationService {
 	public AssessmentMode startAssessment(AssessmentMode assessmentMode);
 	
 	public AssessmentMode stopAssessment(AssessmentMode assessmentMode);
+	
+	
+	
+	public AssessmentModeStatistics getStatistics(AssessmentMode assessmentMode);
+	
+	public void waitFor(IdentityRef identity, TransientAssessmentMode assessmentMode);
+	
+	public void start(IdentityRef identity, TransientAssessmentMode assessmentMode);
 
 }

src/main/java/org/olat/course/assessment/manager/AssessmentModeCoordinationServiceImpl.java

@@ -28,13 +28,16 @@ import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 
 import org.apache.logging.log4j.Logger;
+import org.olat.basesecurity.IdentityRef;
 import org.olat.basesecurity.model.IdentityRefImpl;
 import org.olat.core.commons.persistence.DB;
 import org.olat.core.gui.control.Event;
 import org.olat.core.logging.Tracing;
+import org.olat.core.util.cache.CacheWrapper;
 import org.olat.core.util.coordinate.CoordinatorManager;
 import org.olat.core.util.event.GenericEventListener;
 import org.olat.core.util.resource.OresHelper;
+import org.olat.core.util.session.UserSessionManager;
 import org.olat.course.CourseFactory;
 import org.olat.course.assessment.AssessmentMode;
 import org.olat.course.assessment.AssessmentMode.Status;
@@ -42,6 +45,7 @@ import org.olat.course.assessment.AssessmentModeCoordinationService;
 import org.olat.course.assessment.AssessmentModeNotificationEvent;
 import org.olat.course.assessment.AssessmentModule;
 import org.olat.course.assessment.model.AssessmentModeImpl;
+import org.olat.course.assessment.model.AssessmentModeStatistics;
 import org.olat.course.assessment.model.CoordinatedAssessmentMode;
 import org.olat.course.assessment.model.TransientAssessmentMode;
 import org.olat.group.ui.edit.BusinessGroupModifiedEvent;
@@ -73,9 +77,12 @@ public class AssessmentModeCoordinationServiceImpl implements AssessmentModeCoor
 	@Autowired
 	private CoordinatorManager coordinatorManager;
 	@Autowired
+	private UserSessionManager userSessionManager;
+	@Autowired
 	private AssessmentModeManagerImpl assessmentModeManager;
 	
 	private Map<Long,CoordinatedAssessmentMode> coordinatedModes = new ConcurrentHashMap<>();
+	private CacheWrapper<Long,AssessmentModeStatistics> coordinatedModeStatistics;
 	
 	protected synchronized void beat() {
 		if(assessmentModule.isAssessmentModeEnabled()) {
@@ -150,12 +157,13 @@ public class AssessmentModeCoordinationServiceImpl implements AssessmentModeCoor
 		}
 	}
 	
-	
-	
 	@Override
 	public void afterPropertiesSet() throws Exception {
 		coordinatorManager.getCoordinator().getEventBus()
 			.registerFor(this, null, OresHelper.lookupType(RepositoryEntry.class));
+		
+		coordinatedModeStatistics = coordinatorManager.getCoordinator().getCacher()
+				.getCache(AssessmentModeStatistics.class.getSimpleName(), "waiting");
 	}
 
 	@Override
@@ -358,6 +366,10 @@ public class AssessmentModeCoordinationServiceImpl implements AssessmentModeCoor
 		AssessmentModeNotificationEvent event = new AssessmentModeNotificationEvent(cmd, transientMode, assessedIdentityKeys);
 		coordinatorManager.getCoordinator().getEventBus()
 			.fireEventToListenersOf(event, AssessmentModeNotificationEvent.ASSESSMENT_MODE_NOTIFICATION);
+		
+		// update the status
+		AssessmentModeStatistics statistics = getStatistics(mode.getKey(), assessedIdentityKeys);
+		statistics.setStatus(mode.getStatus());
 	}
 
 	@Override
@@ -428,4 +440,44 @@ public class AssessmentModeCoordinationServiceImpl implements AssessmentModeCoor
 		RepositoryEntry entry = repositoryEntryDao.loadByKey(mode.getRepositoryEntry().getKey());
 		CourseFactory.loadCourse(entry);
 	}
+
+	@Override
+	public AssessmentModeStatistics getStatistics(AssessmentMode assessmentMode) {
+		AssessmentModeStatistics statistics = getStatistics(assessmentMode.getKey(), null);
+		if(assessmentMode.getStatus() == AssessmentMode.Status.none) {
+			Set<Long> notRegisteredIdentityKeys = statistics.getNotRegisteredAssessedIdentitiesKeys();
+			for(Long notRegisteredIdentityKey:notRegisteredIdentityKeys) {
+				if(userSessionManager.isOnline(notRegisteredIdentityKey)) {
+					statistics.addLoggedInIdentitiesKeys(new IdentityRefImpl(notRegisteredIdentityKey));
+				}
+			}
+		}
+		return statistics;
+	}
+	
+	private AssessmentModeStatistics getStatistics(Long assessmentModeKey, Set<Long> assessedIdentitiesKeys) {
+		AssessmentModeStatistics coordinatedAssessmentMode = coordinatedModeStatistics
+				.computeIfAbsent(assessmentModeKey, key -> new AssessmentModeStatistics());
+		
+		if(assessedIdentitiesKeys != null) {
+			coordinatedAssessmentMode.updatePlannedAssessedIdentitiesKeys(assessedIdentitiesKeys);
+		} else if(coordinatedAssessmentMode.getNumPlanned() == 0) {
+			AssessmentMode mode = assessmentModeManager.getAssessmentModeById(assessmentModeKey);
+			assessedIdentitiesKeys = assessmentModeManager.getAssessedIdentityKeys(mode);
+			coordinatedAssessmentMode.updatePlannedAssessedIdentitiesKeys(assessedIdentitiesKeys);
+		}
+		return coordinatedAssessmentMode;
+	}
+
+	@Override
+	public void waitFor(IdentityRef identity, TransientAssessmentMode assessmentMode) {
+		AssessmentModeStatistics coordinatedAssessmentMode = getStatistics(assessmentMode.getModeKey(), null);
+		coordinatedAssessmentMode.addWaitingAssessedIdentity(identity);
+	}
+	
+	@Override
+	public void start(IdentityRef identity, TransientAssessmentMode assessmentMode) {
+		AssessmentModeStatistics coordinatedAssessmentMode = getStatistics(assessmentMode.getModeKey(), null);
+		coordinatedAssessmentMode.addStartedAssessedIdentity(identity);
+	}
 }
\ No newline at end of file

src/main/java/org/olat/course/assessment/model/AssessmentModeStatistics.java

+/**
+ * <a href="http://www.openolat.org">
+ * OpenOLAT - Online Learning and Training</a><br>
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License"); <br>
+ * you may not use this file except in compliance with the License.<br>
+ * You may obtain a copy of the License at the
+ * <a href="http://www.apache.org/licenses/LICENSE-2.0">Apache homepage</a>
+ * <p>
+ * Unless required by applicable law or agreed to in writing,<br>
+ * software distributed under the License is distributed on an "AS IS" BASIS, <br>
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. <br>
+ * See the License for the specific language governing permissions and <br>
+ * limitations under the License.
+ * <p>
+ * Initial code contributed and copyrighted by<br>
+ * frentix GmbH, http://www.frentix.com
+ * <p>
+ */
+package org.olat.course.assessment.model;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import org.olat.basesecurity.IdentityRef;
+import org.olat.course.assessment.AssessmentMode;
+
+/**
+ * 
+ * Initial date: 11 août 2020<br>
+ * @author srosse, stephane.rosse@frentix.com, http://www.frentix.com
+ *
+ */
+public class AssessmentModeStatistics {
+	
+	private AssessmentMode.Status status;
+
+	private final Set<Long> loggedInIdentitiesKeys = new HashSet<>();
+	private final Set<Long> startedAssessedIdentitiesKeys = new HashSet<>();
+	private final Set<Long> waitingAssessedIdentitiesKeys = new HashSet<>();
+	private final Set<Long> plannedAssessedIdentitiesKeys = new HashSet<>();
+	
+	public AssessmentModeStatistics() {
+		//
+	}
+
+	public AssessmentMode.Status getStatus() {
+		return status;
+	}
+
+	public void setStatus(AssessmentMode.Status status) {
+		this.status = status;
+	}
+	
+	/**
+	 * @return The list of identities keys which are not in one stage
+	 * 		or the other in OpenOlat.
+	 */
+	public synchronized Set<Long> getNotRegisteredAssessedIdentitiesKeys() {
+		Set<Long> all = new HashSet<>(plannedAssessedIdentitiesKeys);
+		all.removeAll(loggedInIdentitiesKeys);
+		all.removeAll(waitingAssessedIdentitiesKeys);
+		all.removeAll(startedAssessedIdentitiesKeys);
+		return all;
+	}
+	
+	public synchronized int getNumInOpenOlat() {
+		return waitingAssessedIdentitiesKeys.size()
+				+ startedAssessedIdentitiesKeys.size()
+				+ loggedInIdentitiesKeys.size();
+	}
+
+	public synchronized int getNumPlanned() {
+		return plannedAssessedIdentitiesKeys.size();
+	}
+
+	public synchronized int getNumWaiting() {
+		return waitingAssessedIdentitiesKeys.size();
+	}
+
+	public synchronized int getNumStarted() {
+		return startedAssessedIdentitiesKeys.size();
+	}
+	
+	public boolean isAssessedIdentity(Long identityKey) {
+		return waitingAssessedIdentitiesKeys.contains(identityKey)
+				|| startedAssessedIdentitiesKeys.contains(identityKey)
+				|| loggedInIdentitiesKeys.contains(identityKey);
+	}
+	
+	public synchronized void addLoggedInIdentitiesKeys(IdentityRef identity) {
+		if(!waitingAssessedIdentitiesKeys.contains(identity.getKey()) && !startedAssessedIdentitiesKeys.contains(identity.getKey())) {
+			loggedInIdentitiesKeys.add(identity.getKey());	
+		}
+	}
+	
+	public synchronized void addStartedAssessedIdentity(IdentityRef identity) {
+		loggedInIdentitiesKeys.remove(identity.getKey());
+		waitingAssessedIdentitiesKeys.remove(identity.getKey());
+		startedAssessedIdentitiesKeys.add(identity.getKey());
+	}
+	
+	public synchronized void addWaitingAssessedIdentity(IdentityRef identity) {
+		loggedInIdentitiesKeys.remove(identity.getKey());
+		waitingAssessedIdentitiesKeys.add(identity.getKey());
+		startedAssessedIdentitiesKeys.remove(identity.getKey());
+	}
+	
+	public synchronized void updatePlannedAssessedIdentitiesKeys(Set<Long> assessedIdentitiesKeys) {
+		plannedAssessedIdentitiesKeys.clear();
+		plannedAssessedIdentitiesKeys.addAll(assessedIdentitiesKeys);
+	}
+}

src/main/java/org/olat/course/assessment/model/CoordinatedAssessmentMode.java

@@ -56,6 +56,7 @@ public class CoordinatedAssessmentMode {
 	public void setAssessmentMode(AssessmentMode assessmentMode) {
 		this.assessmentMode = assessmentMode;
 	}
+	
 	@Override
 	public int hashCode() {
 		return key.hashCode();

src/main/java/org/olat/course/assessment/ui/mode/AssessmentModeGuardController.java

@@ -46,6 +46,7 @@ import org.olat.core.util.StringHelper;
 import org.olat.core.util.coordinate.CoordinatorManager;
 import org.olat.core.util.event.GenericEventListener;
 import org.olat.course.assessment.AssessmentMode.Status;
+import org.olat.course.assessment.AssessmentModeCoordinationService;
 import org.olat.course.assessment.AssessmentModeManager;
 import org.olat.course.assessment.AssessmentModeNotificationEvent;
 import org.olat.course.assessment.model.TransientAssessmentMode;
@@ -72,6 +73,8 @@ public class AssessmentModeGuardController extends BasicController implements Ge
 	
 	@Autowired
 	private AssessmentModeManager assessmentModeMgr;
+	@Autowired
+	private AssessmentModeCoordinationService assessmentModeCoordinationService;
 	
 	/**
 	 *
@@ -197,6 +200,9 @@ public class AssessmentModeGuardController extends BasicController implements Ge
 			Link go = guard.getGo();
 			Link cont = guard.getContinue();
 			state = updateButtons(mode, now, go, cont);
+			if(go.isVisible()) {
+				assessmentModeCoordinationService.waitFor(getIdentity(), mode);
+			}
 		} else {
 			state = "error";
 		}
@@ -389,7 +395,7 @@ public class AssessmentModeGuardController extends BasicController implements Ge
 	 */
 	private void launchAssessmentMode(UserRequest ureq, TransientAssessmentMode mode) {
 		cmc.deactivate();
-		
+	
 		ureq.getUserSession().setAssessmentModes(null);
 		OLATResourceable resource = mode.getResource();
 		ureq.getUserSession().setLockResource(resource, mode);
@@ -401,13 +407,16 @@ public class AssessmentModeGuardController extends BasicController implements Ge
 			businessPath += "[CourseNode:" + mode.getStartElementKey() + "]";
 		}
 		NewControllerFactory.getInstance().launch(businessPath, ureq, getWindowControl());
+
+		assessmentModeCoordinationService.start(getIdentity(), mode);
 	}
 	
 	public static final class ResourceGuard {
 
 		private String status;
 		private String errors;
-		private final Link goButton, continueButton;
+		private final Link goButton;
+		private final Link continueButton;
 		
 		private final Long modeKey;
 		private String name;

src/main/java/org/olat/course/assessment/ui/tool/AssessmentModeOverviewListController.java

@@ -58,11 +58,13 @@ 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.model.AssessmentModeStatistics;
 import org.olat.course.assessment.ui.mode.AssessmentModeHelper;
 import org.olat.course.assessment.ui.mode.AssessmentModeListController;
 import org.olat.course.assessment.ui.mode.ModeStatusCellRenderer;
 import org.olat.course.assessment.ui.mode.TimeCellRenderer;
 import org.olat.course.assessment.ui.tool.AssessmentModeOverviewListTableModel.ModeCols;
+import org.olat.course.assessment.ui.tool.component.AssessmentModeProgressionItem;
 import org.olat.course.assessment.ui.tool.event.AssessmentModeStatusEvent;
 import org.olat.course.assessment.ui.tool.event.CourseNodeEvent;
 import org.olat.course.nodes.CourseNode;
@@ -157,6 +159,9 @@ public class AssessmentModeOverviewListController extends FormBasicController im
 			for(FormLink elementLink:elementLinks) {
 				cmps.add(elementLink.getComponent());
 			}
+			if(mode.getWaitBarItem() != null) {
+				cmps.add(mode.getWaitBarItem().getComponent());
+			}
 		}
 		return cmps;
 	}
@@ -195,12 +200,15 @@ public class AssessmentModeOverviewListController extends FormBasicController im
 		long endInMillseconds = cal.getTimeInMillis() - now;
 		boolean endSoon = (endInMillseconds < (5l * 60l * 1000l))
 				&& (mode.getStatus() == Status.assessment || mode.getStatus() == Status.followup);
+		
+		
+		
 		AssessmentModeOverviewRow row = new AssessmentModeOverviewRow(mode, isToday, endSoon, endInMillseconds);
 		
 		LectureBlock block = mode.getLectureBlock();
 		boolean allowToStartStop = assessmentCallback.canStartStopAllAssessments()
 				|| (block != null && teachedLectures.contains(block.getKey()));
-		
+
 		if(mode.isManualBeginEnd() && allowToStartStop) {
 			if(assessmentModeCoordinationService.canStart(mode)) {
 				String id = "start_" + (++count);
@@ -209,6 +217,7 @@ public class AssessmentModeOverviewListController extends FormBasicController im
 				startButton.setIconLeftCSS("o_icon o_icon-fw o_as_mode_assessment");
 				startButton.setUserObject(row);
 				flc.add(id, startButton);
+				forgeStatistics(mode, row);
 				row.setActionButton(startButton);
 			} else if(assessmentModeCoordinationService.canStop(mode)) {
 				String id = "end_" + (++count);
@@ -217,8 +226,15 @@ public class AssessmentModeOverviewListController extends FormBasicController im
 				endButton.setIconLeftCSS("o_icon o_icon-fw o_as_mode_stop");
 				endButton.setUserObject(row);
 				flc.add(id, endButton);
+				forgeStatistics(mode, row);
 				row.setActionButton(endButton);
 			}
+		} else if (mode.getStatus() == AssessmentMode.Status.leadtime
+				|| mode.getStatus() == AssessmentMode.Status.assessment
+				|| mode.getStatus() == AssessmentMode.Status.followup) {
+			forgeStatistics(mode, row);
+		} else {
+			row.setWaitBarItem(null);
 		}
 		
 		String elements = mode.getElementList();
@@ -243,6 +259,20 @@ public class AssessmentModeOverviewListController extends FormBasicController im
 
 		return row;
 	}
+	
+	private void forgeStatistics(AssessmentMode mode, AssessmentModeOverviewRow row) {
+		AssessmentModeStatistics statistics = assessmentModeCoordinationService.getStatistics(mode);
+		if(statistics != null) {
+			statistics.setStatus(mode.getStatus());// direct from the database
+			
+			String id = "wait_" + (++count);
+			AssessmentModeProgressionItem waitBarItem = new AssessmentModeProgressionItem(id, mode, getTranslator());
+			waitBarItem.setMax(statistics.getNumPlanned());
+			waitBarItem.setActual(statistics.getNumInOpenOlat());
+			row.setWaitBarItem(waitBarItem);
+			flc.add(waitBarItem);
+		}
+	}
 
 	@Override
 	protected void doDispose() {

src/main/java/org/olat/course/assessment/ui/tool/AssessmentModeOverviewRow.java

@@ -25,6 +25,7 @@ import java.util.List;
 import org.olat.core.gui.components.form.flexible.elements.FormLink;
 import org.olat.core.util.CodeHelper;
 import org.olat.course.assessment.AssessmentMode;
+import org.olat.course.assessment.ui.tool.component.AssessmentModeProgressionItem;
 
 /**
  * 
@@ -35,6 +36,7 @@ import org.olat.course.assessment.AssessmentMode;
 public class AssessmentModeOverviewRow {
 	
 	private FormLink actionButton;
+	private AssessmentModeProgressionItem waitBarItem;
 	private final List<FormLink> elementLinks = new ArrayList<>();
 	
 	private final String id;
@@ -74,6 +76,14 @@ public class AssessmentModeOverviewRow {
 	public AssessmentMode getAssessmentMode() {
 		return assessmentMode;
 	}
+	
+	public AssessmentModeProgressionItem getWaitBarItem() {
+		return waitBarItem;
+	}
+	
+	public void setWaitBarItem(AssessmentModeProgressionItem waitBarItem) {
+		this.waitBarItem = waitBarItem;
+	}
 
 	public FormLink getActionButton() {
 		return actionButton;

src/main/java/org/olat/course/assessment/ui/tool/_content/assessment_mode_overview_row.html

 <div id="$row.id" class="o_assessment_mode_row #if($r.isTrue(${row.isEndSoon()})) o_assessment_end_soon #end #if($r.isTrue(${row.isToday()})) o_assessment_today #end clearfix">
 	<h4>$r.escapeHtml($row.name) <small>${helper.getBeginEndDate($row.assessmentMode)}</small></h4>
+	#if($r.isNotNull($row.waitBarItem))
+	<p>$r.render($row.waitBarItem)</p>
+	#end
 	<p>$r.translate("table.header.assessmentStatus"): <span><i class="o_icon o_icon-fw $helper.getCssClass($row.assessmentMode)"> </i> ${helper.getStatusLabel($row.assessmentMode)}</span> #if($r.isNotNull($row.actionButtonName)) $r.render($row.actionButton) #end</p>
 	#set($elementLinks = ${row.getElementLinkNames()})
 	#if($r.isNotEmpty($elementLinks))

src/main/java/org/olat/course/assessment/ui/tool/_i18n/LocalStrings_de.properties

@@ -2,6 +2,8 @@
 assessment.mode.now=Der Pr\u00FCfungmodus ist aktiv von {0} bis {1}.
 assessment.mode.several.now=Mehrere Pr\u00FCfungmodus sind aktiv von {0} bis {1}.
 assessment.modes.overview=Pr\u00FCfungsmodus
+assessment.progress.started.infos={1} von maximal {0} Teilnehmer nehmen aktuell an der Pr\u00FCfung teil.
+assessment.progress.wait.infos={1} von maximal {0} Teilnehmer warten auf Pr\u00FCfungsstart.
 assessment.status.done=$org.olat.modules.assessment.ui\:assessment.status.done
 assessment.status.inProgress=$org.olat.modules.assessment.ui\:assessment.status.inProgress
 assessment.status.inReview=$org.olat.modules.assessment.ui\:assessment.status.inReview

src/main/java/org/olat/course/assessment/ui/tool/_i18n/LocalStrings_en.properties

@@ -2,6 +2,8 @@
 assessment.mode.now=The assessment mode is active from {0} until {1}. 
 assessment.mode.several.now=Several assessment modes are active from {0} until {1}.
 assessment.modes.overview=Assessment mode
+assessment.progress.started.infos={1} of at most {0} participants are currently taking the exam.
+assessment.progress.wait.infos={1} of at most {0} participants are waiting assessment start.
 assessment.status.done=$org.olat.modules.assessment.ui\:assessment.status.done
 assessment.status.inProgress=$org.olat.modules.assessment.ui\:assessment.status.inProgress
 assessment.status.inReview=$org.olat.modules.assessment.ui\:assessment.status.inReview

src/main/java/org/olat/course/assessment/ui/tool/component/AssessmentModeProgressionComponent.java

+/**
+ * <a href="http://www.openolat.org">
+ * OpenOLAT - Online Learning and Training</a><br>
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License"); <br>
+ * you may not use this file except in compliance with the License.<br>
+ * You may obtain a copy of the License at the
+ * <a href="http://www.apache.org/licenses/LICENSE-2.0">Apache homepage</a>
+ * <p>
+ * Unless required by applicable law or agreed to in writing,<br>
+ * software distributed under the License is distributed on an "AS IS" BASIS, <br>
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. <br>
+ * See the License for the specific language governing permissions and <br>
+ * limitations under the License.
+ * <p>
+ * Initial code contributed and copyrighted by<br>
+ * frentix GmbH, http://www.frentix.com
+ * <p>
+ */
+package org.olat.course.assessment.ui.tool.component;
+
+import org.olat.core.CoreSpringFactory;
+import org.olat.core.gui.components.ComponentRenderer;
+import org.olat.core.gui.components.form.flexible.impl.FormBaseComponentImpl;
+import org.olat.core.gui.components.progressbar.ProgressBar;
+import org.olat.core.gui.components.progressbar.ProgressBar.LabelAlignment;
+import org.olat.core.gui.components.progressbar.ProgressBar.RenderSize;
+import org.olat.core.gui.components.progressbar.ProgressBar.RenderStyle;
+import org.olat.core.gui.translator.Translator;
+import org.olat.course.assessment.AssessmentMode;
+import org.olat.course.assessment.AssessmentMode.Status;
+import org.olat.course.assessment.AssessmentModeCoordinationService;
+import org.olat.course.assessment.model.AssessmentModeStatistics;
+
+/**
+ * 
+ * Initial date: 11 août 2020<br>
+ * @author srosse, stephane.rosse@frentix.com, http://www.frentix.com
+ *
+ */
+public class AssessmentModeProgressionComponent extends FormBaseComponentImpl {
+	
+	private static final AssessmentModeProgressionRenderer RENDERER = new AssessmentModeProgressionRenderer();
+	
+	private final ProgressBar progressBar;
+	private final AssessmentMode assessmentMode;
+	private AssessmentModeCoordinationService assessmentModeCoordinationService;
+	
+	private int planned = -1;
+	private int loggedIn = -1;
+	private AssessmentMode.Status status;
+	
+	public AssessmentModeProgressionComponent(String name, AssessmentMode assessmentMode, Translator translator) {
+		super(name);
+		setTranslator(translator);
+		this.assessmentMode = assessmentMode;
+		status = assessmentMode.getStatus();
+		assessmentModeCoordinationService = CoreSpringFactory.getImpl(AssessmentModeCoordinationService.class);
+		progressBar = new ProgressBar(name.concat("_progress"));
+		progressBar.setRenderSize(RenderSize.inline);
+		progressBar.setRenderStyle(RenderStyle.pie);
+		progressBar.setLabelAlignment(LabelAlignment.none);
+		progressBar.setPercentagesEnabled(false);
+		progressBar.setDomReplacementWrapperRequired(false);
+		setDomReplacementWrapperRequired(false);
+	}
+	
+	public ProgressBar getProgressBar() {
+		return progressBar;
+	}
+	
+	public String getInformations() {
+		String i18nKey = status == Status.none || status == Status.leadtime ? "assessment.progress.wait.infos" : "assessment.progress.started.infos";
+		return getTranslator().translate(i18nKey, new String[] { Integer.toString(planned), Integer.toString(loggedIn) });
+	}
+	
+	public void setMax(int i) {
+		planned = i;
+		progressBar.setMax(i);
+	}
+	
+	public void setActual(int i) {
+		loggedIn = i;
+		progressBar.setActual(i);
+	}
+
+	@Override
+	public boolean isDirty() {
+		boolean dirty = super.isDirty();
+		AssessmentModeStatistics stats = assessmentModeCoordinationService.getStatistics(assessmentMode);
+		if(planned != stats.getNumPlanned()) {
+			planned = stats.getNumPlanned();
+			progressBar.setMax(planned);
+			dirty |= true;
+		}
+		
+		if(loggedIn != stats.getNumInOpenOlat()) {
+			loggedIn = stats.getNumInOpenOlat();
+			progressBar.setActual(loggedIn);
+			dirty |= true;
+		}
+		
+		if(status != stats.getStatus()) {
+			status = stats.getStatus();
+			dirty |= true;
+		}
+		
+		return dirty;
+	}
+
+	@Override
+	public ComponentRenderer getHTMLRendererSingleton() {
+		return RENDERER;
+	}
+	
+	
+
+}

src/main/java/org/olat/course/assessment/ui/tool/component/AssessmentModeProgressionItem.java

+/**
+ * <a href="http://www.openolat.org">
+ * OpenOLAT - Online Learning and Training</a><br>
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License"); <br>
+ * you may not use this file except in compliance with the License.<br>
+ * You may obtain a copy of the License at the
+ * <a href="http://www.apache.org/licenses/LICENSE-2.0">Apache homepage</a>
+ * <p>
+ * Unless required by applicable law or agreed to in writing,<br>
+ * software distributed under the License is distributed on an "AS IS" BASIS, <br>
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. <br>
+ * See the License for the specific language governing permissions and <br>
+ * limitations under the License.
+ * <p>
+ * Initial code contributed and copyrighted by<br>
+ * frentix GmbH, http://www.frentix.com
+ * <p>
+ */
+package org.olat.course.assessment.ui.tool.component;
+
+import org.olat.core.gui.UserRequest;
+import org.olat.core.gui.components.Component;
+import org.olat.core.gui.components.form.flexible.impl.FormItemImpl;
+import org.olat.core.gui.translator.Translator;
+import org.olat.course.assessment.AssessmentMode;
+
+/**
+ * 
+ * Initial date: 11 août 2020<br>
+ * @author srosse, stephane.rosse@frentix.com, http://www.frentix.com
+ *
+ */
+public class AssessmentModeProgressionItem extends FormItemImpl {
+	
+	private final AssessmentModeProgressionComponent component;
+	
+	public AssessmentModeProgressionItem(String name, AssessmentMode assessmentMode, Translator translator) {
+		super(name);
+		setTranslator(translator);
+		component = new AssessmentModeProgressionComponent(name, assessmentMode, translator);
+	}
+	
+	@Override
+	protected Component getFormItemComponent() {
+		return component;
+	}
+	
+	public void setMax(int i) {
+		component.setMax(i);
+	}
+	
+	public void setActual(int i) {
+		component.setActual(i);
+	}
+
+	@Override
+	public void evalFormRequest(UserRequest ureq) {
+		//
+	}
+
+	@Override
+	public void reset() {
+		//
+	}
+
+	@Override
+	protected void rootFormAvailable() {
+		//
+	}
+}

src/main/java/org/olat/course/assessment/ui/tool/component/AssessmentModeProgressionRenderer.java

+/**
+ * <a href="http://www.openolat.org">
+ * OpenOLAT - Online Learning and Training</a><br>
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License"); <br>
+ * you may not use this file except in compliance with the License.<br>
+ * You may obtain a copy of the License at the
+ * <a href="http://www.apache.org/licenses/LICENSE-2.0">Apache homepage</a>
+ * <p>
+ * Unless required by applicable law or agreed to in writing,<br>
+ * software distributed under the License is distributed on an "AS IS" BASIS, <br>
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. <br>
+ * See the License for the specific language governing permissions and <br>
+ * limitations under the License.
+ * <p>
+ * Initial code contributed and copyrighted by<br>
+ * frentix GmbH, http://www.frentix.com
+ * <p>
+ */
+package org.olat.course.assessment.ui.tool.component;
+
+import org.olat.core.gui.components.Component;
+import org.olat.core.gui.components.DefaultComponentRenderer;
+import org.olat.core.gui.components.progressbar.ProgressBar;
+import org.olat.core.gui.render.RenderResult;
+import org.olat.core.gui.render.Renderer;
+import org.olat.core.gui.render.StringOutput;
+import org.olat.core.gui.render.URLBuilder;
+import org.olat.core.gui.translator.Translator;
+
+/**
+ * 
+ * Initial date: 11 août 2020<br>
+ * @author srosse, stephane.rosse@frentix.com, http://www.frentix.com
+ *
+ */
+public class AssessmentModeProgressionRenderer extends DefaultComponentRenderer {
+
+	@Override
+	public void render(Renderer renderer, StringOutput sb, Component source, URLBuilder ubu, Translator translator,
+			RenderResult renderResult, String[] args) {
+
+		AssessmentModeProgressionComponent cmp = (AssessmentModeProgressionComponent)source;
+		sb.append("<span id='o_c").append(cmp.getDispatchID()).append("'>");
+		
+		ProgressBar progressBar = cmp.getProgressBar();
+		progressBar.getHTMLRendererSingleton().render(renderer, sb, progressBar, ubu, translator, null, null);
+		sb.append(" ");
+		
+		sb.append(cmp.getInformations());
+		
+		sb.append("</span>");
+	}
+}