@Override protected void formOK(UserRequest ureq) { commitFields(); commitStepLabels(); String selectedType = typeEl.getSelectedKey(); SliderType type = SliderType.valueOf(selectedType); rubric.setSliderType(type); if (type == SliderType.continuous) { rubric.setStart(1); rubric.setEnd(100); rubric.setSteps(100); } else { int steps = Integer.parseInt(stepsEl.getSelectedKey()); rubric.setStart(1); rubric.setEnd(steps); rubric.setSteps(steps); } for (Iterator<Slider> sliderIt = rubric.getSliders().iterator(); sliderIt.hasNext(); ) { Slider slider = sliderIt.next(); if (!StringHelper.containsNonWhitespace(slider.getStartLabel()) && !StringHelper.containsNonWhitespace(slider.getEndLabel())) { sliderIt.remove(); } } rubricCtrl.updateForm(); fireEvent(ureq, new ChangePartEvent(rubric)); fireEvent(ureq, new ClosePartEvent(rubric)); }
@Override public void render( final StringOutput sb, final Renderer renderer, final Object val, final Locale locale, final int alignment, final String action) { if (renderer == null) { // render for export String value = getCellValue(val); if (!StringHelper.containsNonWhitespace(value)) { value = getHoverText(val); } sb.append(value); } else { sb.append("<i class='").append(getCssClass(val)).append("'> </i> <span"); String hoverText = getHoverText(val); if (StringHelper.containsNonWhitespace(hoverText)) { sb.append(" title=\""); sb.append(StringEscapeUtils.escapeHtml(hoverText)); } sb.append("\">"); sb.append(getCellValue(val)); sb.append("</span>"); } }
@Override public boolean isIpAllowed(String ipList, String address) { boolean allOk = false; if (!StringHelper.containsNonWhitespace(ipList)) { allOk |= true; } else { for (StringTokenizer tokenizer = new StringTokenizer(ipList, "\n\r", false); tokenizer.hasMoreTokens(); ) { String ipRange = tokenizer.nextToken(); if (StringHelper.containsNonWhitespace(ipRange)) { int indexMask = ipRange.indexOf("/"); int indexPseudoRange = ipRange.indexOf("-"); if (indexMask > 0) { allOk |= IPUtils.isValidRange(ipRange, address); } else if (indexPseudoRange > 0) { String begin = ipRange.substring(0, indexPseudoRange).trim(); String end = ipRange.substring(indexPseudoRange + 1).trim(); allOk |= IPUtils.isValidRange(begin, end, address); } else { allOk |= ipRange.equals(address); } } } } return allOk; }
@Override public boolean isInterceptionRequired(UserRequest ureq) { UserSession usess = ureq.getUserSession(); boolean interception = false; if (isREST(ureq)) { // do nothing } else if (!historyModule.isResumeEnabled()) { String bc = getLandingBC(ureq); launch(ureq, bc); } else if (usess.getRoles().isGuestOnly()) { String bc = getLandingBC(ureq); launch(ureq, bc); } else { Preferences prefs = usess.getGuiPreferences(); String resumePrefs = (String) prefs.get(WindowManager.class, "resume-prefs"); if (!StringHelper.containsNonWhitespace(resumePrefs)) { resumePrefs = historyModule.getResumeDefaultSetting(); } if ("none".equals(resumePrefs)) { String bc = getLandingBC(ureq); launch(ureq, bc); } else if ("auto".equals(resumePrefs)) { HistoryPoint historyEntry = HistoryManager.getInstance().readHistoryPoint(ureq.getIdentity()); if (historyEntry != null && StringHelper.containsNonWhitespace(historyEntry.getBusinessPath())) { List<ContextEntry> cloneCes = BusinessControlFactory.getInstance().cloneContextEntries(historyEntry.getEntries()); BusinessControl bc = BusinessControlFactory.getInstance().createFromContextEntries(cloneCes); launch(ureq, bc); } else { String bc = getLandingBC(ureq); launch(ureq, bc); } } else if ("ondemand".equals(resumePrefs)) { HistoryPoint historyEntry = historyManager.readHistoryPoint(ureq.getIdentity()); if (historyEntry != null && StringHelper.containsNonWhitespace(historyEntry.getBusinessPath())) { interception = true; String bc = getLandingBC(ureq); if (StringHelper.containsNonWhitespace(bc)) { noButton.setVisible(false); } else { landingButton.setVisible(false); } } else { String bc = getLandingBC(ureq); launch(ureq, bc); } } } return interception; }
/** * Resolves a file path in the base container or creates this file under the given path. The * method creates any missing directories. * * @param baseContainer The base directory. User must have write permissions on this container * @param relFilePath The path relative to the base container. Must start with a '/'. To separate * sub directories use '/' * @return The resolved or created leaf or NULL if a problem happened */ public static VFSLeaf resolveOrCreateLeafFromPath( VFSContainer baseContainer, String relFilePath) { if (StringHelper.containsNonWhitespace(relFilePath)) { int lastSlash = relFilePath.lastIndexOf("/"); String relDirPath = relFilePath; String fileName = null; if (lastSlash == -1) { // relFilePath is the file name - no directories involved relDirPath = null; fileName = relFilePath; } else if (lastSlash == 0) { // Remove start slash from file name relDirPath = null; fileName = relFilePath.substring(1, relFilePath.length()); } else { relDirPath = relFilePath.substring(0, lastSlash); fileName = relFilePath.substring(lastSlash); } // Create missing directories and set parent dir for later file creation VFSContainer parent = baseContainer; if (StringHelper.containsNonWhitespace(relDirPath)) { parent = resolveOrCreateContainerFromPath(baseContainer, relDirPath); } // Now create file in that dir if (StringHelper.containsNonWhitespace(fileName)) { VFSLeaf leaf = null; VFSItem resolvedFile = parent.resolve(fileName); if (resolvedFile == null) { leaf = parent.createChildLeaf(fileName); if (leaf == null) { log.error( "Could not create leaf with relPath::" + relFilePath + " in base container::" + getRealPath(baseContainer), null); } } else { if (resolvedFile instanceof VFSLeaf) { leaf = (VFSLeaf) resolvedFile; } else { leaf = null; log.error( "Could not create relPath::" + relFilePath + ", a directory with this name exists (but not a file) in base container::" + getRealPath(baseContainer), null); } } return leaf; } } return null; }
/** * Search first in the user preferences, after in rules * * @param ureq * @return */ private String getLandingBC(UserRequest ureq) { Preferences prefs = ureq.getUserSession().getGuiPreferences(); String landingPage = (String) prefs.get(WindowManager.class, "landing-page"); if (StringHelper.containsNonWhitespace(landingPage)) { String path = Rules.cleanUpLandingPath(landingPage); if (StringHelper.containsNonWhitespace(path)) { return BusinessControlFactory.getInstance().formatFromURI(path); } } return lpModule.getRules().match(ureq.getUserSession()); }
@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); } }
/** * Returns a CSV line for the given LoggingObject - containing all properties in the exact same * way as in the config file - excluding those which could not be retrieved, i.e. for which no * PropertyDescriptor could be created * * @param loggingObject the LoggingObject for which a CSV line should be created * @return the CSV line representing the given LoggingObject */ public String getCSVRow(LoggingObject loggingObject, boolean anonymize, Long resourceableId) { List<String> loggingObjectList = new ArrayList<String>(); for (Iterator<PropertyDescriptor> it = orderedExportedPropertyDescriptors.iterator(); it.hasNext(); ) { PropertyDescriptor pd = it.next(); String strValue = ""; try { Object value = pd.getReadMethod().invoke(loggingObject, (Object[]) null); if (value != null) { strValue = String.valueOf(value); } if (anonymize && anonymizedProperties.contains(pd.getName())) { // do anonymization strValue = makeAnonymous(String.valueOf(value), resourceableId); } } catch (IllegalArgumentException e) { // nothing to do } catch (IllegalAccessException e) { // nothing to do } catch (InvocationTargetException e) { // nothing to do } loggingObjectList.add(strValue); } return StringHelper.formatAsCSVString(loggingObjectList); }
/** * Helper to create the proposed directory name for the page base on the course node short title. * The title is normalized, converted to ASCII and all strange characters are removed. Users * should recognize the proposed directory name in most cases. As a fallback, the course node ID * is used in case everything is stripped. If a proposed name already exists, the directory will * get a number appended. <br> * The file name will always be "index.html" <br> * The end result will look something like this: <br> * * <pre>/single_page3/index.html</pre> * * @param courseNode * @param courseFolderBaseContainer * @return The proposed relative file path */ public static String createUniqueRelFilePathFromShortTitle( CourseNode courseNode, VFSContainer courseFolderBaseContainer) { // Normalize course node title to something URL and filesystem safe // containing only ASCII characters String safePath = FileUtils.normalizeFilename(courseNode.getShortTitle().toLowerCase()) .trim() .replaceAll("[^\\p{ASCII}]", "") // delete non-ASCII .replaceAll("[\\p{Punct}]+", "_") // replace punctuation characters .replaceAll("\\s+", "_") // replace whitespace .replaceAll("_+", "_") // multiple replacement strings .replaceAll("^_", "") // delete replacement string at beginning .replaceAll("_$", "") // delete replacement string at end .toLowerCase(Locale.ENGLISH); // If string is empty, use node ID instead if (!StringHelper.containsNonWhitespace(safePath)) { safePath = courseNode.getIdent(); } // Check if directory already exists, if yes, append number at end of // directory VFSItem direxists = courseFolderBaseContainer.resolve(safePath); int i = 1; while (direxists != null && i < 100) { i++; safePath = FileUtils.appendNumberAtTheEndOfFilename(safePath, i); direxists = courseFolderBaseContainer.resolve(safePath); } return "/" + safePath + "/" + safePath + ".html"; }
@Override public void evalFormRequest(UserRequest ureq) { String uri = ureq.getModuleURI(); if (uri == null) { QTIWorksAssessmentTestEvent event = null; String cmd = ureq.getParameter("cid"); if (StringHelper.containsNonWhitespace(cmd)) { switch (QTIWorksAssessmentTestEvent.Event.valueOf(cmd)) { case selectItem: { String selectedItem = ureq.getParameter("item"); event = new QTIWorksAssessmentTestEvent(selectItem, selectedItem, this); getRootForm().fireFormEvent(ureq, event); component.setDirty(true); testComponent.setDirty(true); break; } case mark: { String selectedItem = ureq.getParameter("item"); event = new QTIWorksAssessmentTestEvent(mark, selectedItem, this); getRootForm().fireFormEvent(ureq, event); break; } default: break; } } } }
@Override public boolean isSafelyAllowed(HttpServletRequest request, String safeExamBrowserKeys) { boolean safe = false; boolean debug = log.isDebug(); if (StringHelper.containsNonWhitespace(safeExamBrowserKeys)) { String safeExamHash = request.getHeader("x-safeexambrowser-requesthash"); String url = request.getRequestURL().toString(); for (StringTokenizer tokenizer = new StringTokenizer(safeExamBrowserKeys); tokenizer.hasMoreTokens() && !safe; ) { String safeExamBrowserKey = tokenizer.nextToken(); String hash = Encoder.sha256Exam(url + safeExamBrowserKey); if (safeExamHash != null && safeExamHash.equals(hash)) { safe = true; } if (debug) { log.debug( (safeExamHash.equals(hash) ? "Success" : "Failed") + " : " + safeExamHash + " (Header) " + hash + " (Calculated)"); } } } else { safe = true; } return safe; }
@Override protected boolean validateFormLogic(UserRequest ureq) { String searchValue = search.getValue(); if (isUsedInStepWizzard()) { return true; } if ((lastSearchValue == null && StringHelper.containsNonWhitespace(searchValue)) || (lastSearchValue != null && !lastSearchValue.equals(searchValue))) { // User pressed enter in input field to search for groups, no group // selected yet. Just search for groups that matches for this input doSearchGroups(searchValue, ureq); lastSearchValue = searchValue; return false; } errorComp.clearError(); boolean result = false; List<Long> ownerGroups = getCheckedTutorKeys(); List<Long> partGroups = getCheckedParticipantKeys(); result = (ownerGroups.size() > 0 || partGroups.size() > 0); if (!result) { errorComp.setErrorKey("error.choose.one", null); } return result; }
public void setElementCSSClass(String cssClass) { if (StringHelper.containsNonWhitespace(cssClass)) { wrapper.contextPut("cssClass", cssClass); } else { wrapper.contextRemove("cssClass"); } }
private void commitFields() { for (SliderRow row : sliders) { String start = row.getStartLabelEl().getValue(); String end = row.getEndLabelEl().getValue(); if (StringHelper.containsNonWhitespace(start)) { row.getSlider().setStartLabel(start); } else { row.getSlider().setStartLabel(null); } if (StringHelper.containsNonWhitespace(end)) { row.getSlider().setEndLabel(end); } else { row.getSlider().setEndLabel(null); } } }
/** @return */ public Integer getGroupMin() { String result = businessGroupMinimumMembers.getValue(); if (StringHelper.containsNonWhitespace(result)) { result = result.replaceAll(" ", ""); return Integer.parseInt(result); } else { return null; } }
/** * Returns the CSV Header line containing all property names in the exact same way as in the * config file - excluding those properties which could not be retrieved, i.e. for which no * PropertyDescriptor could be created * * @return the CSV Header line containing all property names in the exact same way as in the * config file - excluding those properties which could not be retrieved, i.e. for which no * PropertyDescriptor could be created */ public String getCSVHeader() { List<String> propertyNames = new ArrayList<String>(); for (Iterator<PropertyDescriptor> it = orderedExportedPropertyDescriptors.iterator(); it.hasNext(); ) { PropertyDescriptor pd = it.next(); propertyNames.add(pd.getName()); } return StringHelper.formatAsCSVString(propertyNames); }
/** * @param ureq * @return */ private StringBuilder createChangelogMsg(UserRequest ureq) { /* * TODO:pb:is ImsRepositoryResolver the right place for getting the change log? */ // re could be null, but if we are here it should not be null! Roles userRoles = ureq.getUserSession().getRoles(); boolean showAll = userRoles.isAuthor() || userRoles.isOLATAdmin(); // get changelog Formatter formatter = Formatter.getInstance(ureq.getLocale()); ImsRepositoryResolver resolver = new ImsRepositoryResolver(referenceTestEntry); QTIChangeLogMessage[] qtiChangeLog = resolver.getDocumentChangeLog(); StringBuilder qtiChangelog = new StringBuilder(); if (qtiChangeLog.length > 0) { // there are resource changes Arrays.sort(qtiChangeLog); for (int i = qtiChangeLog.length - 1; i >= 0; i--) { // show latest change first if (!showAll && qtiChangeLog[i].isPublic()) { // logged in person is a normal user, hence public messages only Date msgDate = new Date(qtiChangeLog[i].getTimestmp()); qtiChangelog .append("\nChange date: ") .append(formatter.formatDateAndTime(msgDate)) .append("\n"); String msg = StringHelper.escapeHtml(qtiChangeLog[i].getLogMessage()); qtiChangelog.append(msg); qtiChangelog.append("\n********************************\n"); } else if (showAll) { // logged in person is an author, olat admin, owner, show all messages Date msgDate = new Date(qtiChangeLog[i].getTimestmp()); qtiChangelog .append("\nChange date: ") .append(formatter.formatDateAndTime(msgDate)) .append("\n"); String msg = StringHelper.escapeHtml(qtiChangeLog[i].getLogMessage()); qtiChangelog.append(msg); qtiChangelog.append("\n********************************\n"); } // else non public messages are not shown to normal user } } return qtiChangelog; }
private void launch(UserRequest ureq, String businessPath) { if (StringHelper.containsNonWhitespace(businessPath)) { try { // make the resume secure. If something fail, don't generate a red screen NewControllerFactory.getInstance().launch(businessPath, ureq, getWindowControl()); } catch (Exception e) { logError("Error while resuming", e); } } }
@Override public boolean isThumbnailPossible(VFSLeaf file) { String extension = FileUtils.getFileSuffix(file.getName()); if (StringHelper.containsNonWhitespace(extension)) { for (ThumbnailSPI thumbnailSPI : thumbnailSPIes) { if (thumbnailSPI.getExtensions().contains(extension)) { return true; } } } return false; }
public String getCharacterDataFromElement(Node parentNode) { StringBuilder sb = new StringBuilder(); for (Node node = parentNode.getFirstChild(); node != null; node = node.getNextSibling()) { if (node.getNodeType() == Node.TEXT_NODE) { String text = node.getNodeValue(); if (StringHelper.containsNonWhitespace(text)) { sb.append(text); } } } return sb.toString(); }
private void cleanup() { if (StringHelper.containsNonWhitespace(datas.getDataBackupFile())) { OlatRootFileImpl backupFile = new OlatRootFileImpl(datas.getDataBackupFile(), null); if (backupFile.exists()) { File dir = backupFile.getBasefile().getParentFile(); if (dir != null && dir.exists()) { FileUtils.deleteDirsAndFiles(dir, true, true); } } } cleanupUnzip(); }
public static boolean isPaged(HttpServletRequest httpRequest, Request request) { String accept = httpRequest.getHeader("Accept"); if (StringHelper.containsNonWhitespace(accept)) { MediaType requestMediaType = MediaType.valueOf(accept); if (APPLICATION_JSON_PAGED.equals(requestMediaType) || APPLICATION_XML_PAGED.equals(requestMediaType)) { return true; } } Variant variant = request.selectVariant(variants); return (variant != null && (variant.equals(APPLICATION_JSON_PAGED) || variant.equals(APPLICATION_XML_PAGED))); }
private void updateGUI(ModelInfos modelInfos) { if (modelInfos.isSame()) { applyToAllEl.select(onKeys[0], true); table.setVisible(false); if (groupPassedEl != null) { groupPassedEl.setVisible(true); Boolean passed = modelInfos.getPassed(); groupPassedEl.select(onKeys[0], passed != null && passed.booleanValue()); } if (groupScoreEl != null) { groupScoreEl.setVisible(true); Float score = modelInfos.getScore(); if (score != null) { String scoreVal = AssessmentHelper.getRoundedScore(score); groupScoreEl.setValue(scoreVal); } else { groupScoreEl.setValue(""); } } if (groupCommentEl != null) { groupCommentEl.setVisible(true); String comment = modelInfos.getComment(); if (comment != null) { groupCommentEl.setValue(comment); } } } else { applyToAllEl.select(onKeys[0], false); table.setVisible(true); if (groupPassedEl != null) { groupPassedEl.setVisible(false); } if (groupScoreEl != null) { groupScoreEl.setVisible(false); } if (groupCommentEl != null) { groupCommentEl.setVisible(false); } } if (StringHelper.containsNonWhitespace(modelInfos.getDuplicates())) { String warning = translate( "error.duplicate.memberships", new String[] {gtaNode.getShortTitle(), modelInfos.getDuplicates()}); flc.contextPut("duplicateWarning", warning); } else { flc.contextRemove("duplicateWarning"); } }
private void exposeUserTestDataToVC(UserRequest ureq) { // config : show score info Object enableScoreInfoObject = modConfig.get(IQEditController.CONFIG_KEY_ENABLESCOREINFO); if (enableScoreInfoObject != null) { myContent.contextPut("enableScoreInfo", enableScoreInfoObject); } else { myContent.contextPut("enableScoreInfo", Boolean.TRUE); } // configuration data myContent.contextPut("attemptsConfig", modConfig.get(IQEditController.CONFIG_KEY_ATTEMPTS)); // user data Identity identity = userCourseEnv.getIdentityEnvironment().getIdentity(); if (courseNode instanceof PersistentAssessableCourseNode) { PersistentAssessableCourseNode acn = (PersistentAssessableCourseNode) courseNode; AssessmentEntry assessmentEntry = acn.getUserAssessmentEntry(userCourseEnv); if (assessmentEntry == null) { myContent.contextPut("blockAfterSuccess", Boolean.FALSE); myContent.contextPut("score", null); myContent.contextPut("hasPassedValue", Boolean.FALSE); myContent.contextPut("passed", Boolean.FALSE); myContent.contextPut("comment", null); myContent.contextPut("attempts", 0); } else { // block if test passed (and config set to check it) Boolean blockAfterSuccess = modConfig.getBooleanEntry(IQEditController.CONFIG_KEY_BLOCK_AFTER_SUCCESS); Boolean blocked = Boolean.FALSE; if (blockAfterSuccess != null && blockAfterSuccess.booleanValue()) { Boolean passed = assessmentEntry.getPassed(); if (passed != null && passed.booleanValue()) { blocked = Boolean.TRUE; } } myContent.contextPut("blockAfterSuccess", blocked); myContent.contextPut("score", AssessmentHelper.getRoundedScore(assessmentEntry.getScore())); myContent.contextPut( "hasPassedValue", (assessmentEntry.getPassed() == null ? Boolean.FALSE : Boolean.TRUE)); myContent.contextPut("passed", assessmentEntry.getPassed()); StringBuilder comment = Formatter.stripTabsAndReturns(assessmentEntry.getComment()); myContent.contextPut("comment", StringHelper.xssScan(comment)); myContent.contextPut("attempts", assessmentEntry.getAttempts()); } } UserNodeAuditManager am = userCourseEnv.getCourseEnvironment().getAuditManager(); myContent.contextPut("log", am.getUserNodeLog(courseNode, identity)); exposeResults(ureq); }
private void render(StringOutput sb, MemberView member) { List<BusinessGroupShort> groups = member.getGroups(); if (groups != null && !groups.isEmpty()) { boolean and = false; for (BusinessGroupShort group : groups) { and = and(sb, and); if (group.getName() == null) { sb.append(group.getKey()); } else { sb.append(StringHelper.escapeHtml(group.getName())); } } } }
private String getResponseSummary(Response response) { String responseSummary; if (response.getContent() == null) { responseSummary = null; } else { responseSummary = response.getContent().renderAsText(); if (responseSummary.length() > 128) { responseSummary = new NekoHTMLFilter().filter(responseSummary); if (responseSummary.length() > 128) { responseSummary = responseSummary.substring(0, 125) + "..."; } } } return StringHelper.containsNonWhitespace(responseSummary) ? responseSummary : null; }
public String getInfos() { if (infos == null && link.getOffer() != null) { OfferImpl casted = (OfferImpl) link.getOffer(); if (StringHelper.containsNonWhitespace(casted.getToken())) { return casted.getToken(); } if (!link.getOffer().getPrice().isEmpty()) { String price = PriceFormat.fullFormat(link.getOffer().getPrice()); if (acModule.isVatEnabled()) { BigDecimal vat = acModule.getVat(); String vatStr = vat == null ? "" : vat.setScale(3, BigDecimal.ROUND_HALF_EVEN).toPlainString(); return translate("access.info.price.vat", new String[] {price, vatStr}); } else { return translate("access.info.price.noVat", new String[] {price}); } } } if (StringHelper.containsNonWhitespace(infos)) { return infos; } return ""; }
/** * [used by Spring] * * @param cronExpression */ public void setCronExpression(String cronExpression) { if (CronExpression.isValidExpression(cronExpression)) { this.cronExpression = cronExpression; } else { if (StringHelper.containsNonWhitespace(cronExpression)) { // was not empty, so someone tried to set someting here, let user know that it was garbage log.warn( "Configured cron expression is not valid::" + cronExpression + " check your search.indexing.cronjob.expression property", null); } this.cronExpression = null; } }
@Override protected void formInnerEvent(UserRequest ureq, FormItem source, FormEvent event) { if (selectLink == source) { Set<Integer> selections = getItemsTable().getMultiSelectedIndex(); if (!selections.isEmpty()) { List<QuestionItemView> items = getItemViews(selections); fireEvent(ureq, new QItemViewEvent("select-item", items)); } } else if (myListEl == source) { String selectedCollKey = myListEl.getSelectedKey(); if (StringHelper.isLong(selectedCollKey)) { Long collectionKey = Long.parseLong(selectedCollKey); doSelectCollection(ureq, collectionKey); } } super.formInnerEvent(ureq, source, event); }
/** * Retrieves the groups where the enrollment happens * * @response.representation.200.qname {http://www.example.com}groupVO * @response.representation.200.mediaType application/xml, application/json * @response.representation.200.doc The groups * @response.representation.200.example {@link * org.olat.restapi.support.vo.Examples#SAMPLE_GROUPVO} * @response.representation.401.doc The roles of the authenticated user are not sufficient * @response.representation.404.doc The course or course node not found * @param nodeId The node's id * @param httpRequest The HTTP request * @return An array of groups */ @GET @Path("{nodeId}/groups") @Produces({MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON}) public Response getGroups( @PathParam("courseId") Long courseId, @PathParam("nodeId") String nodeId, @Context HttpServletRequest httpRequest) { if (!isAuthor(httpRequest)) { return Response.serverError().status(Status.UNAUTHORIZED).build(); } ICourse course = CoursesWebService.loadCourse(courseId); if (course == null) { return Response.serverError().status(Status.NOT_FOUND).build(); } else if (!isAuthorEditor(course, httpRequest)) { return Response.serverError().status(Status.UNAUTHORIZED).build(); } BusinessGroupService bgs = CoreSpringFactory.getImpl(BusinessGroupService.class); CourseNode node = getParentNode(course, nodeId); ModuleConfiguration config = node.getModuleConfiguration(); String groupNames = (String) config.get(ENCourseNode.CONFIG_GROUPNAME); @SuppressWarnings("unchecked") List<Long> groupKeys = (List<Long>) config.get(ENCourseNode.CONFIG_GROUP_IDS); if (groupKeys == null && StringHelper.containsNonWhitespace(groupNames)) { groupKeys = bgs.toGroupKeys( groupNames, course.getCourseEnvironment().getCourseGroupManager().getCourseEntry()); } if (groupKeys == null || groupKeys.isEmpty()) { return Response.ok(new GroupVO[0]).build(); } List<GroupVO> voes = new ArrayList<GroupVO>(); List<BusinessGroup> groups = bgs.loadBusinessGroups(groupKeys); for (BusinessGroup group : groups) { voes.add(get(group)); } GroupVO[] voArr = new GroupVO[voes.size()]; voes.toArray(voArr); return Response.ok(voArr).build(); }