Example usage for org.apache.wicket.model.util CollectionModel CollectionModel

List of usage examples for org.apache.wicket.model.util CollectionModel CollectionModel

Introduction

In this page you can find the example usage for org.apache.wicket.model.util CollectionModel CollectionModel.

Prototype

public CollectionModel(Collection<T> collection) 

Source Link

Document

Creates model that will contain collection

Usage

From source file:com.asptt.plongee.resa.ui.web.wicket.page.admin.GererPlongeeAOuvrirTwo.java

public GererPlongeeAOuvrirTwo(final Plongee plongee) {
    setPageTitle("Ouvrir plongee");
    modalPlongee = new ModalWindow("modalPlongee");
    modalPlongee.setTitle("This is modal window with panel content.");
    modalPlongee.setCookieName("modal-plongee");
    add(modalPlongee);//from  ww w. jav a2 s .c  om

    CompoundPropertyModel<Plongee> modelPlongee = new CompoundPropertyModel<Plongee>(plongee);

    List<Adherent> dps;
    dps = getResaSession().getAdherentService().rechercherDPsNonInscrits(
            getResaSession().getAdherentService().rechercherAdherentsActifs(), plongee);

    dps.removeAll(plongee.getParticipants());

    IChoiceRenderer<Adherent> rendDp = new ChoiceRenderer<Adherent>("nom", "nom");

    final Palette<Adherent> palDp = new Palette<Adherent>("paletteDps",
            new ListModel<Adherent>(new ArrayList<Adherent>()), new CollectionModel<Adherent>(dps), rendDp, 10,
            false) {
    };

    List<Adherent> pilotes = getResaSession().getAdherentService().rechercherPilotesNonInscrits(
            getResaSession().getAdherentService().rechercherAdherentsActifs(), plongee);

    pilotes.removeAll(plongee.getParticipants());

    IChoiceRenderer<Adherent> rendPilote = new ChoiceRenderer<Adherent>("nom", "nom");

    final Palette<Adherent> palPilote = new Palette<Adherent>("palettePilotes",
            new ListModel<Adherent>(new ArrayList<Adherent>()), new CollectionModel<Adherent>(pilotes),
            rendPilote, 10, false) {
    };

    final Form<Plongee> form = new Form<Plongee>("form") {

        private static final long serialVersionUID = 4611593854191923422L;

        @Override
        protected void onSubmit() {

            IModel<?> modelDps = palDp.getDefaultModel();
            List<Adherent> dps = (List<Adherent>) modelDps.getObject();

            IModel<?> modelPilotes = palPilote.getDefaultModel();
            List<Adherent> pilotes = (List<Adherent>) modelPilotes.getObject();
            /*
             * Impossible de gerer les doublons avec un HashSet Alors on le
             * fait ' la main'
             */
            List<String> idInscrits = new ArrayList<String>();
            for (Adherent adherent : dps) {
                if (!idInscrits.contains(adherent.getNumeroLicense())) {
                    idInscrits.add(adherent.getNumeroLicense());
                }
            }
            for (Adherent adherent : pilotes) {
                if (!idInscrits.contains(adherent.getNumeroLicense())) {
                    idInscrits.add(adherent.getNumeroLicense());
                }
            }
            /*
             * Maintenant qu'on  la liste des id on reconstitue une liste
             * d'adherent
             */
            List<Adherent> adhInscrits = new ArrayList<Adherent>();
            for (String id : idInscrits) {
                adhInscrits.add(getResaSession().getAdherentService().rechercherAdherentParIdentifiant(id));
            }
            /*
             * Reste plus qu'a inscrire...
             */
            for (Adherent adh : adhInscrits) {
                try {
                    getResaSession().getPlongeeService().inscrireAdherent(plongee, adh,
                            PlongeeMail.PAS_DE_MAIL);
                } catch (ResaException e) {
                    e.printStackTrace();
                    ErrorPage ep = new ErrorPage(e);
                    setResponsePage(ep);
                }
            }
            PageParameters param = new PageParameters();
            param.put("plongeeAOuvrir", plongee);
            param.put("inscrits", adhInscrits);
            //setResponsePage(new GererPlongeeAOuvrirThree(plongee));
            setResponsePage(new InscriptionConfirmationPlongeePage(plongee));
        }//fin du onSubmit()
    };

    form.setModel(modelPlongee);
    // Le nombre max. de places, pour info
    maxPlaces = new TextField<Integer>("nbMaxPlaces");
    maxPlaces.setOutputMarkupId(true);
    form.add(maxPlaces.setEnabled(false));
    // Le niveau mini. des plongeurs, pour info
    niveauMinimum = new TextField<Integer>("niveauMinimum");
    niveauMinimum.setOutputMarkupId(true);
    form.add(niveauMinimum.setEnabled(false));

    // La Date de visibilite de la plonge, pour info
    dateVisible = new TextField<Date>("dateVisible");
    dateVisible.setOutputMarkupId(true);
    form.add(dateVisible.setEnabled(false));

    // Ajout des palettes
    form.add(palDp);
    form.add(palPilote);

    add(form);

    form.add(new IndicatingAjaxLink("change") {
        @Override
        public void onClick(AjaxRequestTarget target) {
            replaceModalWindow(target, form.getModel());
            modalPlongee.show(target);
        }
    });

}

From source file:com.asptt.plongee.resa.wicket.page.admin.plongee.GererPlongeeAOuvrirTwo.java

