@Override protected void initForm(FormItemContainer formLayout, Controller listener, UserRequest ureq) { if (formLayout instanceof FormLayoutContainer) { FormLayoutContainer layout = (FormLayoutContainer) formLayout; layout.contextPut("numOfMembers", Integer.toString(numOfMembers)); FormLayoutContainer layoutCont = FormLayoutContainer.createDefaultFormLayout("confirm", getTranslator()); formLayout.add("confirm", layoutCont); layoutCont.setRootForm(mainForm); StringBuilder message = new StringBuilder(); for (RepositoryEntry row : rows) { if (message.length() > 0) message.append(", "); message.append(StringHelper.escapeHtml(row.getDisplayname())); } String[] acknowledge = new String[] {translate("details.read.only.acknowledge.msg")}; acknowledgeEl = uifactory.addCheckboxesHorizontal( "confirm", "details.read.only.acknowledge", layoutCont, new String[] {""}, acknowledge); FormLayoutContainer buttonsCont = FormLayoutContainer.createButtonLayout("buttons", getTranslator()); layoutCont.add(buttonsCont); uifactory.addFormCancelButton("cancel", buttonsCont, ureq, getWindowControl()); readOnlyButton = uifactory.addFormLink("details.closed", buttonsCont, Link.BUTTON); } }
public MembersManagementMainController( UserRequest ureq, WindowControl wControl, RepositoryEntry re) { super(ureq, wControl); this.repoEntry = re; acModule = CoreSpringFactory.getImpl(AccessControlModule.class); acService = CoreSpringFactory.getImpl(ACService.class); // logging getUserActivityLogger().setStickyActionType(ActionType.admin); ICourse course = CourseFactory.loadCourse(re.getOlatResource()); addLoggingResourceable(LoggingResourceable.wrap(course)); // ui stuff menuTree = new MenuTree("menuTree"); menuTree.setTreeModel(buildTreeModel()); menuTree.setRootVisible(false); menuTree.addListener(this); mainVC = createVelocityContainer("main_members"); columnLayoutCtr = new LayoutMain3ColsController( ureq, getWindowControl(), menuTree, null, mainVC, "members-" + repoEntry.getKey()); listenTo(columnLayoutCtr); putInitialPanel(columnLayoutCtr.getInitialComponent()); selectMenuItem(ureq, CMD_MEMBERS); }
@Override protected void initRuntimeTools(Dropdown toolsDropdown) { if (reSecurity.isEntryAdmin()) { membersLink = LinkFactory.createToolLink( "members", translate("details.members"), this, "o_sel_repo_members"); membersLink.setIconLeftCSS("o_icon o_icon-fw o_icon_membersmanagement"); toolsDropdown.addComponent(membersLink); } if (reSecurity.isEntryAdmin() || reSecurity.isCourseCoach() || reSecurity.isGroupCoach()) { assessmentLink = LinkFactory.createToolLink( "assessment", translate("command.openassessment"), this, "o_icon_assessment_tool"); assessmentLink.setElementCssClass("o_sel_course_assessment_tool"); toolsDropdown.addComponent(assessmentLink); } if (reSecurity.isEntryAdmin()) { RepositoryEntry re = getRepositoryEntry(); ordersLink = LinkFactory.createToolLink( "bookings", translate("details.orders"), this, "o_sel_repo_booking"); ordersLink.setIconLeftCSS("o_icon o_icon-fw o_icon_booking"); boolean booking = acService.isResourceAccessControled(re.getOlatResource(), null); ordersLink.setEnabled(booking); toolsDropdown.addComponent(ordersLink); } }
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); } }
private void doLayout(UserRequest ureq) { RepositoryEntry entry = getRepositoryEntry(); ScormPackageConfig scormConfig = ScormMainManager.getInstance().getScormPackageConfig(entry.getOlatResource()); DeliveryOptions config = scormConfig == null ? null : scormConfig.getDeliveryOptions(); final OLATResource resource = entry.getOlatResource(); WindowControl bwControl = getSubWindowControl("Layout"); final DeliveryOptionsConfigurationController deliveryOptionsCtrl = new DeliveryOptionsConfigurationController( ureq, addToHistory(ureq, bwControl), config, "Knowledge Transfer#_scorm_layout"); deliveryOptionsCtrl.addControllerListener( new ControllerEventListener() { @Override public void dispatchEvent(UserRequest uureq, Controller source, Event event) { if (source == deliveryOptionsCtrl && (event == Event.DONE_EVENT || event == Event.CHANGED_EVENT)) { DeliveryOptions newConfig = deliveryOptionsCtrl.getDeliveryOptions(); ScormPackageConfig sConfig = ScormMainManager.getInstance().getScormPackageConfig(resource); if (sConfig == null) { sConfig = new ScormPackageConfig(); } sConfig.setDeliveryOptions(newConfig); ScormMainManager.getInstance().setScormPackageConfig(resource, sConfig); } } }); pushController(ureq, translate("tab.layout"), deliveryOptionsCtrl); setActiveTool(deliveryOptionsLink); }
public Bookmark(Mark mark, RepositoryEntry entry) { this.mark = mark; title = entry.getDisplayname(); description = entry.getDescription(); statusCode = entry.getStatusCode(); creationDate = entry.getCreationDate(); displayrestype = entry.getOlatResource().getResourceableTypeName(); }
@Override public RepositoryEntryLifecycle getLifecycle() { if (lifecycle == null) { RepositoryEntry re = getCourseRepositoryEntry(); if (re != null) { lifecycle = re.getLifecycle(); } } return lifecycle; }
private Controller selectMenuItem(UserRequest ureq, String cmd) { OLATResourceable ores = OresHelper.createOLATResourceableInstance(cmd, 0l); ThreadLocalUserActivityLogger.addLoggingResourceInfo( LoggingResourceable.wrapBusinessPath(ores)); WindowControl bwControl = BusinessControlFactory.getInstance() .createBusinessWindowControl(ores, null, getWindowControl()); addToHistory(ureq, bwControl); Controller selectedCtrl = null; if (CMD_MEMBERS.equals(cmd)) { if (membersOverviewCtrl == null) { membersOverviewCtrl = new MembersOverviewController(ureq, bwControl, repoEntry); listenTo(membersOverviewCtrl); } mainVC.put("content", membersOverviewCtrl.getInitialComponent()); selectedCtrl = membersOverviewCtrl; } else if (CMD_GROUPS.equals(cmd)) { if (groupsCtrl == null) { groupsCtrl = new CourseBusinessGroupListController(ureq, bwControl, repoEntry); listenTo(groupsCtrl); } groupsCtrl.reloadModel(); mainVC.put("content", groupsCtrl.getInitialComponent()); selectedCtrl = groupsCtrl; } else if (CMD_BOOKING.equals(cmd)) { if (ordersController == null) { ordersController = new OrdersAdminController(ureq, bwControl, repoEntry.getOlatResource()); listenTo(ordersController); } mainVC.put("content", ordersController.getInitialComponent()); selectedCtrl = ordersController; } else if (CMD_RIGHTS.equals(cmd)) { if (rightsController == null) { rightsController = new GroupsAndRightsController(ureq, bwControl, repoEntry.getOlatResource()); listenTo(rightsController); } mainVC.put("content", rightsController.getInitialComponent()); selectedCtrl = rightsController; } TreeNode selTreeNode = TreeHelper.findNodeByUserObject(cmd, menuTree.getTreeModel().getRootNode()); if (selTreeNode != null && !selTreeNode.getIdent().equals(menuTree.getSelectedNodeId())) { menuTree.setSelectedNodeId(selTreeNode.getIdent()); } return selectedCtrl; }
@Test public void testRemoveCoach_withBusinessGroups() { RepositoryEntry re = JunitTestHelper.createAndPersistRepositoryEntry(); // create a group with members Identity owner = JunitTestHelper.createAndPersistIdentityAsRndUser("remp-proc-1"); Identity member = JunitTestHelper.createAndPersistIdentityAsRndUser("remp-proc-2"); Identity coach = JunitTestHelper.createAndPersistIdentityAsRndUser("mbr-proc-3"); repositoryEntryRelationDao.addRole(owner, re, GroupRoles.owner.name()); repositoryEntryRelationDao.addRole(member, re, GroupRoles.coach.name()); repositoryEntryRelationDao.addRole(coach, re, GroupRoles.coach.name()); BusinessGroup businessGroup = businessGroupDao.createAndPersist( coach, "mbr-proc-1", "mbr-proc-desc", -1, -1, false, false, false, false, false); businessGroupRelationDao.addRelationToResource(businessGroup, re); // create a publisher SubscriptionContext context = new SubscriptionContext(re.getOlatResource(), ""); PublisherData publisherData = new PublisherData("testGroupPublishers", "e.g. something", null); Publisher publisher = notificationManager.getOrCreatePublisher(context, publisherData); Assert.assertNotNull(publisher); dbInstance.commitAndCloseSession(); // subscribe notificationManager.subscribe(owner, context, publisherData); notificationManager.subscribe(member, context, publisherData); notificationManager.subscribe(coach, context, publisherData); dbInstance.commitAndCloseSession(); // remove member and coach as coach of the repo entry List<Identity> removeIdentities = new ArrayList<>(2); removeIdentities.add(member); removeIdentities.add(coach); repositoryManager.removeTutors(owner, removeIdentities, re); // wait for the remove of subscription waitForCondition( new CheckUnsubscription(member, context, dbInstance, notificationManager), 5000); sleep(1000); // check that subscription of id1 was deleted but not the ones of id2 and coach boolean subscribedMember = notificationManager.isSubscribed(member, context); Assert.assertFalse(subscribedMember); boolean subscribedCoach = notificationManager.isSubscribed(coach, context); Assert.assertTrue(subscribedCoach); boolean subscribedOwner = notificationManager.isSubscribed(owner, context); Assert.assertTrue(subscribedOwner); }
private boolean setReadOnlyEntries(UserRequest ureq, List<RepositoryEntry> entries) { boolean allOk = true; for (RepositoryEntry entry : entries) { RepositoryEntry reloadedEntry = repositoryService.loadByKey(entry.getKey()); if (reloadedEntry != null) { repositoryService.closeRepositoryEntry(reloadedEntry); ThreadLocalUserActivityLogger.log( LearningResourceLoggingAction.LEARNING_RESOURCE_DEACTIVATE, getClass(), LoggingResourceable.wrap(reloadedEntry, OlatResourceableType.genRepoEntry)); fireEvent( ureq, new EntryChangedEvent(reloadedEntry, getIdentity(), Change.closed, "closed")); } } return allOk; }
private GenericTreeModel buildTreeModel() { GenericTreeModel gtm = new GenericTreeModel(); GenericTreeNode root = new GenericTreeNode(); root.setTitle(translate("menu.members")); root.setAltText(translate("menu.members.alt")); gtm.setRootNode(root); GenericTreeNode node = new GenericTreeNode(translate("menu.members"), CMD_MEMBERS); node.setAltText(translate("menu.members.alt")); root.addChild(node); node = new GenericTreeNode(translate("menu.groups"), CMD_GROUPS); node.setAltText(translate("menu.groups.alt")); root.addChild(node); if (acModule.isEnabled()) { // check if the course is managed and/or has offers if (!RepositoryEntryManagedFlag.isManaged(repoEntry, RepositoryEntryManagedFlag.bookings) || acService.isResourceAccessControled(repoEntry.getOlatResource(), null)) { node = new GenericTreeNode(translate("menu.orders"), CMD_BOOKING); node.setAltText(translate("menu.orders.alt")); root.addChild(node); } } node = new GenericTreeNode(translate("menu.rights"), CMD_RIGHTS); node.setAltText(translate("menu.rights.alt")); root.addChild(node); return gtm; }
@Test public void isTemplateInUse() { Identity owner = JunitTestHelper.createAndPersistIdentityAsRndUser("port-u-9"); Identity id = JunitTestHelper.createAndPersistIdentityAsRndUser("port-u-10"); RepositoryEntry templateEntry = createTemplate(owner, "Template", "TE"); dbInstance.commitAndCloseSession(); // assign a template Binder templateBinder = portfolioService.getBinderByResource(templateEntry.getOlatResource()); Binder template = portfolioService.assignBinder(id, templateBinder, templateEntry, null, null); dbInstance.commit(); Assert.assertNotNull(template); boolean inUse = portfolioService.isTemplateInUse(templateBinder, templateEntry, null); Assert.assertTrue(inUse); }
@Test public void createRepositoryEntry() { Identity initialAuthor = JunitTestHelper.createAndPersistIdentityAsRndUser("auth-1"); String displayName = "ServiceTest"; String resourceName = "ServiceTest"; String description = "Test the brand new service"; RepositoryEntry re = repositoryService.create( initialAuthor, null, resourceName, displayName, description, null, 0); dbInstance.commit(); Assert.assertNotNull(re); Assert.assertNotNull(re.getCreationDate()); Assert.assertNotNull(re.getLastModified()); Assert.assertNotNull(re.getOlatResource()); }
@Test public void testRemoveParticipant() { RepositoryEntry re = JunitTestHelper.createAndPersistRepositoryEntry(); // create a group with members Identity owner = JunitTestHelper.createAndPersistIdentityAsRndUser("remp-proc-1"); Identity member = JunitTestHelper.createAndPersistIdentityAsRndUser("remp-proc-2"); Identity participant = JunitTestHelper.createAndPersistIdentityAsRndUser("mbr-proc-3"); repositoryEntryRelationDao.addRole(owner, re, GroupRoles.owner.name()); repositoryEntryRelationDao.addRole(member, re, GroupRoles.coach.name()); repositoryEntryRelationDao.addRole(member, re, GroupRoles.participant.name()); repositoryEntryRelationDao.addRole(participant, re, GroupRoles.participant.name()); // create a publisher SubscriptionContext context = new SubscriptionContext(re.getOlatResource(), ""); PublisherData publisherData = new PublisherData("testGroupPublishers", "e.g. something", null); Publisher publisher = notificationManager.getOrCreatePublisher(context, publisherData); Assert.assertNotNull(publisher); dbInstance.commitAndCloseSession(); // subscribe notificationManager.subscribe(owner, context, publisherData); notificationManager.subscribe(member, context, publisherData); notificationManager.subscribe(participant, context, publisherData); dbInstance.commitAndCloseSession(); // remove member and participant as participant of the repo entry List<Identity> removeIdentities = new ArrayList<>(2); removeIdentities.add(member); removeIdentities.add(participant); MailPackage mailing = new MailPackage(false); repositoryManager.removeParticipants(owner, removeIdentities, re, mailing, false); // wait for the remove of subscription waitForCondition( new CheckUnsubscription(participant, context, dbInstance, notificationManager), 5000); sleep(1000); // check that subscription of id1 was deleted but not the ones of id2 and coach boolean subscribedPart = notificationManager.isSubscribed(participant, context); Assert.assertFalse(subscribedPart); boolean subscribedMember = notificationManager.isSubscribed(member, context); Assert.assertTrue(subscribedMember); boolean subscribedOwner = notificationManager.isSubscribed(owner, context); Assert.assertTrue(subscribedOwner); }
@Test public void syncBinder() { Identity owner = JunitTestHelper.createAndPersistIdentityAsRndUser("port-u-10"); Identity id = JunitTestHelper.createAndPersistIdentityAsRndUser("port-u-11"); RepositoryEntry templateEntry = createTemplate(owner, "Template", "TE"); dbInstance.commitAndCloseSession(); // make 2 sections Binder templateBinder = portfolioService.getBinderByResource(templateEntry.getOlatResource()); // add 2 sections for (int i = 0; i < 2; i++) { portfolioService.appendNewSection("Section " + i, "Section " + i, null, null, templateBinder); dbInstance.commit(); } List<Section> templateSections = portfolioService.getSections(templateBinder); Assert.assertNotNull(templateSections); Assert.assertEquals(3, templateSections.size()); // user get a the binder from the template Binder binder = portfolioService.assignBinder(id, templateBinder, templateEntry, "ac-234", new Date()); dbInstance.commit(); Assert.assertNotNull(binder); boolean inUse = portfolioService.isTemplateInUse(templateBinder, templateEntry, "ac-234"); Assert.assertTrue(inUse); // update the template with 2 more sections for (int i = 2; i < 4; i++) { portfolioService.appendNewSection("Section " + i, "Section " + i, null, null, templateBinder); dbInstance.commit(); } SynchedBinder synchedBinder = portfolioService.loadAndSyncBinder(binder); Assert.assertNotNull(synchedBinder); dbInstance.commit(); Assert.assertTrue(synchedBinder.isChanged()); Assert.assertEquals(binder, synchedBinder.getBinder()); List<Section> synchedSections = portfolioService.getSections(synchedBinder.getBinder()); Assert.assertEquals(5, synchedSections.size()); }
/** Same workflow as the repository. This workflow is pretty critical. */ @Test public void isStructuredMapOwner() { final OLATResource resource = epStructureManager.createPortfolioMapTemplateResource(); // create a repository entry final RepositoryEntry addedEntry = repositoryManager.createRepositoryEntryInstance(ident1.getName()); addedEntry.setCanDownload(false); addedEntry.setCanLaunch(true); addedEntry.setDisplayname("test repo"); addedEntry.setResourcename("-"); addedEntry.setAccess(RepositoryEntry.ACC_OWNERS); // Set the resource on the repository entry and save the entry. final OLATResource ores = resourceManager.findOrPersistResourceable(resource); addedEntry.setOlatResource(ores); // create security group final SecurityGroup newGroup = securityManager.createAndPersistSecurityGroup(); securityManager.createAndPersistPolicy(newGroup, Constants.PERMISSION_ACCESS, newGroup); securityManager.createAndPersistPolicy( newGroup, Constants.PERMISSION_HASROLE, EPStructureManager.ORES_MAPOWNER); securityManager.addIdentityToSecurityGroup(ident1, newGroup); addedEntry.setOwnerGroup(newGroup); repositoryManager.saveRepositoryEntry(addedEntry); dbInstance.commitAndCloseSession(); // create the template owned by ident1 final PortfolioStructureMap template = epStructureManager.createAndPersistPortfolioMapTemplateFromEntry(ident1, addedEntry); final PortfolioStructure page1 = epFrontendManager.createAndPersistPortfolioPage(template, "Page title", "Page description"); assertNotNull(page1); dbInstance.commitAndCloseSession(); // assign the template to ident2 final PortfolioStructureMap map = epFrontendManager.assignStructuredMapToUser(ident2, template, null, null, null, null); assertNotNull(map); dbInstance.commitAndCloseSession(); // check if ident2 is owner of the map assertTrue(epFrontendManager.isMapOwner(ident2, map.getOlatResource())); // check if ident1 is not the owner of the map assertFalse(epFrontendManager.isMapOwner(ident1, map.getOlatResource())); // check if ident1 is owner of the template assertTrue(epFrontendManager.isMapOwner(ident1, template.getOlatResource())); }
private void addEnrollmentDate( RepositoryEntry entry, Identity id, GroupRoles role, int amount, int field) { RepositoryEntryToGroupRelation rel = entry.getGroups().iterator().next(); rel.getGroup(); Calendar cal = Calendar.getInstance(); cal.setTime(new Date()); cal.add(field, amount); GroupMembershipImpl membership = new GroupMembershipImpl(); membership.setCreationDate(cal.getTime()); membership.setLastModified(cal.getTime()); membership.setGroup(rel.getGroup()); membership.setIdentity(id); membership.setRole(role.name()); dbInstance.getCurrentEntityManager().persist(membership); dbInstance.commit(); }
private void appendCourseCalendars( UserRequest ureq, WindowControl wControl, List<KalendarRenderWrapper> calendars, Map<CalendarKey, CalendarUserConfiguration> configMap) { if (calendarModule.isEnableCourseElementCalendar() || calendarModule.isEnableCourseToolCalendar()) { // add course calendars List<Object[]> resources = getCourses(ureq.getIdentity()); Set<OLATResource> editoredResources = getEditorGrants(ureq.getIdentity()); Set<Long> duplicates = new HashSet<>(); for (Object[] resource : resources) { RepositoryEntry courseEntry = (RepositoryEntry) resource[0]; if (duplicates.contains(courseEntry.getKey())) { continue; } duplicates.add(courseEntry.getKey()); String role = (String) resource[1]; Long courseResourceableID = courseEntry.getOlatResource().getResourceableId(); try { ICourse course = CourseFactory.loadCourse(courseEntry); if (isCourseCalendarEnabled(course)) { // calendar course aren't enabled per default but course node of type calendar are // always possible // REVIEW if (!course.getCourseEnvironment().getCourseConfig().isCalendarEnabled()) // continue; // add course calendar KalendarRenderWrapper courseCalendarWrapper = calendarManager.getCourseCalendar(course); boolean isPrivileged = GroupRoles.owner.name().equals(role) || editoredResources.contains(courseEntry.getOlatResource()); if (isPrivileged) { courseCalendarWrapper.setAccess(KalendarRenderWrapper.ACCESS_READ_WRITE); } else { courseCalendarWrapper.setAccess(KalendarRenderWrapper.ACCESS_READ_ONLY); } if (role != null && (GroupRoles.owner.name().equals(role) || GroupRoles.coach.name().equals(role) || GroupRoles.participant.name().equals(role))) { courseCalendarWrapper.setPrivateEventsVisible(true); } CalendarUserConfiguration config = configMap.get(courseCalendarWrapper.getCalendarKey()); if (config != null) { courseCalendarWrapper.setConfiguration(config); } courseCalendarWrapper.setLinkProvider( new CourseLinkProviderController( course, Collections.singletonList(course), ureq, wControl)); calendars.add(courseCalendarWrapper); } } catch (CorruptedCourseException e) { OLATResource olatResource = courseEntry.getOlatResource(); log.error( "Corrupted course: " + olatResource.getResourceableTypeName() + " :: " + courseResourceableID, null); } } } }
@Test public void createAndLoadRepositoryEntry() { Identity initialAuthor = JunitTestHelper.createAndPersistIdentityAsRndUser("auth-1"); String displayName = "Service test 2"; String resourceName = "ServiceTest"; String description = "Test the brand new service"; RepositoryEntry re = repositoryService.create( initialAuthor, null, resourceName, displayName, description, null, 0); dbInstance.commitAndCloseSession(); Assert.assertNotNull(re); RepositoryEntry loadedEntry = repositoryService.loadByKey(re.getKey()); Assert.assertNotNull(loadedEntry); Assert.assertNotNull(re.getCreationDate()); Assert.assertNotNull(re.getLastModified()); Assert.assertNotNull(re.getOlatResource()); Assert.assertNotNull(loadedEntry.getGroups()); Assert.assertEquals(1, loadedEntry.getGroups().size()); // saved? Assert.assertEquals(displayName, re.getDisplayname()); Assert.assertEquals(resourceName, re.getResourcename()); Assert.assertEquals(description, re.getDescription()); // default value Assert.assertFalse(re.getCanCopy()); Assert.assertFalse(re.getCanDownload()); Assert.assertFalse(re.getCanReference()); Assert.assertEquals(0, re.getAccess()); }
@Test public void deleteCourseSoftly() { Identity coach = JunitTestHelper.createAndPersistIdentityAsRndUser("re-soft-"); Identity coachGroup = JunitTestHelper.createAndPersistIdentityAsRndUser("re-soft-"); Identity participant = JunitTestHelper.createAndPersistIdentityAsRndUser("re-soft-"); Identity initialAuthor = JunitTestHelper.createAndPersistIdentityAsRndUser("auth-del-1"); RepositoryEntry re = JunitTestHelper.deployDemoCourse(initialAuthor); dbInstance.commitAndCloseSession(); // add business group BusinessGroup group = businessGroupService.createBusinessGroup( coachGroup, "Relation 1", "tg", null, null, false, false, re); businessGroupService.addResourceTo(group, re); dbInstance.commit(); // catalog List<CatalogEntry> rootEntries = catalogManager.getRootCatalogEntries(); CatalogEntry catEntry = catalogManager.createCatalogEntry(); catEntry.setName("Soft"); catEntry.setRepositoryEntry(re); catEntry.setParent(rootEntries.get(0)); catEntry.setOwnerGroup(securityManager.createAndPersistSecurityGroup()); catalogManager.saveCatalogEntry(catEntry); dbInstance.commit(); // check the catalog List<CatalogEntry> catEntries = catalogManager.getCatalogCategoriesFor(re); Assert.assertNotNull(catEntries); Assert.assertEquals(1, catEntries.size()); // add owner, coach... repositoryEntryRelationDao.addRole(coach, re, GroupRoles.coach.name()); repositoryEntryRelationDao.addRole(participant, re, GroupRoles.participant.name()); dbInstance.commit(); // kill it softly like A. Keys repositoryService.deleteSoftly(re, initialAuthor, false); dbInstance.commit(); // check that the members are removed List<Identity> coachAndParticipants = repositoryEntryRelationDao.getMembers( re, RepositoryEntryRelationType.both, GroupRoles.coach.name(), GroupRoles.participant.name()); Assert.assertNotNull(coachAndParticipants); Assert.assertEquals(0, coachAndParticipants.size()); // check the relations between course and business groups SearchBusinessGroupParams params = new SearchBusinessGroupParams(); List<BusinessGroup> groups = businessGroupService.findBusinessGroups(params, re, 0, -1); Assert.assertNotNull(groups); Assert.assertEquals(0, groups.size()); // check the catalog List<CatalogEntry> removedCatEntries = catalogManager.getCatalogCategoriesFor(re); Assert.assertNotNull(removedCatEntries); Assert.assertEquals(0, removedCatEntries.size()); RepositoryEntry reloadEntry = repositoryService.loadByKey(re.getKey()); Assert.assertNotNull(reloadEntry); Assert.assertEquals(0, reloadEntry.getAccess()); Assert.assertNotNull(reloadEntry.getDeletionDate()); Assert.assertEquals(initialAuthor, reloadEntry.getDeletedBy()); }
@Test public void assignTask_relativeToInitialLaunchDate() { // create a course with 3 members Identity id1 = JunitTestHelper.createAndPersistIdentityAsRndUser("initial-launch-1"); Identity id2 = JunitTestHelper.createAndPersistIdentityAsRndUser("initial-launch-2"); Identity id3 = JunitTestHelper.createAndPersistIdentityAsRndUser("initial-launch-3"); ICourse course = CoursesWebService.createEmptyCourse(null, "initial-launch-dates", "course long name", null); RepositoryEntry re = course.getCourseEnvironment().getCourseGroupManager().getCourseEntry(); repositoryEntryRelationDao.addRole(id1, re, GroupRoles.participant.name()); repositoryEntryRelationDao.addRole(id2, re, GroupRoles.participant.name()); repositoryEntryRelationDao.addRole(id3, re, GroupRoles.participant.name()); dbInstance.commit(); // create user course infos Long courseResId = course.getCourseEnvironment().getCourseResourceableId(); userCourseInformationsManager.updateUserCourseInformations(re.getOlatResource(), id1); userCourseInformationsManager.updateUserCourseInformations(re.getOlatResource(), id2); userCourseInformationsManager.updateUserCourseInformations(re.getOlatResource(), id3); dbInstance.commit(); // fake the date updateInitialLaunchDate(courseResId, id1, -5, Calendar.DATE); updateInitialLaunchDate(courseResId, id2, -35, Calendar.DATE); updateInitialLaunchDate(courseResId, id3, -75, Calendar.DATE); dbInstance.commitAndCloseSession(); // create a fake node GTACourseNode node = new GTACourseNode(); node.getModuleConfiguration() .setStringValue(GTACourseNode.GTASK_TYPE, GTAType.individual.name()); node.getModuleConfiguration().setBooleanEntry(GTACourseNode.GTASK_RELATIVE_DATES, true); node.getModuleConfiguration().setIntValue(GTACourseNode.GTASK_ASSIGNMENT_DEADLINE_RELATIVE, 40); node.getModuleConfiguration() .setStringValue( GTACourseNode.GTASK_ASSIGNMENT_DEADLINE_RELATIVE_TO, GTARelativeToDates.courseLaunch.name()); // need the task list TaskList tasks = gtaManager.createIfNotExists(re, node); Assert.assertNotNull(tasks); dbInstance.commit(); { // check 3 days ReminderRuleImpl rule = getAssignedTaskRules(3, LaunchUnit.day); List<Identity> all = assignTaskRuleSPI.evaluateRule(re, node, rule); Assert.assertEquals(1, all.size()); Assert.assertTrue(all.contains(id3)); } { // check 5 days ReminderRuleImpl rule = getAssignedTaskRules(5, LaunchUnit.day); List<Identity> all = assignTaskRuleSPI.evaluateRule(re, node, rule); Assert.assertEquals(2, all.size()); Assert.assertTrue(all.contains(id2)); Assert.assertTrue(all.contains(id3)); } { // check 1 week ReminderRuleImpl rule = getAssignedTaskRules(1, LaunchUnit.week); List<Identity> all = assignTaskRuleSPI.evaluateRule(re, node, rule); Assert.assertEquals(2, all.size()); Assert.assertTrue(all.contains(id2)); Assert.assertTrue(all.contains(id3)); } { // check 1 month ReminderRuleImpl rule = getAssignedTaskRules(1, LaunchUnit.month); List<Identity> all = assignTaskRuleSPI.evaluateRule(re, node, rule); Assert.assertEquals(2, all.size()); Assert.assertTrue(all.contains(id2)); Assert.assertTrue(all.contains(id3)); } { // check 2 month ReminderRuleImpl rule = getAssignedTaskRules(2, LaunchUnit.month); List<Identity> all = assignTaskRuleSPI.evaluateRule(re, node, rule); Assert.assertEquals(3, all.size()); Assert.assertTrue(all.contains(id1)); Assert.assertTrue(all.contains(id2)); Assert.assertTrue(all.contains(id3)); } }
@Test public void syncBinder_moveInNewSection_moreComplexCase() { Identity owner = JunitTestHelper.createAndPersistIdentityAsRndUser("port-u-10"); Identity id = JunitTestHelper.createAndPersistIdentityAsRndUser("port-u-11"); RepositoryEntry templateEntry = createTemplate(owner, "Template", "TE"); dbInstance.commitAndCloseSession(); // make 2 sections Binder templateBinder = portfolioService.getBinderByResource(templateEntry.getOlatResource()); SectionRef sectionRef0 = portfolioService.getSections(templateBinder).get(0); // add 2 sections SectionRef sectionRef1 = portfolioService.appendNewSection("1 section ", "Section 1", null, null, templateBinder); SectionRef sectionRef2 = portfolioService.appendNewSection("2 section ", "Section 2", null, null, templateBinder); dbInstance.commit(); // make 4 assignments Section templateSection0 = portfolioService.getSection(sectionRef0); Section templateSection1 = portfolioService.getSection(sectionRef1); Section templateSection2 = portfolioService.getSection(sectionRef2); Assignment assignment0_1 = portfolioService.addAssignment( "0.1 Assignment", "", "", AssignmentType.essay, templateSection0, false, false, false, null); Assignment assignment1_1 = portfolioService.addAssignment( "1.1 Assignment", "", "", AssignmentType.essay, templateSection1, false, false, false, null); Assignment assignment1_2 = portfolioService.addAssignment( "1.2 Assignment", "", "", AssignmentType.essay, templateSection1, false, false, false, null); Assignment assignment2_1 = portfolioService.addAssignment( "2.1 Assignment", "", "", AssignmentType.essay, templateSection2, false, false, false, null); Assignment assignment2_2 = portfolioService.addAssignment( "2.2 Assignment", "", "", AssignmentType.essay, templateSection2, false, false, false, null); dbInstance.commit(); List<Assignment> templateAssignments = portfolioService.getAssignments(templateBinder, null); Assert.assertEquals(5, templateAssignments.size()); // a user take the binder and synched it a first time Binder binder = portfolioService.assignBinder(id, templateBinder, templateEntry, "74", null); dbInstance.commit(); SynchedBinder synchedBinder = portfolioService.loadAndSyncBinder(binder); dbInstance.commitAndCloseSession(); Assert.assertNotNull(synchedBinder); Assert.assertEquals(binder, synchedBinder.getBinder()); // start all assignments List<Assignment> assignments = portfolioService.getAssignments(binder, null); Assert.assertEquals(5, assignments.size()); for (Assignment assignment : assignments) { portfolioService.startAssignment(assignment, id); dbInstance.commit(); } dbInstance.commit(); // check that the student has it's 4 pages List<Page> pages = portfolioService.getPages(binder, null); Assert.assertEquals(5, pages.size()); // author create 2 new sections, move the 4 to the top SectionRef sectionRef3 = portfolioService.appendNewSection("3 section ", "Section 3", null, null, templateBinder); SectionRef sectionRef4 = portfolioService.appendNewSection("4 section ", "Section 4", null, null, templateBinder); dbInstance.commit(); Section templateSection3 = portfolioService.getSection(sectionRef3); Section templateSection4 = portfolioService.getSection(sectionRef4); templateBinder = portfolioService.moveUpSection(templateBinder, templateSection4); dbInstance.commit(); templateBinder = portfolioService.moveUpSection(templateBinder, templateSection4); dbInstance.commit(); templateBinder = portfolioService.moveUpSection(templateBinder, templateSection4); dbInstance.commit(); templateBinder = portfolioService.moveUpSection(templateBinder, templateSection4); dbInstance.commit(); // add new assignment Assignment assignment3_1 = portfolioService.addAssignment( "3.1 Assignment", "", "", AssignmentType.essay, templateSection3, false, false, false, null); Assignment assignment4_1 = portfolioService.addAssignment( "4.1 Assignment", "", "", AssignmentType.essay, templateSection4, false, false, false, null); dbInstance.commit(); // the author move some assignments portfolioService.moveAssignment(templateSection1, assignment1_1, templateSection3); dbInstance.commit(); portfolioService.moveAssignment(templateSection1, assignment1_2, templateSection2); dbInstance.commit(); portfolioService.moveAssignment(templateSection2, assignment2_1, templateSection3); dbInstance.commit(); portfolioService.moveAssignment(templateSection2, assignment2_2, templateSection4); dbInstance.commitAndCloseSession(); // update the data of some assignments assignment2_1 = assignmentDao.loadAssignmentByKey(assignment2_1.getKey()); assignment4_1 = assignmentDao.loadAssignmentByKey(assignment4_1.getKey()); assignment2_1 = portfolioService.updateAssignment( assignment2_1, "2.1 Assignment", "Assignment 2 description", "", AssignmentType.essay, false, false, false, null); assignment4_1 = portfolioService.updateAssignment( assignment4_1, "4.1 Assignment", "Assignment 4 description", "", AssignmentType.document, false, false, false, null); dbInstance.commit(); // check the move List<Assignment> templateAssignmentsSection0 = portfolioService.getAssignments(templateSection0, null); Assert.assertTrue(templateAssignmentsSection0.contains(assignment0_1)); List<Assignment> templateAssignmentsSection1 = portfolioService.getAssignments(templateSection1, null); Assert.assertTrue(templateAssignmentsSection1.isEmpty()); List<Assignment> templateAssignmentsSection2 = portfolioService.getAssignments(templateSection2, null); Assert.assertEquals(1, templateAssignmentsSection2.size()); Assert.assertTrue(templateAssignmentsSection2.contains(assignment1_2)); List<Assignment> templateAssignmentsSection3 = portfolioService.getAssignments(templateSection3, null); Assert.assertEquals(3, templateAssignmentsSection3.size()); Assert.assertTrue(templateAssignmentsSection3.contains(assignment1_1)); Assert.assertTrue(templateAssignmentsSection3.contains(assignment2_1)); Assert.assertTrue(templateAssignmentsSection3.contains(assignment3_1)); List<Assignment> templateAssignmentsSection4 = portfolioService.getAssignments(templateSection4, null); Assert.assertEquals(2, templateAssignmentsSection4.size()); Assert.assertTrue(templateAssignmentsSection4.contains(assignment2_2)); Assert.assertTrue(templateAssignmentsSection4.contains(assignment4_1)); // synched and check the sections order SynchedBinder synchedBinder2 = portfolioService.loadAndSyncBinder(binder); Binder freshBinder = synchedBinder2.getBinder(); dbInstance.commitAndCloseSession(); List<Section> sections = portfolioService.getSections(freshBinder); Assert.assertEquals(5, sections.size()); Section section4 = sections.get(0); Section section0 = sections.get(1); Section section1 = sections.get(2); Section section2 = sections.get(3); Section section3 = sections.get(4); Assert.assertEquals(templateSection0, section0.getTemplateReference()); Assert.assertEquals(templateSection1, section1.getTemplateReference()); Assert.assertEquals(templateSection2, section2.getTemplateReference()); Assert.assertEquals(templateSection3, section3.getTemplateReference()); Assert.assertEquals(templateSection4, section4.getTemplateReference()); // load pages from section 0 List<Page> pagesSection0 = portfolioService.getPages(section0); Assert.assertEquals(1, pagesSection0.size()); Page page0_1 = pagesSection0.get(0); Assert.assertTrue(page0_1.getTitle().equals("0.1 Assignment")); // load pages from section 1 List<Page> pagesSection1 = portfolioService.getPages(section1); Assert.assertTrue(pagesSection1.isEmpty()); // and pages from section 2 List<Page> pagesSection2 = portfolioService.getPages(section2); Assert.assertEquals(1, pagesSection2.size()); Page page1_2 = pagesSection2.get(0); Assert.assertTrue(page1_2.getTitle().equals("1.2 Assignment")); // and pages from section 3 List<Page> pagesSection3 = portfolioService.getPages(section3); Assert.assertEquals(2, pagesSection3.size()); Page page1_1 = pagesSection3.get(0); Page page2_1 = pagesSection3.get(1); Assert.assertTrue( page1_1.getTitle().equals("1.1 Assignment") || page1_1.getTitle().equals("2.1 Assignment")); Assert.assertTrue( page2_1.getTitle().equals("1.1 Assignment") || page2_1.getTitle().equals("2.1 Assignment")); // and pages from section 4 List<Page> pagesSection4 = portfolioService.getPages(section4); Assert.assertEquals(1, pagesSection4.size()); Page page2_2 = pagesSection4.get(0); Assert.assertTrue(page2_2.getTitle().equals("2.2 Assignment")); // check the assignments // section 0 List<Assignment> assignmentsSection0 = section0.getAssignments(); Assert.assertEquals(1, assignmentsSection0.size()); Assignment templateSynchedSection0a = assignmentsSection0.get(0).getTemplateReference(); Assert.assertTrue(assignment0_1.equals(templateSynchedSection0a)); // section 1 List<Assignment> assignmentsSection1 = section1.getAssignments(); Assert.assertTrue(assignmentsSection1.isEmpty()); // section 2 List<Assignment> assignmentsSection2 = section2.getAssignments(); Assert.assertEquals(1, assignmentsSection2.size()); Assignment templateSynchedSection2a = assignmentsSection2.get(0).getTemplateReference(); Assert.assertTrue(assignment1_2.equals(templateSynchedSection2a)); // section 3 List<Assignment> assignmentsSection3 = section3.getAssignments(); Assert.assertEquals(3, assignmentsSection3.size()); Assignment templateSynchedSection3a = assignmentsSection3.get(0).getTemplateReference(); Assignment templateSynchedSection3b = assignmentsSection3.get(1).getTemplateReference(); Assignment templateSynchedSection3c = assignmentsSection3.get(2).getTemplateReference(); Assert.assertTrue( assignment3_1.equals(templateSynchedSection3a) || assignment3_1.equals(templateSynchedSection3b) || assignment3_1.equals(templateSynchedSection3c)); Assert.assertTrue( assignment2_1.equals(templateSynchedSection3a) || assignment2_1.equals(templateSynchedSection3b) || assignment2_1.equals(templateSynchedSection3c)); Assert.assertTrue( assignment1_1.equals(templateSynchedSection3a) || assignment1_1.equals(templateSynchedSection3b) || assignment1_1.equals(templateSynchedSection3c)); // section 4 List<Assignment> assignmentsSection4 = section4.getAssignments(); Assert.assertEquals(2, assignmentsSection4.size()); Assignment templateSynchedSection4a = assignmentsSection4.get(0).getTemplateReference(); Assignment templateSynchedSection4b = assignmentsSection4.get(1).getTemplateReference(); Assert.assertTrue( assignment2_2.equals(templateSynchedSection4a) || assignment2_2.equals(templateSynchedSection4b)); Assert.assertTrue( assignment4_1.equals(templateSynchedSection4a) || assignment4_1.equals(templateSynchedSection4b)); // check update of assignments Assert.assertEquals("Assignment 2 description", assignment2_1.getSummary()); Assert.assertEquals("Assignment 4 description", assignment4_1.getSummary()); }
@Test public void removeAssignment() { Identity owner = JunitTestHelper.createAndPersistIdentityAsRndUser("port-u-10"); RepositoryEntry templateEntry = createTemplate(owner, "Template", "TE"); dbInstance.commitAndCloseSession(); // make the binder and the section Binder templateBinder = portfolioService.getBinderByResource(templateEntry.getOlatResource()); SectionRef sectionRef = portfolioService.getSections(templateBinder).get(0); dbInstance.commit(); // make 4 assignments Section templateSection = portfolioService.getSection(sectionRef); Assignment assignment_1 = portfolioService.addAssignment( "1 Assignment", "", "", AssignmentType.essay, templateSection, false, false, false, null); Assignment assignment_2 = portfolioService.addAssignment( "2 Assignment", "", "", AssignmentType.essay, templateSection, false, false, false, null); Assignment assignment_3 = portfolioService.addAssignment( "3 Assignment", "", "", AssignmentType.essay, templateSection, false, false, false, null); Assignment assignment_4 = portfolioService.addAssignment( "3 Assignment", "", "", AssignmentType.essay, templateSection, false, false, false, null); dbInstance.commitAndCloseSession(); boolean ok = portfolioService.deleteAssignment(assignment_3); Assert.assertTrue(ok); dbInstance.commitAndCloseSession(); List<Assignment> assignments = portfolioService.getSection(sectionRef).getAssignments(); Assert.assertNotNull(assignments); Assert.assertEquals(3, assignments.size()); Assert.assertTrue(assignments.contains(assignment_1)); Assert.assertTrue(assignments.contains(assignment_2)); Assert.assertFalse(assignments.contains(assignment_3)); Assert.assertTrue(assignments.contains(assignment_4)); }
@Test public void syncBinder_moveInNewSection() { Identity owner = JunitTestHelper.createAndPersistIdentityAsRndUser("port-u-10"); Identity id = JunitTestHelper.createAndPersistIdentityAsRndUser("port-u-11"); RepositoryEntry templateEntry = createTemplate(owner, "Template", "TE"); dbInstance.commitAndCloseSession(); // make 2 sections Binder templateBinder = portfolioService.getBinderByResource(templateEntry.getOlatResource()); SectionRef sectionRef0 = portfolioService.getSections(templateBinder).get(0); // add 2 sections SectionRef sectionRef1 = portfolioService.appendNewSection("1 section ", "Section 1", null, null, templateBinder); SectionRef sectionRef2 = portfolioService.appendNewSection("2 section ", "Section 2", null, null, templateBinder); dbInstance.commit(); // make 4 assignments Section templateSection0 = portfolioService.getSection(sectionRef0); Section templateSection1 = portfolioService.getSection(sectionRef1); Section templateSection2 = portfolioService.getSection(sectionRef2); Assignment assignment1_1 = portfolioService.addAssignment( "1.1 Assignment", "", "", AssignmentType.essay, templateSection1, false, false, false, null); Assignment assignment1_2 = portfolioService.addAssignment( "1.2 Assignment", "", "", AssignmentType.essay, templateSection1, false, false, false, null); Assignment assignment2_1 = portfolioService.addAssignment( "2.1 Assignment", "", "", AssignmentType.essay, templateSection2, false, false, false, null); Assignment assignment2_2 = portfolioService.addAssignment( "2.2 Assignment", "", "", AssignmentType.essay, templateSection2, false, false, false, null); dbInstance.commit(); List<Assignment> templateAssignments = portfolioService.getAssignments(templateBinder, null); Assert.assertEquals(4, templateAssignments.size()); // a user take the binder and synched it a first time Binder binder = portfolioService.assignBinder(id, templateBinder, templateEntry, "72", null); dbInstance.commit(); SynchedBinder synchedBinder = portfolioService.loadAndSyncBinder(binder); dbInstance.commitAndCloseSession(); Assert.assertNotNull(synchedBinder); Assert.assertEquals(binder, synchedBinder.getBinder()); // start all assignments List<Assignment> assignments = portfolioService.getAssignments(binder, null); Assert.assertEquals(4, assignments.size()); for (Assignment assignment : assignments) { portfolioService.startAssignment(assignment, id); dbInstance.commit(); } dbInstance.commit(); // check that the student has it's 4 pages List<Page> pages = portfolioService.getPages(binder, null); Assert.assertEquals(4, pages.size()); // author create a new section and move an assignment SectionRef sectionRef3 = portfolioService.appendNewSection("3 section ", "Section 3", null, null, templateBinder); dbInstance.commit(); Section templateSection3 = portfolioService.getSection(sectionRef3); Assignment assignment3_1 = portfolioService.addAssignment( "3.1 Assignment", "", "", AssignmentType.essay, templateSection3, false, false, false, null); dbInstance.commit(); // the author move an assigment portfolioService.moveAssignment(templateSection1, assignment1_1, templateSection2); dbInstance.commit(); portfolioService.moveAssignment(templateSection2, assignment2_1, templateSection3); dbInstance.commitAndCloseSession(); // check the move List<Assignment> templateAssignmentsSection1 = portfolioService.getAssignments(templateSection1, null); Assert.assertTrue(templateAssignmentsSection1.contains(assignment1_2)); List<Assignment> templateAssignmentsSection2 = portfolioService.getAssignments(templateSection2, null); Assert.assertTrue(templateAssignmentsSection2.contains(assignment2_2)); Assert.assertTrue(templateAssignmentsSection2.contains(assignment1_1)); List<Assignment> templateAssignmentsSection3 = portfolioService.getAssignments(templateSection3, null); Assert.assertTrue(templateAssignmentsSection3.contains(assignment2_1)); Assert.assertTrue(templateAssignmentsSection3.contains(assignment3_1)); // synched and check the sections order SynchedBinder synchedBinder2 = portfolioService.loadAndSyncBinder(binder); Binder freshBinder = synchedBinder2.getBinder(); List<Section> sections = portfolioService.getSections(freshBinder); Assert.assertEquals(4, sections.size()); Section section0 = sections.get(0); Section section1 = sections.get(1); Section section2 = sections.get(2); Section section3 = sections.get(3); Assert.assertEquals(templateSection0, section0.getTemplateReference()); Assert.assertEquals(templateSection1, section1.getTemplateReference()); Assert.assertEquals(templateSection2, section2.getTemplateReference()); Assert.assertEquals(templateSection3, section3.getTemplateReference()); // load pages from section 1 List<Page> pagesSection1 = portfolioService.getPages(section1); Assert.assertEquals(1, pagesSection1.size()); Page page1_2 = pagesSection1.get(0); Assert.assertTrue(page1_2.getTitle().equals("1.2 Assignment")); // and pages from section 2 List<Page> pagesSection2 = portfolioService.getPages(section2); Assert.assertEquals(2, pagesSection2.size()); Page page2_2 = pagesSection2.get(0); Page page1_1 = pagesSection2.get(1); Assert.assertTrue( page2_2.getTitle().equals("1.1 Assignment") || page2_2.getTitle().equals("2.2 Assignment")); Assert.assertTrue( page1_1.getTitle().equals("1.1 Assignment") || page1_1.getTitle().equals("2.2 Assignment")); // and pages from section 3 List<Page> pagesSection3 = portfolioService.getPages(section3); Assert.assertEquals(1, pagesSection3.size()); Page page2_1 = pagesSection3.get(0); Assert.assertTrue(page2_1.getTitle().equals("2.1 Assignment")); List<Assignment> assignmentsSection3 = section3.getAssignments(); Assert.assertEquals(2, assignmentsSection3.size()); Assignment templateSynchedSection3a = assignmentsSection3.get(0).getTemplateReference(); Assignment templateSynchedSection3b = assignmentsSection3.get(1).getTemplateReference(); Assert.assertTrue( assignment3_1.equals(templateSynchedSection3a) || assignment3_1.equals(templateSynchedSection3b)); Assert.assertTrue( assignment2_1.equals(templateSynchedSection3a) || assignment2_1.equals(templateSynchedSection3b)); }
/** * @see org.olat.core.gui.control.DefaultController#event(org.olat.core.gui.UserRequest, * org.olat.core.gui.control.Controller, org.olat.core.gui.control.Event) */ @Override public void event(final UserRequest ureq, final Controller source, final Event event) { final String cmd = event.getCommand(); if (source == searchCtr) { if (cmd.equals(RepositoryTableModel.TABLE_ACTION_SELECT_ENTRY)) { // user selected entry to get a preview selectedRepositoryEntry = searchCtr.getSelectedEntry(); final RepositoryEntry repositoryEntry = searchCtr.getSelectedEntry(); final RepositoryHandler typeToLaunch = RepositoryHandlerFactory.getInstance().getRepositoryHandler(repositoryEntry); if (typeToLaunch == null) { final StringBuilder sb = new StringBuilder(translate("error.launch")); sb.append(": No launcher for repository entry: "); sb.append(repositoryEntry.getKey()); throw new OLATRuntimeException(RepositoryDetailsController.class, sb.toString(), null); } // do skip the increment launch counter, this is only a preview! final OLATResourceable ores = repositoryEntry.getOlatResource(); removeAsListenerAndDispose(previewCtr); previewCtr = typeToLaunch.createLaunchController(ores, null, ureq, getWindowControl()); listenTo(previewCtr); removeAsListenerAndDispose(previewModalCtr); previewModalCtr = new CloseableModalController( getWindowControl(), translate("referencableSearch.preview.close"), previewCtr.getInitialComponent()); listenTo(previewModalCtr); previewModalCtr.activate(); } else if (cmd.equals(RepositoryTableModel.TABLE_ACTION_SELECT_LINK)) { // done, user selected a repo entry selectedRepositoryEntry = searchCtr.getSelectedEntry(); fireEvent(ureq, EVENT_REPOSITORY_ENTRY_SELECTED); } initLinks(); } else if (source == addController) { if (event.equals(Event.DONE_EVENT)) { cmc.deactivate(); selectedRepositoryEntry = addController.getAddedEntry(); fireEvent(ureq, EVENT_REPOSITORY_ENTRY_SELECTED); // info message final String message = translate( "message.entry.selected", new String[] { addController.getAddedEntry().getDisplayname(), addController.getAddedEntry().getResourcename() }); getWindowControl().setInfo(message); } else if (event.equals(Event.CANCELLED_EVENT)) { cmc.deactivate(); } else if (event.equals(Event.FAILED_EVENT)) { showError("add.failed"); } } }
@Override public List<CalendarFileInfos> getListOfCalendarsFiles(Identity identity) { List<CalendarFileInfos> aggregatedFiles = new ArrayList<>(); Map<CalendarKey, CalendarUserConfiguration> configMap = calendarManager.getCalendarUserConfigurationsMap(identity); // personal calendar CalendarKey personalCalendarKey = new CalendarKey(identity.getName(), CalendarManager.TYPE_USER); CalendarUserConfiguration personalCalendarConfig = configMap.get(personalCalendarKey); if (calendarModule.isEnablePersonalCalendar() && (personalCalendarConfig == null || personalCalendarConfig.isInAggregatedFeed())) { File iCalFile = calendarManager.getCalendarICalFile(CalendarManager.TYPE_USER, identity.getName()); if (iCalFile != null) { aggregatedFiles.add( new CalendarFileInfos(identity.getName(), CalendarManager.TYPE_USER, iCalFile)); } // reload every hour List<CalendarFileInfos> importedCalendars = importCalendarManager.getImportedCalendarInfosForIdentity(identity, true); aggregatedFiles.addAll(importedCalendars); } // group calendars if (calendarModule.isEnableGroupCalendar()) { SearchBusinessGroupParams groupParams = new SearchBusinessGroupParams(identity, true, true); groupParams.addTools(CollaborationTools.TOOL_CALENDAR); List<BusinessGroup> groups = businessGroupService.findBusinessGroups(groupParams, null, 0, -1); for (BusinessGroup group : groups) { String calendarId = group.getKey().toString(); CalendarKey key = new CalendarKey(calendarId, CalendarManager.TYPE_GROUP); CalendarUserConfiguration calendarConfig = configMap.get(key); if (calendarConfig == null || calendarConfig.isInAggregatedFeed()) { File iCalFile = calendarManager.getCalendarICalFile(CalendarManager.TYPE_GROUP, calendarId); if (iCalFile != null) { aggregatedFiles.add( new CalendarFileInfos(calendarId, CalendarManager.TYPE_GROUP, iCalFile)); } } } } if (calendarModule.isEnableCourseElementCalendar() || calendarModule.isEnableCourseToolCalendar()) { List<Object[]> resources = getCourses(identity); for (Object[] resource : resources) { RepositoryEntry courseEntry = (RepositoryEntry) resource[0]; String calendarId = courseEntry.getOlatResource().getResourceableId().toString(); CalendarKey key = new CalendarKey(calendarId, CalendarManager.TYPE_COURSE); CalendarUserConfiguration calendarConfig = configMap.get(key); if (calendarConfig == null || calendarConfig.isInAggregatedFeed()) { File iCalFile = calendarManager.getCalendarICalFile(CalendarManager.TYPE_COURSE, calendarId); if (iCalFile != null) { aggregatedFiles.add( new CalendarFileInfos(calendarId, CalendarManager.TYPE_COURSE, iCalFile)); } } } } return aggregatedFiles; }
@Test public void deleteSynchedBinder() { Identity owner = JunitTestHelper.createAndPersistIdentityAsRndUser("port-u-12"); Identity id = JunitTestHelper.createAndPersistIdentityAsRndUser("port-u-13"); RepositoryEntry templateEntry = createTemplate(owner, "Template", "TE"); dbInstance.commitAndCloseSession(); // get section Binder templateBinder = portfolioService.getBinderByResource(templateEntry.getOlatResource()); SectionRef sectionRef = portfolioService.getSections(templateBinder).get(0); dbInstance.commit(); // make 2 assignments Section templateSection = portfolioService.getSection(sectionRef); Assignment assignment_1 = portfolioService.addAssignment( "1 Assignment", "", "", AssignmentType.essay, templateSection, false, false, false, null); Assignment assignment_2 = portfolioService.addAssignment( "2 Assignment", "", "", AssignmentType.essay, templateSection, false, false, false, null); dbInstance.commit(); List<Assignment> templateAssignments = portfolioService.getAssignments(templateBinder, null); Assert.assertEquals(2, templateAssignments.size()); // synched and check the sections order Binder binder = portfolioService.assignBinder(id, templateBinder, templateEntry, null, null); SynchedBinder synchedBinder = portfolioService.loadAndSyncBinder(binder); binder = synchedBinder.getBinder(); dbInstance.commitAndCloseSession(); List<Assignment> assignments = portfolioService.getAssignments(binder, null); Assignment startedAssignment_1 = portfolioService.startAssignment(assignments.get(0), id); Assignment startedAssignment_2 = portfolioService.startAssignment(assignments.get(1), id); Long startedPageKey_1 = startedAssignment_1.getPage().getKey(); Long startedPageKey_2 = startedAssignment_2.getPage().getKey(); dbInstance.commitAndCloseSession(); // add some comments OLATResourceable startedPageOres_1 = OresHelper.createOLATResourceableInstance(Page.class, startedPageKey_1); userCommentsDao.createComment(id, startedPageOres_1, null, "Hello"); // delete boolean deleted = portfolioService.deleteBinder(binder); dbInstance.commit(); Assert.assertTrue(deleted); // check that the template is save Assignment reloadAssignment_1 = assignmentDao.loadAssignmentByKey(assignment_1.getKey()); Assert.assertNotNull(reloadAssignment_1); Assignment reloadAssignment_2 = assignmentDao.loadAssignmentByKey(assignment_2.getKey()); Assert.assertNotNull(reloadAssignment_2); // check that the binder is really deleted Binder reloadedBinder = binderDao.loadByKey(binder.getKey()); Assert.assertNull(reloadedBinder); Assignment reloadStartedAssignment_1 = assignmentDao.loadAssignmentByKey(startedAssignment_1.getKey()); Assert.assertNull(reloadStartedAssignment_1); Assignment reloadStartedAssignment_2 = assignmentDao.loadAssignmentByKey(startedAssignment_2.getKey()); Assert.assertNull(reloadStartedAssignment_2); Page reloadedStartedPage_1 = pageDao.loadByKey(startedPageKey_1); Assert.assertNull(reloadedStartedPage_1); Page reloadedStartedPage_2 = pageDao.loadByKey(startedPageKey_2); Assert.assertNull(reloadedStartedPage_2); }
@Test public void submitTask_relativeLifecycle() { // prepare a course with a volatile task Identity participant1 = JunitTestHelper.createAndPersistIdentityAsRndUser("gta-user-1"); Identity participant2 = JunitTestHelper.createAndPersistIdentityAsRndUser("gta-user-2"); RepositoryEntry re = JunitTestHelper.createAndPersistRepositoryEntry("", false); repositoryEntryRelationDao.addRole(participant1, re, GroupRoles.participant.name()); repositoryEntryRelationDao.addRole(participant2, re, GroupRoles.participant.name()); dbInstance.commit(); String label = "Life cycle for relative date"; String softKey = UUID.randomUUID().toString(); Calendar cal = Calendar.getInstance(); cal.setTime(new Date()); cal.add(Calendar.DATE, -5); Date from = cal.getTime(); cal.add(Calendar.DATE, 20); Date to = cal.getTime(); RepositoryEntryLifecycle lifecycle = reLifeCycleDao.create(label, softKey, true, from, to); re.setLifecycle(lifecycle); re = dbInstance.getCurrentEntityManager().merge(re); dbInstance.commit(); // create a fake node with a relative submit deadline 15 days after the start of the course GTACourseNode node = new GTACourseNode(); node.getModuleConfiguration() .setStringValue(GTACourseNode.GTASK_TYPE, GTAType.individual.name()); node.getModuleConfiguration().setBooleanEntry(GTACourseNode.GTASK_RELATIVE_DATES, true); node.getModuleConfiguration().setIntValue(GTACourseNode.GTASK_SUBMIT_DEADLINE_RELATIVE, 15); node.getModuleConfiguration() .setStringValue( GTACourseNode.GTASK_SUBMIT_DEADLINE_RELATIVE_TO, GTARelativeToDates.courseStart.name()); TaskList tasks = gtaManager.createIfNotExists(re, node); Assert.assertNotNull(tasks); dbInstance.commitAndCloseSession(); // the course has start 5 days before, deadline is 15 days after it // conclusion the deadline is 10 days from now { // check before 5 days ReminderRuleImpl rule = getSubmitTaskRules(5, LaunchUnit.day); List<Identity> all = submissionTaskRuleSPI.evaluateRule(re, node, rule); Assert.assertEquals(0, all.size()); } { // check before 1 week ReminderRuleImpl rule = getSubmitTaskRules(1, LaunchUnit.week); List<Identity> all = submissionTaskRuleSPI.evaluateRule(re, node, rule); Assert.assertEquals(0, all.size()); } { // check before 10 days ReminderRuleImpl rule = getSubmitTaskRules(10, LaunchUnit.day); List<Identity> all = submissionTaskRuleSPI.evaluateRule(re, node, rule); Assert.assertEquals(2, all.size()); Assert.assertTrue(all.contains(participant1)); Assert.assertTrue(all.contains(participant2)); } { // check before 2 days ReminderRuleImpl rule = getSubmitTaskRules(10, LaunchUnit.week); List<Identity> all = submissionTaskRuleSPI.evaluateRule(re, node, rule); Assert.assertEquals(2, all.size()); Assert.assertTrue(all.contains(participant1)); Assert.assertTrue(all.contains(participant2)); } { // check before 30 days ReminderRuleImpl rule = getSubmitTaskRules(30, LaunchUnit.day); List<Identity> all = submissionTaskRuleSPI.evaluateRule(re, node, rule); Assert.assertEquals(2, all.size()); Assert.assertTrue(all.contains(participant1)); Assert.assertTrue(all.contains(participant2)); } { // check before 1 months ReminderRuleImpl rule = getSubmitTaskRules(1, LaunchUnit.month); List<Identity> all = submissionTaskRuleSPI.evaluateRule(re, node, rule); Assert.assertEquals(2, all.size()); Assert.assertTrue(all.contains(participant1)); Assert.assertTrue(all.contains(participant2)); } { // check before 5 months ReminderRuleImpl rule = getSubmitTaskRules(5, LaunchUnit.month); List<Identity> all = submissionTaskRuleSPI.evaluateRule(re, node, rule); Assert.assertEquals(2, all.size()); Assert.assertTrue(all.contains(participant1)); Assert.assertTrue(all.contains(participant2)); } { // check before 1 year ReminderRuleImpl rule = getSubmitTaskRules(1, LaunchUnit.year); List<Identity> all = submissionTaskRuleSPI.evaluateRule(re, node, rule); Assert.assertEquals(2, all.size()); Assert.assertTrue(all.contains(participant1)); Assert.assertTrue(all.contains(participant2)); } }
@Test public void removeAssignment_usedOne() { Identity owner = JunitTestHelper.createAndPersistIdentityAsRndUser("port-u-10"); Identity id = JunitTestHelper.createAndPersistIdentityAsRndUser("port-u-11"); RepositoryEntry templateEntry = createTemplate(owner, "Template", "TE"); dbInstance.commitAndCloseSession(); // make 2 sections Binder templateBinder = portfolioService.getBinderByResource(templateEntry.getOlatResource()); SectionRef sectionRef = portfolioService.getSections(templateBinder).get(0); dbInstance.commit(); // make 4 assignments Section templateSection = portfolioService.getSection(sectionRef); Assignment assignment_1 = portfolioService.addAssignment( "1 Assignment", "", "", AssignmentType.essay, templateSection, false, false, false, null); Assignment assignment_2 = portfolioService.addAssignment( "2 Assignment", "", "", AssignmentType.essay, templateSection, false, false, false, null); Assignment assignment_3 = portfolioService.addAssignment( "3 Assignment", "", "", AssignmentType.essay, templateSection, false, false, false, null); Assignment assignment_4 = portfolioService.addAssignment( "4 Assignment", "", "", AssignmentType.essay, templateSection, false, false, false, null); dbInstance.commit(); List<Assignment> templateAssignments = portfolioService.getAssignments(templateBinder, null); Assert.assertEquals(4, templateAssignments.size()); Assert.assertTrue(templateAssignments.contains(assignment_1)); Assert.assertTrue(templateAssignments.contains(assignment_2)); Assert.assertTrue(templateAssignments.contains(assignment_3)); Assert.assertTrue(templateAssignments.contains(assignment_4)); // synched and check the sections order Binder binder = portfolioService.assignBinder(id, templateBinder, templateEntry, null, null); SynchedBinder synchedBinder = portfolioService.loadAndSyncBinder(binder); binder = synchedBinder.getBinder(); dbInstance.commitAndCloseSession(); List<Assignment> assignments = portfolioService.getAssignments(binder, null); portfolioService.startAssignment(assignments.get(0), id); portfolioService.startAssignment(assignments.get(1), id); portfolioService.startAssignment(assignments.get(2), id); portfolioService.startAssignment(assignments.get(3), id); dbInstance.commit(); List<Section> sections = portfolioService.getSections(binder); List<Page> pages = portfolioService.getPages(sections.get(0)); Assert.assertEquals(4, pages.size()); // delete an assignment boolean ok = portfolioService.deleteAssignment(assignment_3); Assert.assertTrue(ok); dbInstance.commitAndCloseSession(); // sync the binder SynchedBinder reSynchedBinder = portfolioService.loadAndSyncBinder(binder); binder = reSynchedBinder.getBinder(); dbInstance.commitAndCloseSession(); // deleting an assignment doesn't delete the pages List<Page> allPages = portfolioService.getPages(sections.get(0)); Assert.assertEquals(4, allPages.size()); // sync twice SynchedBinder reReSynchedBinder = portfolioService.loadAndSyncBinder(binder); binder = reReSynchedBinder.getBinder(); dbInstance.commitAndCloseSession(); }
/** * @see org.olat.core.gui.control.DefaultController#event(org.olat.core.gui.UserRequest, * org.olat.core.gui.components.Component, org.olat.core.gui.control.Event) */ @Override public void event(UserRequest ureq, Component source, Event event) { if (source == onCommand) { // toggle on Preferences prefs = ureq.getUserSession().getGuiPreferences(); prefs.put(CourseGlossaryToolLinkController.class, guiPrefsKey, Boolean.TRUE); prefs.save(); // update gui mainVC.remove(onCommand); offCommand = LinkFactory.createLink("command.glossary.off", mainVC, this); offCommand.setTitle("command.glossary.off.alt"); offCommand.setCustomEnabledLinkCSS("b_toolbox_toggle"); // notify textmarker controller glossMarkupItmCtr.setTextMarkingEnabled(true); fireEvent(ureq, new Event("glossaryOn")); } else if (source == offCommand) { // toggle off Preferences prefs = ureq.getUserSession().getGuiPreferences(); prefs.put(CourseGlossaryToolLinkController.class, guiPrefsKey, Boolean.FALSE); prefs.save(); // update gui mainVC.remove(offCommand); onCommand = LinkFactory.createLink("command.glossary.on", mainVC, this); onCommand.setTitle("command.glossary.on.alt"); onCommand.setCustomEnabledLinkCSS("b_toolbox_toggle"); // notify textmarker controller glossMarkupItmCtr.setTextMarkingEnabled(false); fireEvent(ureq, new Event("glossaryOff")); } else if (source == mainVC && event.getCommand().equals("command.glossary")) { // start glossary in window final CourseConfig cc = courseEnvir.getCourseConfig(); // do not cache cc, not save // 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 = new ControllerCreator() { public Controller createController(UserRequest lureq, WindowControl 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, null, null, glossaryController.getInitialComponent(), null); // dispose glossary on layout dispose layoutCtr.addDisposableChildController(glossaryController); return layoutCtr; } } }; ControllerCreator layoutCtrlr = BaseFullWebappPopupLayoutFactory.createAuthMinimalPopupLayout(ureq, ctrlCreator); // open in new browser window openInNewBrowserWindow(ureq, layoutCtrlr); return; // immediate return after opening new browser window! } } }