use of org.olat.course.nodes.AbstractAccessableCourseNode in project OpenOLAT by OpenOLAT.
the class NavigationHandler method doEvaluateJumpTo.
private NodeClickedRef doEvaluateJumpTo(UserRequest ureq, WindowControl wControl, CourseNode courseNode, ControllerEventListener listeningController, String nodecmd, String nodeSubCmd, Controller currentNodeController) {
NodeClickedRef nclr;
if (log.isDebug()) {
log.debug("evaluateJumpTo courseNode = " + courseNode.getIdent() + ", " + courseNode.getShortName());
}
// build the new treemodel by evaluating the preconditions
TreeEvaluation treeEval = new TreeEvaluation();
GenericTreeModel treeModel = new GenericTreeModel();
CourseNode rootCn = userCourseEnv.getCourseEnvironment().getRunStructure().getRootNode();
NodeEvaluation rootNodeEval = rootCn.eval(userCourseEnv.getConditionInterpreter(), treeEval, filter);
TreeNode treeRoot = rootNodeEval.getTreeNode();
treeModel.setRootNode(treeRoot);
// find the treenode that corresponds to the node (!= selectedTreeNode since
// we built the TreeModel anew in the meantime
TreeNode newCalledTreeNode = treeEval.getCorrespondingTreeNode(courseNode);
if (newCalledTreeNode == null) {
// the clicked node is not visible anymore!
// if the new calculated model does not contain the selected node anymore
// (because of visibility changes of at least one of the ancestors
// -> issue an user infomative msg
// nclr: the new treemodel, not visible, no selected nodeid, no
// calledcoursenode, no nodeconstructionresult
nclr = new NodeClickedRef(treeModel, false, null, null, null, null, false);
} else {
// calculate the NodeClickedRef
// 1. get the correct (new) nodeevaluation
NodeEvaluation nodeEval = (NodeEvaluation) newCalledTreeNode.getUserObject();
if (nodeEval.getCourseNode() != courseNode) {
throw new AssertException("error in structure");
}
if (!nodeEval.isVisible()) {
throw new AssertException("node eval not visible!!");
}
// 2. start with the current NodeEvaluation, evaluate overall accessiblity
// per node bottom-up to see if all ancestors still grant access to the
// desired node
boolean mayAccessWholeTreeUp = mayAccessWholeTreeUp(nodeEval);
String newSelectedNodeId = newCalledTreeNode.getIdent();
Controller controller;
AdditionalConditionManager addMan = null;
if (courseNode instanceof AbstractAccessableCourseNode) {
Long courseId = userCourseEnv.getCourseEnvironment().getCourseResourceableId();
CourseNodePasswordManager cnpm = CourseNodePasswordManagerImpl.getInstance();
Identity identity = userCourseEnv.getIdentityEnvironment().getIdentity();
AdditionalConditionAnswerContainer answerContainer = cnpm.getAnswerContainer(identity);
addMan = new AdditionalConditionManager((AbstractAccessableCourseNode) courseNode, courseId, answerContainer);
}
if (!mayAccessWholeTreeUp || (addMan != null && !addMan.evaluateConditions())) {
if (nodeEval.oldStyleConditionsOk()) {
controller = addMan.nextUserInputController(ureq, wControl, userCourseEnv);
if (listeningController != null) {
controller.addControllerListener(listeningController);
}
} else {
// NOTE: we do not take into account what node caused the non-access by
// being !isAtLeastOneAccessible, but always state the
// NoAccessExplanation of the Node originally called by the user
String explan = courseNode.getNoAccessExplanation();
String sExplan = (explan == null ? "" : Formatter.formatLatexFormulas(explan));
controller = MessageUIFactory.createInfoMessage(ureq, wControl, null, sExplan);
// write log information
ThreadLocalUserActivityLogger.log(CourseLoggingAction.COURSE_NAVIGATION_NODE_NO_ACCESS, getClass(), LoggingResourceable.wrap(courseNode));
}
NodeRunConstructionResult ncr = new NodeRunConstructionResult(controller, null, null, null);
// nclr: the new treemodel, visible, selected nodeid, calledcoursenode,
// nodeconstructionresult
nclr = new NodeClickedRef(treeModel, true, newSelectedNodeId, null, courseNode, ncr, false);
} else if (!CourseNodeFactory.getInstance().getCourseNodeConfigurationEvenForDisabledBB(courseNode.getType()).isEnabled()) {
Translator pT = Util.createPackageTranslator(EditorMainController.class, ureq.getLocale());
controller = MessageUIFactory.createInfoMessage(ureq, wControl, null, pT.translate("course.building.block.disabled.user"));
NodeRunConstructionResult ncr = new NodeRunConstructionResult(controller, null, null, null);
nclr = new NodeClickedRef(treeModel, true, newSelectedNodeId, null, courseNode, ncr, false);
} else {
if (STCourseNode.isDelegatingSTCourseNode(courseNode) && (courseNode.getChildCount() > 0)) {
// the clicked node is a STCourse node and is set to "delegate", so
// delegate to its first visible child; if no child is visible, just skip and do normal eval
INode child;
for (int i = 0; i < courseNode.getChildCount(); i++) {
child = courseNode.getChildAt(i);
if (child instanceof CourseNode) {
CourseNode cn = (CourseNode) child;
NodeEvaluation cnEval = cn.eval(userCourseEnv.getConditionInterpreter(), treeEval, filter);
if (cnEval.isVisible()) {
return doEvaluateJumpTo(ureq, wControl, cn, listeningController, nodecmd, nodeSubCmd, currentNodeController);
}
}
}
}
// access the node, display its result in the right pane
NodeRunConstructionResult ncr;
// calculate the new businesscontext for the coursenode being called.
// type: class of node; key = node.getIdent;
// don't use the concrete instance since for the course: to jump to a coursenode with a given id is all there is to know
Class<CourseNode> oresC = CourseNode.class;
Long oresK = new Long(Long.parseLong(courseNode.getIdent()));
final OLATResourceable ores = OresHelper.createOLATResourceableInstance(oresC, oresK);
ContextEntry ce = BusinessControlFactory.getInstance().createContextEntry(ores);
WindowControl bwControl = BusinessControlFactory.getInstance().createBusinessWindowControl(ce, wControl);
if (previewMode) {
ncr = new NodeRunConstructionResult(courseNode.createPreviewController(ureq, bwControl, userCourseEnv, nodeEval));
} else {
// cleanup already existing controllers with external models for this node first, never disposed otherwise
if (externalTreeModels.containsKey(courseNode.getIdent()) && !(TreeEvent.COMMAND_TREENODE_OPEN.equals(nodeSubCmd) || TreeEvent.COMMAND_TREENODE_CLOSE.equals(nodeSubCmd))) {
SubTree subTree = externalTreeModels.get(courseNode.getIdent());
ControllerEventListener existingSubtreemodelListener = subTree.getTreeModelListener();
if (existingSubtreemodelListener != null && currentNodeController != null && !currentNodeController.isDisposed()) {
currentNodeController.dispose();
}
}
ncr = courseNode.createNodeRunConstructionResult(ureq, bwControl, userCourseEnv, nodeEval, nodecmd);
// remember as instance variable for next click
ControllerEventListener subtreemodelListener = ncr.getSubTreeListener();
if (subtreemodelListener != null) {
GenericTreeModel subTreeModel = (GenericTreeModel) ncr.getSubTreeModel();
externalTreeModels.put(courseNode.getIdent(), new SubTree(ncr.getRunController(), subTreeModel, subtreemodelListener));
if (!newSelectedNodeId.equals(ncr.getSelectedTreeNodeId())) {
if (ncr.getSelectedTreeNodeId() != null) {
TreeNode selectedNode = subTreeModel.getNodeById(ncr.getSelectedTreeNodeId());
if (selectedNode != null && selectedNode.getUserObject() instanceof String) {
openCourseNodeIds.add((String) selectedNode.getUserObject());
}
}
}
}
}
if (TreeEvent.COMMAND_TREENODE_OPEN.equals(nodeSubCmd)) {
openCourseNodeIds.add(courseNode.getIdent());
newSelectedNodeId = convertToTreeNodeId(treeEval, selectedCourseNodeId);
} else if (TreeEvent.COMMAND_TREENODE_CLOSE.equals(nodeSubCmd)) {
removeChildrenFromOpenNodes(courseNode);
newSelectedNodeId = convertToTreeNodeId(treeEval, selectedCourseNodeId);
if (!isInParentLine(courseNode)) {
selectedCourseNodeId = courseNode.getIdent();
} else {
selectedCourseNodeId = null;
newSelectedNodeId = null;
}
} else {
// add the selected node to the open one, if not, strange behaviour
selectedCourseNodeId = courseNode.getIdent();
openCourseNodeIds.add(selectedCourseNodeId);
if (ncr != null) {
String subNodeId = ncr.getSelectedTreeNodeId();
if (subNodeId != null) {
openCourseNodeIds.add(subNodeId);
}
}
}
openTreeNodeIds = convertToTreeNodeIds(treeEval, openCourseNodeIds);
reattachExternalTreeModels(treeEval);
if ((TreeEvent.COMMAND_TREENODE_OPEN.equals(nodeSubCmd) || TreeEvent.COMMAND_TREENODE_CLOSE.equals(nodeSubCmd)) && currentNodeController != null && !currentNodeController.isDisposed()) {
nclr = new NodeClickedRef(treeModel, true, null, openTreeNodeIds, null, null, false);
} else {
// nclr: the new treemodel, visible, selected nodeid, calledcoursenode,
// nodeconstructionresult
nclr = new NodeClickedRef(treeModel, true, newSelectedNodeId, openTreeNodeIds, courseNode, ncr, false);
// attach listener; we know we have a runcontroller here
if (listeningController != null) {
nclr.getRunController().addControllerListener(listeningController);
}
}
// write log information
ThreadLocalUserActivityLogger.log(CourseLoggingAction.COURSE_NAVIGATION_NODE_ACCESS, getClass(), LoggingResourceable.wrap(courseNode));
}
}
return nclr;
}
use of org.olat.course.nodes.AbstractAccessableCourseNode in project OpenOLAT by OpenOLAT.
the class AbstractCourseNodeWebService method updateCourseNode.
// fxdiff FXOLAT-122: course management
private CourseNodeVO updateCourseNode(String nodeId, String shortTitle, String longTitle, String learningObjectives, String visibilityExpertRules, String accessExpertRules, CustomConfigDelegate delegateConfig, CourseEditSession editSession) {
ICourse course = editSession.getCourse();
TreeNode updateEditorNode = course.getEditorTreeModel().getNodeById(nodeId);
CourseNode updatedNode = course.getEditorTreeModel().getCourseNode(nodeId);
if (StringHelper.containsNonWhitespace(shortTitle)) {
updatedNode.setShortTitle(shortTitle);
}
if (StringHelper.containsNonWhitespace(longTitle)) {
updatedNode.setLongTitle(longTitle);
}
if (StringHelper.containsNonWhitespace(learningObjectives)) {
updatedNode.setLearningObjectives(learningObjectives);
}
if (visibilityExpertRules != null) {
Condition cond = createExpertCondition(CONDITION_ID_VISIBILITY, visibilityExpertRules);
updatedNode.setPreConditionVisibility(cond);
}
if (StringHelper.containsNonWhitespace(accessExpertRules) && updatedNode instanceof AbstractAccessableCourseNode) {
Condition cond = createExpertCondition(CONDITION_ID_ACCESS, accessExpertRules);
((AbstractAccessableCourseNode) updatedNode).setPreConditionAccess(cond);
}
if (delegateConfig != null) {
ModuleConfiguration moduleConfig = updatedNode.getModuleConfiguration();
delegateConfig.configure(course, updatedNode, moduleConfig);
}
course.getEditorTreeModel().nodeConfigChanged(updateEditorNode);
CourseEditorTreeNode editorNode = course.getEditorTreeModel().getCourseEditorNodeContaining(updatedNode);
CourseNodeVO vo = get(updatedNode);
vo.setParentId(editorNode.getParent() == null ? null : editorNode.getParent().getIdent());
return vo;
}
use of org.olat.course.nodes.AbstractAccessableCourseNode in project OpenOLAT by OpenOLAT.
the class AbstractCourseNodeWebService method createCourseNode.
private CourseNodeVO createCourseNode(String type, String shortTitle, String longTitle, String learningObjectives, String visibilityExpertRules, String accessExpertRules, CustomConfigDelegate delegateConfig, CourseEditSession editSession, CourseNode parentNode, Integer position) {
CourseNodeConfiguration newNodeConfig = CourseNodeFactory.getInstance().getCourseNodeConfiguration(type);
CourseNode insertedNode = newNodeConfig.getInstance();
insertedNode.setShortTitle(shortTitle);
insertedNode.setLongTitle(longTitle);
insertedNode.setLearningObjectives(learningObjectives);
insertedNode.setNoAccessExplanation("You don't have access");
if (StringHelper.containsNonWhitespace(visibilityExpertRules)) {
Condition cond = this.createExpertCondition(CONDITION_ID_VISIBILITY, visibilityExpertRules);
insertedNode.setPreConditionVisibility(cond);
}
if (StringHelper.containsNonWhitespace(accessExpertRules) && insertedNode instanceof AbstractAccessableCourseNode) {
Condition cond = createExpertCondition(CONDITION_ID_ACCESS, accessExpertRules);
((AbstractAccessableCourseNode) insertedNode).setPreConditionAccess(cond);
}
ICourse course = editSession.getCourse();
if (delegateConfig != null) {
ModuleConfiguration moduleConfig = insertedNode.getModuleConfiguration();
delegateConfig.configure(course, insertedNode, moduleConfig);
}
if (position == null || position.intValue() < 0) {
course.getEditorTreeModel().addCourseNode(insertedNode, parentNode);
} else {
course.getEditorTreeModel().insertCourseNodeAt(insertedNode, parentNode, position);
}
CourseEditorTreeNode editorNode = course.getEditorTreeModel().getCourseEditorNodeContaining(insertedNode);
CourseNodeVO vo = get(insertedNode);
vo.setParentId(editorNode.getParent() == null ? null : editorNode.getParent().getIdent());
return vo;
}
use of org.olat.course.nodes.AbstractAccessableCourseNode in project openolat by klemens.
the class AbstractCourseNodeWebService method updateCourseNode.
// fxdiff FXOLAT-122: course management
private CourseNodeVO updateCourseNode(String nodeId, String shortTitle, String longTitle, String learningObjectives, String visibilityExpertRules, String accessExpertRules, CustomConfigDelegate delegateConfig, CourseEditSession editSession) {
ICourse course = editSession.getCourse();
TreeNode updateEditorNode = course.getEditorTreeModel().getNodeById(nodeId);
CourseNode updatedNode = course.getEditorTreeModel().getCourseNode(nodeId);
if (StringHelper.containsNonWhitespace(shortTitle)) {
updatedNode.setShortTitle(shortTitle);
}
if (StringHelper.containsNonWhitespace(longTitle)) {
updatedNode.setLongTitle(longTitle);
}
if (StringHelper.containsNonWhitespace(learningObjectives)) {
updatedNode.setLearningObjectives(learningObjectives);
}
if (visibilityExpertRules != null) {
Condition cond = createExpertCondition(CONDITION_ID_VISIBILITY, visibilityExpertRules);
updatedNode.setPreConditionVisibility(cond);
}
if (StringHelper.containsNonWhitespace(accessExpertRules) && updatedNode instanceof AbstractAccessableCourseNode) {
Condition cond = createExpertCondition(CONDITION_ID_ACCESS, accessExpertRules);
((AbstractAccessableCourseNode) updatedNode).setPreConditionAccess(cond);
}
if (delegateConfig != null) {
ModuleConfiguration moduleConfig = updatedNode.getModuleConfiguration();
delegateConfig.configure(course, updatedNode, moduleConfig);
}
course.getEditorTreeModel().nodeConfigChanged(updateEditorNode);
CourseEditorTreeNode editorNode = course.getEditorTreeModel().getCourseEditorNodeContaining(updatedNode);
CourseNodeVO vo = get(updatedNode);
vo.setParentId(editorNode.getParent() == null ? null : editorNode.getParent().getIdent());
return vo;
}
use of org.olat.course.nodes.AbstractAccessableCourseNode in project openolat by klemens.
the class AbstractCourseNodeWebService method createCourseNode.
private CourseNodeVO createCourseNode(String type, String shortTitle, String longTitle, String learningObjectives, String visibilityExpertRules, String accessExpertRules, CustomConfigDelegate delegateConfig, CourseEditSession editSession, CourseNode parentNode, Integer position) {
CourseNodeConfiguration newNodeConfig = CourseNodeFactory.getInstance().getCourseNodeConfiguration(type);
CourseNode insertedNode = newNodeConfig.getInstance();
insertedNode.setShortTitle(shortTitle);
insertedNode.setLongTitle(longTitle);
insertedNode.setLearningObjectives(learningObjectives);
insertedNode.setNoAccessExplanation("You don't have access");
if (StringHelper.containsNonWhitespace(visibilityExpertRules)) {
Condition cond = this.createExpertCondition(CONDITION_ID_VISIBILITY, visibilityExpertRules);
insertedNode.setPreConditionVisibility(cond);
}
if (StringHelper.containsNonWhitespace(accessExpertRules) && insertedNode instanceof AbstractAccessableCourseNode) {
Condition cond = createExpertCondition(CONDITION_ID_ACCESS, accessExpertRules);
((AbstractAccessableCourseNode) insertedNode).setPreConditionAccess(cond);
}
ICourse course = editSession.getCourse();
if (delegateConfig != null) {
ModuleConfiguration moduleConfig = insertedNode.getModuleConfiguration();
delegateConfig.configure(course, insertedNode, moduleConfig);
}
if (position == null || position.intValue() < 0) {
course.getEditorTreeModel().addCourseNode(insertedNode, parentNode);
} else {
course.getEditorTreeModel().insertCourseNodeAt(insertedNode, parentNode, position);
}
CourseEditorTreeNode editorNode = course.getEditorTreeModel().getCourseEditorNodeContaining(insertedNode);
CourseNodeVO vo = get(insertedNode);
vo.setParentId(editorNode.getParent() == null ? null : editorNode.getParent().getIdent());
return vo;
}
Aggregations