コード例 #1
0
ファイル: GitblitAuthority.java プロジェクト: noelmac/gitblit
  private boolean sendEmail(UserModel user, X509Metadata metadata, File zip) {
    // send email
    try {
      if (mail.isReady()) {
        Message message = mail.createMessage(user.emailAddress);
        message.setSubject("Your Gitblit client certificate for " + metadata.serverHostname);

        // body of email
        String body =
            X509Utils.processTemplate(
                new File(folder, X509Utils.CERTS + File.separator + "mail.tmpl"), metadata);
        if (StringUtils.isEmpty(body)) {
          body =
              MessageFormat.format(
                  "Hi {0}\n\nHere is your client certificate bundle.\nInside the zip file are installation instructions.",
                  user.getDisplayName());
        }
        Multipart mp = new MimeMultipart();
        MimeBodyPart messagePart = new MimeBodyPart();
        messagePart.setText(body);
        mp.addBodyPart(messagePart);

        // attach zip
        MimeBodyPart filePart = new MimeBodyPart();
        FileDataSource fds = new FileDataSource(zip);
        filePart.setDataHandler(new DataHandler(fds));
        filePart.setFileName(fds.getName());
        mp.addBodyPart(filePart);

        message.setContent(mp);

        mail.sendNow(message);
        return true;
      } else {
        JOptionPane.showMessageDialog(
            GitblitAuthority.this,
            "Sorry, the mail server settings are not configured properly.\nCan not send email.",
            Translation.get("gb.error"),
            JOptionPane.ERROR_MESSAGE);
      }
    } catch (Exception e) {
      Utils.showException(GitblitAuthority.this, e);
    }
    return false;
  }
コード例 #2
0
ファイル: UserPage.java プロジェクト: LemonKL/gitblit
  private void addPreferences(UserModel user) {
    // add preferences
    Form<Void> prefs = new Form<Void>("prefsForm");

    List<Language> languages =
        Arrays.asList(
            new Language("Deutsch", "de"),
            new Language("English", "en"),
            new Language("Español", "es"),
            new Language("Français", "fr"),
            new Language("Italiano", "it"),
            new Language("日本語", "ja"),
            new Language("한국말", "ko"),
            new Language("Nederlands", "nl"),
            new Language("Norsk", "no"),
            new Language("Język Polski", "pl"),
            new Language("Português", "pt_BR"),
            new Language("簡體中文", "zh_CN"),
            new Language("正體中文", "zh_TW"));

    Locale locale = user.getPreferences().getLocale();
    if (locale == null) {
      // user has not specified language preference
      // try server default preference
      String lc = app().settings().getString(Keys.web.forceDefaultLocale, null);
      if (StringUtils.isEmpty(lc)) {
        // server default language is not configured
        // try browser preference
        Locale sessionLocale = GitBlitWebSession.get().getLocale();
        if (sessionLocale != null) {
          locale = sessionLocale;
        }
      } else {

      }
    }

    Language preferredLanguage = null;
    if (locale != null) {
      String localeCode = locale.getLanguage();
      if (!StringUtils.isEmpty(locale.getCountry())) {
        localeCode += "_" + locale.getCountry();
      }

      for (Language language : languages) {
        if (language.code.equals(localeCode)) {
          // language_COUNTRY match
          preferredLanguage = language;
        } else if (preferredLanguage != null && language.code.startsWith(locale.getLanguage())) {
          // language match
          preferredLanguage = language;
        }
      }
    }

    final IModel<String> displayName = Model.of(user.getDisplayName());
    final IModel<String> emailAddress =
        Model.of(user.emailAddress == null ? "" : user.emailAddress);
    final IModel<Language> language = Model.of(preferredLanguage);
    final IModel<Boolean> emailMeOnMyTicketChanges =
        Model.of(user.getPreferences().isEmailMeOnMyTicketChanges());
    final IModel<Transport> transport = Model.of(user.getPreferences().getTransport());

    prefs.add(
        new TextOption(
                "displayName",
                getString("gb.displayName"),
                getString("gb.displayNameDescription"),
                displayName)
            .setVisible(app().authentication().supportsDisplayNameChanges(user)));

    prefs.add(
        new TextOption(
                "emailAddress",
                getString("gb.emailAddress"),
                getString("gb.emailAddressDescription"),
                emailAddress)
            .setVisible(app().authentication().supportsEmailAddressChanges(user)));

    prefs.add(
        new ChoiceOption<Language>(
            "language",
            getString("gb.languagePreference"),
            getString("gb.languagePreferenceDescription"),
            language,
            languages));

    prefs.add(
        new BooleanOption(
                "emailMeOnMyTicketChanges",
                getString("gb.emailMeOnMyTicketChanges"),
                getString("gb.emailMeOnMyTicketChangesDescription"),
                emailMeOnMyTicketChanges)
            .setVisible(app().notifier().isSendingMail()));

    List<Transport> availableTransports = new ArrayList<>();
    if (app().services().isServingSSH()) {
      availableTransports.add(Transport.SSH);
    }
    if (app().services().isServingHTTP()) {
      availableTransports.add(Transport.HTTP);
    }
    if (app().services().isServingHTTPS()) {
      availableTransports.add(Transport.HTTPS);
    }
    if (app().services().isServingGIT()) {
      availableTransports.add(Transport.GIT);
    }

    prefs.add(
        new ChoiceOption<Transport>(
            "transport",
            getString("gb.transportPreference"),
            getString("gb.transportPreferenceDescription"),
            transport,
            availableTransports));

    prefs.add(
        new AjaxButton("save") {

          private static final long serialVersionUID = 1L;

          @Override
          protected void onSubmit(AjaxRequestTarget target, Form<?> form) {

            UserModel user = GitBlitWebSession.get().getUser();

            user.displayName = displayName.getObject();
            user.emailAddress = emailAddress.getObject();

            Language lang = language.getObject();
            if (lang != null) {
              user.getPreferences().setLocale(lang.code);
            }

            user.getPreferences().setEmailMeOnMyTicketChanges(emailMeOnMyTicketChanges.getObject());
            user.getPreferences().setTransport(transport.getObject());

            try {
              app().gitblit().reviseUser(user.username, user);

              setRedirect(true);
              setResponsePage(UserPage.class, WicketUtils.newUsernameParameter(user.username));
            } catch (GitBlitException e) {
              // logger.error("Failed to update user " + user.username, e);
              // error(getString("gb.failedToUpdateUser"), false);
            }
          }
        });

    // add the preferences tab
    add(new Fragment("preferencesLink", "preferencesLinkFragment", this).setRenderBodyOnly(true));
    Fragment fragment = new Fragment("preferencesTab", "preferencesTabFragment", this);
    fragment.add(prefs);
    add(fragment.setRenderBodyOnly(true));
  }
