Search in sources :

Example 1 with NodeEvaluation

use of org.olat.course.run.userview.NodeEvaluation in project OpenOLAT by OpenOLAT.

the class NavigationHandler method mayAccessWholeTreeUp.

/**
 * @param ne
 * @return
 */
public static boolean mayAccessWholeTreeUp(NodeEvaluation ne) {
    NodeEvaluation curNodeEval = ne;
    boolean mayAccess;
    do {
        mayAccess = curNodeEval.isAtLeastOneAccessible();
        curNodeEval = (NodeEvaluation) curNodeEval.getParent();
    } while (curNodeEval != null && mayAccess);
    // top reached or may not access node
    return mayAccess;
}
Also used : NodeEvaluation(org.olat.course.run.userview.NodeEvaluation)

Example 2 with NodeEvaluation

use of org.olat.course.run.userview.NodeEvaluation 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;
}
Also used : INode(org.olat.core.util.nodes.INode) OLATResourceable(org.olat.core.id.OLATResourceable) AdditionalConditionManager(org.olat.course.condition.additionalconditions.AdditionalConditionManager) WindowControl(org.olat.core.gui.control.WindowControl) ContextEntry(org.olat.core.id.context.ContextEntry) ControllerEventListener(org.olat.core.gui.control.ControllerEventListener) Translator(org.olat.core.gui.translator.Translator) GenericTreeNode(org.olat.core.gui.components.tree.GenericTreeNode) TreeNode(org.olat.core.gui.components.tree.TreeNode) GenericTreeModel(org.olat.core.gui.components.tree.GenericTreeModel) CourseNode(org.olat.course.nodes.CourseNode) AbstractAccessableCourseNode(org.olat.course.nodes.AbstractAccessableCourseNode) STCourseNode(org.olat.course.nodes.STCourseNode) Identity(org.olat.core.id.Identity) EditorMainController(org.olat.course.editor.EditorMainController) AssertException(org.olat.core.logging.AssertException) EditorMainController(org.olat.course.editor.EditorMainController) TitledWrapperController(org.olat.core.gui.control.generic.title.TitledWrapperController) CPRunController(org.olat.course.nodes.cp.CPRunController) Controller(org.olat.core.gui.control.Controller) CourseNodePasswordManager(de.bps.course.nodes.CourseNodePasswordManager) TreeEvaluation(org.olat.course.run.userview.TreeEvaluation) AbstractAccessableCourseNode(org.olat.course.nodes.AbstractAccessableCourseNode) NodeEvaluation(org.olat.course.run.userview.NodeEvaluation) AdditionalConditionAnswerContainer(org.olat.course.condition.additionalconditions.AdditionalConditionAnswerContainer)

Example 3 with NodeEvaluation

use of org.olat.course.run.userview.NodeEvaluation in project OpenOLAT by OpenOLAT.

the class CourseSite method createController.