public GererPlongeeAOuvrirTwo(final Plongee plongee) {
    setPageTitle("Ouvrir plongee");
    final FeedbackPanel feedback = new FeedbackPanel("feedback");
    feedback.setOutputMarkupId(true);//  w w w.j  a va  2s  . c o m
    add(feedback);
    modalPlongee = new ModalWindow("modalPlongee");
    modalPlongee.setTitle("This is modal window with panel content.");
    modalPlongee.setCookieName("modal-plongee");
    add(modalPlongee);

    CompoundPropertyModel<Plongee> modelPlongee = new CompoundPropertyModel<Plongee>(plongee);
    // Liste des DPs
    List<Adherent> dps;
    dps = ResaSession.get().getAdherentService().rechercherDPsNonInscrits(
            ResaSession.get().getAdherentService().rechercherAdherentsActifs(), plongee);
    //Suppression des adherents dj inscrits  la plonge de la liste des DPs
    dps.removeAll(plongee.getParticipants());
    // Init ChoiceRender des DPs
    IChoiceRenderer<Adherent> rendDp = new ChoiceRenderer<Adherent>("nom", "nom");
    // Init de la palettes des DPs
    final Palette<Adherent> palDp = new Palette<Adherent>("paletteDps",
            new ListModel<Adherent>(new ArrayList<Adherent>()), new CollectionModel<Adherent>(dps), rendDp, 10,
            false) {
    };
    //List des Pilotes
    List<Adherent> pilotes = ResaSession.get().getAdherentService().rechercherPilotesNonInscrits(
            ResaSession.get().getAdherentService().rechercherAdherentsActifs(), plongee);
    //Suppression des adherents dj inscrits  la plonge de la liste des Pilotes
    pilotes.removeAll(plongee.getParticipants());
    // Init ChoiceRender des Pilotes
    IChoiceRenderer<Adherent> rendPilote = new ChoiceRenderer<Adherent>("nom", "nom");
    // Init de la palettes des Pilotes
    final Palette<Adherent> palPilote = new Palette<Adherent>("palettePilotes",
            new ListModel<Adherent>(new ArrayList<Adherent>()), new CollectionModel<Adherent>(pilotes),
            rendPilote, 10, false) {
    };
    //Init de la Forme
    final Form<Plongee> form = new Form<Plongee>("form") {
        private static final long serialVersionUID = 4611593854191923422L;

    };
    //Dfinition du model de la form == plongee
    form.setModel(modelPlongee);
    // Le nombre max. de places, pour info
    maxPlaces = new TextField<Integer>("nbMaxPlaces");
    maxPlaces.setOutputMarkupId(true);
    form.add(maxPlaces.setEnabled(false));
    // Le niveau mini. des plongeurs, pour info
    niveauMinimum = new TextField<Integer>("niveauMinimum");
    niveauMinimum.setOutputMarkupId(true);
    form.add(niveauMinimum.setEnabled(false));
    // La Date de visibilite de la plonge, pour info
    dateReservation = new TextField<Date>("dateReservation");
    dateReservation.setOutputMarkupId(true);
    form.add(dateReservation.setEnabled(false));
    //ajout du warning
    warning = new TextArea<String>("warning");
    warning.setOutputMarkupId(true);
    form.add(warning.setEnabled(false));

    // Ajout des palettes
    form.add(palDp);
    form.add(palPilote);
    // Ajout du lien pour modifier les caracteristiques de la plonge
    form.add(new IndicatingAjaxLink("change") {
        @Override
        public void onClick(AjaxRequestTarget target) {
            replaceModalWindow(target, form.getModel());
            modalPlongee.show(target);
        }
    });
    // Ajout du bouton submit
    IndicatingAjaxButton b_valider = new IndicatingAjaxButton("validDpPilote") {
        @Override
        protected void onSubmit(AjaxRequestTarget target, Form<?> form) {
            IModel<?> modelDps = palDp.getDefaultModel();
            List<Adherent> dps = (List<Adherent>) modelDps.getObject();

            IModel<?> modelPilotes = palPilote.getDefaultModel();
            List<Adherent> pilotes = (List<Adherent>) modelPilotes.getObject();

            if (dps.size() != 1 || pilotes.size() != 1) {
                error("Un DP et un pilote doivent tre selectionns");
            } else {
                /*
                 * Impossible de gerer les doublons avec un HashSet Alors on le
                 * fait ' la main'
                 */
                List<Adherent> l_dpPilote = new ArrayList<Adherent>();
                l_dpPilote.add(dps.get(0));
                if (!dps.get(0).getNumeroLicense().equalsIgnoreCase(pilotes.get(0).getNumeroLicense())) {
                    l_dpPilote.add(pilotes.get(0));
                }
                // Inscription du DP et Pilote
                for (Adherent adh : l_dpPilote) {
                    try {
                        ResaSession.get().getPlongeeService().inscrireAdherent(plongee, adh,
                                PlongeeMail.PAS_DE_MAIL);
                    } catch (ResaException e) {
                        e.printStackTrace();
                        ErrorPage ep = new ErrorPage(e);
                        setResponsePage(ep);
                    }
                }
                PageParameters param = new PageParameters();
                param.put("plongeeAOuvrir", plongee);
                param.put("inscrits", l_dpPilote);
                setResponsePage(new ListeInscritsPlongeePage(plongee));
            }
        }//fin du onSubmit()

        @Override
        protected void onError(AjaxRequestTarget target, Form<?> form) {
            target.addComponent(feedback);
        }
    };
    form.add(new Link("cancel") {
        @Override
        public void onClick() {
            setResponsePage(GererPlongeeAOuvrirOne.class);
        }
    });
    //add(new Button("cancel", new ResourceModel("button.cancel")));

    form.add(b_valider);

    add(form);
}

From source file:com.gitblit.wicket.pages.EditRepositoryPage.java

License:Apache License

