Something went wrong on our end
Code owners
Assign users and groups as approvers for specific file changes. Learn more.
CourseRuntimeController.java 102.37 KiB
/**
* <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.run;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;
import org.olat.NewControllerFactory;
import org.olat.basesecurity.GroupRoles;
import org.olat.commons.calendar.CalendarModule;
import org.olat.commons.info.ui.InfoSecurityCallback;
import org.olat.core.CoreSpringFactory;
import org.olat.core.commons.controllers.linkchooser.CustomLinkTreeModel;
import org.olat.core.commons.fullWebApp.LayoutMain3ColsController;
import org.olat.core.commons.fullWebApp.popup.BaseFullWebappPopupLayoutFactory;
import org.olat.core.commons.modules.bc.FolderRunController;
import org.olat.core.commons.modules.glossary.GlossaryMainController;
import org.olat.core.commons.persistence.PersistenceHelper;
import org.olat.core.commons.services.mark.Mark;
import org.olat.core.gui.UserRequest;
import org.olat.core.gui.Windows;
import org.olat.core.gui.components.Component;
import org.olat.core.gui.components.dropdown.Dropdown;
import org.olat.core.gui.components.dropdown.Dropdown.Spacer;
import org.olat.core.gui.components.htmlheader.jscss.CustomCSS;
import org.olat.core.gui.components.link.Link;
import org.olat.core.gui.components.link.LinkFactory;
import org.olat.core.gui.components.link.LinkPopupSettings;
import org.olat.core.gui.components.stack.BreadcrumbedStackedPanel.BreadCrumb;
import org.olat.core.gui.components.stack.PopEvent;
import org.olat.core.gui.components.stack.TooledStackedPanel.Align;
import org.olat.core.gui.components.stack.VetoPopEvent;
import org.olat.core.gui.control.ChiefController;
import org.olat.core.gui.control.Controller;
import org.olat.core.gui.control.Event;
import org.olat.core.gui.control.VetoableCloseController;
import org.olat.core.gui.control.WindowControl;
import org.olat.core.gui.control.creator.ControllerCreator;
import org.olat.core.gui.control.generic.closablewrapper.CloseableCalloutWindowController;
import org.olat.core.gui.control.generic.closablewrapper.CloseableModalController;
import org.olat.core.gui.control.generic.dtabs.Activateable2;
import org.olat.core.gui.control.generic.dtabs.DTab;
import org.olat.core.gui.control.generic.dtabs.DTabs;
import org.olat.core.gui.control.generic.messages.MessageUIFactory;
import org.olat.core.gui.control.generic.popup.PopupBrowserWindow;
import org.olat.core.id.Identity;
import org.olat.core.id.OLATResourceable;
import org.olat.core.id.context.BusinessControlFactory;
import org.olat.core.id.context.ContextEntry;
import org.olat.core.id.context.StateEntry;import org.olat.core.logging.OLATSecurityException;
import org.olat.core.logging.activity.ThreadLocalUserActivityLogger;
import org.olat.core.util.StringHelper;
import org.olat.core.util.coordinate.CoordinatorManager;
import org.olat.core.util.event.GenericEventListener;
import org.olat.core.util.event.MultiUserEvent;
import org.olat.core.util.mail.MailPackage;
import org.olat.core.util.mail.MailerResult;
import org.olat.core.util.prefs.Preferences;
import org.olat.core.util.resource.OresHelper;
import org.olat.core.util.tree.TreeVisitor;
import org.olat.core.util.vfs.NamedContainerImpl;
import org.olat.core.util.vfs.VFSContainer;
import org.olat.course.CourseFactory;
import org.olat.course.CourseModule;
import org.olat.course.ICourse;
import org.olat.course.archiver.ArchiverMainController;
import org.olat.course.archiver.FullAccessArchiverCallback;
import org.olat.course.area.CourseAreasController;
import org.olat.course.assessment.AssessmentModule;
import org.olat.course.assessment.ui.mode.AssessmentModeListController;
import org.olat.course.assessment.ui.mode.AssessmentModeSecurityCallback;
import org.olat.course.assessment.ui.mode.AssessmentModeSecurityCallbackFactory;
import org.olat.course.assessment.ui.tool.AssessmentToolController;
import org.olat.course.certificate.ui.CertificateAndEfficiencyStatementController;
import org.olat.course.config.CourseConfig;
import org.olat.course.config.CourseConfigEvent;
import org.olat.course.config.ui.CourseSettingsController;
import org.olat.course.db.CourseDBManager;
import org.olat.course.db.CustomDBMainController;
import org.olat.course.editor.EditorMainController;
import org.olat.course.groupsandrights.CourseGroupManager;
import org.olat.course.groupsandrights.CourseRights;
import org.olat.course.learningpath.LearningPathService;
import org.olat.course.learningpath.manager.LearningPathNodeAccessProvider;
import org.olat.course.learningpath.ui.LearningPathIdentityListController;
import org.olat.course.learningpath.ui.MyLearningPathController;
import org.olat.course.member.MembersManagementMainController;
import org.olat.course.nodeaccess.ui.UnsupportedCourseNodesController;
import org.olat.course.nodes.CourseNode;
import org.olat.course.nodes.ENCourseNode;
import org.olat.course.nodes.bc.CourseDocumentsController;
import org.olat.course.nodes.co.COToolController;
import org.olat.course.nodes.feed.blog.BlogToolController;
import org.olat.course.nodes.fo.FOToolController;
import org.olat.course.nodes.info.InfoCourseSecurityCallback;
import org.olat.course.nodes.info.InfoRunController;
import org.olat.course.nodes.members.MembersToolRunController;
import org.olat.course.nodes.wiki._content.WikiToolController;
import org.olat.course.reminder.ui.CourseRemindersController;
import org.olat.course.run.calendar.CourseCalendarController;
import org.olat.course.run.glossary.CourseGlossaryFactory;
import org.olat.course.run.glossary.CourseGlossaryToolLinkController;
import org.olat.course.run.tools.CourseTool;
import org.olat.course.run.tools.OpenCourseToolEvent;
import org.olat.course.run.userview.UserCourseEnvironment;
import org.olat.course.run.userview.UserCourseEnvironmentImpl;
import org.olat.course.statistic.StatisticCourseNodesController;
import org.olat.course.statistic.StatisticMainController;
import org.olat.course.statistic.StatisticType;
import org.olat.course.tree.CourseInternalLinkTreeModel;
import org.olat.group.BusinessGroup;
import org.olat.group.BusinessGroupRef;
import org.olat.group.BusinessGroupService;
import org.olat.group.ui.edit.BusinessGroupModifiedEvent;
import org.olat.instantMessaging.InstantMessagingModule;
import org.olat.instantMessaging.InstantMessagingService;
import org.olat.instantMessaging.OpenInstantMessageEvent;
import org.olat.modules.assessment.ui.AssessmentToolSecurityCallback;
import org.olat.modules.lecture.LectureModule;import org.olat.modules.lecture.LectureService;
import org.olat.modules.lecture.RepositoryEntryLectureConfiguration;
import org.olat.modules.lecture.ui.LectureRepositoryAdminController;
import org.olat.modules.lecture.ui.LecturesSecurityCallback;
import org.olat.modules.lecture.ui.LecturesSecurityCallbackFactory;
import org.olat.modules.lecture.ui.TeacherOverviewController;
import org.olat.modules.reminder.ReminderModule;
import org.olat.note.NoteController;
import org.olat.repository.LeavingStatusList;
import org.olat.repository.RepositoryEntry;
import org.olat.repository.RepositoryEntryManagedFlag;
import org.olat.repository.RepositoryEntrySecurity;
import org.olat.repository.RepositoryEntryStatusEnum;
import org.olat.repository.RepositoryManager;
import org.olat.repository.controllers.EntryChangedEvent;
import org.olat.repository.ui.RepositoryEntryLifeCycleChangeController;
import org.olat.repository.ui.RepositoryEntryRuntimeController;
import org.olat.resource.OLATResource;
import org.olat.search.SearchModule;
import org.olat.search.SearchServiceUIFactory;
import org.olat.search.SearchServiceUIFactory.DisplayOption;
import org.olat.search.service.QuickSearchEvent;
import org.olat.search.ui.SearchInputController;
import org.olat.util.logging.activity.LoggingResourceable;
import org.springframework.beans.factory.annotation.Autowired;
/**
*
* Initial date: 20.08.2014<br>
* @author srosse, stephane.rosse@frentix.com, http://www.frentix.com
*
*/
public class CourseRuntimeController extends RepositoryEntryRuntimeController implements GenericEventListener, VetoableCloseController {
private static final String JOINED = "joined";
private static final String LEFT = "left";
private static final String CMD_START_GROUP_PREFIX = "cmd.group.start.ident.";
private Delayed delayedClose;
//tools
private Link folderLink,
assessmentLink, archiverLink,
courseStatisticLink, surveyStatisticLink, testStatisticLink,
areaLink, dbLink, convertLearningPathLink,
//settings
lecturesAdminLink, reminderLink,
assessmentModeLink, lifeCycleChangeLink,
//my course
efficiencyStatementsLink, noteLink, leaveLink,
// course tools
learningPathLink, learningPathsLink, calendarLink, chatLink, participantListLink, participantInfoLink,
blogLink, wikiLink, forumLink, documentsLink, emailLink, searchLink,
//glossary
openGlossaryLink, enableGlossaryLink, lecturesLink;
private Link currentUserCountLink;
private Dropdown myCourse, glossary;
private CloseableModalController cmc;
private COToolController emailCtrl;
private BlogToolController blogCtrl;
private WikiToolController wikiCtrl;
private FOToolController forumCtrl;
private CourseDocumentsController documentsCtrl;
private CourseAreasController areasCtrl;
private ConfirmLeaveController leaveDialogBox;
private ArchiverMainController archiverCtrl;
private CustomDBMainController databasesCtrl;
private FolderRunController courseFolderCtrl;
private InfoRunController participatInfoCtrl; private SearchInputController searchController;
private StatisticMainController statisticsCtrl;
private CourseRemindersController remindersCtrl;
private TeacherOverviewController lecturesCtrl;
private AssessmentToolController assessmentToolCtr;
private MembersToolRunController participatListCtrl;
private MembersManagementMainController membersCtrl;
private StatisticCourseNodesController statsToolCtr;
private AssessmentModeListController assessmentModeCtrl;
private LectureRepositoryAdminController lecturesAdminCtrl;
private UnsupportedCourseNodesController unsupportedCourseNodesCtrl;
private CloseableCalloutWindowController courseSearchCalloutCtr;
protected RepositoryEntryLifeCycleChangeController lifeCycleChangeCtr;
private Map<String, Boolean> courseRightsCache;
@Autowired
private CourseModule courseModule;
@Autowired
private LectureModule lectureModule;
@Autowired
private LectureService lectureService;
@Autowired
private ReminderModule reminderModule;
@Autowired
private CalendarModule calendarModule;
@Autowired
private CoordinatorManager coordinatorManager;
@Autowired
private BusinessGroupService businessGroupService;
@Autowired
private AssessmentModule assessmentModule;
@Autowired
private InstantMessagingModule imModule;
@Autowired
private CourseDBManager courseDBManager;
@Autowired
private SearchModule searchModule;
@Autowired
private LearningPathService learningPathService;
public CourseRuntimeController(UserRequest ureq, WindowControl wControl,
RepositoryEntry re, RepositoryEntrySecurity reSecurity, RuntimeControllerCreator runtimeControllerCreator,
boolean offerBookmark, boolean showCourseConfigLink) {
super(ureq, wControl, re, reSecurity, runtimeControllerCreator, offerBookmark, showCourseConfigLink);
if(!corrupted) {
ICourse course = CourseFactory.loadCourse(getRepositoryEntry());
addLoggingResourceable(LoggingResourceable.wrap(course));
coordinatorManager.getCoordinator().getEventBus().registerFor(this, getIdentity(), getOlatResourceable());
// - group modification events
coordinatorManager.getCoordinator().getEventBus().registerFor(this, getIdentity(), getRepositoryEntry());
if (courseModule.displayParticipantsCount()) {
coordinatorManager.getCoordinator().getEventBus().fireEventToListenersOf(new MultiUserEvent(JOINED), getOlatResourceable());
updateCurrentUserCount();
}
if(enableGlossaryLink != null) {
Preferences prefs = ureq.getUserSession().getGuiPreferences();
String guiPrefsKey = CourseGlossaryFactory.createGuiPrefsKey(course);
Boolean state = (Boolean) prefs.get(CourseGlossaryToolLinkController.class, guiPrefsKey);
setGlossaryLinkTitle(ureq, state);
}
}
}
@Override
protected boolean isCorrupted(RepositoryEntry entry) { try {
CourseFactory.loadCourse(entry);
return false;
} catch (Exception e) {
return true;
}
}
@Override
protected void onSecurityReloaded(UserRequest ureq) {
if(corrupted) return;
loadRights();
RunMainController runMainController = getRunMainController();
if(runMainController != null) {
runMainController.reloadGroupMemberships(reSecurity);
runMainController.updateCurrentCourseNode(ureq);
}
}
private void loadRights() {
ICourse course = CourseFactory.loadCourse(getRepositoryEntry());
CourseGroupManager cgm = course.getCourseEnvironment().getCourseGroupManager();
// 3) all other rights are defined in the groupmanagement using the learning
// group rights
UserCourseEnvironmentImpl uce = getUserCourseEnvironment();
if(uce != null) {
uce.setUserRoles(reSecurity.isEntryAdmin() || reSecurity.isPrincipal() || reSecurity.isMasterCoach(), reSecurity.isCoach(), reSecurity.isParticipant());
if(reSecurity.isOnlyPrincipal() || reSecurity.isOnlyMasterCoach()) {
uce.setCourseReadOnly(Boolean.TRUE);
} else if(reSecurity.isReadOnly()) {
if(overrideReadOnly) {
uce.setCourseReadOnly(Boolean.FALSE);
} else {
uce.setCourseReadOnly(Boolean.TRUE);
}
} else {
uce.setCourseReadOnly(Boolean.FALSE);
}
uce.getScoreAccounting().evaluateAll(true);
}
courseRightsCache = new HashMap<>();
if(!reSecurity.isEntryAdmin() && !isGuestOnly) {
GroupRoles role = GroupRoles.valueOf(reSecurity.getCurrentRole().name());
List<String> rights = cgm.getRights(getIdentity(), role);
courseRightsCache.put(CourseRights.RIGHT_GROUPMANAGEMENT, Boolean.valueOf(rights.contains(CourseRights.RIGHT_GROUPMANAGEMENT)));
courseRightsCache.put(CourseRights.RIGHT_MEMBERMANAGEMENT, Boolean.valueOf(rights.contains(CourseRights.RIGHT_MEMBERMANAGEMENT)));
courseRightsCache.put(CourseRights.RIGHT_COURSEEDITOR, Boolean.valueOf(rights.contains(CourseRights.RIGHT_COURSEEDITOR)));
courseRightsCache.put(CourseRights.RIGHT_ARCHIVING, Boolean.valueOf(rights.contains(CourseRights.RIGHT_ARCHIVING)));
courseRightsCache.put(CourseRights.RIGHT_ASSESSMENT, Boolean.valueOf(rights.contains(CourseRights.RIGHT_ASSESSMENT)));
courseRightsCache.put(CourseRights.RIGHT_ASSESSMENT_MODE, Boolean.valueOf(rights.contains(CourseRights.RIGHT_ASSESSMENT_MODE)));
courseRightsCache.put(CourseRights.RIGHT_GLOSSARY, Boolean.valueOf(rights.contains(CourseRights.RIGHT_GLOSSARY)));
courseRightsCache.put(CourseRights.RIGHT_STATISTICS, Boolean.valueOf(rights.contains(CourseRights.RIGHT_STATISTICS)));
courseRightsCache.put(CourseRights.RIGHT_DB, Boolean.valueOf(rights.contains(CourseRights.RIGHT_DB)));
}
}
private boolean hasCourseRight(String right) {
Boolean bool = courseRightsCache.get(right);
return bool != null && bool.booleanValue();
}
private UserCourseEnvironmentImpl getUserCourseEnvironment() {
RunMainController run = getRunMainController();
UserCourseEnvironmentImpl uce = run == null ? null : run.getUce();
if(uce != null && uce.isCourseReadOnly() && overrideReadOnly) {
uce.setCourseReadOnly(Boolean.FALSE);
} return uce;
}
/**
* Refresh the cached repository entry of the course
* @return
*/
@Override
protected RepositoryEntry loadRepositoryEntry() {
RepositoryEntry refreshedEntry = super.loadRepositoryEntry();
ICourse course = CourseFactory.loadCourse(getRepositoryEntry());
course.getCourseEnvironment().updateCourseEntry(refreshedEntry);
return refreshedEntry;
}
/**
* Refresh the cached repository entry of the course
* @return
*/
@Override
protected RepositoryEntry refreshRepositoryEntry(RepositoryEntry refreshedEntry) {
ICourse course = CourseFactory.loadCourse(refreshedEntry);
course.getCourseEnvironment().updateCourseEntry(refreshedEntry);
return super.refreshRepositoryEntry(refreshedEntry);
}
private RunMainController getRunMainController() {
return getRuntimeController() instanceof RunMainController ?
(RunMainController)getRuntimeController() : null;
}
private CourseNode getCurrentCourseNode() {
RunMainController run = getRunMainController();
return run == null ? null : run.getCurrentCourseNode();
}
private boolean isInEditor() {
RunMainController run = getRunMainController();
return run != null && run.isInEditor();
}
private void setIsInEditor(boolean editor) {
RunMainController run = getRunMainController();
if(run != null) run.setInEditor(editor);
}
private void reloadGroupMemberships() {
RunMainController run = getRunMainController();
if(run != null) {
run.reloadGroupMemberships(reSecurity);
}
}
private void toolControllerDone(UserRequest ureq) {
RunMainController run = getRunMainController();
if(run != null) {
addCustomCSS(ureq);
run.toolCtrDone(ureq, reSecurity);
currentToolCtr = null;
}
}
private void setTextMarkingEnabled(boolean enable) {
RunMainController run = getRunMainController();
if(run != null) run.setTextMarkingEnabled(enable);
}
public void setCourseCloseEnabled(boolean enabled) {
toolbarPanel.setShowCloseLink(true, enabled);
}
public void setToolControllerEnabled(boolean enabled) {
toolbarPanel.setToolbarEnabled(enabled);
}
private void addCustomCSS(UserRequest ureq) {
ICourse course = CourseFactory.loadCourse(getRepositoryEntry());
CustomCSS customCSS = CourseFactory.getCustomCourseCss(ureq.getUserSession(), course.getCourseEnvironment());
ChiefController cc = getWindowControl().getWindowBackOffice().getChiefController();
if (cc != null) {
if(customCSS == null) {
cc.removeCurrentCustomCSSFromView();
} else {
cc.addCurrentCustomCSSToView(customCSS);
}
}
setCustomCSS(customCSS);
}
private void removeCustomCSS() {
ChiefController cc = getWindowControl().getWindowBackOffice().getChiefController();
if (cc != null) {
cc.removeCurrentCustomCSSFromView();
}
setCustomCSS(null);
setCourseClosedMessage();
}
@Override
protected void initToolbar(Dropdown toolsDropdown) {
toolsDropdown.removeAllComponents();
if(corrupted) return;
ICourse course = CourseFactory.loadCourse(getRepositoryEntry());
if(!course.getCourseConfig().isToolbarEnabled() && !reSecurity.isEntryAdmin() && !reSecurity.isCoach()
&& !hasCourseRight(CourseRights.RIGHT_COURSEEDITOR) && !hasCourseRight(CourseRights.RIGHT_MEMBERMANAGEMENT)
&& !hasCourseRight(CourseRights.RIGHT_GROUPMANAGEMENT) && !hasCourseRight(CourseRights.RIGHT_ARCHIVING)
&& !hasCourseRight(CourseRights.RIGHT_STATISTICS) && !hasCourseRight(CourseRights.RIGHT_DB)
&& !hasCourseRight(CourseRights.RIGHT_ASSESSMENT) && !hasCourseRight(CourseRights.RIGHT_ASSESSMENT_MODE)) {
toolbarPanel.setToolbarEnabled(false);
} else {
toolbarPanel.setToolbarEnabled(true);
}
// make bread crumb disappear if not enabled
if (!course.getCourseConfig().isBreadCrumbEnabled() && !toolbarPanel.isToolbarEnabled()) {
// disable if toolbar also not visible
toolbarPanel.setBreadcrumbEnabled(false);
}
initToolsMenu(toolsDropdown);
initToolsMyCourse(course);
initGeneralTools(course);
RunMainController rmc = getRunMainController();
if(rmc != null) {
rmc.initToolbarAndProgressbar();
}
setCourseClosedMessage();
}
private void setCourseClosedMessage() {
UserCourseEnvironment userCourseEnv = getUserCourseEnvironment();
if(userCourseEnv != null && getRepositoryEntry().getEntryStatus() == RepositoryEntryStatusEnum.closed) {
toolbarPanel.setMessage(translate("course.closed"));
toolbarPanel.setMessageCssClass("o_warning");
} else {
toolbarPanel.setMessage(null);
toolbarPanel.setMessageComponent(null);
}
}
@Override
protected void initToolsMenu(Dropdown toolsDropdown) {
toolsDropdown.removeAllComponents();
toolsDropdown.setDirty(true);
if(!isAssessmentLock()) {
ICourse course = CourseFactory.loadCourse(getRepositoryEntry());
UserCourseEnvironmentImpl uce = getUserCourseEnvironment();
initToolsMenuSettings(toolsDropdown);
initToolsMenuEditor(toolsDropdown, uce);
initToolsMenuRuntime(toolsDropdown, uce);
initToolsMenuStatistics(toolsDropdown, course, uce);
initToolsMenuEdition(toolsDropdown);
initToolsMenuDelete(toolsDropdown);
}
}
@Override
protected void initToolsMenuSettings(Dropdown tools) {
// 1) administrative tools
if (reSecurity.isEntryAdmin() || reSecurity.isPrincipal() || reSecurity.isMasterCoach() || reSecurity.isCoach()
|| hasCourseRight(CourseRights.RIGHT_COURSEEDITOR) || hasCourseRight(CourseRights.RIGHT_MEMBERMANAGEMENT)
|| hasCourseRight(CourseRights.RIGHT_GROUPMANAGEMENT)) {
tools.setI18nKey("header.tools");
tools.setElementCssClass("o_sel_course_tools");
if(reSecurity.isEntryAdmin() || hasCourseRight(CourseRights.RIGHT_COURSEEDITOR)) {
settingsLink = LinkFactory.createToolLink("settings", translate("details.settings"), this, "o_sel_repo_settings");
settingsLink.setIconLeftCSS("o_icon o_icon-fw o_icon_settings");
settingsLink.setElementCssClass("o_sel_course_settings");
settingsLink.setUrl(BusinessControlFactory.getInstance()
.getAuthenticatedURLFromBusinessPathStrings(businessPathEntry, "[Settings:0]"));
tools.addComponent(settingsLink);
}
if (reSecurity.isEntryAdmin() || reSecurity.isPrincipal() || reSecurity.isMasterCoach() || hasCourseRight(CourseRights.RIGHT_GROUPMANAGEMENT) || hasCourseRight(CourseRights.RIGHT_MEMBERMANAGEMENT)) {
membersLink = LinkFactory.createToolLink("unifiedusermngt", translate("command.opensimplegroupmngt"), this, "o_icon_membersmanagement");
membersLink.setUrl(BusinessControlFactory.getInstance()
.getAuthenticatedURLFromBusinessPathStrings(businessPathEntry, "[MembersMgmt:0][Members:0][All:0]"));
membersLink.setElementCssClass("o_sel_course_members");
tools.addComponent(membersLink);
}
tools.addComponent(new Spacer("first"));
}
}
private void initToolsMenuEditor(Dropdown tools, final UserCourseEnvironmentImpl uce) {
if(uce == null) return;
if (reSecurity.isEntryAdmin() || hasCourseRight(CourseRights.RIGHT_COURSEEDITOR)) {
boolean managed = RepositoryEntryManagedFlag.isManaged(getRepositoryEntry(), RepositoryEntryManagedFlag.editcontent);
boolean readOnly = uce.isCourseReadOnly();
editLink = LinkFactory.createToolLink("edit.cmd", translate("command.openeditor"), this, "o_icon_courseeditor");
editLink.setUrl(BusinessControlFactory.getInstance()
.getAuthenticatedURLFromBusinessPathStrings(businessPathEntry, "[Editor:0]]"));
editLink.setElementCssClass("o_sel_course_editor");
editLink.setEnabled(!corrupted && !managed);
editLink.setVisible(!readOnly);
tools.addComponent(editLink);
}
if (reSecurity.isEntryAdmin() || reSecurity.isPrincipal() || reSecurity.isMasterCoach() || hasCourseRight(CourseRights.RIGHT_COURSEEDITOR)) {
folderLink = LinkFactory.createToolLink("cfd", translate("command.coursefolder"), this, "o_icon_coursefolder");
folderLink.setUrl(BusinessControlFactory.getInstance()
.getAuthenticatedURLFromBusinessPathStrings(businessPathEntry, "[Coursefolder:0]]"));
folderLink.setElementCssClass("o_sel_course_folder");
tools.addComponent(folderLink); tools.addComponent(new Spacer(""));
}
}
private void initToolsMenuRuntime(Dropdown tools, final UserCourseEnvironmentImpl uce) {
boolean courseAuthorRight = reSecurity.isEntryAdmin() || hasCourseRight(CourseRights.RIGHT_COURSEEDITOR);
if (courseAuthorRight || reSecurity.isPrincipal() || reSecurity.isMasterCoach() || reSecurity.isCoach()
|| hasCourseRight(CourseRights.RIGHT_DB)
|| hasCourseRight(CourseRights.RIGHT_ASSESSMENT) || hasCourseRight(CourseRights.RIGHT_ASSESSMENT_MODE)) {
tools.addComponent(new Spacer(""));
if (reSecurity.isEntryAdmin() || reSecurity.isPrincipal() || reSecurity.isMasterCoach() || reSecurity.isCoach() || hasCourseRight(CourseRights.RIGHT_ASSESSMENT)) {
assessmentLink = LinkFactory.createToolLink("assessment", translate("command.openassessment"), this, "o_icon_assessment_tool");
assessmentLink.setUrl(BusinessControlFactory.getInstance()
.getAuthenticatedURLFromBusinessPathStrings(businessPathEntry, "[assessmentToolv2:0]"));
assessmentLink.setElementCssClass("o_sel_course_assessment_tool");
tools.addComponent(assessmentLink);
}
if(lectureModule.isEnabled() && (courseAuthorRight || reSecurity.isPrincipal() || reSecurity.isMasterCoach()) && isLectureEnabled()) {
lecturesAdminLink = LinkFactory.createToolLink("lectures.admin.cmd", translate("command.options.lectures.admin"), this, "o_icon_lecture");
lecturesAdminLink.setUrl(BusinessControlFactory.getInstance()
.getAuthenticatedURLFromBusinessPathStrings(businessPathEntry, "[LecturesAdmin:0][LectureBlocks:0]"));
lecturesAdminLink.setElementCssClass("o_sel_course_lectures_admin");
tools.addComponent(lecturesAdminLink);
}
if(reminderModule.isEnabled() && courseAuthorRight) {
reminderLink = LinkFactory.createToolLink("reminders.cmd", translate("command.options.reminders"), this, "o_icon_reminder");
reminderLink.setUrl(BusinessControlFactory.getInstance()
.getAuthenticatedURLFromBusinessPathStrings(businessPathEntry, "[Reminders:0]"));
reminderLink.setElementCssClass("o_sel_course_reminders");
reminderLink.setVisible(!uce.isCourseReadOnly());
tools.addComponent(reminderLink);
}
if (courseAuthorRight || reSecurity.isPrincipal() || reSecurity.isMasterCoach() || hasCourseRight(CourseRights.RIGHT_ASSESSMENT_MODE)) {
//course author right or the assessment mode access right
boolean managed = RepositoryEntryManagedFlag.isManaged(getRepositoryEntry(), RepositoryEntryManagedFlag.editcontent);
assessmentModeLink = LinkFactory.createToolLink("assessment.mode.cmd", translate("command.assessment.mode"), this, "o_icon_assessment_mode");
assessmentModeLink.setUrl(BusinessControlFactory.getInstance()
.getAuthenticatedURLFromBusinessPathStrings(businessPathEntry, "[AssessmentMode:0]"));
assessmentModeLink.setElementCssClass("o_sel_course_assessment_mode");
assessmentModeLink.setEnabled(!managed);
assessmentModeLink.setVisible(assessmentModule.isAssessmentModeEnabled() && !uce.isCourseReadOnly());
tools.addComponent(assessmentModeLink);
}
if (reSecurity.isEntryAdmin() || hasCourseRight(CourseRights.RIGHT_COURSEEDITOR)) {
areaLink = LinkFactory.createToolLink("careas", translate("command.courseareas"), this, "o_icon_courseareas");
areaLink.setUrl(BusinessControlFactory.getInstance()
.getAuthenticatedURLFromBusinessPathStrings(businessPathEntry, "[CourseAreas:0]"));
areaLink.setElementCssClass("o_sel_course_areas");
tools.addComponent(areaLink);
}
if (courseDBManager.isEnabled() && (reSecurity.isEntryAdmin() || hasCourseRight(CourseRights.RIGHT_DB))) {
dbLink = LinkFactory.createToolLink("customDb",translate("command.opendb"), this, "o_icon_coursedb");
//TODO url
tools.addComponent(dbLink);
}
}
}
private boolean isLectureEnabled() {
RepositoryEntryLectureConfiguration lectureConfig = lectureService.getRepositoryEntryLectureConfiguration(getRepositoryEntry());
return lectureConfig != null && lectureConfig.isLectureEnabled();
}
private void initToolsMenuStatistics(Dropdown tools, ICourse course, final UserCourseEnvironmentImpl uce) {
if (reSecurity.isEntryAdmin() || reSecurity.isPrincipal() || reSecurity.isMasterCoach() || reSecurity.isCoach()
|| hasCourseRight(CourseRights.RIGHT_ARCHIVING) || hasCourseRight(CourseRights.RIGHT_STATISTICS)) {
tools.addComponent(new Spacer(""));
if (reSecurity.isEntryAdmin() || reSecurity.isPrincipal() || reSecurity.isMasterCoach() || hasCourseRight(CourseRights.RIGHT_STATISTICS)) {
courseStatisticLink = LinkFactory.createToolLink("statistic",translate("command.openstatistic"), this, "o_icon_statistics_tool");
courseStatisticLink.setUrl(BusinessControlFactory.getInstance()
.getAuthenticatedURLFromBusinessPathStrings(businessPathEntry, "[CourseStatistics:0]"));
tools.addComponent(courseStatisticLink);
}
if (uce != null && (reSecurity.isEntryAdmin() || reSecurity.isPrincipal() || reSecurity.isMasterCoach() || reSecurity.isCoach() || hasCourseRight(CourseRights.RIGHT_STATISTICS))) {
final AtomicInteger testNodes = new AtomicInteger();
final AtomicInteger surveyNodes = new AtomicInteger();
new TreeVisitor(node -> {
if(((CourseNode)node).isStatisticNodeResultAvailable(uce, StatisticType.TEST)) {
testNodes.incrementAndGet();
} else if(((CourseNode)node).isStatisticNodeResultAvailable(uce, StatisticType.SURVEY)) {
surveyNodes.incrementAndGet();
}
}, course.getRunStructure().getRootNode(), true).visitAll();
if(testNodes.intValue() > 0) {
testStatisticLink = LinkFactory.createToolLink("qtistatistic", translate("command.openteststatistic"), this, "o_icon_statistics_tool");
testStatisticLink.setUrl(BusinessControlFactory.getInstance()
.getAuthenticatedURLFromBusinessPathStrings(businessPathEntry, "[TestStatistics:0]"));
tools.addComponent(testStatisticLink);
}
if(surveyNodes.intValue() > 0) {
surveyStatisticLink = LinkFactory.createToolLink("qtistatistic", translate("command.opensurveystatistic"), this, "o_icon_statistics_tool");
surveyStatisticLink.setUrl(BusinessControlFactory.getInstance()
.getAuthenticatedURLFromBusinessPathStrings(businessPathEntry, "[SurveyStatistics:0]"));
tools.addComponent(surveyStatisticLink);
}
}
if (reSecurity.isEntryAdmin() || hasCourseRight(CourseRights.RIGHT_ARCHIVING)) {
archiverLink = LinkFactory.createToolLink("archiver", translate("command.openarchiver"), this, "o_icon_archive_tool");
archiverLink.setUrl(BusinessControlFactory.getInstance()
.getAuthenticatedURLFromBusinessPathStrings(businessPathEntry, "[Archives:0]"));
tools.addComponent(archiverLink);
}
ordersLink = LinkFactory.createToolLink("bookings", translate("details.orders"), this, "o_sel_repo_booking");
ordersLink.setIconLeftCSS("o_icon o_icon-fw o_icon_booking");
ordersLink.setElementCssClass("o_sel_course_ac_tool");
boolean booking = acService.isResourceAccessControled(getRepositoryEntry().getOlatResource(), null);
ordersLink.setVisible(!corrupted && booking);
tools.addComponent(ordersLink);
}
}
@Override
protected void initToolsMenuEdition(Dropdown toolsDropdown) {
super.initToolsMenuEdition(toolsDropdown);
if (copyLink != null) {
ICourse course = CourseFactory.loadCourse(getRepositoryEntry());
if (course != null && !LearningPathNodeAccessProvider.TYPE.equals(course.getCourseConfig().getNodeAccessType().getType())) {
Integer index = toolsDropdown.getComponentIndex(copyLink);
if(index != null) {
convertLearningPathLink = LinkFactory.createToolLink("convert.course.learning.path",
translate("tools.convert.course.learning.path"), this, "o_icon o_icon-fw o_icon_learning_path");
toolsDropdown.addComponent(index.intValue() + 1, convertLearningPathLink);
}
}
}
}
@Override
protected void initToolsMenuDelete(Dropdown settingsDropdown) {
RepositoryEntry re = getRepositoryEntry();
boolean closeManged = RepositoryEntryManagedFlag.isManaged(re, RepositoryEntryManagedFlag.close);
if(reSecurity.isEntryAdmin()) {
boolean deleteManaged = RepositoryEntryManagedFlag.isManaged(re, RepositoryEntryManagedFlag.delete);
if(settingsDropdown.size() > 0 && !deleteManaged) {
settingsDropdown.addComponent(new Spacer("close-delete"));
}
if(!closeManged || !deleteManaged) {
// If a resource is closable (currently only course) and
// deletable (currently all resources) we offer those two
// actions in a separate page, unless both are managed
// operations. In that case we don't show anything at all.
// If only one of the two actions are managed, we go to the
// separate page as well and show only the relevant action
// there.
lifeCycleChangeLink = LinkFactory.createToolLink("lifeCycleChange", translate("details.lifecycle.change"), this, "o_icon o_icon-fw o_icon_lifecycle");
settingsDropdown.addComponent(lifeCycleChangeLink);
} else {
if(!deleteManaged) {
String type = translate(handler.getSupportedType());
String deleteTitle = translate("details.delete.alt", new String[]{ type });
deleteLink = LinkFactory.createToolLink("delete", deleteTitle, this, "o_icon o_icon-fw o_icon_delete_item");
deleteLink.setElementCssClass("o_sel_repo_close");
settingsDropdown.addComponent(deleteLink);
}
}
}
}
private void initToolsMyCourse(ICourse course) {
boolean assessmentLock = isAssessmentLock();
UserCourseEnvironment userCourseEnv = getUserCourseEnvironment();
myCourse = new Dropdown("myCourse", "header.tools.mycourse", false, getTranslator());
myCourse.setElementCssClass("dropdown-menu-right");
myCourse.setIconCSS("o_icon o_icon_user");
// Personal tools on right side
CourseConfig cc = course.getCourseConfig();
if ((cc.isEfficencyStatementEnabled() || cc.isCertificateEnabled()) && !isGuestOnly && !assessmentLock
&& userCourseEnv != null && userCourseEnv.isParticipant()) {
efficiencyStatementsLink = LinkFactory.createToolLink("efficiencystatement",
translate(CourseTool.efficiencystatement.getI18nKey()), this,
CourseTool.efficiencystatement.getIconCss());
myCourse.addComponent(efficiencyStatementsLink);
}
if (!isGuestOnly && !assessmentLock) {
noteLink = LinkFactory.createToolLink("personalnote",translate("command.personalnote"), this, "o_icon_notes");
noteLink.setPopup(new LinkPopupSettings(750, 550, "notes"));
myCourse.addComponent(noteLink);
}
if (allowBookmark && !isGuestOnly) {
boolean marked = markManager.isMarked(getRepositoryEntry(), getIdentity(), null);
String css = marked ? Mark.MARK_CSS_ICON : Mark.MARK_ADD_CSS_ICON;
bookmarkLink = LinkFactory.createToolLink("bookmark",translate("command.bookmark"), this, css);
bookmarkLink.setTitle(translate(marked ? "details.bookmark.remove" : "details.bookmark"));
myCourse.addComponent(bookmarkLink);
}
if (userCourseEnv != null) {
if(myCourse.size() > 0 && (!userCourseEnv.getCoachedGroups().isEmpty() || !userCourseEnv.getParticipatingGroups().isEmpty() || !userCourseEnv.getWaitingLists().isEmpty())) {
myCourse.addComponent(new Spacer(""));
}
// 2) add coached groups
if (!userCourseEnv.getCoachedGroups().isEmpty()) {
for (BusinessGroup group: userCourseEnv.getCoachedGroups()) {
Link link = LinkFactory.createToolLink(CMD_START_GROUP_PREFIX + group.getKey(), "group", StringHelper.escapeHtml(group.getName()), this);
link.setIconLeftCSS("o_icon o_icon-fw o_icon_group");
link.setUserObject(group);
link.setEnabled(!assessmentLock);
myCourse.addComponent(link);
}
}
// 3) add participating groups
if (!userCourseEnv.getParticipatingGroups().isEmpty()) {
for (BusinessGroup group: userCourseEnv.getParticipatingGroups()) {
Link link = LinkFactory.createToolLink(CMD_START_GROUP_PREFIX + group.getKey(), "group", StringHelper.escapeHtml(group.getName()), this);
link.setIconLeftCSS("o_icon o_icon-fw o_icon_group");
link.setUserObject(group);
link.setEnabled(!assessmentLock);
myCourse.addComponent(link);
}
}
// 5) add waiting-list groups
if (!userCourseEnv.getWaitingLists().isEmpty()) {
for (BusinessGroup group: userCourseEnv.getWaitingLists()) {
int pos = businessGroupService.getPositionInWaitingListFor(getIdentity(), group);
String name = StringHelper.escapeHtml(group.getName()) + " (" + pos + ")";
Link link = LinkFactory.createToolLink(CMD_START_GROUP_PREFIX + group.getKey(), "group", name, this);
link.setIconLeftCSS("o_icon o_icon-fw o_icon_group");
link.setUserObject(group);
link.setEnabled(false);
myCourse.addComponent(link);
}
}
if(repositoryService.isParticipantAllowedToLeave(getRepositoryEntry())
&& !assessmentLock && !roles.isGuestOnly() && !userCourseEnv.isCourseReadOnly()
&& isAllowedToLeave(userCourseEnv)) {
leaveLink = LinkFactory.createToolLink("sign.out", "leave", translate("sign.out"), this);
leaveLink.setIconLeftCSS("o_icon o_icon-fw o_icon_sign_out");
myCourse.addComponent(new Spacer("leaving-space"));
myCourse.addComponent(leaveLink);
}
}
if(myCourse.size() > 0) {
toolbarPanel.addTool(myCourse, Align.right);
}
}
private boolean isAllowedToLeave(UserCourseEnvironment userCourseEnv) {
if(!userCourseEnv.getParticipatingGroups().isEmpty()) {
CourseNode rootNode = userCourseEnv.getCourseEnvironment().getRunStructure().getRootNode();
OLATResource courseResource = userCourseEnv.getCourseEnvironment().getCourseGroupManager().getCourseResource();
AtomicBoolean bool = new AtomicBoolean(false);
new TreeVisitor(node -> {
if(!bool.get() && node instanceof ENCourseNode) {
try {
ENCourseNode enNode = (ENCourseNode)node;
boolean cancelEnrollEnabled = enNode.getModuleConfiguration().getBooleanSafe(ENCourseNode.CONF_CANCEL_ENROLL_ENABLED);
if(!cancelEnrollEnabled && enNode.isUsedForEnrollment(userCourseEnv.getParticipatingGroups(), courseResource)) {
bool.set(true);
}
} catch (Exception e) {
logError("", e);
}
}
}, rootNode, true).visitAll();
if(bool.get()) {
return false;// is in a enrollment group
}
}
return (userCourseEnv.isParticipant() || !userCourseEnv.getParticipatingGroups().isEmpty());
}
private void initGeneralTools(ICourse course) {
boolean assessmentLock = isAssessmentLock();
UserCourseEnvironment userCourseEnv = getUserCourseEnvironment();
CourseConfig cc = course.getCourseConfig();
if (!assessmentLock && showDetails) {
detailsLink = LinkFactory.createToolLink("courseconfig",translate("command.courseconfig"), this, "o_icon_details");
detailsLink.setUrl(BusinessControlFactory.getInstance()
.getAuthenticatedURLFromBusinessPathStrings(businessPathEntry, "[Infos:0]"));
toolbarPanel.addTool(detailsLink);
}
if (!assessmentLock && !isGuestOnly
&& LearningPathNodeAccessProvider.TYPE.equals(cc.getNodeAccessType().getType())) {
learningPathLink = LinkFactory.createToolLink("learningPath", translate("command.learning.path"), this, CourseTool.learningpath.getIconCss());
learningPathLink.setUrl(BusinessControlFactory.getInstance()
.getAuthenticatedURLFromBusinessPathStrings(businessPathEntry, "[LearningPath:0]"));
toolbarPanel.addTool(learningPathLink);
}
if (learningPathLink != null) {
learningPathLink.setVisible(userCourseEnv != null && userCourseEnv.isParticipant());
}
if (!assessmentLock && !isGuestOnly
&& LearningPathNodeAccessProvider.TYPE.equals(cc.getNodeAccessType().getType())) {
learningPathsLink = LinkFactory.createToolLink("learningPaths", translate("command.learning.paths"), this, CourseTool.learningpath.getIconCss());
learningPathsLink.setUrl(BusinessControlFactory.getInstance()
.getAuthenticatedURLFromBusinessPathStrings(businessPathEntry, "[LearningPaths:0]"));
toolbarPanel.addTool(learningPathsLink);
}
if (learningPathsLink != null) {
learningPathsLink.setVisible(userCourseEnv != null && (userCourseEnv.isCoach() || userCourseEnv.isAdmin()));
}
boolean calendarIsEnabled = !assessmentLock && !isGuestOnly && calendarModule.isEnabled()
&& calendarModule.isEnableCourseToolCalendar() && reSecurity.canLaunch();
if (calendarIsEnabled && userCourseEnv != null) {
calendarLink = LinkFactory.createToolLink("calendar",translate("command.calendar"), this, "o_icon_calendar");
calendarLink.setPopup(new LinkPopupSettings(950, 750, "cal"));
calendarLink.setUrl(BusinessControlFactory.getInstance()
.getAuthenticatedURLFromBusinessPathStrings(businessPathEntry, "[Calendar:0]"));
calendarLink.setVisible(cc.isCalendarEnabled());
toolbarPanel.addTool(calendarLink);
}
if(!assessmentLock && isLecturesLinkEnabled()) {
lecturesLink = LinkFactory.createToolLink("command.lectures", translate("command.lectures"), this, "o_icon_lecture");
lecturesLink.setUrl(BusinessControlFactory.getInstance()
.getAuthenticatedURLFromBusinessPathStrings(businessPathEntry, "[Lectures:0]"));
toolbarPanel.addTool(lecturesLink);
}
if(!assessmentLock && !isGuestOnly && userCourseEnv != null) {
participantListLink = LinkFactory.createToolLink("participantlist",
translate(CourseTool.participantlist.getI18nKey()), this,
CourseTool.participantlist.getIconCss());
participantListLink.setUrl(BusinessControlFactory.getInstance()
.getAuthenticatedURLFromBusinessPathStrings(businessPathEntry, "[ParticipantList:0]"));
participantListLink.setVisible(cc.isParticipantListEnabled());
toolbarPanel.addTool(participantListLink);
}
if(!assessmentLock && userCourseEnv != null) {
participantInfoLink = LinkFactory.createToolLink("participantinfo",
translate(CourseTool.participantinfos.getI18nKey()), this,
CourseTool.participantinfos.getIconCss());
participantInfoLink.setUrl(BusinessControlFactory.getInstance()
.getAuthenticatedURLFromBusinessPathStrings(businessPathEntry, "[ParticipantInfos:0]"));
participantInfoLink.setVisible(cc.isParticipantInfoEnabled());
toolbarPanel.addTool(participantInfoLink);
}
if(!assessmentLock && !isGuestOnly && userCourseEnv != null && !userCourseEnv.isCourseReadOnly()) {
emailLink = LinkFactory.createToolLink("email", translate(CourseTool.email.getI18nKey()), this, CourseTool.email.getIconCss());
emailLink.setUrl(BusinessControlFactory.getInstance()
.getAuthenticatedURLFromBusinessPathStrings(businessPathEntry, "[email:0]"));
emailLink.setVisible(cc.isEmailEnabled());
toolbarPanel.addTool(emailLink);
}
if(!assessmentLock && userCourseEnv != null) {
blogLink = LinkFactory.createToolLink("blog", translate(CourseTool.blog.getI18nKey()), this, CourseTool.blog.getIconCss());
blogLink.setUrl(BusinessControlFactory.getInstance()
.getAuthenticatedURLFromBusinessPathStrings(businessPathEntry, "[blog:0]"));
blogLink.setVisible(cc.isBlogEnabled());
toolbarPanel.addTool(blogLink);
}
if(!assessmentLock && userCourseEnv != null) {
wikiLink = LinkFactory.createToolLink("wiki", translate(CourseTool.wiki.getI18nKey()), this, CourseTool.wiki.getIconCss());
wikiLink.setUrl(BusinessControlFactory.getInstance()
.getAuthenticatedURLFromBusinessPathStrings(businessPathEntry, "[wiki:0]"));
wikiLink.setVisible(cc.isWikiEnabled());
toolbarPanel.addTool(wikiLink);
}
if(!assessmentLock && userCourseEnv != null) {
forumLink = LinkFactory.createToolLink("forum", translate(CourseTool.forum.getI18nKey()), this, CourseTool.forum.getIconCss());
forumLink.setUrl(BusinessControlFactory.getInstance()
.getAuthenticatedURLFromBusinessPathStrings(businessPathEntry, "[forum:0]"));
forumLink.setVisible(cc.isForumEnabled());
toolbarPanel.addTool(forumLink);
}
if(!assessmentLock && userCourseEnv != null) {
documentsLink = LinkFactory.createToolLink("documents", translate(CourseTool.documents.getI18nKey()), this, CourseTool.documents.getIconCss());
documentsLink.setUrl(BusinessControlFactory.getInstance()
.getAuthenticatedURLFromBusinessPathStrings(businessPathEntry, "[documents:0]"));
documentsLink.setVisible(cc.isDocumentsEnabled());
toolbarPanel.addTool(documentsLink);
}
if(!assessmentLock) {
glossary = new Dropdown("glossary", "command.glossary", false, getTranslator());
glossary.setIconCSS("o_icon o_FileResource-GLOSSARY_icon");
glossary.setVisible(cc.hasGlossary() && cc.isGlossaryEnabled());
openGlossaryLink = LinkFactory.createToolLink("command.glossary.open", translate("command.glossary.open"), this);
openGlossaryLink.setPopup(new LinkPopupSettings(950, 750, "gloss"));
glossary.addComponent(openGlossaryLink);
enableGlossaryLink = LinkFactory.createToolLink("command.glossary.on.off", translate("command.glossary.on.alt"), this);
glossary.addComponent(enableGlossaryLink);
toolbarPanel.addTool(glossary);
}
//add group chat to toolbox
boolean chatIsEnabled = !assessmentLock && !isGuestOnly && imModule.isEnabled()
&& imModule.isCourseEnabled() && reSecurity.canLaunch();
if(chatIsEnabled && userCourseEnv != null && !userCourseEnv.isCourseReadOnly()) {
chatLink = LinkFactory.createToolLink("chat",translate("command.coursechat"), this, "o_icon_chat");
chatLink.setVisible(imModule.isCourseEnabled() && cc.isChatEnabled()); toolbarPanel.addTool(chatLink);
}
// add course search to toolbox
boolean isSearchEnabled = !assessmentLock && searchModule.isSearchAllowed(roles);
if (isSearchEnabled) {
searchLink = LinkFactory.createToolLink("coursesearch", translate("command.coursesearch"), this, "o_icon_search");
searchLink.setVisible(cc.isCourseSearchEnabled());
toolbarPanel.addTool(searchLink);
}
}
//check the configuration enable the lectures and the user is a teacher
private boolean isLecturesLinkEnabled() {
if(lectureModule.isEnabled()) {
if(reSecurity.isEntryAdmin()) {
return lectureService.isRepositoryEntryLectureEnabled(getRepositoryEntry());
} else {
//check the configuration enable the lectures and the user is a teacher
return lectureService.hasLecturesAsTeacher(getRepositoryEntry(), getIdentity());
}
}
return false;
}
@Override
public void setActiveTool(Link tool) {
if(myCourse != null) {
myCourse.setActiveLink(tool);
}
super.setActiveTool(tool);
}
@Override
protected void doDispose() {
super.doDispose();
if (courseModule.displayParticipantsCount()) {
coordinatorManager.getCoordinator().getEventBus().fireEventToListenersOf(new MultiUserEvent(LEFT), getOlatResourceable());
}
}
@Override
public boolean requestForClose(UserRequest ureq) {
if(editorCtrl instanceof VetoableCloseController) {
return ((VetoableCloseController) editorCtrl).requestForClose(ureq);
}
return true;
}
@Override
public void event(Event event) {
if(event instanceof CourseConfigEvent) {
processCourseConfigEvent((CourseConfigEvent)event);
} else if (event instanceof EntryChangedEvent ) {
EntryChangedEvent repoEvent = (EntryChangedEvent) event;
if (repoEvent.isMe(getRepositoryEntry())) {
processEntryChangedEvent(repoEvent);
}
//All events are MultiUserEvent, check with command at the end
} else if (event instanceof MultiUserEvent) {
if (event.getCommand().equals(JOINED) || event.getCommand().equals(LEFT)) {
updateCurrentUserCount();
}
}
super.event(event);
}
@Override
protected void event(UserRequest ureq, Component source, Event event) { if(assessmentModeLink == source) {
doAssessmentMode(ureq);
} else if (lifeCycleChangeLink == source) {
doLifeCycleChange(ureq);
} else if(reminderLink == source) {
doReminders(ureq);
} else if(lecturesAdminLink == source) {
doLecturesAdmin(ureq);
} else if(lecturesLink == source) {
doLectures(ureq);
} else if(archiverLink == source) {
doArchive(ureq);
} else if(folderLink == source) {
doCourseFolder(ureq);
} else if(areaLink == source) {
doCourseAreas(ureq);
} else if(dbLink == source) {
doDatabases(ureq);
} else if(courseStatisticLink == source) {
doCourseStatistics(ureq);
} else if(testStatisticLink == source) {
doAssessmentTestStatistics(ureq);
} else if(surveyStatisticLink == source) {
doAssessmentSurveyStatistics(ureq);
} else if(assessmentLink == source) {
doAssessmentTool(ureq);
} else if (convertLearningPathLink == source) {
doConvertToLearningPath(ureq);
} else if(participantListLink == source) {
doParticipantList(ureq);
} else if(participantInfoLink == source) {
doParticipantInfo(ureq);
} else if(emailLink == source) {
doEmail(ureq);
} else if(blogLink == source) {
doBlog(ureq);
} else if(wikiLink == source) {
doWiki(ureq);
} else if(forumLink == source) {
doForum(ureq);
} else if(documentsLink == source) {
doDocuments(ureq);
} else if(learningPathLink == source) {
doLearningPath(ureq);
} else if(learningPathsLink == source) {
doLearningPaths(ureq);
} else if(calendarLink == source) {
launchCalendar(ureq);
} else if(chatLink == source) {
launchChat(ureq);
} else if(searchLink == source) {
launchCourseSearch(ureq);
} else if(efficiencyStatementsLink == source) {
doEfficiencyStatements(ureq);
} else if(noteLink == source) {
launchPersonalNotes(ureq);
} else if(openGlossaryLink == source) {
launchGlossary(ureq);
} else if(leaveLink == source) {
doConfirmLeave(ureq);
} else if(source instanceof Link && "group".equals(((Link)source).getCommand())) {
BusinessGroupRef ref = (BusinessGroupRef)((Link)source).getUserObject();
launchGroup(ureq, ref.getKey());
} else if(source == toolbarPanel) {
if(event instanceof VetoPopEvent) {
delayedClose = Delayed.pop;
} else if(event instanceof PopEvent) {
processPopEvent(ureq, (PopEvent)event);
}
} else if(enableGlossaryLink == source) { toggleGlossary(ureq);
}
// Update window title
if (source instanceof Link) {
Link link = (Link) source;
ICourse course = CourseFactory.loadCourse(getRepositoryEntry());
String newTitle = course.getCourseTitle() + " - " + link.getI18n();
getWindowControl().getWindowBackOffice().getWindow().setTitle(getTranslator(), newTitle);
}
super.event(ureq, source, event);
}
@Override
protected void processPopEvent(UserRequest ureq, PopEvent pop) {
super.processPopEvent(ureq, pop);
Controller popedController = pop.getController();
if(popedController != null && popedController == membersCtrl) {
// The user maybe has changed his own membership.
// Reload the security to ensure the right user switch roles etc.
reloadSecurity(ureq);
}
if(popedController != null && popedController == assessmentToolCtr) {
setCourseClosedMessage();
}
if(popedController != getRunMainController()) {
toolControllerDone(ureq);
}
}
@Override
protected void event(UserRequest ureq, Controller source, Event event) {
if(getRunMainController() == source) {
if(event instanceof BusinessGroupModifiedEvent) {
processBusinessGroupModifiedEvent(ureq, (BusinessGroupModifiedEvent)event);
} else if (event instanceof OpenCourseToolEvent) {
CourseTool tool = ((OpenCourseToolEvent)event).getTool();
doOpenTool(ureq, tool);
}
} else if (lifeCycleChangeCtr == source) {
if (event == RepositoryEntryLifeCycleChangeController.deletedEvent) {
doClose(ureq);
cleanUp();
}
} else if (currentToolCtr == source) {
if (event == Event.DONE_EVENT) {
// special check for editor
toolControllerDone(ureq);
}
} else if(source == leaveDialogBox) {
if (event.equals(Event.DONE_EVENT)) {
doLeave(ureq);
}else{
cmc.deactivate();
}
} else if (source == searchController) {
if (QuickSearchEvent.QUICKSEARCH.equals(event.getCommand())) {
doDeactivateQuickSearch();
}
} else if (source == unsupportedCourseNodesCtrl) {
cmc.deactivate();
cleanUp();
}
if(editorCtrl == source && source instanceof VetoableCloseController) {
if(event == Event.DONE_EVENT) {
if(delayedClose != null) {
switch(delayedClose) { case archive: doArchive(ureq); break;
case assessmentMode: doAssessmentMode(ureq); break;
case assessmentSurveyStatistics: doAssessmentSurveyStatistics(ureq); break;
case assessmentTestStatistics: doAssessmentTestStatistics(ureq); break;
case assessmentTool: doAssessmentTool(ureq); break;
case reminders: doReminders(ureq); break;
case learningPath: doLearningPath(ureq); break;
case learningPaths: doLearningPaths(ureq); break;
case lecturesAdmin: doLecturesAdmin(ureq); break;
case lectures: doLectures(ureq); break;
case courseAreas: doCourseAreas(ureq); break;
case courseFolder: doCourseFolder(ureq); break;
case courseStatistics: doCourseStatistics(ureq); break;
case databases: doDatabases(ureq); break;
case details: doDetails(ureq); break;
case settings: doSettings(ureq, null); break;
case efficiencyStatements: doEfficiencyStatements(ureq); break;
case members: doMembers(ureq); break;
case orders: doOrders(ureq); break;
case close: doClose(ureq); break;
case pop: popToRoot(ureq); cleanUp(); break;
case participantList: doParticipantList(ureq); break;
case participantInfo: doParticipantInfo(ureq); break;
case email: doEmail(ureq); break;
case blog: doBlog(ureq); break;
case wiki: doWiki(ureq); break;
case forum: doForum(ureq); break;
case documents: doDocuments(ureq); break;
}
delayedClose = null;
} else {
fireEvent(ureq, Event.DONE_EVENT);
}
}
}
super.event(ureq, source, event);
}
@Override
protected void cleanUp() {
removeAsListenerAndDispose(unsupportedCourseNodesCtrl);
removeAsListenerAndDispose(lifeCycleChangeCtr);
removeAsListenerAndDispose(assessmentModeCtrl);
removeAsListenerAndDispose(lecturesAdminCtrl);
removeAsListenerAndDispose(assessmentToolCtr);
removeAsListenerAndDispose(courseFolderCtrl);
removeAsListenerAndDispose(statisticsCtrl);
removeAsListenerAndDispose(remindersCtrl);
removeAsListenerAndDispose(databasesCtrl);
removeAsListenerAndDispose(lecturesCtrl);
removeAsListenerAndDispose(archiverCtrl);
removeAsListenerAndDispose(statsToolCtr);
removeAsListenerAndDispose(membersCtrl);
removeAsListenerAndDispose(areasCtrl);
removeAsListenerAndDispose(leaveDialogBox);
unsupportedCourseNodesCtrl = null;
lifeCycleChangeCtr = null;
assessmentModeCtrl = null;
lecturesAdminCtrl = null;
assessmentToolCtr = null;
courseFolderCtrl = null;
statisticsCtrl = null;
remindersCtrl = null;
databasesCtrl = null;
lecturesCtrl = null;
archiverCtrl = null;
statsToolCtr = null;
membersCtrl = null;
areasCtrl = null;
super.cleanUp();
}
@Override
public void activate(UserRequest ureq, List<ContextEntry> entries, StateEntry state) {
if(entries == null || entries.isEmpty()) {
if(currentToolCtr != null) {
addToHistory(ureq, currentToolCtr);
} else {
Controller runtimeCtrl = getRuntimeController();
if(runtimeCtrl instanceof Activateable2) {
((Activateable2)runtimeCtrl).activate(ureq, entries, state);
} else {
addToHistory(ureq, runtimeCtrl);
}
}
return;
}
entries = removeRepositoryEntry(entries);
if(entries != null && !entries.isEmpty()) {
String type = entries.get(0).getOLATResourceable().getResourceableTypeName();
if("Payment".equalsIgnoreCase(type)) {
doPostSuccessfullAccess(ureq);
} else if("Editor".equalsIgnoreCase(type)) {
if (!isInEditor() && !RepositoryEntryManagedFlag.isManaged(getRepositoryEntry(), RepositoryEntryManagedFlag.editcontent)) {
doEdit(ureq);
}
} else if("Infos".equalsIgnoreCase(type)) {
doDetails(ureq);
} else if("LearningPath".equalsIgnoreCase(type)) {
if (learningPathLink != null && learningPathLink.isVisible()) {
doLearningPath(ureq);
}
} else if("LearningPaths".equalsIgnoreCase(type)) {
if (learningPathsLink != null && learningPathsLink.isVisible()) {
activateSubEntries(ureq, doLearningPaths(ureq), entries);
}
} else if("Settings".equalsIgnoreCase(type) || "EditDescription".equalsIgnoreCase(type)) {
List<ContextEntry> subEntries = entries.subList(1, entries.size());
doSettings(ureq, subEntries);
} else if("ParticipantList".equalsIgnoreCase(type)) {
if (participantListLink != null && participantListLink.isVisible()) {
doParticipantList(ureq);
}
} else if("ParticipantInfos".equalsIgnoreCase(type)) {
if (participantInfoLink != null && participantInfoLink.isVisible()) {
doParticipantInfo(ureq);
}
} else if("Email".equalsIgnoreCase(type)) {
if (emailLink != null && emailLink.isVisible()) {
doEmail(ureq);
}
} else if("Blog".equalsIgnoreCase(type)) {
if (blogLink != null && blogLink.isVisible()) {
activateSubEntries(ureq, doBlog(ureq), entries);
}
} else if("Wiki".equalsIgnoreCase(type)) {
if (wikiLink != null && wikiLink.isVisible()) {
activateSubEntries(ureq, doWiki(ureq), entries);
}
} else if("Forum".equalsIgnoreCase(type)) {
if (forumLink != null && forumLink.isVisible()) {
doForum(ureq);
}
} else if("Calendar".equalsIgnoreCase(type)) {
if (calendarLink != null && calendarLink.isVisible()) {
doCalendar(ureq);
} } else if("Documents".equalsIgnoreCase(type)) {
if (documentsLink != null && documentsLink.isVisible()) {
activateSubEntries(ureq, doDocuments(ureq), entries);
}
} else if("Certification".equalsIgnoreCase(type)) {
if (efficiencyStatementsLink != null && efficiencyStatementsLink.isVisible()) {
doEfficiencyStatements(ureq);
}
} else if("Reminders".equalsIgnoreCase(type) || "RemindersLogs".equalsIgnoreCase(type)) {
doReminders(ureq);
} else if("Lectures".equalsIgnoreCase(type)) {
activateSubEntries(ureq, doLectures(ureq), entries);
} else if("LectureBlock".equalsIgnoreCase(type)) {
Activateable2 lectures = doLectures(ureq);
if(lectures != null) {
lectures.activate(ureq, entries, state);
}
} else if("LecturesAdmin".equalsIgnoreCase(type)) {
activateSubEntries(ureq, doLecturesAdmin(ureq), entries);
} else if("CourseFolder".equalsIgnoreCase(type)) {
doCourseFolder(ureq);
} else if("AssessmentMode".equalsIgnoreCase(type)) {
doAssessmentMode(ureq);
} else if("CourseAreas".equalsIgnoreCase(type)) {
doCourseAreas(ureq);
} else if("CourseStatistics".equalsIgnoreCase(type)) {
activateSubEntries(ureq, doCourseStatistics(ureq), entries);
} else if("Archives".equalsIgnoreCase(type)) {
activateSubEntries(ureq, doArchive(ureq), entries);
} else if("MembersMgmt".equalsIgnoreCase(type)) {
activateSubEntries(ureq, doMembers(ureq), entries);
} else if ("assessmentTool".equalsIgnoreCase(type) || "assessmentToolv2".equalsIgnoreCase(type)) {
//check the security before, the link is perhaps in the wrong hands
if(reSecurity.isEntryAdmin() || reSecurity.isPrincipal() || reSecurity.isMasterCoach() || reSecurity.isCoach() || hasCourseRight(CourseRights.RIGHT_ASSESSMENT)) {
try {
Activateable2 assessmentCtrl = doAssessmentTool(ureq);
if(assessmentCtrl != null) {
List<ContextEntry> subEntries;
if(entries.size() > 1 && entries.get(1).getOLATResourceable().getResourceableTypeName().equals(type)) {
subEntries = entries.subList(2, entries.size());
} else {
subEntries = entries.subList(1, entries.size());
}
assessmentCtrl.activate(ureq, subEntries, entries.get(0).getTransientState());
}
} catch (OLATSecurityException e) {
//the wrong link to the wrong person
}
}
} else if ("TestStatistics".equalsIgnoreCase(type) || "SurveyStatistics".equalsIgnoreCase(type)) {
//check the security before, the link is perhaps in the wrong hands
if(reSecurity.isEntryAdmin() || reSecurity.isPrincipal() || reSecurity.isMasterCoach() || reSecurity.isCoach() || hasCourseRight(CourseRights.RIGHT_ASSESSMENT)) {
try {
Activateable2 assessmentCtrl = null;
if("TestStatistics".equalsIgnoreCase(type)) {
assessmentCtrl = doAssessmentTestStatistics(ureq);
} else {
assessmentCtrl = doAssessmentSurveyStatistics(ureq);
}
List<ContextEntry> subEntries;
if(entries.size() > 1 && entries.get(1).getOLATResourceable().getResourceableTypeName().equals(type)) {
subEntries = entries.subList(2, entries.size());
} else {
subEntries = entries.subList(1, entries.size());
}
assessmentCtrl.activate(ureq, subEntries, entries.get(0).getTransientState());
} catch (OLATSecurityException e) {
//the wrong link to the wrong person
} }
} else if(type != null && type.startsWith("path=")) {
if (reSecurity.isEntryAdmin() || hasCourseRight(CourseRights.RIGHT_COURSEEDITOR)) {
String path = BusinessControlFactory.getInstance().getPath(entries.get(0));
FolderRunController folderCtrl = doCourseFolder(ureq);
if(folderCtrl != null) {
folderCtrl.activatePath(ureq, path);
}
}
}
}
RunMainController rmc = getRunMainController();
if(rmc != null) {
rmc.activate(ureq, entries, state);
}
}
private void doOpenTool(UserRequest ureq, CourseTool tool) {
switch (tool) {
case blog: {
if (blogLink != null && blogLink.isVisible()) {
doBlog(ureq);
} else {
doShowToolNotAvailable(CourseTool.blog);
}
}
break;
case documents: {
if (documentsLink != null && documentsLink.isVisible()) {
doDocuments(ureq);
} else {
doShowToolNotAvailable(CourseTool.documents);
}
}
break;
case efficiencystatement: {
if (efficiencyStatementsLink != null && efficiencyStatementsLink.isVisible()) {
doEfficiencyStatements(ureq);
} else {
doShowToolNotAvailable(CourseTool.efficiencystatement);
}
}
break;
case email: {
if (emailLink != null && emailLink.isVisible()) {
doEmail(ureq);
} else {
doShowToolNotAvailable(CourseTool.email);
}
}
break;
case forum: {
if (forumLink != null && forumLink.isVisible()) {
doForum(ureq);
} else {
doShowToolNotAvailable(CourseTool.forum);
}
}
break;
case learningpath: {
if (learningPathLink != null && learningPathLink.isVisible()) {
doLearningPath(ureq);
} else if (learningPathsLink != null && learningPathsLink.isVisible()) {
doLearningPaths(ureq);
} else {
doShowToolNotAvailable(CourseTool.learningpath);
}
}
break; case participantlist: {
if (participantListLink != null && participantListLink.isVisible()) {
doParticipantList(ureq);
} else {
doShowToolNotAvailable(CourseTool.participantlist);
}
}
break;
case participantinfos: {
if (participantInfoLink != null && participantInfoLink.isVisible()) {
doParticipantInfo(ureq);
} else {
doShowToolNotAvailable(CourseTool.participantinfos);
}
}
break;
case wiki: {
if (wikiLink != null && wikiLink.isVisible()) {
doWiki(ureq);
} else {
doShowToolNotAvailable(CourseTool.wiki);
}
}
break;
default:
getWindowControl().setWarning(translate("msg.tool.not.available", new String[] { tool.name() } ));
}
}
private void doShowToolNotAvailable(CourseTool tool) {
getWindowControl().setWarning(translate("msg.tool.not.available", new String[] { translate(tool.getI18nKey()) } ));
}
@Override
protected void doEdit(UserRequest ureq) {
if ((reSecurity.isEntryAdmin()
|| hasCourseRight(CourseRights.RIGHT_COURSEEDITOR))) {
removeCustomCSS();
popToRoot(ureq);
cleanUp();
CourseNode currentCourseNode = getCurrentCourseNode();
WindowControl bwControl = getSubWindowControl("Editor");
EditorMainController ctrl = CourseFactory.createEditorController(ureq, addToHistory(ureq, bwControl),
toolbarPanel, getRepositoryEntry(), currentCourseNode);
//user activity logger which was initialized with course run
if(ctrl != null){
editorCtrl = pushController(ureq, "Editor", ctrl);
listenTo(editorCtrl);
setIsInEditor(true);
currentToolCtr = editorCtrl;
setActiveTool(editLink);
}
}
}
@Override
protected Activateable2 doSettings(UserRequest ureq, List<ContextEntry> entries) {
if(delayedClose == Delayed.settings || requestForClose(ureq)) {
if (reSecurity.isEntryAdmin() || hasCourseRight(CourseRights.RIGHT_COURSEEDITOR)) {
removeCustomCSS();
WindowControl bwControl = getSubWindowControl("Settings");
RepositoryEntry refreshedEntry = loadRepositoryEntry();
CourseSettingsController ctrl
= new CourseSettingsController(ureq, addToHistory(ureq, bwControl), toolbarPanel, refreshedEntry);
listenTo(ctrl);
settingsCtrl = pushController(ureq, translate("details.settings"), ctrl); currentToolCtr = settingsCtrl;
setActiveTool(settingsLink);
settingsCtrl.activate(ureq, entries, null);
return settingsCtrl;
}
} else {
delayedClose = Delayed.settings;
}
return null;
}
@Override
protected Activateable2 doMembers(UserRequest ureq) {
if(delayedClose == Delayed.members || requestForClose(ureq)) {
if (reSecurity.isEntryAdmin() || reSecurity.isPrincipal() || reSecurity.isMasterCoach() || hasCourseRight(CourseRights.RIGHT_GROUPMANAGEMENT) || hasCourseRight(CourseRights.RIGHT_MEMBERMANAGEMENT)) {
removeCustomCSS();
if(currentToolCtr instanceof MembersManagementMainController) {
((MembersManagementMainController)currentToolCtr).activate(ureq, null, null);
} else {
WindowControl bwControl = getSubWindowControl("MembersMgmt");
MembersManagementMainController ctrl = new MembersManagementMainController(ureq, addToHistory(ureq, bwControl), toolbarPanel,
getRepositoryEntry(), getUserCourseEnvironment(), reSecurity.isEntryAdmin(), reSecurity.isPrincipal() || reSecurity.isMasterCoach(),
hasCourseRight(CourseRights.RIGHT_GROUPMANAGEMENT), hasCourseRight(CourseRights.RIGHT_MEMBERMANAGEMENT));
listenTo(ctrl);
membersCtrl = pushController(ureq, translate("command.opensimplegroupmngt"), ctrl);
setActiveTool(membersLink);
currentToolCtr = membersCtrl;
}
}
} else {
delayedClose = Delayed.members;
}
return membersCtrl;
}
private void doConfirmLeave(UserRequest ureq) {
String title = translate("sign.out");
leaveDialogBox = new ConfirmLeaveController(ureq, getWindowControl(), getRepositoryEntry());
listenTo(leaveDialogBox);
cmc = new CloseableModalController(getWindowControl(), "close", leaveDialogBox.getInitialComponent(), true, title);
listenTo(cmc);
cmc.activate();
}
private void doLeave(UserRequest ureq) {
if(roles.isGuestOnly()) return;
MailerResult result = new MailerResult();
MailPackage reMailing = new MailPackage(result, getWindowControl().getBusinessControl().getAsString(), true);
//leave course
LeavingStatusList status = new LeavingStatusList();
repositoryManager.leave(getIdentity(), getRepositoryEntry(), status, reMailing);
//leave groups
businessGroupService.leave(getIdentity(), getRepositoryEntry(), status, reMailing);
if(status.isWarningManagedGroup() || status.isWarningManagedCourse()) {
showWarning("sign.out.warning.managed");
} else if(status.isWarningGroupWithMultipleResources()) {
showWarning("sign.out.warning.mutiple.resources");
} else {
showInfo("sign.out.success", new String[]{ getRepositoryEntry().getDisplayname() });
}
doClose(ureq);
}
private void doDeactivateQuickSearch() {
courseSearchCalloutCtr.deactivate();
}
private void doLifeCycleChange(UserRequest ureq) {
List<Link> breadCrumbs = toolbarPanel.getBreadCrumbs();
BreadCrumb lastCrumb = null;
if (!breadCrumbs.isEmpty()) {
lastCrumb = (BreadCrumb) breadCrumbs.get(breadCrumbs.size()-1).getUserObject();
}
if (lastCrumb == null || lastCrumb.getController() != lifeCycleChangeCtr) {
// only create and add to stack if not already there
lifeCycleChangeCtr = new RepositoryEntryLifeCycleChangeController(ureq, getWindowControl(),
getRepositoryEntry(), reSecurity, handler);
listenTo(lifeCycleChangeCtr);
currentToolCtr = lifeCycleChangeCtr;
toolbarPanel.pushController(translate("details.lifecycle.change"), lifeCycleChangeCtr);
}
}
private void doAssessmentMode(UserRequest ureq) {
if(delayedClose == Delayed.assessmentMode || requestForClose(ureq)) {
if (reSecurity.isEntryAdmin() || reSecurity.isPrincipal() || reSecurity.isMasterCoach()
|| hasCourseRight(CourseRights.RIGHT_COURSEEDITOR) || hasCourseRight(CourseRights.RIGHT_ASSESSMENT_MODE)) {
removeCustomCSS();
boolean canManage = reSecurity.isEntryAdmin() || hasCourseRight(CourseRights.RIGHT_COURSEEDITOR) || hasCourseRight(CourseRights.RIGHT_ASSESSMENT_MODE);
AssessmentModeSecurityCallback secCallback = AssessmentModeSecurityCallbackFactory.getSecurityCallback(canManage);
WindowControl swControl = addToHistory(ureq, OresHelper.createOLATResourceableInstance("AssessmentMode", 0l), null);
AssessmentModeListController ctrl = new AssessmentModeListController(ureq, swControl,
toolbarPanel, getRepositoryEntry(), secCallback);
assessmentModeCtrl = pushController(ureq, translate("command.assessment.mode"), ctrl);
setActiveTool(assessmentModeLink);
currentToolCtr = assessmentModeCtrl;
}
} else {
delayedClose = Delayed.assessmentMode;
}
}
private void doReminders(UserRequest ureq) {
if(delayedClose == Delayed.reminders || requestForClose(ureq)) {
if (reSecurity.isEntryAdmin() || hasCourseRight(CourseRights.RIGHT_COURSEEDITOR)) {
removeCustomCSS();
CourseRemindersController ctrl = new CourseRemindersController(ureq, getWindowControl(), getRepositoryEntry(), toolbarPanel);
remindersCtrl = pushController(ureq, translate("command.reminders"), ctrl);
setActiveTool(reminderLink);
currentToolCtr = remindersCtrl;
}
} else {
delayedClose = Delayed.reminders;
}
}
private LectureRepositoryAdminController doLecturesAdmin(UserRequest ureq) {
if(delayedClose == Delayed.lecturesAdmin || requestForClose(ureq)) {
if (reSecurity.isEntryAdmin() || reSecurity.isPrincipal() || reSecurity.isMasterCoach() || hasCourseRight(CourseRights.RIGHT_COURSEEDITOR)) {
removeCustomCSS();
OLATResourceable ores = OresHelper.createOLATResourceableType("LecturesAdmin");
WindowControl swControl = addToHistory(ureq, ores, null);
LecturesSecurityCallback secCallback = LecturesSecurityCallbackFactory
.getSecurityCallback(reSecurity.isEntryAdmin() || hasCourseRight(CourseRights.RIGHT_COURSEEDITOR), reSecurity.isMasterCoach(), false,
getUserCourseEnvironment().isCourseReadOnly());
LectureRepositoryAdminController ctrl = new LectureRepositoryAdminController(ureq, swControl, toolbarPanel, getRepositoryEntry(), secCallback);
listenTo(ctrl);
lecturesAdminCtrl = pushController(ureq, translate("command.options.lectures.admin"), ctrl);
setActiveTool(lecturesAdminLink);
currentToolCtr = lecturesAdminCtrl;
return lecturesAdminCtrl;
} else { return null;
}
} else {
delayedClose = Delayed.lecturesAdmin;
return null;
}
}
private TeacherOverviewController doLectures(UserRequest ureq) {
if(delayedClose == Delayed.lectures || requestForClose(ureq)) {
removeCustomCSS();
OLATResourceable ores = OresHelper.createOLATResourceableType("lectures");
WindowControl swControl = addToHistory(ureq, ores, null);
TeacherOverviewController ctrl = new TeacherOverviewController(ureq, swControl, toolbarPanel, getRepositoryEntry(),
reSecurity.isEntryAdmin(), lectureModule.isShowLectureBlocksAllTeachersDefault());
lecturesCtrl = pushController(ureq, translate("command.lectures"), ctrl);
setActiveTool(lecturesLink);
currentToolCtr = lecturesCtrl;
return lecturesCtrl;
} else {
delayedClose = Delayed.lectures;
return null;
}
}
private ArchiverMainController doArchive(UserRequest ureq) {
if(delayedClose == Delayed.archive || requestForClose(ureq)) {
if (reSecurity.isEntryAdmin() || hasCourseRight(CourseRights.RIGHT_ARCHIVING)) {
removeCustomCSS();
ICourse course = CourseFactory.loadCourse(getRepositoryEntry());
WindowControl swControl = this.addToHistory(ureq, OresHelper.createOLATResourceableInstance("Archives", 0l), null);
ArchiverMainController ctrl = new ArchiverMainController(ureq, swControl, course, new FullAccessArchiverCallback());
listenTo(ctrl);
archiverCtrl = pushController(ureq, translate("command.openarchiver"), ctrl);
currentToolCtr = archiverCtrl;
setActiveTool(archiverLink);
return ctrl;
}
} else {
delayedClose = Delayed.archive;
}
return null;
}
private FolderRunController doCourseFolder(UserRequest ureq) {
if(delayedClose == Delayed.courseFolder || requestForClose(ureq)) {
removeCustomCSS();
// Folder for course with custom link model to jump to course nodes
ICourse course = CourseFactory.loadCourse(getRepositoryEntry());
VFSContainer courseContainer;
if(overrideReadOnly) {
courseContainer = course.getCourseFolderContainer(overrideReadOnly);
} else {
courseContainer = course.getCourseFolderContainer();
}
VFSContainer namedCourseFolder = new NamedContainerImpl(translate("command.coursefolder"), courseContainer);
CustomLinkTreeModel customLinkTreeModel = new CourseInternalLinkTreeModel(course.getEditorTreeModel());
WindowControl swControl = addToHistory(ureq, OresHelper.createOLATResourceableInstance("CourseFolder", 0l), null);
FolderRunController ctrl = new FolderRunController(namedCourseFolder, true, true, true, true, ureq, swControl, null, customLinkTreeModel, null);
ctrl.addLoggingResourceable(LoggingResourceable.wrap(course));
courseFolderCtrl = pushController(ureq, translate("command.coursefolder"), ctrl);
setActiveTool(folderLink);
currentToolCtr = courseFolderCtrl;
} else {
delayedClose = Delayed.courseFolder;
}
return courseFolderCtrl; }
private void doCourseAreas(UserRequest ureq) {
if(delayedClose == Delayed.courseAreas || requestForClose(ureq)) {
removeCustomCSS();
ICourse course = CourseFactory.loadCourse(getRepositoryEntry());
WindowControl swControl = addToHistory(ureq, OresHelper.createOLATResourceableInstance("CourseAreas", 0l), null);
CourseAreasController ctrl = new CourseAreasController(ureq, swControl,
getRepositoryEntry().getOlatResource(), getUserCourseEnvironment().isCourseReadOnly());
ctrl.addLoggingResourceable(LoggingResourceable.wrap(course));
areasCtrl = pushController(ureq, translate("command.courseareas"), ctrl);
setActiveTool(areaLink);
currentToolCtr = areasCtrl;
} else {
delayedClose = Delayed.courseAreas;
}
}
private void doDatabases(UserRequest ureq) {
if(delayedClose == Delayed.databases || requestForClose(ureq)) {
if (reSecurity.isEntryAdmin() || hasCourseRight(CourseRights.RIGHT_DB)) {
removeCustomCSS();
ICourse course = CourseFactory.loadCourse(getRepositoryEntry());
CustomDBMainController ctrl = new CustomDBMainController(ureq, getWindowControl(), course,
getUserCourseEnvironment().isCourseReadOnly());
listenTo(ctrl);
databasesCtrl = pushController(ureq, translate("command.opendb"), ctrl);
setActiveTool(dbLink);
currentToolCtr = databasesCtrl;
}
} else {
delayedClose = Delayed.databases;
}
}
private StatisticMainController doCourseStatistics(UserRequest ureq) {
if(delayedClose == Delayed.courseStatistics || requestForClose(ureq)) {
if (reSecurity.isEntryAdmin() || reSecurity.isPrincipal() || reSecurity.isMasterCoach()
|| hasCourseRight(CourseRights.RIGHT_STATISTICS)) {
removeCustomCSS();
ICourse course = CourseFactory.loadCourse(getRepositoryEntry());
WindowControl swControl = this.addToHistory(ureq, OresHelper.createOLATResourceableInstance("CourseStatistics", 0l), null);
StatisticMainController ctrl = new StatisticMainController(ureq, swControl, course);
listenTo(ctrl);
statisticsCtrl = pushController(ureq, translate("command.openstatistic"), ctrl);
setActiveTool(courseStatisticLink);
currentToolCtr = statisticsCtrl;
}
} else {
delayedClose = Delayed.courseStatistics;
}
return statisticsCtrl;
}
private Activateable2 doAssessmentTestStatistics(UserRequest ureq) {
Activateable2 controller = null;
if(delayedClose == Delayed.assessmentTestStatistics || requestForClose(ureq)) {
controller = doAssessmentStatistics(ureq, "command.openteststatistic", "TestStatistics", testStatisticLink, StatisticType.TEST);
} else {
delayedClose = Delayed.assessmentTestStatistics;
}
return controller;
}
private Activateable2 doAssessmentSurveyStatistics(UserRequest ureq) {
Activateable2 controller = null;
if(delayedClose == Delayed.assessmentSurveyStatistics || requestForClose(ureq)) {
controller = doAssessmentStatistics(ureq, "command.opensurveystatistic", "SurveyStatistics",
surveyStatisticLink, StatisticType.SURVEY);
} else { delayedClose = Delayed.assessmentSurveyStatistics;
}
return controller;
}
/**
* Only an helper method for the 2 methods above. Don't call it directly, there is no request on close guard.
* @param ureq
* @param i18nCrumbKey
* @param typeName
* @param tool
* @param types
* @return
*/
private Activateable2 doAssessmentStatistics(UserRequest ureq, String i18nCrumbKey, String typeName, Link tool, StatisticType type) {
OLATResourceable ores = OresHelper.createOLATResourceableType(typeName);
ThreadLocalUserActivityLogger.addLoggingResourceInfo(LoggingResourceable.wrapBusinessPath(ores));
WindowControl swControl = addToHistory(ureq, ores, null);
if (reSecurity.isEntryAdmin() || reSecurity.isPrincipal() || reSecurity.isMasterCoach() || reSecurity.isCoach() || hasCourseRight(CourseRights.RIGHT_STATISTICS)) {
removeCustomCSS();
UserCourseEnvironmentImpl uce = getUserCourseEnvironment();
StatisticCourseNodesController ctrl = new StatisticCourseNodesController(ureq, swControl, toolbarPanel, reSecurity, uce, type);
listenTo(ctrl);
statsToolCtr = pushController(ureq, translate(i18nCrumbKey), ctrl);
currentToolCtr = statsToolCtr;
setActiveTool(tool);
return statsToolCtr;
}
return null;
}
private Activateable2 doAssessmentTool(UserRequest ureq) {
if(delayedClose == Delayed.assessmentTool || requestForClose(ureq)) {
OLATResourceable ores = OresHelper.createOLATResourceableType("assessmentToolv2");
ThreadLocalUserActivityLogger.addLoggingResourceInfo(LoggingResourceable.wrapBusinessPath(ores));
WindowControl swControl = addToHistory(ureq, ores, null);
boolean admin = reSecurity.isEntryAdmin() || reSecurity.isPrincipal() || reSecurity.isMasterCoach() || hasCourseRight(CourseRights.RIGHT_ASSESSMENT);
boolean nonMembers = reSecurity.isEntryAdmin();
List<BusinessGroup> coachedGroups = null;
UserCourseEnvironment userCourseEnv = getUserCourseEnvironment();
if(reSecurity.isGroupCoach()) {
coachedGroups = userCourseEnv.getCoachedGroups();
}
AssessmentToolSecurityCallback secCallBack
= new AssessmentToolSecurityCallback(admin, nonMembers, reSecurity.isCourseCoach(), reSecurity.isGroupCoach(), reSecurity.isCurriculumCoach(), coachedGroups);
removeCustomCSS();
AssessmentToolController ctrl = new AssessmentToolController(ureq, swControl, toolbarPanel, getRepositoryEntry(), userCourseEnv, secCallBack);
ctrl.activate(ureq, null, null);
listenTo(ctrl);
assessmentToolCtr = pushController(ureq, translate("command.openassessment"), ctrl);
assessmentToolCtr.assessmentModeMessage();
currentToolCtr = assessmentToolCtr;
setActiveTool(assessmentLink);
ctrl.initToolbar();
return assessmentToolCtr;
} else {
delayedClose = Delayed.assessmentTool;
}
return null;
}
private void doEfficiencyStatements(UserRequest ureq) {
if(delayedClose == Delayed.efficiencyStatements || requestForClose(ureq)) {
// will not be disposed on course run dispose, popus up as new browserwindow
WindowControl bwControl = getSubWindowControl("Certification");
CertificateAndEfficiencyStatementController efficiencyStatementController
= new CertificateAndEfficiencyStatementController(addToHistory(ureq, bwControl), ureq, getRepositoryEntry()); listenTo(efficiencyStatementController);
efficiencyStatementController = pushController(ureq, translate("command.efficiencystatement"), efficiencyStatementController);
currentToolCtr = efficiencyStatementController;
setActiveTool(efficiencyStatementsLink);
} else {
delayedClose = Delayed.efficiencyStatements;
}
}
private void toggleGlossary(UserRequest ureq) {
// enable / disable glossary highlighting according to user prefs
Preferences prefs = ureq.getUserSession().getGuiPreferences();
String guiPrefsKey = CourseGlossaryFactory.createGuiPrefsKey(getOlatResourceable());
Boolean state = (Boolean) prefs.get(CourseGlossaryToolLinkController.class, guiPrefsKey);
Boolean newState = state == null ? Boolean.TRUE : new Boolean(!state.booleanValue());
setGlossaryLinkTitle(ureq, newState);
prefs.putAndSave(CourseGlossaryToolLinkController.class, guiPrefsKey, newState);
}
private void setGlossaryLinkTitle(UserRequest ureq, Boolean state) {
if(enableGlossaryLink == null) return;
String oresName = ICourse.class.getSimpleName();
Long courseID = getOlatResourceable().getResourceableId();
// must work with SP and CP nodes, IFrameDisplayController listens to this event and expects "ICourse" resources.
OLATResourceable ores = OresHelper.createOLATResourceableInstance(oresName, courseID);
if (state == null || !state.booleanValue()) {
enableGlossaryLink.setCustomDisplayText(translate("command.glossary.on.alt"));
setTextMarkingEnabled(false);
ureq.getUserSession().getSingleUserEventCenter().fireEventToListenersOf(new MultiUserEvent("glossaryOff"), ores);
} else {
enableGlossaryLink.setCustomDisplayText(translate("command.glossary.off.alt"));
setTextMarkingEnabled(true);
ureq.getUserSession().getSingleUserEventCenter().fireEventToListenersOf(new MultiUserEvent("glossaryOn"), ores);
}
}
private void doConvertToLearningPath(UserRequest ureq) {
ICourse course = CourseFactory.loadCourse(getRepositoryEntry());
List<CourseNode> unsupportedCourseNodes = learningPathService.getUnsupportedCourseNodes(course);
if (!unsupportedCourseNodes.isEmpty()) {
showUnsupportedMessage(ureq, unsupportedCourseNodes);
return;
}
RepositoryEntry lpEntry = learningPathService.migrate(getRepositoryEntry(), getIdentity());
String bPath = "[RepositoryEntry:" + lpEntry.getKey() + "]";
NewControllerFactory.getInstance().launch(bPath, ureq, getWindowControl());
}
private void showUnsupportedMessage(UserRequest ureq, List<CourseNode> unsupportedCourseNodes) {
unsupportedCourseNodesCtrl = new UnsupportedCourseNodesController(ureq, getWindowControl(), unsupportedCourseNodes);
listenTo(unsupportedCourseNodesCtrl);
cmc = new CloseableModalController(getWindowControl(), translate("close"),
unsupportedCourseNodesCtrl.getInitialComponent(), true, translate("unsupported.course.nodes.title"));
cmc.activate();
listenTo(cmc);
}
@Override
protected void launchContent(UserRequest ureq) {
super.launchContent(ureq);
if(getRunMainController() != null) {
addCustomCSS(ureq);
getRunMainController().initToolbarAndProgressbar();
}
}
private void doLearningPath(UserRequest ureq) { if(delayedClose == Delayed.learningPath || requestForClose(ureq)) {
OLATResourceable ores = OresHelper.createOLATResourceableType("LearningPath");
WindowControl swControl = addToHistory(ureq, ores, null);
MyLearningPathController learningPathCtrl = new MyLearningPathController(ureq, swControl,
toolbarPanel, getUserCourseEnvironment());
listenTo(learningPathCtrl);
pushController(ureq, translate("command.learning.path"), learningPathCtrl);
currentToolCtr = learningPathCtrl;
setActiveTool(learningPathLink);
} else {
delayedClose = Delayed.learningPath;
}
}
private Activateable2 doLearningPaths(UserRequest ureq) {
if(delayedClose == Delayed.learningPaths || requestForClose(ureq)) {
OLATResourceable ores = OresHelper.createOLATResourceableType("LearningPaths");
WindowControl swControl = addToHistory(ureq, ores, null);
LearningPathIdentityListController learningPathIdentityListCtrl = new LearningPathIdentityListController(ureq, swControl,
toolbarPanel, getUserCourseEnvironment());
listenTo(learningPathIdentityListCtrl);
pushController(ureq, translate("command.learning.paths"), learningPathIdentityListCtrl);
currentToolCtr = learningPathIdentityListCtrl;
setActiveTool(learningPathsLink);
return learningPathIdentityListCtrl;
}
delayedClose = Delayed.learningPaths;
return null;
}
private void launchChat(UserRequest ureq) {
boolean vip = reSecurity.isCoach() || reSecurity.isEntryAdmin();
ICourse course = CourseFactory.loadCourse(getRepositoryEntry());
OpenInstantMessageEvent event = new OpenInstantMessageEvent(ureq, course, course.getCourseTitle(), vip);
ureq.getUserSession().getSingleUserEventCenter().fireEventToListenersOf(event, InstantMessagingService.TOWER_EVENT_ORES);
}
private void launchCourseSearch(UserRequest ureq) {
// do not dispose SearchInputController after search to remain able to listen to its events
removeAsListenerAndDispose(courseSearchCalloutCtr);
courseSearchCalloutCtr = null;
removeAsListenerAndDispose(searchController);
searchController = null;
SearchServiceUIFactory searchServiceUIFactory = (SearchServiceUIFactory)CoreSpringFactory.getBean(SearchServiceUIFactory.class);
searchController = searchServiceUIFactory.createInputController(ureq, getWindowControl(), DisplayOption.STANDARD, null);
listenTo(searchController);
courseSearchCalloutCtr = new CloseableCalloutWindowController(ureq, getWindowControl(),
searchController.getInitialComponent(), searchLink.getDispatchID(), null, true, null);
courseSearchCalloutCtr.addDisposableChildController(searchController);
courseSearchCalloutCtr.activate();
listenTo(courseSearchCalloutCtr);
}
private void doParticipantList(UserRequest ureq) {
if(delayedClose == Delayed.participantList || requestForClose(ureq)) {
removeCustomCSS();
OLATResourceable ores = OresHelper.createOLATResourceableType("ParticipantList");
WindowControl swControl = addToHistory(ureq, ores, null);
participatListCtrl = new MembersToolRunController(ureq, swControl, getUserCourseEnvironment());
pushController(ureq, translate("command.participant.list"), participatListCtrl);
setActiveTool(participantListLink);
currentToolCtr = participatListCtrl;
} else {
delayedClose = Delayed.participantList;
};
}
private void doParticipantInfo(UserRequest ureq) {
if(delayedClose == Delayed.participantInfo || requestForClose(ureq)) {
removeCustomCSS();
boolean autoSubscribe = false;
boolean canAdd;
boolean canAdmin;
if(getUserCourseEnvironment().isCourseReadOnly()) {
canAdd = false;
canAdmin = false;
} else {
boolean isAdmin = getUserCourseEnvironment().isAdmin();
canAdd = isAdmin || getUserCourseEnvironment().isCoach();
canAdmin = isAdmin;
}
InfoSecurityCallback secCallback = new InfoCourseSecurityCallback(getIdentity(), canAdd, canAdmin);
OLATResourceable ores = OresHelper.createOLATResourceableType("ParticipantInfos");
WindowControl swControl = addToHistory(ureq, ores, null);
participatInfoCtrl = new InfoRunController(ureq, swControl, getUserCourseEnvironment(), "ParticipantInfos",
secCallback, autoSubscribe);
pushController(ureq, translate("command.participant.info"), participatInfoCtrl);
setActiveTool(participantInfoLink);
currentToolCtr = participatInfoCtrl;
} else {
delayedClose = Delayed.participantInfo;
};
}
private void doEmail(UserRequest ureq) {
if(delayedClose == Delayed.email || requestForClose(ureq)) {
removeCustomCSS();
OLATResourceable ores = OresHelper.createOLATResourceableType("email");
WindowControl swControl = addToHistory(ureq, ores, null);
emailCtrl = new COToolController(ureq, swControl, getUserCourseEnvironment());
pushController(ureq, translate("command.email"), emailCtrl);
setActiveTool(emailLink);
currentToolCtr = emailCtrl;
} else {
delayedClose = Delayed.email;
}
}
private BlogToolController doBlog(UserRequest ureq) {
if(delayedClose == Delayed.blog || requestForClose(ureq)) {
removeCustomCSS();
OLATResourceable ores = OresHelper.createOLATResourceableType("blog");
WindowControl swControl = addToHistory(ureq, ores, null);
blogCtrl = new BlogToolController(ureq, swControl, getUserCourseEnvironment());
pushController(ureq, translate("command.blog"), blogCtrl);
setActiveTool(blogLink);
currentToolCtr = blogCtrl;
return blogCtrl;
}
delayedClose = Delayed.blog;
return null;
}
private WikiToolController doWiki(UserRequest ureq) {
if(delayedClose == Delayed.wiki || requestForClose(ureq)) {
removeCustomCSS();
OLATResourceable ores = OresHelper.createOLATResourceableType("wiki");
WindowControl swControl = addToHistory(ureq, ores, null); wikiCtrl = new WikiToolController(ureq, swControl, getUserCourseEnvironment());
pushController(ureq, translate("command.wiki"), wikiCtrl);
setActiveTool(wikiLink);
currentToolCtr = wikiCtrl;
return wikiCtrl;
}
delayedClose = Delayed.wiki;
return null;
}
private void doForum(UserRequest ureq) {
if(delayedClose == Delayed.forum || requestForClose(ureq)) {
removeCustomCSS();
OLATResourceable ores = OresHelper.createOLATResourceableType("forum");
WindowControl swControl = addToHistory(ureq, ores, null);
forumCtrl = new FOToolController(ureq, swControl, getUserCourseEnvironment());
pushController(ureq, translate("command.forum"), forumCtrl);
setActiveTool(forumLink);
currentToolCtr = forumCtrl;
} else {
delayedClose = Delayed.forum;
};
}
private CourseDocumentsController doDocuments(UserRequest ureq) {
if(delayedClose == Delayed.documents || requestForClose(ureq)) {
removeCustomCSS();
OLATResourceable ores = OresHelper.createOLATResourceableType("documents");
WindowControl swControl = addToHistory(ureq, ores, null);
documentsCtrl = new CourseDocumentsController(ureq, swControl, getUserCourseEnvironment());
pushController(ureq, translate("command.documents"), documentsCtrl);
setActiveTool(documentsLink);
currentToolCtr = documentsCtrl;
return documentsCtrl;
}
delayedClose = Delayed.documents;
return null;
}
/**
* Open the calendar as sub-controller.
*
* @param ureq The user request
* @return The calendar controller
*/
private CourseCalendarController doCalendar(UserRequest ureq) {
OLATResourceable ores = OresHelper.createOLATResourceableType("Calendar");
WindowControl swControl = addToHistory(ureq, ores, null);
CourseCalendarController calendarController = new CourseCalendarController(ureq, swControl, getUserCourseEnvironment());
pushController(ureq, translate("command.calendar"), calendarController);
setActiveTool(calendarLink);
currentToolCtr = calendarController;
return calendarController;
}
/**
* Open the course calendar as popup.
*
* @param ureq The user request
*/
private void launchCalendar(UserRequest ureq) {
ControllerCreator ctrlCreator = (lureq, lwControl) -> {
ICourse course = CourseFactory.loadCourse(getRepositoryEntry());
ContextEntry ce = BusinessControlFactory.getInstance().createContextEntry(getRepositoryEntry());
WindowControl llwControl = BusinessControlFactory.getInstance().createBusinessWindowControl(ce, lwControl); CourseCalendarController calendarController = new CourseCalendarController(lureq, llwControl, getUserCourseEnvironment());
// use a one-column main layout
LayoutMain3ColsController layoutCtr = new LayoutMain3ColsController(lureq, llwControl, calendarController);
layoutCtr.setCustomCSS(CourseFactory.getCustomCourseCss(lureq.getUserSession(), course.getCourseEnvironment()));
layoutCtr.addDisposableChildController(calendarController); // dispose calendar on layout dispose
return layoutCtr;
};
//wrap the content controller into a full header layout
ControllerCreator layoutCtrlr = BaseFullWebappPopupLayoutFactory.createAuthMinimalPopupLayout(ureq, ctrlCreator);
//open in new browser window
PopupBrowserWindow pbw = getWindowControl().getWindowBackOffice().getWindowManager().createNewPopupBrowserWindowFor(ureq, layoutCtrlr);
pbw.open(ureq);
}
private void launchGroup(UserRequest ureq, Long groupKey) {
// launch the group in a new top nav tab
BusinessGroup group = businessGroupService.loadBusinessGroup(groupKey);
// check if the group still exists and the user is really in this group
// (security, changed group)
if (group != null && businessGroupService.isIdentityInBusinessGroup(getIdentity(), group)) {
// create group without admin flag enabled even though the user might be
// coach. the flag is not needed here
// since the groups knows itself if the user is coach and the user sees
// only his own groups.
String bsuinessPath = "[BusinessGroup:" + group.getKey() + "]";
NewControllerFactory.getInstance().launch(bsuinessPath, ureq, getWindowControl());
} else {
// display error and do logging
getWindowControl().setError(translate("error.invalid.group"));
logAudit("User tried to launch a group but user is not owner or participant "
+ "of group or group doesn't exist. Hacker attack or group has been changed or deleted. group key :: " + groupKey);
// refresh toolbox that contained wrong group
reloadGroupMemberships();
}
}
private void launchPersonalNotes(UserRequest ureq) {
// will not be disposed on course run dispose, pop up as new browser window
ControllerCreator ctrlCreator = (lureq, lwControl) -> {
ICourse course = CourseFactory.loadCourse(getRepositoryEntry());
Controller notesCtr = new NoteController(lureq, course, course.getCourseTitle(), lwControl);
LayoutMain3ColsController layoutCtr = new LayoutMain3ColsController(lureq, lwControl, notesCtr);
layoutCtr.setCustomCSS(CourseFactory.getCustomCourseCss(lureq.getUserSession(), course.getCourseEnvironment()));
layoutCtr.addDisposableChildController(notesCtr); // dispose glossary on layout dispose
return layoutCtr;
};
//wrap the content controller into a full header layout
ControllerCreator popupLayoutCtr = BaseFullWebappPopupLayoutFactory.createAuthMinimalPopupLayout(ureq, ctrlCreator);
//open in new browser window
openInNewBrowserWindow(ureq, popupLayoutCtr);
}
private void launchGlossary(UserRequest ureq) {
// start glossary in window
ICourse course = CourseFactory.loadCourse(getRepositoryEntry());
final CourseConfig cc = course.getCourseConfig(); // do not cache cc, not save
final boolean allowGlossaryEditing = reSecurity.isEntryAdmin() || hasCourseRight(CourseRights.RIGHT_GLOSSARY);
// if glossary had been opened from LR as Tab before, warn user:
DTabs dts = Windows.getWindows(ureq).getWindow(ureq).getDTabs();
RepositoryEntry repoEntry = RepositoryManager.getInstance().lookupRepositoryEntryBySoftkey(cc.getGlossarySoftKey(), false);
DTab dt = dts.getDTab(repoEntry.getOlatResource());
if (dt != null) {
List<ContextEntry> entries = BusinessControlFactory.getInstance().createCEListFromResourceType(allowGlossaryEditing ? "true" : "false");
dts.activate(ureq, dt, entries);
} else {
ControllerCreator ctrlCreator = (lureq, lwControl) -> {
GlossaryMainController glossaryController = CourseGlossaryFactory.createCourseGlossaryMainRunController(lwControl, lureq, cc, allowGlossaryEditing);
listenTo(glossaryController);
if (glossaryController == null) { // happens in the unlikely event of a user who is in a course and
// now
// tries to access the glossary
String text = translate("error.noglossary");
return MessageUIFactory.createInfoMessage(lureq, lwControl, null, text);
} else {
// use a one-column main layout
LayoutMain3ColsController layoutCtr = new LayoutMain3ColsController(lureq, lwControl, glossaryController);
// dispose glossary on layout dispose
layoutCtr.addDisposableChildController(glossaryController);
return layoutCtr;
}
};
ControllerCreator layoutCtrlr = BaseFullWebappPopupLayoutFactory.createAuthMinimalPopupLayout(ureq, ctrlCreator);
// open in new browser window
openInNewBrowserWindow(ureq, layoutCtrlr);
}
}
@Override
protected void processClosedUnclosedEvent(UserRequest ureq) {
super.processClosedUnclosedEvent(ureq);
RunMainController runCtrl = getRunMainController();
if(runCtrl != null && runCtrl.getCurrentCourseNode() != null) {
runCtrl.updateCurrentCourseNode(ureq);
}
}
private void processCourseConfigEvent(CourseConfigEvent event) {
switch(event.getType()) {
case search: {
if(searchLink != null) {
ICourse course = CourseFactory.loadCourse(getRepositoryEntry());
CourseConfig cc = course.getCourseEnvironment().getCourseConfig();
searchLink.setVisible(cc.isCourseSearchEnabled());
toolbarPanel.setDirty(true);
}
break;
}
case calendar: {
if(calendarLink != null) {
ICourse course = CourseFactory.loadCourse(getRepositoryEntry());
CourseConfig cc = course.getCourseEnvironment().getCourseConfig();
calendarLink.setVisible(cc.isCalendarEnabled() && calendarModule.isEnabled() && calendarModule.isEnableCourseToolCalendar());
toolbarPanel.setDirty(true);
}
break;
}
case participantList: {
if(participantListLink != null) {
ICourse course = CourseFactory.loadCourse(getRepositoryEntry());
CourseConfig cc = course.getCourseEnvironment().getCourseConfig();
participantListLink.setVisible(cc.isParticipantListEnabled());
toolbarPanel.setDirty(true);
}
break;
}
case participantInfo: {
if(participantInfoLink != null) {
ICourse course = CourseFactory.loadCourse(getRepositoryEntry());
CourseConfig cc = course.getCourseEnvironment().getCourseConfig();
participantInfoLink.setVisible(cc.isParticipantInfoEnabled());
toolbarPanel.setDirty(true);
}
break;
}
case email: {
if(emailLink != null) { ICourse course = CourseFactory.loadCourse(getRepositoryEntry());
CourseConfig cc = course.getCourseEnvironment().getCourseConfig();
emailLink.setVisible(cc.isEmailEnabled());
toolbarPanel.setDirty(true);
}
break;
}
case blog: {
if(blogLink != null) {
ICourse course = CourseFactory.loadCourse(getRepositoryEntry());
CourseConfig cc = course.getCourseEnvironment().getCourseConfig();
blogLink.setVisible(cc.isBlogEnabled());
toolbarPanel.setDirty(true);
}
break;
}
case wiki: {
if(wikiLink != null) {
ICourse course = CourseFactory.loadCourse(getRepositoryEntry());
CourseConfig cc = course.getCourseEnvironment().getCourseConfig();
wikiLink.setVisible(cc.isWikiEnabled());
toolbarPanel.setDirty(true);
}
break;
}
case forum: {
if(forumLink != null) {
ICourse course = CourseFactory.loadCourse(getRepositoryEntry());
CourseConfig cc = course.getCourseEnvironment().getCourseConfig();
forumLink.setVisible(cc.isForumEnabled());
toolbarPanel.setDirty(true);
}
break;
}
case documents: {
if(documentsLink != null) {
ICourse course = CourseFactory.loadCourse(getRepositoryEntry());
CourseConfig cc = course.getCourseEnvironment().getCourseConfig();
documentsLink.setVisible(cc.isDocumentsEnabled());
toolbarPanel.setDirty(true);
}
break;
}
case chat: {
if(chatLink != null) {
ICourse course = CourseFactory.loadCourse(getRepositoryEntry());
CourseConfig cc = course.getCourseEnvironment().getCourseConfig();
chatLink.setVisible(cc.isChatEnabled());
toolbarPanel.setDirty(true);
}
break;
}
case efficiencyStatement: {
if(efficiencyStatementsLink != null) {
ICourse course = CourseFactory.loadCourse(getRepositoryEntry());
CourseConfig cc = course.getCourseEnvironment().getCourseConfig();
efficiencyStatementsLink.setVisible(cc.isEfficencyStatementEnabled() || cc.isCertificateEnabled());
toolbarPanel.setDirty(true);
}
break;
}
case glossary: {
if(glossary != null) {
ICourse course = CourseFactory.loadCourse(getRepositoryEntry());
CourseConfig cc = course.getCourseEnvironment().getCourseConfig();
glossary.setVisible(cc.hasGlossary() && cc.isGlossaryEnabled());
toolbarPanel.setDirty(true);
}
break;
} case layout: {
//don't restart for that
break;
}
case completionType: {
doDisposeAfterEvent();
break;
}
}
}
private void processBusinessGroupModifiedEvent(UserRequest ureq, BusinessGroupModifiedEvent bgme) {
Identity identity = getIdentity();
// only do something if this identity is affected by change and the action
// was adding or removing of the user
if (bgme.wasMyselfAdded(identity) || bgme.wasMyselfRemoved(identity)) {
reloadSecurity(ureq);
reloadGroupMemberships();
initToolbar();
} else if (bgme.getCommand().equals(BusinessGroupModifiedEvent.GROUPRIGHTS_MODIFIED_EVENT)) {
// check if this affects a right group where the user does participate.
// if so, we need to rebuild the toolboxes
UserCourseEnvironmentImpl uce = getUserCourseEnvironment();
if (uce != null && (PersistenceHelper.listContainsObjectByKey(uce.getParticipatingGroups(), bgme.getModifiedGroupKey()) ||
PersistenceHelper.listContainsObjectByKey(uce.getCoachedGroups(), bgme.getModifiedGroupKey()))) {
reloadSecurity(ureq);
reloadGroupMemberships();
initToolbar();
}
}
}
@Override
protected void processEntryChangedEvent(EntryChangedEvent repoEvent) {
switch(repoEvent.getChange()) {
case modifiedAtPublish:
case modifiedAccess:
processEntryAccessChanged(repoEvent);
break;
case deleted:
doDisposeAfterEvent();
break;
default:
super.processEntryChangedEvent(repoEvent);
break;
}
}
private void processEntryAccessChanged(EntryChangedEvent repoEvent) {
if(repoEvent.isMe(getIdentity())) {
//author is not affected
} else {
loadRepositoryEntry();
reSecurity.setWrappedSecurity(repositoryManager.isAllowed(getIdentity(), roles, getRepositoryEntry()));
if(reSecurity.canLaunch()) {
reloadStatus();
loadRights();
} else {
doDisposeAfterEvent();
loadRights();
initToolbar();
}
}
}
private void updateCurrentUserCount() {
if (currentUserCountLink == null) {
// either called from event handler, not initialized yet
// or display of user count is not configured
return; }
int currentUserCount = coordinatorManager.getCoordinator().getEventBus().getListeningIdentityCntFor(getOlatResourceable());
if(currentUserCount == 0) {
currentUserCount = 1;
}
currentUserCountLink.setCustomDisplayText(translate("participants.in.course", new String[]{String.valueOf(currentUserCount)}));
}
private void doDisposeAfterEvent() {
RunMainController run = getRunMainController();
if(run != null) {
run.doDisposeAfterEvent();
}
}
private enum Delayed {
archive,
assessmentMode,
assessmentSurveyStatistics,
assessmentTestStatistics,
assessmentTool,
reminders,
lecturesAdmin,
lectures,
courseAreas,
courseFolder,
courseStatistics,
databases,
details,
settings,
learningPath,
learningPaths,
efficiencyStatements,
members,
orders,
close,
pop,
participantList,
participantInfo,
email,
blog,
wiki,
forum,
documents
}
}