@Override
protected MainLayoutController createController(UserRequest ureq, WindowControl wControl, SiteConfiguration config) {
    RepositoryManager rm = RepositoryManager.getInstance();
    RepositoryService rs = CoreSpringFactory.getImpl(RepositoryService.class);
    RepositoryEntry entry = rm.lookupRepositoryEntryBySoftkey(repositorySoftKey, false);
    if (entry == null) {
        return getAlternativeController(ureq, wControl, config);
    }
    MainLayoutController c;
    ICourse course = CourseFactory.loadCourse(entry);
    UserSession usess = ureq.getUserSession();
    // course-launch-state depending course-settings
    RepositoryEntrySecurity reSecurity = rm.isAllowed(ureq, entry);
    boolean isAllowedToLaunch = reSecurity.canLaunch();
    boolean hasAccess = false;
    if (isAllowedToLaunch) {
        // either check with securityCallback or use access-settings from course-nodes
        if (siteSecCallback != null) {
            hasAccess = siteSecCallback.isAllowedToLaunchSite(ureq);
        } else if (usess.isInAssessmentModeProcess() && !usess.matchLockResource(course)) {
            hasAccess = false;
        } else {
            // check within course: accessibility of course root node
            CourseNode rootNode = course.getRunStructure().getRootNode();
            UserCourseEnvironmentImpl uce = new UserCourseEnvironmentImpl(ureq.getUserSession().getIdentityEnvironment(), course.getCourseEnvironment());
            NodeEvaluation nodeEval = rootNode.eval(uce.getConditionInterpreter(), new TreeEvaluation(), new VisibleTreeFilter());
            boolean mayAccessWholeTreeUp = NavigationHandler.mayAccessWholeTreeUp(nodeEval);
            hasAccess = mayAccessWholeTreeUp && nodeEval.isVisible();
        }
    }
    // load course (admins always see content) or alternative controller if course is not launchable
    if (hasAccess || usess.getRoles().isOLATAdmin()) {
        rs.incrementLaunchCounter(entry);
        // build up the context path for linked course
        WindowControl bwControl = BusinessControlFactory.getInstance().createBusinessWindowControl(ureq, entry, new StateSite(this), wControl, true);
        CourseRuntimeController runCtr = new CourseRuntimeController(ureq, bwControl, entry, reSecurity, new RuntimeControllerCreator() {

            @Override
            public Controller create(UserRequest uureq, WindowControl wwControl, TooledStackedPanel toolbarPanel, RepositoryEntry re, RepositoryEntrySecurity security, AssessmentMode assessmentMode) {
                return new RunMainController(uureq, wwControl, toolbarPanel, CourseFactory.loadCourse(re), re, security, assessmentMode);
            }
        }, false, true);
        // Configure run controller
        // a: don't show close link, is opened as site not tab
        runCtr.setCourseCloseEnabled(false);
        // b: don't show toolbar
        if (!showToolController) {
            runCtr.setToolControllerEnabled(false);
        }
        c = runCtr;
    } else {
        // access restricted (not in group / author) -> show controller
        // defined in olat_extensions (type autoCreator)
        c = getAlternativeController(ureq, wControl, config);
    }
    return c;
}
Also used : TooledStackedPanel(org.olat.core.gui.components.stack.TooledStackedPanel) AssessmentMode(org.olat.course.assessment.AssessmentMode) StateSite(org.olat.core.id.context.StateSite) VisibleTreeFilter(org.olat.course.run.userview.VisibleTreeFilter) RunMainController(org.olat.course.run.RunMainController) ICourse(org.olat.course.ICourse) RepositoryEntry(org.olat.repository.RepositoryEntry) WindowControl(org.olat.core.gui.control.WindowControl) MainLayoutController(org.olat.core.gui.control.generic.layout.MainLayoutController) RunMainController(org.olat.course.run.RunMainController) CourseRuntimeController(org.olat.course.run.CourseRuntimeController) Controller(org.olat.core.gui.control.Controller) RuntimeControllerCreator(org.olat.repository.ui.RepositoryEntryRuntimeController.RuntimeControllerCreator) UserCourseEnvironmentImpl(org.olat.course.run.userview.UserCourseEnvironmentImpl) RepositoryEntrySecurity(org.olat.repository.model.RepositoryEntrySecurity) CourseRuntimeController(org.olat.course.run.CourseRuntimeController) UserSession(org.olat.core.util.UserSession) TreeEvaluation(org.olat.course.run.userview.TreeEvaluation) MainLayoutController(org.olat.core.gui.control.generic.layout.MainLayoutController) RepositoryManager(org.olat.repository.RepositoryManager) CourseNode(org.olat.course.nodes.CourseNode) NodeEvaluation(org.olat.course.run.userview.NodeEvaluation) UserRequest(org.olat.core.gui.UserRequest) RepositoryService(org.olat.repository.RepositoryService)

Example 4 with NodeEvaluation

use of org.olat.course.run.userview.NodeEvaluation in project OpenOLAT by OpenOLAT.

the class CourseTemplateSearchController method loadCourseModel.