コード例 #3
0
  protected void setupPage(RepositoryModel model) {
    this.repositoryModel = model;

    // ensure this user can create or edit this repository
    checkPermissions(repositoryModel);

    List<String> indexedBranches = new ArrayList<String>();
    List<String> federationSets = new ArrayList<String>();
    final List<RegistrantAccessPermission> repositoryUsers =
        new ArrayList<RegistrantAccessPermission>();
    final List<RegistrantAccessPermission> repositoryTeams =
        new ArrayList<RegistrantAccessPermission>();
    List<String> preReceiveScripts = new ArrayList<String>();
    List<String> postReceiveScripts = new ArrayList<String>();

    GitBlitWebSession session = GitBlitWebSession.get();
    final UserModel user = session.getUser() == null ? UserModel.ANONYMOUS : session.getUser();
    final boolean allowEditName =
        isCreate || isAdmin || repositoryModel.isUsersPersonalRepository(user.username);

    if (isCreate) {
      if (user.canAdmin()) {
        super.setupPage(getString("gb.newRepository"), "");
      } else {
        super.setupPage(getString("gb.newRepository"), user.getDisplayName());
      }
    } else {
      super.setupPage(getString("gb.edit"), repositoryModel.name);
      repositoryUsers.addAll(GitBlit.self().getUserAccessPermissions(repositoryModel));
      repositoryTeams.addAll(GitBlit.self().getTeamAccessPermissions(repositoryModel));
      Collections.sort(repositoryUsers);
      Collections.sort(repositoryTeams);

      federationSets.addAll(repositoryModel.federationSets);
      if (!ArrayUtils.isEmpty(repositoryModel.indexedBranches)) {
        indexedBranches.addAll(repositoryModel.indexedBranches);
      }
    }

    final String oldName = repositoryModel.name;

    final RegistrantPermissionsPanel usersPalette =
        new RegistrantPermissionsPanel(
            "users",
            RegistrantType.USER,
            GitBlit.self().getAllUsernames(),
            repositoryUsers,
            getAccessPermissions());
    final RegistrantPermissionsPanel teamsPalette =
        new RegistrantPermissionsPanel(
            "teams",
            RegistrantType.TEAM,
            GitBlit.self().getAllTeamnames(),
            repositoryTeams,
            getAccessPermissions());

    // owners palette
    List<String> owners = new ArrayList<String>(repositoryModel.owners);
    List<String> persons = GitBlit.self().getAllUsernames();
    final Palette<String> ownersPalette =
        new Palette<String>(
            "owners",
            new ListModel<String>(owners),
            new CollectionModel<String>(persons),
            new StringChoiceRenderer(),
            12,
            true);

    // indexed local branches palette
    List<String> allLocalBranches = new ArrayList<String>();
    allLocalBranches.add(Constants.DEFAULT_BRANCH);
    allLocalBranches.addAll(repositoryModel.getLocalBranches());
    boolean luceneEnabled = GitBlit.getBoolean(Keys.web.allowLuceneIndexing, true);
    final Palette<String> indexedBranchesPalette =
        new Palette<String>(
            "indexedBranches",
            new ListModel<String>(indexedBranches),
            new CollectionModel<String>(allLocalBranches),
            new StringChoiceRenderer(),
            8,
            false);
    indexedBranchesPalette.setEnabled(luceneEnabled);

    // federation sets palette
    List<String> sets = GitBlit.getStrings(Keys.federation.sets);
    final Palette<String> federationSetsPalette =
        new Palette<String>(
            "federationSets",
            new ListModel<String>(federationSets),
            new CollectionModel<String>(sets),
            new StringChoiceRenderer(),
            8,
            false);

    // pre-receive palette
    if (!ArrayUtils.isEmpty(repositoryModel.preReceiveScripts)) {
      preReceiveScripts.addAll(repositoryModel.preReceiveScripts);
    }
    final Palette<String> preReceivePalette =
        new Palette<String>(
            "preReceiveScripts",
            new ListModel<String>(preReceiveScripts),
            new CollectionModel<String>(GitBlit.self().getPreReceiveScriptsUnused(repositoryModel)),
            new StringChoiceRenderer(),
            12,
            true);

    // post-receive palette
    if (!ArrayUtils.isEmpty(repositoryModel.postReceiveScripts)) {
      postReceiveScripts.addAll(repositoryModel.postReceiveScripts);
    }
    final Palette<String> postReceivePalette =
        new Palette<String>(
            "postReceiveScripts",
            new ListModel<String>(postReceiveScripts),
            new CollectionModel<String>(
                GitBlit.self().getPostReceiveScriptsUnused(repositoryModel)),
            new StringChoiceRenderer(),
            12,
            true);

    // custom fields
    final Map<String, String> customFieldsMap = GitBlit.getMap(Keys.groovy.customFields);
    List<String> customKeys = new ArrayList<String>(customFieldsMap.keySet());
    final ListView<String> customFieldsListView =
        new ListView<String>("customFieldsListView", customKeys) {

          private static final long serialVersionUID = 1L;

          @Override
          protected void populateItem(ListItem<String> item) {
            String key = item.getModelObject();
            item.add(new Label("customFieldLabel", customFieldsMap.get(key)));

            String value = "";
            if (repositoryModel.customFields != null
                && repositoryModel.customFields.containsKey(key)) {
              value = repositoryModel.customFields.get(key);
            }
            TextField<String> field =
                new TextField<String>("customFieldValue", new Model<String>(value));
            item.add(field);
          }
        };
    customFieldsListView.setReuseItems(true);

    CompoundPropertyModel<RepositoryModel> rModel =
        new CompoundPropertyModel<RepositoryModel>(repositoryModel);
    Form<RepositoryModel> form =
        new Form<RepositoryModel>("editForm", rModel) {

          private static final long serialVersionUID = 1L;

          @Override
          protected void onSubmit() {
            try {
              // confirm a repository name was entered
              if (repositoryModel.name == null && StringUtils.isEmpty(repositoryModel.name)) {
                error(getString("gb.pleaseSetRepositoryName"));
                return;
              }

              // ensure name is trimmed
              repositoryModel.name = repositoryModel.name.trim();

              // automatically convert backslashes to forward slashes
              repositoryModel.name = repositoryModel.name.replace('\\', '/');
              // Automatically replace // with /
              repositoryModel.name = repositoryModel.name.replace("//", "/");

              // prohibit folder paths
              if (repositoryModel.name.startsWith("/")) {
                error(getString("gb.illegalLeadingSlash"));
                return;
              }
              if (repositoryModel.name.startsWith("../")) {
                error(getString("gb.illegalRelativeSlash"));
                return;
              }
              if (repositoryModel.name.contains("/../")) {
                error(getString("gb.illegalRelativeSlash"));
                return;
              }
              if (repositoryModel.name.endsWith("/")) {
                repositoryModel.name =
                    repositoryModel.name.substring(0, repositoryModel.name.length() - 1);
              }

              // confirm valid characters in repository name
              Character c = StringUtils.findInvalidCharacter(repositoryModel.name);
              if (c != null) {
                error(MessageFormat.format(getString("gb.illegalCharacterRepositoryName"), c));
                return;
              }

              if (user.canCreate() && !user.canAdmin() && allowEditName) {
                // ensure repository name begins with the user's path
                if (!repositoryModel.name.startsWith(user.getPersonalPath())) {
                  error(
                      MessageFormat.format(
                          getString("gb.illegalPersonalRepositoryLocation"),
                          user.getPersonalPath()));
                  return;
                }

                if (repositoryModel.name.equals(user.getPersonalPath())) {
                  // reset path prefix and show error
                  repositoryModel.name = user.getPersonalPath() + "/";
                  error(getString("gb.pleaseSetRepositoryName"));
                  return;
                }
              }

              // confirm access restriction selection
              if (repositoryModel.accessRestriction == null) {
                error(getString("gb.selectAccessRestriction"));
                return;
              }

              // confirm federation strategy selection
              if (repositoryModel.federationStrategy == null) {
                error(getString("gb.selectFederationStrategy"));
                return;
              }

              // save federation set preferences
              if (repositoryModel.federationStrategy.exceeds(FederationStrategy.EXCLUDE)) {
                repositoryModel.federationSets.clear();
                Iterator<String> sets = federationSetsPalette.getSelectedChoices();
                while (sets.hasNext()) {
                  repositoryModel.federationSets.add(sets.next());
                }
              }

              // set author metric exclusions
              String ax = metricAuthorExclusions.getObject();
              if (!StringUtils.isEmpty(ax)) {
                Set<String> list = new HashSet<String>();
                for (String exclusion : StringUtils.getStringsFromValue(ax, " ")) {
                  if (StringUtils.isEmpty(exclusion)) {
                    continue;
                  }
                  if (exclusion.indexOf(' ') > -1) {
                    list.add("\"" + exclusion + "\"");
                  } else {
                    list.add(exclusion);
                  }
                }
                repositoryModel.metricAuthorExclusions = new ArrayList<String>(list);
              }

              // set mailing lists
              String ml = mailingLists.getObject();
              if (!StringUtils.isEmpty(ml)) {
                Set<String> list = new HashSet<String>();
                for (String address : ml.split("(,|\\s)")) {
                  if (StringUtils.isEmpty(address)) {
                    continue;
                  }
                  list.add(address.toLowerCase());
                }
                repositoryModel.mailingLists = new ArrayList<String>(list);
              }

              // indexed branches
              List<String> indexedBranches = new ArrayList<String>();
              Iterator<String> branches = indexedBranchesPalette.getSelectedChoices();
              while (branches.hasNext()) {
                indexedBranches.add(branches.next());
              }
              repositoryModel.indexedBranches = indexedBranches;

              // owners
              repositoryModel.owners.clear();
              Iterator<String> owners = ownersPalette.getSelectedChoices();
              while (owners.hasNext()) {
                repositoryModel.addOwner(owners.next());
              }

              // pre-receive scripts
              List<String> preReceiveScripts = new ArrayList<String>();
              Iterator<String> pres = preReceivePalette.getSelectedChoices();
              while (pres.hasNext()) {
                preReceiveScripts.add(pres.next());
              }
              repositoryModel.preReceiveScripts = preReceiveScripts;

              // post-receive scripts
              List<String> postReceiveScripts = new ArrayList<String>();
              Iterator<String> post = postReceivePalette.getSelectedChoices();
              while (post.hasNext()) {
                postReceiveScripts.add(post.next());
              }
              repositoryModel.postReceiveScripts = postReceiveScripts;

              // custom fields
              repositoryModel.customFields = new LinkedHashMap<String, String>();
              for (int i = 0; i < customFieldsListView.size(); i++) {
                ListItem<String> child = (ListItem<String>) customFieldsListView.get(i);
                String key = child.getModelObject();

                TextField<String> field = (TextField<String>) child.get("customFieldValue");
                String value = field.getValue();

                repositoryModel.customFields.put(key, value);
              }

              // save the repository
              GitBlit.self().updateRepositoryModel(oldName, repositoryModel, isCreate);

              // repository access permissions
              if (repositoryModel.accessRestriction.exceeds(AccessRestrictionType.NONE)) {
                GitBlit.self().setUserAccessPermissions(repositoryModel, repositoryUsers);
                GitBlit.self().setTeamAccessPermissions(repositoryModel, repositoryTeams);
              }
            } catch (GitBlitException e) {
              error(e.getMessage());
              return;
            }
            setRedirect(false);
            setResponsePage(RepositoriesPage.class);
          }
        };

    // do not let the browser pre-populate these fields
    form.add(new SimpleAttributeModifier("autocomplete", "off"));

    // field names reflective match RepositoryModel fields
    form.add(new TextField<String>("name").setEnabled(allowEditName));
    form.add(new TextField<String>("description"));
    form.add(ownersPalette);
    form.add(
        new CheckBox("allowForks").setEnabled(GitBlit.getBoolean(Keys.web.allowForking, true)));
    DropDownChoice<AccessRestrictionType> accessRestriction =
        new DropDownChoice<AccessRestrictionType>(
            "accessRestriction",
            Arrays.asList(AccessRestrictionType.values()),
            new AccessRestrictionRenderer());
    form.add(accessRestriction);
    form.add(new CheckBox("isFrozen"));
    // TODO enable origin definition
    form.add(new TextField<String>("origin").setEnabled(false /* isCreate */));

    // allow relinking HEAD to a branch or tag other than master on edit repository
    List<String> availableRefs = new ArrayList<String>();
    if (!ArrayUtils.isEmpty(repositoryModel.availableRefs)) {
      availableRefs.addAll(repositoryModel.availableRefs);
    }
    form.add(
        new DropDownChoice<String>("HEAD", availableRefs).setEnabled(availableRefs.size() > 0));

    boolean gcEnabled = GitBlit.getBoolean(Keys.git.enableGarbageCollection, false);
    List<Integer> gcPeriods = Arrays.asList(1, 2, 3, 4, 5, 7, 10, 14);
    form.add(
        new DropDownChoice<Integer>("gcPeriod", gcPeriods, new GCPeriodRenderer())
            .setEnabled(gcEnabled));
    form.add(new TextField<String>("gcThreshold").setEnabled(gcEnabled));

    // federation strategies - remove ORIGIN choice if this repository has
    // no origin.
    List<FederationStrategy> federationStrategies =
        new ArrayList<FederationStrategy>(Arrays.asList(FederationStrategy.values()));
    if (StringUtils.isEmpty(repositoryModel.origin)) {
      federationStrategies.remove(FederationStrategy.FEDERATE_ORIGIN);
    }
    form.add(
        new DropDownChoice<FederationStrategy>(
            "federationStrategy", federationStrategies, new FederationTypeRenderer()));
    form.add(new CheckBox("useTickets"));
    form.add(new CheckBox("useDocs"));
    form.add(new CheckBox("useIncrementalPushTags"));
    form.add(new CheckBox("showRemoteBranches"));
    form.add(new CheckBox("showReadme"));
    form.add(new CheckBox("skipSizeCalculation"));
    form.add(new CheckBox("skipSummaryMetrics"));
    List<Integer> maxActivityCommits = Arrays.asList(-1, 0, 25, 50, 75, 100, 150, 200, 250, 500);
    form.add(
        new DropDownChoice<Integer>(
            "maxActivityCommits", maxActivityCommits, new MaxActivityCommitsRenderer()));

    metricAuthorExclusions =
        new Model<String>(
            ArrayUtils.isEmpty(repositoryModel.metricAuthorExclusions)
                ? ""
                : StringUtils.flattenStrings(repositoryModel.metricAuthorExclusions, " "));
    form.add(new TextField<String>("metricAuthorExclusions", metricAuthorExclusions));

    mailingLists =
        new Model<String>(
            ArrayUtils.isEmpty(repositoryModel.mailingLists)
                ? ""
                : StringUtils.flattenStrings(repositoryModel.mailingLists, " "));
    form.add(new TextField<String>("mailingLists", mailingLists));
    form.add(indexedBranchesPalette);

    List<AuthorizationControl> acList = Arrays.asList(AuthorizationControl.values());
    final RadioChoice<AuthorizationControl> authorizationControl =
        new RadioChoice<Constants.AuthorizationControl>(
            "authorizationControl", acList, new AuthorizationControlRenderer());
    form.add(authorizationControl);

    final CheckBox verifyCommitter = new CheckBox("verifyCommitter");
    verifyCommitter.setOutputMarkupId(true);
    form.add(verifyCommitter);

    form.add(usersPalette);
    form.add(teamsPalette);
    form.add(federationSetsPalette);
    form.add(preReceivePalette);
    form.add(
        new BulletListPanel(
            "inheritedPreReceive",
            getString("gb.inherited"),
            GitBlit.self().getPreReceiveScriptsInherited(repositoryModel)));
    form.add(postReceivePalette);
    form.add(
        new BulletListPanel(
            "inheritedPostReceive",
            getString("gb.inherited"),
            GitBlit.self().getPostReceiveScriptsInherited(repositoryModel)));

    WebMarkupContainer customFieldsSection = new WebMarkupContainer("customFieldsSection");
    customFieldsSection.add(customFieldsListView);
    form.add(
        customFieldsSection.setVisible(!GitBlit.getString(Keys.groovy.customFields, "").isEmpty()));

    // initial enable/disable of permission controls
    if (repositoryModel.accessRestriction.equals(AccessRestrictionType.NONE)) {
      // anonymous everything, disable all controls
      usersPalette.setEnabled(false);
      teamsPalette.setEnabled(false);
      authorizationControl.setEnabled(false);
      verifyCommitter.setEnabled(false);
    } else {
      // authenticated something
      // enable authorization controls
      authorizationControl.setEnabled(true);
      verifyCommitter.setEnabled(true);

      boolean allowFineGrainedControls =
          repositoryModel.authorizationControl.equals(AuthorizationControl.NAMED);
      usersPalette.setEnabled(allowFineGrainedControls);
      teamsPalette.setEnabled(allowFineGrainedControls);
    }

    accessRestriction.add(
        new AjaxFormComponentUpdatingBehavior("onchange") {

          private static final long serialVersionUID = 1L;

          protected void onUpdate(AjaxRequestTarget target) {
            // enable/disable permissions panel based on access restriction
            boolean allowAuthorizationControl =
                repositoryModel.accessRestriction.exceeds(AccessRestrictionType.NONE);
            authorizationControl.setEnabled(allowAuthorizationControl);
            verifyCommitter.setEnabled(allowAuthorizationControl);

            boolean allowFineGrainedControls =
                allowAuthorizationControl
                    && repositoryModel.authorizationControl.equals(AuthorizationControl.NAMED);
            usersPalette.setEnabled(allowFineGrainedControls);
            teamsPalette.setEnabled(allowFineGrainedControls);

            if (allowFineGrainedControls) {
              repositoryModel.authorizationControl = AuthorizationControl.NAMED;
            }

            target.addComponent(authorizationControl);
            target.addComponent(verifyCommitter);
            target.addComponent(usersPalette);
            target.addComponent(teamsPalette);
          }
        });

    authorizationControl.add(
        new AjaxFormChoiceComponentUpdatingBehavior() {

          private static final long serialVersionUID = 1L;

          protected void onUpdate(AjaxRequestTarget target) {
            // enable/disable permissions panel based on access restriction
            boolean allowAuthorizationControl =
                repositoryModel.accessRestriction.exceeds(AccessRestrictionType.NONE);
            authorizationControl.setEnabled(allowAuthorizationControl);

            boolean allowFineGrainedControls =
                allowAuthorizationControl
                    && repositoryModel.authorizationControl.equals(AuthorizationControl.NAMED);
            usersPalette.setEnabled(allowFineGrainedControls);
            teamsPalette.setEnabled(allowFineGrainedControls);

            if (allowFineGrainedControls) {
              repositoryModel.authorizationControl = AuthorizationControl.NAMED;
            }

            target.addComponent(authorizationControl);
            target.addComponent(usersPalette);
            target.addComponent(teamsPalette);
          }
        });

    form.add(new Button("save"));
    Button cancel =
        new Button("cancel") {
          private static final long serialVersionUID = 1L;

          @Override
          public void onSubmit() {
            setResponsePage(RepositoriesPage.class);
          }
        };
    cancel.setDefaultFormProcessing(false);
    form.add(cancel);

    add(form);
  }