protected void setupPage(RepositoryModel model) {
    this.repositoryModel = model;

    // ensure this user can create or edit this repository
    checkPermissions(repositoryModel);/*from  www  .jav  a  2  s.c om*/

    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(app().repositories().getUserAccessPermissions(repositoryModel));
        repositoryTeams.addAll(app().repositories().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,
            app().users().getAllUsernames(), repositoryUsers, getAccessPermissions());
    final RegistrantPermissionsPanel teamsPalette = new RegistrantPermissionsPanel("teams", RegistrantType.TEAM,
            app().users().getAllTeamNames(), repositoryTeams, getAccessPermissions());

    // owners palette
    List<UserChoice> owners = new ArrayList<UserChoice>();
    List<UserChoice> persons = new ArrayList<UserChoice>();
    for (String owner : repositoryModel.owners) {
        UserModel o = app().users().getUserModel(owner);
        if (o != null) {
            owners.add(new UserChoice(o.getDisplayName(), o.username, o.emailAddress));
        } else {
            UserChoice userChoice = new UserChoice(owner);
            owners.add(userChoice);
            persons.add(userChoice);
        }
    }

    for (String person : app().users().getAllUsernames()) {
        UserModel o = app().users().getUserModel(person);
        if (o != null) {
            persons.add(new UserChoice(o.getDisplayName(), o.username, o.emailAddress));
        } else {
            persons.add(new UserChoice(person));
        }
    }
    final Palette<UserChoice> ownersPalette = new Palette<UserChoice>("owners",
            new ListModel<UserChoice>(owners), new CollectionModel<UserChoice>(persons),
            new ChoiceRenderer<UserChoice>(null, "userId"), 12, false);

    // indexed local branches palette
    List<String> allLocalBranches = new ArrayList<String>();
    allLocalBranches.add(Constants.DEFAULT_BRANCH);
    allLocalBranches.addAll(repositoryModel.getLocalBranches());
    boolean luceneEnabled = app().settings().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 = app().settings().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>(app().repositories().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>(app().repositories().getPostReceiveScriptsUnused(repositoryModel)),
            new StringChoiceRenderer(), 12, true);

    // custom fields
    final Map<String, String> customFieldsMap = app().settings().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 {
                if (!namePanel.updateModel(repositoryModel)) {
                    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)) {
                    repositoryModel.metricAuthorExclusions = new ArrayList<String>();
                } else {
                    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)) {
                    repositoryModel.mailingLists = new ArrayList<String>();
                } else {
                    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<UserChoice> owners = ownersPalette.getSelectedChoices();
                while (owners.hasNext()) {
                    repositoryModel.addOwner(owners.next().getUserId());
                }

                // 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>();
                Iterator<Component> customFieldsListViewIterator = customFieldsListView.iterator();
                while (customFieldsListViewIterator.hasNext()) {

                    ListItem<String> child = (ListItem<String>) customFieldsListViewIterator.next();
                    String key = child.getModelObject();

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

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

                // save the repository
                app().gitblit().updateRepositoryModel(oldName, repositoryModel, isCreate);

                // repository access permissions
                if (repositoryModel.accessRestriction.exceeds(AccessRestrictionType.NONE)) {
                    app().gitblit().setUserAccessPermissions(repositoryModel, repositoryUsers);
                    app().gitblit().setTeamAccessPermissions(repositoryModel, repositoryTeams);
                }
            } catch (GitBlitException e) {
                error(e.getMessage());
                return;
            }
            setResponsePage(SummaryPage.class, WicketUtils.newRepositoryParameter(repositoryModel.name));
        }
    };

    // Determine available refs & branches
    List<String> availableRefs = new ArrayList<String>();
    List<String> availableBranches = new ArrayList<String>();
    if (!ArrayUtils.isEmpty(repositoryModel.availableRefs)) {
        for (String ref : repositoryModel.availableRefs) {
            if (!ref.startsWith(Constants.R_TICKET)) {
                availableRefs.add(ref);
                if (ref.startsWith(Constants.R_HEADS)) {
                    availableBranches.add(Repository.shortenRefName(ref));
                }
            }
        }
    }

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

    //
    //
    // GENERAL
    //
    namePanel = new RepositoryNamePanel("namePanel", repositoryModel);
    namePanel.setEditable(allowEditName);
    form.add(namePanel);

    // XXX AccessPolicyPanel is defined later.

    form.add(new ChoiceOption<String>("head", getString("gb.headRef"), getString("gb.headRefDescription"),
            new PropertyModel<String>(repositoryModel, "HEAD"), availableRefs));

    //
    // PERMISSIONS
    //
    form.add(ownersPalette);
    form.add(usersPalette);
    form.add(teamsPalette);

    //
    // TICKETS
    //
    form.add(new BooleanOption("acceptNewPatchsets", getString("gb.acceptNewPatchsets"),
            getString("gb.acceptNewPatchsetsDescription"),
            new PropertyModel<Boolean>(repositoryModel, "acceptNewPatchsets")));

    form.add(new BooleanOption("acceptNewTickets", getString("gb.acceptNewTickets"),
            getString("gb.acceptNewTicketsDescription"),
            new PropertyModel<Boolean>(repositoryModel, "acceptNewTickets")));

    form.add(new BooleanOption("requireApproval", getString("gb.requireApproval"),
            getString("gb.requireApprovalDescription"),
            new PropertyModel<Boolean>(repositoryModel, "requireApproval")));

    form.add(new ChoiceOption<String>("mergeTo", getString("gb.mergeTo"), getString("gb.mergeToDescription"),
            new PropertyModel<String>(repositoryModel, "mergeTo"), availableBranches));
    form.add(new ChoiceOption<MergeType>("mergeType", getString("gb.mergeType"),
            getString("gb.mergeTypeDescription"), new PropertyModel<MergeType>(repositoryModel, "mergeType"),
            Arrays.asList(MergeType.values())));

    //
    // RECEIVE
    //
    form.add(new BooleanOption("isFrozen", getString("gb.isFrozen"), getString("gb.isFrozenDescription"),
            new PropertyModel<Boolean>(repositoryModel, "isFrozen")));

    form.add(new BooleanOption("incrementalPushTags", getString("gb.enableIncrementalPushTags"),
            getString("gb.useIncrementalPushTagsDescription"),
            new PropertyModel<Boolean>(repositoryModel, "useIncrementalPushTags")));

    final CheckBox verifyCommitter = new CheckBox("checkbox",
            new PropertyModel<Boolean>(repositoryModel, "verifyCommitter"));
    verifyCommitter.setOutputMarkupId(true);
    form.add(new BooleanOption("verifyCommitter", getString("gb.verifyCommitter"),
            getString("gb.verifyCommitterDescription") + "<br/>" + getString("gb.verifyCommitterNote"),
            verifyCommitter).setIsHtmlDescription(true));

    form.add(preReceivePalette);
    form.add(new BulletListPanel("inheritedPreReceive", getString("gb.inherited"),
            app().repositories().getPreReceiveScriptsInherited(repositoryModel)));
    form.add(postReceivePalette);
    form.add(new BulletListPanel("inheritedPostReceive", getString("gb.inherited"),
            app().repositories().getPostReceiveScriptsInherited(repositoryModel)));

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

    //
    // FEDERATION
    //
    List<FederationStrategy> federationStrategies = new ArrayList<FederationStrategy>(
            Arrays.asList(FederationStrategy.values()));
    // federation strategies - remove ORIGIN choice if this repository has no origin.
    if (StringUtils.isEmpty(repositoryModel.origin)) {
        federationStrategies.remove(FederationStrategy.FEDERATE_ORIGIN);
    }

    form.add(new ChoiceOption<FederationStrategy>("federationStrategy", getString("gb.federationStrategy"),
            getString("gb.federationStrategyDescription"),
            new DropDownChoice<FederationStrategy>("choice",
                    new PropertyModel<FederationStrategy>(repositoryModel, "federationStrategy"),
                    federationStrategies, new FederationTypeRenderer())));

    form.add(federationSetsPalette);

    //
    // SEARCH
    //
    form.add(indexedBranchesPalette);

    //
    // GARBAGE COLLECTION
    //
    boolean gcEnabled = app().settings().getBoolean(Keys.git.enableGarbageCollection, false);
    int defaultGcPeriod = app().settings().getInteger(Keys.git.defaultGarbageCollectionPeriod, 7);
    if (repositoryModel.gcPeriod == 0) {
        repositoryModel.gcPeriod = defaultGcPeriod;
    }
    List<Integer> gcPeriods = Arrays.asList(1, 2, 3, 4, 5, 7, 10, 14);
    form.add(new ChoiceOption<Integer>("gcPeriod", getString("gb.gcPeriod"),
            getString("gb.gcPeriodDescription"), new DropDownChoice<Integer>("choice",
                    new PropertyModel<Integer>(repositoryModel, "gcPeriod"), gcPeriods, new GCPeriodRenderer()))
                            .setEnabled(gcEnabled));

    form.add(new TextOption("gcThreshold", getString("gb.gcThreshold"), getString("gb.gcThresholdDescription"),
            "span1", new PropertyModel<String>(repositoryModel, "gcThreshold")).setEnabled(gcEnabled));

    //
    // MISCELLANEOUS
    //

    form.add(new TextOption("origin", getString("gb.origin"), getString("gb.originDescription"), "span6",
            new PropertyModel<String>(repositoryModel, "origin")).setEnabled(false));

    form.add(new BooleanOption("showRemoteBranches", getString("gb.showRemoteBranches"),
            getString("gb.showRemoteBranchesDescription"),
            new PropertyModel<Boolean>(repositoryModel, "showRemoteBranches")));

    form.add(new BooleanOption("skipSizeCalculation", getString("gb.skipSizeCalculation"),
            getString("gb.skipSizeCalculationDescription"),
            new PropertyModel<Boolean>(repositoryModel, "skipSizeCalculation")));

    form.add(new BooleanOption("skipSummaryMetrics", getString("gb.skipSummaryMetrics"),
            getString("gb.skipSummaryMetricsDescription"),
            new PropertyModel<Boolean>(repositoryModel, "skipSummaryMetrics")));

    List<Integer> maxActivityCommits = Arrays.asList(-1, 0, 25, 50, 75, 100, 150, 200, 250, 500);
    form.add(new ChoiceOption<Integer>("maxActivityCommits", getString("gb.maxActivityCommits"),
            getString("gb.maxActivityCommitsDescription"),
            new DropDownChoice<Integer>("choice",
                    new PropertyModel<Integer>(repositoryModel, "maxActivityCommits"), maxActivityCommits,
                    new MaxActivityCommitsRenderer())));

    List<CommitMessageRenderer> renderers = Arrays.asList(CommitMessageRenderer.values());
    form.add(new ChoiceOption<CommitMessageRenderer>("commitMessageRenderer",
            getString("gb.commitMessageRenderer"), getString("gb.commitMessageRendererDescription"),
            new DropDownChoice<CommitMessageRenderer>("choice",
                    new PropertyModel<CommitMessageRenderer>(repositoryModel, "commitMessageRenderer"),
                    renderers)));

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

    form.add(new TextOption("metricAuthorExclusions", getString("gb.metricAuthorExclusions"),
            getString("gb.metricAuthorExclusions"), "span6", metricAuthorExclusions));

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

    form.add(new TextOption("mailingLists", getString("gb.mailingLists"), getString("gb.mailingLists"), "span6",
            mailingLists));

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

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

    //
    // ACCESS POLICY PANEL (GENERAL)
    //
    AjaxFormChoiceComponentUpdatingBehavior callback = new AjaxFormChoiceComponentUpdatingBehavior() {

        private static final long serialVersionUID = 1L;

        @Override
        protected void onUpdate(AjaxRequestTarget target) {
            accessPolicyPanel.updateModel(repositoryModel);

            boolean allowAuthorizationControl = repositoryModel.accessRestriction
                    .exceeds(AccessRestrictionType.NONE);
            verifyCommitter.setEnabled(allowAuthorizationControl);

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

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

            target.add(verifyCommitter);
            target.add(usersPalette);
            target.add(teamsPalette);
        }
    };

    accessPolicyPanel = new AccessPolicyPanel("accessPolicyPanel", repositoryModel, callback);
    form.add(accessPolicyPanel);

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

        @Override
        public void onSubmit() {
            if (isCreate) {
                setResponsePage(RepositoriesPage.class);
            } else {
                setResponsePage(SummaryPage.class, WicketUtils.newRepositoryParameter(repositoryModel.name));
            }
        }
    };
    cancel.setDefaultFormProcessing(false);
    form.add(cancel);

    // the user can delete if deletions are allowed AND the user is an admin or the personal owner
    // assigned ownership is not sufficient to allow deletion
    boolean canDelete = !isCreate && app().repositories().canDelete(repositoryModel)
            && (user.canAdmin() || user.isMyPersonalRepository(repositoryModel.name));

    Link<Void> delete = new Link<Void>("delete") {

        private static final long serialVersionUID = 1L;

        @Override
        public void onClick() {
            RepositoryModel latestModel = app().repositories().getRepositoryModel(repositoryModel.name);
            boolean canDelete = app().repositories().canDelete(latestModel);
            if (canDelete) {
                if (app().gitblit().deleteRepositoryModel(latestModel)) {
                    info(MessageFormat.format(getString("gb.repositoryDeleted"), latestModel));
                    if (latestModel.isPersonalRepository()) {
                        // redirect to user's profile page
                        String prefix = app().settings().getString(Keys.git.userRepositoryPrefix, "~");
                        String username = latestModel.projectPath.substring(prefix.length());
                        setResponsePage(UserPage.class, WicketUtils.newUsernameParameter(username));
                    } else {
                        // redirect to server repositories page
                        setResponsePage(RepositoriesPage.class);
                    }
                } else {
                    error(MessageFormat.format(getString("gb.repositoryDeleteFailed"), latestModel));
                }
            } else {
                error(MessageFormat.format(getString("gb.repositoryDeleteFailed"), latestModel));
            }
        }
    };

    if (canDelete) {
        delete.add(new JavascriptEventConfirmation("click",
                MessageFormat.format(getString("gb.deleteRepository"), repositoryModel)));
    }
    form.add(delete.setVisible(canDelete));

    add(form);
}