private void loadCourseModel(CourseNode courseNode, UserCourseEnvironment uce, List<CourseTemplateRow> rows, Set<CurrentBinder> currentSet) {
    if (courseNode instanceof PortfolioCourseNode) {
        PortfolioCourseNode pNode = (PortfolioCourseNode) courseNode;
        NodeEvaluation ne = pNode.eval(uce.getConditionInterpreter(), new TreeEvaluation(), new VisibleTreeFilter());
        if (NavigationHandler.mayAccessWholeTreeUp(ne)) {
            RepositoryEntry refEntry = pNode.getReferencedRepositoryEntry();
            if ("BinderTemplate".equals(refEntry.getOlatResource().getResourceableTypeName())) {
                RepositoryEntry courseEntry = uce.getCourseEnvironment().getCourseGroupManager().getCourseEntry();
                CurrentBinder binderKey = new CurrentBinder(courseEntry.getKey(), pNode.getIdent());
                if (!currentSet.contains(binderKey)) {
                    rows.add(new CourseTemplateRow(courseEntry, pNode, refEntry));
                }
            }
        }
    }
    for (int i = courseNode.getChildCount(); i-- > 0; ) {
        loadCourseModel((CourseNode) courseNode.getChildAt(i), uce, rows, currentSet);
    }
}
Also used : CourseTemplateRow(org.olat.modules.portfolio.ui.model.CourseTemplateRow) PortfolioCourseNode(org.olat.course.nodes.PortfolioCourseNode) VisibleTreeFilter(org.olat.course.run.userview.VisibleTreeFilter) TreeEvaluation(org.olat.course.run.userview.TreeEvaluation) RepositoryEntry(org.olat.repository.RepositoryEntry) NodeEvaluation(org.olat.course.run.userview.NodeEvaluation)

Example 5 with NodeEvaluation

use of org.olat.course.run.userview.NodeEvaluation in project OpenOLAT by OpenOLAT.

the class BCCourseNode method getSecurisedNodeFolderContainer.

public static OlatNamedContainerImpl getSecurisedNodeFolderContainer(BCCourseNode node, CourseEnvironment courseEnv, IdentityEnvironment ienv) {
    boolean isOlatAdmin = ienv.getRoles().isOLATAdmin();
    boolean isGuestOnly = ienv.getRoles().isGuestOnly();
    UserCourseEnvironmentImpl uce = new UserCourseEnvironmentImpl(ienv, courseEnv);
    NodeEvaluation ne = node.eval(uce.getConditionInterpreter(), new TreeEvaluation(), new VisibleTreeFilter());
    OlatNamedContainerImpl container = getNodeFolderContainer(node, courseEnv);
    VFSSecurityCallback secCallback = new FolderNodeCallback(container.getRelPath(), ne, isOlatAdmin, isGuestOnly, null);
    container.setLocalSecurityCallback(secCallback);
    return container;
}
Also used : OlatNamedContainerImpl(org.olat.core.commons.modules.bc.vfs.OlatNamedContainerImpl) FolderNodeCallback(org.olat.course.nodes.bc.FolderNodeCallback) UserCourseEnvironmentImpl(org.olat.course.run.userview.UserCourseEnvironmentImpl) VisibleTreeFilter(org.olat.course.run.userview.VisibleTreeFilter) TreeEvaluation(org.olat.course.run.userview.TreeEvaluation) VFSSecurityCallback(org.olat.core.util.vfs.callbacks.VFSSecurityCallback) NodeEvaluation(org.olat.course.run.userview.NodeEvaluation)

Aggregations

NodeEvaluation (org.olat.course.run.userview.NodeEvaluation)24 TreeEvaluation (org.olat.course.run.userview.TreeEvaluation)16 CourseNode (org.olat.course.nodes.CourseNode)14 TreeNode (org.olat.core.gui.components.tree.TreeNode)12 UserCourseEnvironmentImpl (org.olat.course.run.userview.UserCourseEnvironmentImpl)12 VisibleTreeFilter (org.olat.course.run.userview.VisibleTreeFilter)12 RepositoryEntry (org.olat.repository.RepositoryEntry)10 GenericTreeModel (org.olat.core.gui.components.tree.GenericTreeModel)8 UserCourseEnvironment (org.olat.course.run.userview.UserCourseEnvironment)8 GenericTreeNode (org.olat.core.gui.components.tree.GenericTreeNode)6 Controller (org.olat.core.gui.control.Controller)6 ControllerEventListener (org.olat.core.gui.control.ControllerEventListener)6 WindowControl (org.olat.core.gui.control.WindowControl)6 ContextEntry (org.olat.core.id.context.ContextEntry)6 AssertException (org.olat.core.logging.AssertException)6 AbstractAccessableCourseNode (org.olat.course.nodes.AbstractAccessableCourseNode)6 STCourseNode (org.olat.course.nodes.STCourseNode)6 TitledWrapperController (org.olat.core.gui.control.generic.title.TitledWrapperController)4 IdentityEnvironment (org.olat.core.id.IdentityEnvironment)4 OLATResourceable (org.olat.core.id.OLATResourceable)4