private void filterGroups(List<BusinessGroup> groups) {
   for (Iterator<BusinessGroup> groupIt = groups.iterator(); groupIt.hasNext(); ) {
     if (BusinessGroupManagedFlag.isManaged(
         groupIt.next(), BusinessGroupManagedFlag.membersmanagement)) {
       groupIt.remove();
     }
   }
 }
 public void setAllowWaitingList(boolean allowWaitingList) {
   boolean managed =
       BusinessGroupManagedFlag.isManaged(businessGroup, BusinessGroupManagedFlag.settings);
   enableWaitingList.setEnabled(allowWaitingList && !managed);
 }
  /**
   * @see
   *     org.olat.core.gui.components.form.flexible.impl.FormBasicController#initForm(org.olat.core.gui.components.form.flexible.FormItemContainer,
   *     org.olat.core.gui.control.Controller, org.olat.core.gui.UserRequest)
   */
  @Override
  protected void initForm(FormItemContainer formLayout, Controller listener, UserRequest ureq) {
    // Create the business group name input text element
    if (bulkMode) {
      businessGroupName =
          uifactory.addTextElement(
              "create.form.title.bgnames",
              "create.form.title.bgnames",
              10 * BusinessGroup.MAX_GROUP_NAME_LENGTH,
              "",
              formLayout);
      businessGroupName.setExampleKey("create.form.message.example.group", null);
    } else {
      businessGroupName =
          uifactory.addTextElement(
              "create.form.title.bgname",
              "create.form.title.bgname",
              BusinessGroup.MAX_GROUP_NAME_LENGTH,
              "",
              formLayout);
      businessGroupName.setNotLongerThanCheck(
          BusinessGroup.MAX_GROUP_NAME_LENGTH, "create.form.error.nameTooLong");
      businessGroupName.setRegexMatchCheck(
          BusinessGroup.VALID_GROUPNAME_REGEXP, "create.form.error.illegalName");
    }
    businessGroupName.setElementCssClass("o_sel_group_edit_title");
    businessGroupName.setMandatory(true);
    businessGroupName.setEnabled(
        !BusinessGroupManagedFlag.isManaged(businessGroup, BusinessGroupManagedFlag.title));

    formLayout.setElementCssClass("o_sel_group_edit_group_form");

    // Create the business group description input rich text element
    businessGroupDescription =
        uifactory.addRichTextElementForStringDataMinimalistic(
            "create.form.title.description",
            "create.form.title.description",
            "",
            10,
            -1,
            formLayout,
            getWindowControl());
    businessGroupDescription.setEnabled(
        !BusinessGroupManagedFlag.isManaged(businessGroup, BusinessGroupManagedFlag.description));

    if (businessGroup != null && !bulkMode) {
      // link to group direct jump in business path
      BusinessControlFactory bcf = BusinessControlFactory.getInstance();
      List<ContextEntry> entries =
          bcf.createCEListFromString("[BusinessGroup:" + businessGroup.getKey() + "]");
      String url = bcf.getAsURIString(entries, true);
      StaticTextElement urlEl =
          uifactory.addStaticTextElement("create.form.businesspath", url, formLayout);
      urlEl.setElementCssClass("o_sel_group_url");
      // link to group visiting card
      bcf = BusinessControlFactory.getInstance();
      entries = bcf.createCEListFromString("[GroupCard:" + businessGroup.getKey() + "]");
      url = bcf.getAsURIString(entries, true);
      StaticTextElement cardEl =
          uifactory.addStaticTextElement("create.form.groupcard", url, formLayout);
      cardEl.setElementCssClass("o_sel_group_card_url");
    }

    uifactory.addSpacerElement("myspacer", formLayout, true);

    // Minimum members input
    businessGroupMinimumMembers =
        uifactory.addTextElement(
            "create.form.title.min", "create.form.title.min", 5, "", formLayout);
    businessGroupMinimumMembers.setDisplaySize(6);
    businessGroupMinimumMembers.setVisible(false); // currently the minimum feature is not enabled
    businessGroupMinimumMembers.setElementCssClass("o_sel_group_edit_min_members");

    // Maximum members input
    businessGroupMaximumMembers =
        uifactory.addTextElement(
            "create.form.title.max", "create.form.title.max", 5, "", formLayout);
    businessGroupMaximumMembers.setDisplaySize(6);
    businessGroupMaximumMembers.setElementCssClass("o_sel_group_edit_max_members");

    // Checkboxes
    enableWaitingList =
        uifactory.addCheckboxesHorizontal(
            "create.form.enableWaitinglist", null, formLayout, waitingListKeys, waitingListValues);
    enableWaitingList.setElementCssClass("o_sel_group_edit_waiting_list");
    enableAutoCloseRanks =
        uifactory.addCheckboxesHorizontal(
            "create.form.enableAutoCloseRanks", null, formLayout, autoCloseKeys, autoCloseValues);
    enableAutoCloseRanks.setElementCssClass("o_sel_group_edit_auto_close_ranks");

    // Enable only if specification of min and max members is possible
    businessGroupMinimumMembers.setVisible(false); // currently the minimum feature is not enabled
    businessGroupMaximumMembers.setVisible(true);
    enableWaitingList.setVisible(true);
    enableAutoCloseRanks.setVisible(true);

    boolean managedSettings =
        BusinessGroupManagedFlag.isManaged(businessGroup, BusinessGroupManagedFlag.settings);
    businessGroupMinimumMembers.setEnabled(!managedSettings);
    businessGroupMaximumMembers.setEnabled(!managedSettings);
    enableWaitingList.setEnabled(!managedSettings);
    enableAutoCloseRanks.setEnabled(!managedSettings);

    if ((businessGroup != null) && (!bulkMode)) {
      businessGroupName.setValue(businessGroup.getName());
      businessGroupDescription.setValue(businessGroup.getDescription());
      Integer minimumMembers = businessGroup.getMinParticipants();
      Integer maximumMembers = businessGroup.getMaxParticipants();
      businessGroupMinimumMembers.setValue(
          minimumMembers == null || minimumMembers.intValue() <= 0
              ? ""
              : minimumMembers.toString());
      businessGroupMaximumMembers.setValue(
          maximumMembers == null || maximumMembers.intValue() < 0 ? "" : maximumMembers.toString());
      if (businessGroup.getWaitingListEnabled() != null) {
        enableWaitingList.select(
            "create.form.enableWaitinglist", businessGroup.getWaitingListEnabled());
      }
      if (businessGroup.getAutoCloseRanksEnabled() != null) {
        enableAutoCloseRanks.select(
            "create.form.enableAutoCloseRanks", businessGroup.getAutoCloseRanksEnabled());
      }
    }

    if (!embbeded) {
      // Create submit and cancel buttons
      final FormLayoutContainer buttonLayout =
          FormLayoutContainer.createButtonLayout("buttonLayout", getTranslator());
      formLayout.add(buttonLayout);
      FormSubmit submit = uifactory.addFormSubmitButton("finish", buttonLayout);
      submit.setEnabled(
          !BusinessGroupManagedFlag.isManaged(businessGroup, BusinessGroupManagedFlag.details));
      uifactory.addFormCancelButton("cancel", buttonLayout, ureq, getWindowControl());
    }

    if ((businessGroup != null) && (!bulkMode)) {
      // managed group information
      boolean managed =
          StringHelper.containsNonWhitespace(businessGroup.getExternalId())
              || businessGroup.getManagedFlags().length > 0;
      if (managed) {
        uifactory.addSpacerElement("managedspacer", formLayout, false);

        String extId = businessGroup.getExternalId() == null ? "" : businessGroup.getExternalId();
        StaticTextElement externalIdEl =
            uifactory.addStaticTextElement("create.form.externalid", extId, formLayout);
        externalIdEl.setElementCssClass("o_sel_group_external_id");

        FormLayoutContainer flagsFlc =
            FormLayoutContainer.createHorizontalFormLayout("flc_flags", getTranslator());
        flagsFlc.setLabel("create.form.managedflags", null);
        formLayout.add(flagsFlc);

        String flags =
            businessGroup.getManagedFlagsString() == null
                ? ""
                : businessGroup.getManagedFlagsString().trim();
        String flagsFormatted = null;
        if (flags.length() > 0) {
          // use translator from REST admin package to import managed flags context help strings
          Translator managedTrans =
              Util.createPackageTranslator(RestapiAdminController.class, ureq.getLocale());
          StringBuffer flagList = new StringBuffer();
          flagList.append("<p class=\"o_important\">");
          flagList.append(translate("create.form.managedflags.intro"));
          flagList.append("</div>");
          flagList.append("<ul>");
          for (String flag : flags.split(",")) {
            flagList.append("<li>");
            flagList.append(managedTrans.translate("managed.flags.group." + flag));
            flagList.append("</li>");
          }

          flagsFormatted = flagList.toString();

        } else {
          flagsFormatted = flags;
        }

        StaticTextElement flagsEl =
            uifactory.addStaticTextElement("create.form.managedflags", flagsFormatted, flagsFlc);
        flagsEl.showLabel(false);
        flagsEl.setElementCssClass("o_sel_group_managed_flags");
      }
    }
  }
 public Object getValueAt(BGTableItem wrapped, int col) {
   switch (Cols.values()[col]) {
     case name:
       return wrapped;
     case description:
       String description = wrapped.getBusinessGroupDescription();
       description = FilterFactory.getHtmlTagsFilter().filter(description);
       description = Formatter.truncate(description, 256);
       return description;
     case allowLeave:
       {
         Boolean allowed = wrapped.getAllowLeave();
         if (allowed != null && allowed.booleanValue()) {
           // check managed groups
           if (BusinessGroupManagedFlag.isManaged(
               wrapped.getManagedFlags(), BusinessGroupManagedFlag.membersmanagement)) {
             return Boolean.FALSE;
           }
         }
         return allowed;
       }
     case allowDelete:
       {
         Boolean allowed = wrapped.getAllowDelete();
         if (allowed != null && allowed.booleanValue()) {
           // check managed groups
           if (BusinessGroupManagedFlag.isManaged(
               wrapped.getManagedFlags(), BusinessGroupManagedFlag.delete)) {
             return Boolean.FALSE;
           }
         }
         return allowed;
       }
     case resources:
       return wrapped;
     case accessControl:
       return new Boolean(wrapped.isAccessControl());
     case accessControlLaunch:
       return wrapped.getAccessLink();
     case accessTypes:
       return wrapped.getAccessTypes();
     case mark:
       return wrapped.getMarkLink();
     case lastUsage:
       return wrapped.getBusinessGroupLastUsage();
     case role:
       return wrapped.getMembership();
     case firstTime:
       {
         BusinessGroupMembership membership = wrapped.getMembership();
         return membership == null ? null : membership.getCreationDate();
       }
     case lastTime:
       {
         BusinessGroupMembership membership = wrapped.getMembership();
         return membership == null ? null : membership.getLastModified();
       }
     case key:
       return wrapped.getBusinessGroupKey();
     case freePlaces:
       {
         Integer maxParticipants = wrapped.getMaxParticipants();
         if (maxParticipants != null && maxParticipants.intValue() >= 0) {
           long free =
               maxParticipants - (wrapped.getNumOfParticipants() + wrapped.getNumOfPendings());
           return new GroupNumber(free);
         }
         return GroupNumber.INFINITE;
       }
     case participantsCount:
       {
         long count = wrapped.getNumOfParticipants() + wrapped.getNumOfPendings();
         return count < 0 ? GroupNumber.ZERO : new GroupNumber(count);
       }
     case tutorsCount:
       {
         long count = wrapped.getNumOfOwners();
         return count < 0 ? GroupNumber.ZERO : new GroupNumber(count);
       }
     case waitingListCount:
       {
         if (wrapped.isWaitingListEnabled()) {
           long count = wrapped.getNumWaiting();
           return count < 0 ? GroupNumber.ZERO : new GroupNumber(count);
         }
         return GroupNumber.NONE;
       }
     case wrapper:
       return wrapped;
     case externalId:
       return wrapped.getBusinessGroupExternalId();
     case unlink:
       {
         boolean managed =
             BusinessGroupManagedFlag.isManaged(
                 wrapped.getManagedFlags(), BusinessGroupManagedFlag.resources);
         return managed ? Boolean.FALSE : Boolean.TRUE;
       }
     default:
       return "ERROR";
   }
 }