From source file:com.gitblit.wicket.pages.EditTeamPage.java

License:Apache License

protected void setupPage(final TeamModel teamModel) {
    if (isCreate) {
        super.setupPage(getString("gb.newTeam"), "");
    } else {// w  w w  .  j  ava  2s .  co  m
        super.setupPage(getString("gb.edit"), teamModel.name);
    }

    CompoundPropertyModel<TeamModel> model = new CompoundPropertyModel<TeamModel>(teamModel);

    List<String> repos = getAccessRestrictedRepositoryList(true, null);

    List<String> teamUsers = new ArrayList<String>(teamModel.users);
    List<String> preReceiveScripts = new ArrayList<String>();
    List<String> postReceiveScripts = new ArrayList<String>();

    final String oldName = teamModel.name;
    final List<RegistrantAccessPermission> permissions = teamModel.getRepositoryPermissions();

    // users palette
    final Palette<UserChoice> users = new Palette<UserChoice>("users",
            new ListModel<UserChoice>(getTeamUsers(teamUsers)),
            new CollectionModel<UserChoice>(sortByDisplayName(getTeamUsers(app().users().getAllUsernames()))),
            new ChoiceRenderer<UserChoice>(null, "userId"), 10, false);

    // pre-receive palette
    if (teamModel.preReceiveScripts != null) {
        preReceiveScripts.addAll(teamModel.preReceiveScripts);
    }
    final Palette<String> preReceivePalette = new Palette<String>("preReceiveScripts",
            new ListModel<String>(preReceiveScripts),
            new CollectionModel<String>(app().repositories().getPreReceiveScriptsUnused(null)),
            new StringChoiceRenderer(), 12, true);

    // post-receive palette
    if (teamModel.postReceiveScripts != null) {
        postReceiveScripts.addAll(teamModel.postReceiveScripts);
    }
    final Palette<String> postReceivePalette = new Palette<String>("postReceiveScripts",
            new ListModel<String>(postReceiveScripts),
            new CollectionModel<String>(app().repositories().getPostReceiveScriptsUnused(null)),
            new StringChoiceRenderer(), 12, true);

    Form<TeamModel> form = new Form<TeamModel>("editForm", model) {

        private static final long serialVersionUID = 1L;

        /*
         * (non-Javadoc)
         *
         * @see org.apache.wicket.markup.html.form.Form#onSubmit()
         */
        @Override
        protected void onSubmit() {
            String teamname = teamModel.name;
            if (StringUtils.isEmpty(teamname)) {
                error(getString("gb.pleaseSetTeamName"));
                return;
            }
            if (isCreate) {
                TeamModel model = app().users().getTeamModel(teamname);
                if (model != null) {
                    error(MessageFormat.format(getString("gb.teamNameUnavailable"), teamname));
                    return;
                }
            }
            // update team permissions
            for (RegistrantAccessPermission repositoryPermission : permissions) {
                teamModel.setRepositoryPermission(repositoryPermission.registrant,
                        repositoryPermission.permission);
            }

            Iterator<UserChoice> selectedUsers = users.getSelectedChoices();
            List<String> members = new ArrayList<String>();
            while (selectedUsers.hasNext()) {
                members.add(selectedUsers.next().getUserId().toLowerCase());
            }
            teamModel.users.clear();
            teamModel.users.addAll(members);

            // 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());
                }
                teamModel.mailingLists.clear();
                teamModel.mailingLists.addAll(list);
            }

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

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

            try {
                if (isCreate) {
                    app().gitblit().addTeam(teamModel);
                } else {
                    app().gitblit().reviseTeam(oldName, teamModel);
                }
            } catch (GitBlitException e) {
                error(e.getMessage());
                return;
            }
            if (isCreate) {
                // create another team
                info(MessageFormat.format(getString("gb.teamCreated"), teamModel.name));
            }
            // back to users page
            setResponsePage(TeamsPage.class);
        }
    };

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

    // not all user providers support manipulating team memberships
    boolean editMemberships = app().authentication().supportsTeamMembershipChanges(teamModel);

    // not all user providers support manipulating the admin role
    boolean changeAdminRole = app().authentication().supportsRoleChanges(teamModel, Role.ADMIN);

    // not all user providers support manipulating the create role
    boolean changeCreateRole = app().authentication().supportsRoleChanges(teamModel, Role.CREATE);

    // not all user providers support manipulating the fork role
    boolean changeForkRole = app().authentication().supportsRoleChanges(teamModel, Role.FORK);

    // field names reflective match TeamModel fields
    form.add(new TextField<String>("name"));
    form.add(new CheckBox("canAdmin").setEnabled(changeAdminRole));
    form.add(new CheckBox("canFork")
            .setEnabled(app().settings().getBoolean(Keys.web.allowForking, true) && changeForkRole));
    form.add(new CheckBox("canCreate").setEnabled(changeCreateRole));
    form.add(users.setEnabled(editMemberships));
    mailingLists = new Model<String>(
            teamModel.mailingLists == null ? "" : StringUtils.flattenStrings(teamModel.mailingLists, " "));
    form.add(new TextField<String>("mailingLists", mailingLists));

    form.add(new RegistrantPermissionsPanel("repositories", RegistrantType.REPOSITORY, repos, permissions,
            getAccessPermissions()));
    form.add(preReceivePalette);
    form.add(new BulletListPanel("inheritedPreReceive", "inherited",
            app().repositories().getPreReceiveScriptsInherited(null)));
    form.add(postReceivePalette);
    form.add(new BulletListPanel("inheritedPostReceive", "inherited",
            app().repositories().getPostReceiveScriptsInherited(null)));

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

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

    add(form);
}

From source file:com.gitblit.wicket.pages.EditUserPage.java

License:Apache License

protected void setupPage(final UserModel userModel) {
    if (isCreate) {
        super.setupPage(getString("gb.newUser"), "");
    } else {/*from w  w  w  .j  a  v a2s  .  c  o  m*/
        super.setupPage(getString("gb.edit"), userModel.username);
    }

    final Model<String> confirmPassword = new Model<String>(
            StringUtils.isEmpty(userModel.password) ? "" : userModel.password);
    CompoundPropertyModel<UserModel> model = new CompoundPropertyModel<UserModel>(userModel);

    // build list of projects including all repositories wildcards
    List<String> repos = getAccessRestrictedRepositoryList(true, userModel);

    List<String> userTeams = new ArrayList<String>();
    for (TeamModel team : userModel.teams) {
        userTeams.add(team.name);
    }
    Collections.sort(userTeams);

    final String oldName = userModel.username;
    final List<RegistrantAccessPermission> permissions = app().repositories()
            .getUserAccessPermissions(userModel);

    final Palette<String> teams = new Palette<String>("teams",
            new ListModel<String>(new ArrayList<String>(userTeams)),
            new CollectionModel<String>(app().users().getAllTeamNames()), new StringChoiceRenderer(), 10,
            false);
    Locale locale = userModel.getPreferences().getLocale();
    if (locale == null) {
        locale = Locale.ENGLISH;
    }

    List<Language> languages = UserPage.getLanguages();
    Language preferredLanguage = null;
    if (locale != null) {
        String localeCode = locale.getLanguage();
        if (!StringUtils.isEmpty(locale.getCountry())) {
            localeCode += "_" + locale.getCountry();
        }

        for (Language lang : languages) {
            if (lang.code.equals(localeCode)) {
                // language_COUNTRY match
                preferredLanguage = lang;
            } else if (preferredLanguage != null && lang.code.startsWith(locale.getLanguage())) {
                // language match
                preferredLanguage = lang;
            }
        }
    }
    final IModel<Language> language = Model.of(preferredLanguage);
    Form<UserModel> form = new Form<UserModel>("editForm", model) {

        private static final long serialVersionUID = 1L;

        /*
         * (non-Javadoc)
         *
         * @see org.apache.wicket.markup.html.form.Form#onSubmit()
         */
        @Override
        protected void onSubmit() {
            if (StringUtils.isEmpty(userModel.username)) {
                error(getString("gb.pleaseSetUsername"));
                return;
            }
            Language lang = language.getObject();
            if (lang != null) {
                userModel.getPreferences().setLocale(lang.code);
            }
            // force username to lower-case
            userModel.username = userModel.username.toLowerCase();
            String username = userModel.username;
            if (isCreate) {
                UserModel model = app().users().getUserModel(username);
                if (model != null) {
                    error(MessageFormat.format(getString("gb.usernameUnavailable"), username));
                    return;
                }
            }
            boolean rename = !StringUtils.isEmpty(oldName) && !oldName.equalsIgnoreCase(username);
            if (app().authentication().supportsCredentialChanges(userModel)) {
                if (!userModel.password.equals(confirmPassword.getObject())) {
                    error(getString("gb.passwordsDoNotMatch"));
                    return;
                }
                String password = userModel.password;
                if (!password.toUpperCase().startsWith(StringUtils.MD5_TYPE)
                        && !password.toUpperCase().startsWith(StringUtils.COMBINED_MD5_TYPE)) {
                    // This is a plain text password.
                    // Check length.
                    int minLength = app().settings().getInteger(Keys.realm.minPasswordLength, 5);
                    if (minLength < 4) {
                        minLength = 4;
                    }
                    if (password.trim().length() < minLength) {
                        error(MessageFormat.format(getString("gb.passwordTooShort"), minLength));
                        return;
                    }

                    // change the cookie
                    userModel.cookie = userModel.createCookie();

                    // Optionally store the password MD5 digest.
                    String type = app().settings().getString(Keys.realm.passwordStorage, "md5");
                    if (type.equalsIgnoreCase("md5")) {
                        // store MD5 digest of password
                        userModel.password = StringUtils.MD5_TYPE + StringUtils.getMD5(userModel.password);
                    } else if (type.equalsIgnoreCase("combined-md5")) {
                        // store MD5 digest of username+password
                        userModel.password = StringUtils.COMBINED_MD5_TYPE
                                + StringUtils.getMD5(username + userModel.password);
                    }
                } else if (rename && password.toUpperCase().startsWith(StringUtils.COMBINED_MD5_TYPE)) {
                    error(getString("gb.combinedMd5Rename"));
                    return;
                }
            }

            // update user permissions
            for (RegistrantAccessPermission repositoryPermission : permissions) {
                if (repositoryPermission.mutable) {
                    userModel.setRepositoryPermission(repositoryPermission.registrant,
                            repositoryPermission.permission);
                }
            }

            Iterator<String> selectedTeams = teams.getSelectedChoices();
            userModel.teams.clear();
            while (selectedTeams.hasNext()) {
                TeamModel team = app().users().getTeamModel(selectedTeams.next());
                if (team == null) {
                    continue;
                }
                userModel.teams.add(team);
            }

            try {
                if (isCreate) {
                    app().gitblit().addUser(userModel);
                } else {
                    app().gitblit().reviseUser(oldName, userModel);
                }
            } catch (GitBlitException e) {
                error(e.getMessage());
                return;
            }
            if (isCreate) {
                // create another user
                info(MessageFormat.format(getString("gb.userCreated"), userModel.username));
                setResponsePage(EditUserPage.class);
            } else {
                // back to users page
                setResponsePage(UsersPage.class);
            }
        }
    };

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

    // not all user providers support manipulating username and password
    boolean editCredentials = app().authentication().supportsCredentialChanges(userModel);

    // not all user providers support manipulating display name
    boolean editDisplayName = app().authentication().supportsDisplayNameChanges(userModel);

    // not all user providers support manipulating email address
    boolean editEmailAddress = app().authentication().supportsEmailAddressChanges(userModel);

    // not all user providers support manipulating team memberships
    boolean editTeams = app().authentication().supportsTeamMembershipChanges(userModel);

    // not all user providers support manipulating the admin role
    boolean changeAdminRole = app().authentication().supportsRoleChanges(userModel, Role.ADMIN);

    // not all user providers support manipulating the create role
    boolean changeCreateRole = app().authentication().supportsRoleChanges(userModel, Role.CREATE);

    // not all user providers support manipulating the fork role
    boolean changeForkRole = app().authentication().supportsRoleChanges(userModel, Role.FORK);

    // field names reflective match UserModel fields
    form.add(new TextField<String>("username").setEnabled(editCredentials));
    NonTrimmedPasswordTextField passwordField = new NonTrimmedPasswordTextField("password");
    passwordField.setResetPassword(false);
    form.add(passwordField.setEnabled(editCredentials));
    NonTrimmedPasswordTextField confirmPasswordField = new NonTrimmedPasswordTextField("confirmPassword",
            confirmPassword);
    confirmPasswordField.setResetPassword(false);
    form.add(confirmPasswordField.setEnabled(editCredentials));
    form.add(new TextField<String>("displayName").setEnabled(editDisplayName));
    form.add(new TextField<String>("emailAddress").setEnabled(editEmailAddress));

    DropDownChoice<Language> choice = new DropDownChoice<Language>("language", language, languages);
    form.add(choice.setEnabled(languages.size() > 0));
    if (userModel.canAdmin() && !userModel.canAdmin) {
        // user inherits Admin permission
        // display a disabled-yet-checked checkbox
        form.add(new CheckBox("canAdmin", Model.of(true)).setEnabled(false));
    } else {
        form.add(new CheckBox("canAdmin").setEnabled(changeAdminRole));
    }

    if (userModel.canFork() && !userModel.canFork) {
        // user inherits Fork permission
        // display a disabled-yet-checked checkbox
        form.add(new CheckBox("canFork", Model.of(true)).setEnabled(false));
    } else {
        final boolean forkingAllowed = app().settings().getBoolean(Keys.web.allowForking, true);
        form.add(new CheckBox("canFork").setEnabled(forkingAllowed && changeForkRole));
    }

    if (userModel.canCreate() && !userModel.canCreate) {
        // user inherits Create permission
        // display a disabled-yet-checked checkbox
        form.add(new CheckBox("canCreate", Model.of(true)).setEnabled(false));
    } else {
        form.add(new CheckBox("canCreate").setEnabled(changeCreateRole));
    }

    form.add(new CheckBox("excludeFromFederation"));
    form.add(new CheckBox("disabled"));

    form.add(new RegistrantPermissionsPanel("repositories", RegistrantType.REPOSITORY, repos, permissions,
            getAccessPermissions()));
    form.add(teams.setEnabled(editTeams));

    form.add(new TextField<String>("organizationalUnit").setEnabled(editDisplayName));
    form.add(new TextField<String>("organization").setEnabled(editDisplayName));
    form.add(new TextField<String>("locality").setEnabled(editDisplayName));
    form.add(new TextField<String>("stateProvince").setEnabled(editDisplayName));
    form.add(new TextField<String>("countryCode").setEnabled(editDisplayName));
    form.add(new Button("save"));
    Button cancel = new Button("cancel") {
        private static final long serialVersionUID = 1L;

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

    add(form);
}

From source file:nl.mpi.lamus.web.components.WsNodeActionsPanelTest.java

License:Open Source License

@Override
protected void setUpTest() throws Exception {

    MockitoAnnotations.initMocks(this);

    expectedActionsList.add(mockDeleteAction);
    expectedActionsList.add(mockUnlinkAction);
    expectedActionsList.add(mockLinkAction);
    expectedActionsList.add(mockReplaceAction);

    when(mockTreeNodeActionsProviderBean.getActions(selectedNodes)).thenReturn(expectedActionsList);

    when(mockDeleteAction.getName()).thenReturn("delete_node_action");
    when(mockUnlinkAction.getName()).thenReturn("unlink_node_action");
    when(mockLinkAction.getName()).thenReturn("link_node_action");
    when(mockLinkAsInfoAction.getName()).thenReturn("link_node_info_action");
    when(mockReplaceAction.getName()).thenReturn("replace_node_action");

    addMock(AbstractLamusWicketTest.BEAN_NAME_WORKSPACE_TREE_SERVICE, mockWorkspaceServiceBean);
    addMock(AbstractLamusWicketTest.BEAN_NAME_WORKSPACE_DAO, mockWorkspaceDao);
    addMock(AbstractLamusWicketTest.BEAN_NAME_TREE_NODE_ACTIONS_PROVIDER, mockTreeNodeActionsProviderBean);
    addMock(AbstractLamusWicketTest.BEAN_NAME_NODE_UTIL, mockNodeUtil);
    addMock(AbstractLamusWicketTest.BEAN_NAME_UNLINKED_NODES_MODEL_PROVIDER_FACTORY,
            mockUnlinkedNodesProviderFactory);

    feedbackPanel = new FeedbackPanel("feedbackPanel") {
        {/*from ww w  .j a  v a 2s.  co  m*/
            setOutputMarkupId(true);
        }
    };

    treeNodeActionsPanel = new WsNodeActionsPanel("wsNodeActionsPanel", new CollectionModel<>(selectedNodes),
            feedbackPanel) {

        @Override
        public void refreshTreeAndPanels() {
            refreshStuffCalled = true;
        }
    };
    getTester().startComponentInPage(treeNodeActionsPanel);
}

From source file:nl.mpi.lamus.web.pages.WorkspacePage.java

License:Open Source License

public WorkspacePage(final IModel<Workspace> model) {
    super();/*  w  ww  .  ja va 2 s.  co m*/
    this.model = model;

    wsTreePanel = createWorkspaceTreePanel("workspaceTree");
    wsTreePanel.setOutputMarkupId(true);
    add(wsTreePanel);
    add(new ButtonPanel("buttonPanel", model, getFeedbackPanel()));

    wsNodeActionsPanel = new WsNodeActionsPanel("wsNodeActionsPanel",
            new CollectionModel<WorkspaceTreeNode>(wsTreePanel.getSelectedNodes()), getFeedbackPanel()) {
        @Override
        public void refreshTreeAndPanels() {
            WorkspacePage.this.refreshTreeAndPanels();
        }

        @Override
        public void refreshSelectedUnlinkedNodes() {
            WorkspacePage.this.refreshSelectedUnlinkedNodes();
        }
    };

    wsNodeActionsPanel.setOutputMarkupId(true);
    add(wsNodeActionsPanel);

    List<AbstractTab> tabs = new ArrayList<>();
    tabs.add(new AbstractTab(new Model<>(getLocalizer().getString("workspace_info_tab_panel", this))) {
        @Override
        public WebMarkupContainer getPanel(String panelId) {
            if (wsInfoPanel == null) {
                wsInfoPanel = new WorkspaceInfoPanel(panelId, model);
                wsInfoPanel.setOutputMarkupId(true);
            }
            return wsInfoPanel;
        }
    });
    tabs.add(new AbstractTab(new Model<>(getLocalizer().getString("link_nodes_tab_panel", this))) {
        @Override
        public WebMarkupContainer getPanel(String panelId) {
            return createLinkNodesPanel(panelId);
        }
    });
    tabs.add(new AbstractTab(new Model<>(getLocalizer().getString("upload_files_tab_panel", this))) {
        @Override
        public WebMarkupContainer getPanel(String panelId) {
            return new UploadPanel(panelId, model, getFeedbackPanel());
        }
    });
    AjaxTabbedPanel tabbedPanel = new AjaxTabbedPanel("workspaceTabs", tabs);
    tabbedPanel.setOutputMarkupId(true);
    add(tabbedPanel);
}

From source file:nl.mpi.lamus.web.pages.WorkspacePage.java

License:Open Source License

/**
 * Creates and adds an tree panel to be display in the opened/created workspace
 *
 * @param id/*  w w w.  jav a  2s .co  m*/
 * @return ArchiveTreePanel
 */
private ArchiveTreePanel createWorkspaceTreePanel(String id) {
    WorkspaceTreeNode rootNode = null;
    try {
        rootNode = this.workspaceTreeService.getTreeNode(this.model.getObject().getTopNodeID(), null);
    } catch (WorkspaceNodeNotFoundException ex) {
        Session.get().error(ex.getMessage());
    }
    workspaceTreeProvider = this.workspaceTreeProviderFactory.createTreeModelProvider(rootNode);

    ArchiveTreePanel treePanel = new ArchiveTreePanel(id, workspaceTreeProvider, treeIconProvider);

    treePanel.addArchiveTreePanelListener(new ArchiveTreePanelListener() {
        @Override
        public void nodeSelectionChanged(AjaxRequestTarget target, ArchiveTreePanel treePanel) {

            WorkspaceTreeNode selectedNode = getSelectedNode(treePanel);
            IModel<WorkspaceTreeNode> nodeInfoModel = getSelectedNodesModel(selectedNode);

            if (wsInfoPanel != null) {
                wsInfoPanel.setNodeInfoPanelModel(nodeInfoModel);
            }

            wsNodeActionsPanel.setSelectedUnlinkedNodes(selectedUnlinkedNodes);
            wsNodeActionsPanel.setModel(new CollectionModel<WorkspaceTreeNode>(wsTreePanel.getSelectedNodes()));

            if (linkNodesPanel != null) {

                if (selectedNode != null) {
                    linkNodesPanel.setModel(Model.of(selectedNode));
                } else {
                    if (linkNodesPanel.getModel() == null) {
                        linkNodesPanel.setModel(new Model<WorkspaceTreeNode>());
                    } else {
                        linkNodesPanel.setModelObject(null);
                    }
                }
            }

            if (target != null) {

                if (wsInfoPanel != null) {
                    target.add(wsInfoPanel.getNodeInfoPanel());
                }

                target.add(wsNodeActionsPanel);

                send(wsNodeActionsPanel, Broadcast.BREADTH, selectedUnlinkedNodes);

                if (linkNodesPanel != null) {
                    target.add(linkNodesPanel);
                }
            }
        }
    });
    treePanel.setLinkType(LinkType.AJAX_FALLBACK);
    return treePanel;
}

From source file:nl.verheulconsultants.monitorisp.service.ISPController.java

License:Open Source License

/**
 * Default initialization. Three known hosts to check connections. One dummy host is added to the choices to test failed connections.
 *//*from  w w  w.  j av a2  s .  c om*/
public void initWithDefaults() {
    HOSTS.clear();
    HOSTS.add(new Host("0", "willfailconnection.com"));
    Host uva = new Host("1", "uva.nl");
    HOSTS.add(uva);
    Host xs4all = new Host("2", "xs4all.nl");
    HOSTS.add(xs4all);
    Host vu = new Host("3", "vu.nl");
    HOSTS.add(vu);
    sessionData.paletteModel = new CollectionModel<>(HOSTS);

    sessionData.selected.clear();
    sessionData.selected.add(uva);
    sessionData.selected.add(xs4all);
    sessionData.selected.add(vu);
    selectedModel = new ListModel<>(sessionData.selected);
}

From source file:org.geoserver.w3ds.web.X3DLayerConfigPanel.java

License:GNU General Public License

@SuppressWarnings({ "rawtypes", "unchecked" })
private void initTileSets(IModel model) throws IOException, ParserConfigurationException, SAXException {
    PropertyModel propertyModel = new PropertyModel(model, "resource.metadata");
    tileSets = new DropDownChoice("tileSets", new MapModel(propertyModel, "x3d.tileSet"),
            new CollectionModel<String>(getTileSets()));
    add(tileSets);/*w w w.j a v  a 2  s.  c o  m*/
}