Example usage for org.apache.wicket.markup.html.link Link setVisible

List of usage examples for org.apache.wicket.markup.html.link Link setVisible

Introduction

In this page you can find the example usage for org.apache.wicket.markup.html.link Link setVisible.

Prototype

public final Component setVisible(final boolean visible) 

Source Link

Document

Sets whether this component and any children are visible.

Usage

From source file:abid.password.wicket.pages.BasePage.java

License:Apache License

public BasePage() {
    ErrorInfoFeedbackPanel feedbackPanel = new ErrorInfoFeedbackPanel("feedbackPanel");
    add(feedbackPanel);//from  www.  jav a  2s . c o  m

    Link<String> usersLink = new BookmarkablePageLink<String>("usersLink", UsersPage.class);
    usersLink.setVisible(MutablePasswordSession.get().isSignedIn());
    add(usersLink);

    Link<String> createUserLink = new BookmarkablePageLink<String>("createUserLink", CreateUserPage.class);
    createUserLink.setVisible(MutablePasswordSession.get().isSignedIn());
    add(createUserLink);

    Link<String> logoutLink = new BookmarkablePageLink<String>("logoutLink", LogoutPage.class);
    logoutLink.setVisible(MutablePasswordSession.get().isSignedIn());
    add(logoutLink);
}

From source file:ca.travelagency.salesreports.SalesSummaryPanel.java

License:Apache License

public SalesSummaryPanel(String id, SalesSearch salesSearch) {
    super(id, new CompoundPropertyModel<InvoiceSales>(InvoiceSalesModel.make(salesSearch)));

    ListView<MonthlyDistribution> listView = new ListView<MonthlyDistribution>(
            InvoiceSales.Properties.monthlyDistribution.name()) {
        private static final long serialVersionUID = 1L;

        @Override/*from   ww  w .  jav a  2  s. c  om*/
        protected ListItem<MonthlyDistribution> newItem(int index, IModel<MonthlyDistribution> itemModel) {
            return new OddEvenListItem<MonthlyDistribution>(index, itemModel);
        }

        @Override
        protected void populateItem(final ListItem<MonthlyDistribution> item) {
            item.setModel(new CompoundPropertyModel<MonthlyDistribution>(item.getModelObject()));

            item.add(new Label(MonthlyDistribution.Properties.dateAsString.name()));

            Link<Void> link = new Link<Void>(LINK_TO_INVOICES) {
                private static final long serialVersionUID = 1L;

                @Override
                public void onClick() {
                    getAuthenticatedSession().clearInvoiceFilter();
                    InvoiceFilter invoiceFilter = getAuthenticatedSession().getInvoiceFilter();
                    invoiceFilter.setSystemUser(getSystemUser());
                    Date date = item.getModelObject().getDate();
                    invoiceFilter.setInvoiceDateFrom(date);
                    invoiceFilter.setInvoiceDateTo(DateUtils.addDays(DateUtils.addMonths(date, 1), -1));
                    setResponsePage(new InvoicesPage());
                }
            };
            link.add(new Label(MonthlyDistribution.Properties.count.name()));
            item.add(link);

            item.add(new Label(MonthlyDistribution.Properties.salesAmounts.name() + Condition.SEPARATOR
                    + SalesAmounts.Properties.saleAsString.name()));
            item.add(new Label(MonthlyDistribution.Properties.salesAmounts.name() + Condition.SEPARATOR
                    + SalesAmounts.Properties.costAsString.name()));
            item.add(new Label(MonthlyDistribution.Properties.salesAmounts.name() + Condition.SEPARATOR
                    + SalesAmounts.Properties.commissionAsString.name()));
            item.add(new Label(MonthlyDistribution.Properties.salesAmounts.name() + Condition.SEPARATOR
                    + SalesAmounts.Properties.commissionReceivedAsString.name()));
            item.add(new Label(MonthlyDistribution.Properties.salesAmounts.name() + Condition.SEPARATOR
                    + SalesAmounts.Properties.commissionVerifiedAsString.name()));
            item.add(new Label(MonthlyDistribution.Properties.salesAmounts.name() + Condition.SEPARATOR
                    + SalesAmounts.Properties.taxOnCommissionAsString.name()));
            item.add(new Label(MonthlyDistribution.Properties.salesAmounts.name() + Condition.SEPARATOR
                    + SalesAmounts.Properties.paidAsString.name()));
        }
    };
    add(listView);

    Link<String> downloadLink = new Link<String>(EXPORT_TO_CSV, Model.of(makeCsvOutput())) {
        private static final long serialVersionUID = 1L;

        @Override
        public void onClick() {
            StringBufferResourceStream resourceStream = new StringBufferResourceStream("text/csv");
            resourceStream.append((CharSequence) getDefaultModelObject());

            ResourceStreamRequestHandler handler = new ResourceStreamRequestHandler(resourceStream)
                    .setFileName("export.csv").setContentDisposition(ContentDisposition.ATTACHMENT);

            getRequestCycle().scheduleRequestHandlerAfterCurrent(handler);
        }
    };
    downloadLink.setVisible(!getSales().getMonthlyDistribution().isEmpty());
    add(downloadLink);
}

From source file:ch.tkuhn.nanobrowser.AgentPage.java

License:Open Source License

public AgentPage(final PageParameters parameters) {

    agent = new AgentElement(parameters.get("uri").toString());
    boolean isBot = agent.isBot();

    update();/*from   w ww  . j a va  2s  . co m*/

    add(new MenuBar("menubar"));

    WebMarkupContainer icon = new WebMarkupContainer("icon");
    if (isBot) {
        icon.add(new AttributeModifier("src", new Model<String>("icons/bot.svg")));
    }
    add(icon);

    add(new Label("title", agent.getName()));

    add(new ExternalLink("uri", agent.getURI(), agent.getTruncatedURI()));

    add(new HList("typelist", agent.getTypes(), "Types"));

    if (isBot) {
        add(new HList("commanderlist", agent.getCommanders(), "Commanders"));
    } else {
        add(new WebMarkupContainer("commanderlist"));
    }

    add(new VList("nanopublist", nanopubModel, "Nanopublications"));

    add(new Label("emptyopinions", opinionModel.getObject().isEmpty() ? "(nothing)" : ""));

    add(new ListView<Opinion>("opinions", opinionModel) {

        private static final long serialVersionUID = -4257147575068849793L;

        protected void populateItem(ListItem<Opinion> item) {
            item.add(new Label("opinion", Opinion.getVerbPhrase(item.getModelObject().getOpinionType(), true)));
            item.add(new SentenceItem("opinionsentence", item.getModelObject().getSentence()));
            item.add(new NanopubItem("opinionpub", item.getModelObject().getNanopub(),
                    ThingElement.TINY_GUI_ITEM));
        }

    });

    WebMarkupContainer aa = new WebMarkupContainer("adminactions");
    if (NanobrowserApplication.isInDevelopmentMode()) {
        Link<Object> thatsmeButton;
        aa.add(thatsmeButton = new Link<Object>("thatsme") {

            private static final long serialVersionUID = 8608371149183694875L;

            public void onClick() {
                NanobrowserSession.get().setUser(agent);
                update();
                setResponsePage(AgentPage.class, getPageParameters());
            }

        });
        thatsmeButton.setVisible(!isBot);
    } else {
        aa.add(new AttributeModifier("class", new Model<String>("hidden")));
        aa.add(new Label("thatsme", ""));
    }
    add(aa);

}

From source file:com.doculibre.constellio.wicket.components.sort.AutoHidePagingNavigator.java

License:Open Source License

protected void onBeforeRender() {
    super.onBeforeRender();

    Link firstLink = (Link) get("first");
    firstLink.setVisible(pageable.getPageCount() > 2 && pageable.getCurrentPage() > 0);

    Link prevLink = (Link) get("prev");
    prevLink.setVisible(pageable.getCurrentPage() > 0);

    Link nextLink = (Link) get("next");
    nextLink.setVisible(pageable.getCurrentPage() < pageable.getPageCount() - 1);

    Link lastLink = (Link) get("last");
    lastLink.setVisible(pageable.getPageCount() > 2 && pageable.getCurrentPage() < pageable.getPageCount() - 1);
}

From source file:com.doculibre.constellio.wicket.panels.facets.FacetPanel.java

License:Open Source License

public FacetPanel(String id, final SearchableFacet searchableFacet, final FacetsDataProvider dataProvider,
        final FacetsDataProvider notIncludedDataProvider) {
    super(id, new CompoundPropertyModel(searchableFacet));
    this.searchableFacet = searchableFacet;

    possibleValuesModel = new LoadableDetachableModel() {
        @Override/* w  w w.  ja  v  a2s. co m*/
        protected Object load() {
            SimpleSearch simpleSearch = dataProvider.getSimpleSearch();
            String collectionName = simpleSearch.getCollectionName();
            ConstellioUser user = ConstellioSession.get().getUser();
            List<FacetValue> possibleValues = new ArrayList<FacetValue>();
            List<FacetValue> includedFacetPossibleValues = SolrFacetUtils.getPossibleValues(searchableFacet,
                    dataProvider, collectionName, user);
            List<FacetValue> notIncludedFacetPossibleValues = SolrFacetUtils.getPossibleValues(searchableFacet,
                    notIncludedDataProvider, collectionName, user);
            possibleValues.addAll(includedFacetPossibleValues);
            for (FacetValue notIncludedFacetPossibleValue : notIncludedFacetPossibleValues) {
                boolean alreadyIncluded = false;
                loop2: for (FacetValue possibleValue : possibleValues) {
                    if (possibleValue.getValue().equals(notIncludedFacetPossibleValue.getValue())) {
                        alreadyIncluded = true;
                        break loop2;
                    }
                }
                if (!alreadyIncluded) {
                    possibleValues.add(notIncludedFacetPossibleValue);
                }
            }

            SearchedFacet searchedFacet = simpleSearch.getSearchedFacet(searchableFacet.getName());
            // We already applied a value for this facet
            if (searchedFacet != null) {
                List<FacetValue> deletedValues = new ArrayList<FacetValue>();
                for (FacetValue facetValue : possibleValues) {
                    if (searchedFacet.getExcludedValues().contains(facetValue.getValue())) {
                        // To avoid concurrent modifications
                        deletedValues.add(facetValue);
                    }
                }
                for (FacetValue deletedValue : deletedValues) {
                    // Will remove this value from the possible values
                    possibleValues.remove(deletedValue);
                }

                for (FacetValue facetValue : possibleValues) {
                    if (searchedFacet.getIncludedValues().contains(facetValue.getValue())) {
                        // Aura pour effet de cocher la case au chargement de la
                        // page
                        selectedValues.add(facetValue);
                    }
                }
                applySort(possibleValues, simpleSearch.getFacetSort(searchableFacet.getName()), dataProvider);
            }
            return possibleValues;
        }
    };

    facetForm = new StatelessForm("facetForm");

    List<String> sortOptions = new ArrayList<String>();
    sortOptions.add(SearchableFacet.SORT_ALPHA);
    sortOptions.add(SearchableFacet.SORT_NB_RESULTS);

    IChoiceRenderer sortChoiceRenderer = new StringResourceChoiceRenderer(this);

    sortField = new DropDownChoice("sort", new Model() {
        @Override
        public Object getObject() {
            SimpleSearch simpleSearch = dataProvider.getSimpleSearch();
            return simpleSearch.getFacetSort(searchableFacet.getName());
        }

        @Override
        public void setObject(final Object object) {
            SimpleSearch simpleSearch = dataProvider.getSimpleSearch();
            simpleSearch.setFacetSort(searchableFacet.getName(), (String) object);
            possibleValuesModel.detach();
        }
    }, sortOptions, sortChoiceRenderer);
    sortField.setVisible(!searchableFacet.isQuery() && searchableFacet.isSortable());
    sortField.add(new AjaxFormComponentUpdatingBehavior("onchange") {
        @Override
        protected void onUpdate(AjaxRequestTarget target) {
            target.addComponent(FacetPanel.this);
        }
    });

    refineButton = new Button("refineButton") {
        @Override
        public void onSubmit() {
            SimpleSearch simpleSearch = dataProvider.getSimpleSearch();
            SimpleSearch clone = simpleSearch.clone();

            for (SearchedFacet searchedFacet : clone.getSearchedFacets()) {
                if (searchedFacet.getSearchableFacet().equals(searchableFacet)) {
                    List<String> includedValuesNotAlreadySelected = new ArrayList<String>();
                    for (String includedValue : searchedFacet.getIncludedValues()) {
                        boolean includedValueSelected = false;
                        for (FacetValue selectedValue : selectedValues) {
                            if (selectedValue.getValue().equals(includedValue)) {
                                includedValueSelected = true;
                                break;
                            }
                        }
                        if (!includedValueSelected) {
                            includedValuesNotAlreadySelected.add(includedValue);
                        }
                    }
                    for (String includedValueNotAlreadySelected : includedValuesNotAlreadySelected) {
                        searchedFacet.getIncludedValues().remove(includedValueNotAlreadySelected);
                    }
                }
            }
            for (FacetValue selectedValue : selectedValues) {
                clone.addSearchedFacet(searchableFacet, selectedValue);
            }

            List<SearchedFacet> deletedSearchedFacets = new ArrayList<SearchedFacet>();
            for (SearchedFacet searchedFacet : clone.getSearchedFacets()) {
                if (searchedFacet.getIncludedValues().isEmpty()
                        && searchedFacet.getExcludedValues().isEmpty()) {
                    deletedSearchedFacets.add(searchedFacet);
                }
            }
            for (SearchedFacet deletedSearchedFacet : deletedSearchedFacets) {
                clone.getSearchedFacets().remove(deletedSearchedFacet);
            }

            // ConstellioSession.get().addSearchHistory(clone);

            clone.setPage(0);

            PageFactoryPlugin pageFactoryPlugin = PluginFactory.getPlugin(PageFactoryPlugin.class);
            setResponsePage(pageFactoryPlugin.getSearchResultsPage(), SearchResultsPage.getParameters(clone));
        }

        @Override
        public boolean isVisible() {
            return getPossibleValues().size() > 1;
        }
    };

    excludeButton = new Button("excludeButton") {
        @Override
        public void onSubmit() {
            SimpleSearch simpleSearch = dataProvider.getSimpleSearch();
            SimpleSearch clone = simpleSearch.clone();
            for (FacetValue selectedValue : selectedValues) {
                clone.excludeSearchedFacet(searchableFacet, selectedValue);
            }

            List<SearchedFacet> deletedSearchedFacets = new ArrayList<SearchedFacet>();
            for (SearchedFacet searchedFacet : clone.getSearchedFacets()) {
                if (searchedFacet.getIncludedValues().isEmpty()
                        && searchedFacet.getExcludedValues().isEmpty()) {
                    deletedSearchedFacets.add(searchedFacet);
                }
            }
            for (SearchedFacet deletedSearchedFacet : deletedSearchedFacets) {
                clone.getSearchedFacets().remove(deletedSearchedFacet);
            }

            // ConstellioSession.get().addSearchHistory(clone);

            clone.setPage(0);

            PageFactoryPlugin pageFactoryPlugin = PluginFactory.getPlugin(PageFactoryPlugin.class);
            setResponsePage(pageFactoryPlugin.getSearchResultsPage(), SearchResultsPage.getParameters(clone));
        }

        @Override
        public boolean isVisible() {
            return getPossibleValues().size() > 1 && !searchableFacet.isQuery();
        }
    };

    selectedValuesCheckGroup = new CheckGroup("selectedValuesCheckGroup", selectedValues);

    listViewContainer = new WebMarkupContainer("listViewContainer");
    listViewContainer.setOutputMarkupId(true);

    possibleValuesListView = new PageableListView("possibleValues", possibleValuesModel, Integer.MAX_VALUE) {
        @Override
        protected void populateItem(ListItem item) {
            FacetValue possibleValue = (FacetValue) item.getModelObject();
            final String value = possibleValue.getValue();
            int numFound = possibleValue.getDocCount();
            Check checkbox = checkboxes.get(value);
            if (checkbox == null) {
                checkbox = new Check("selectFacet", new Model(possibleValue)) {
                    @Override
                    public boolean isVisible() {
                        return searchableFacet.isMultiValued() && getPossibleValues().size() > 1;
                    }
                };
                checkboxes.put(value, checkbox);
            }
            item.add(checkbox);

            SimpleSearch simpleSearch = dataProvider.getSimpleSearch();
            SimpleSearch cloneAddFacet = simpleSearch.clone();
            if (searchableFacet != null && !searchableFacet.isMultiValued()) {
                cloneAddFacet.removeSearchedFacet(searchableFacet);
            }
            cloneAddFacet.addSearchedFacet(searchableFacet, possibleValue);
            cloneAddFacet.setPage(0);

            PageFactoryPlugin pageFactoryPlugin = PluginFactory.getPlugin(PageFactoryPlugin.class);
            Link addFacetLink = new BookmarkablePageLink("addFacetLink",
                    pageFactoryPlugin.getSearchResultsPage(), SearchResultsPage.getParameters(cloneAddFacet));
            item.add(addFacetLink);
            if (!searchableFacet.isMultiValued()) {
                SearchedFacet searchedFacet = simpleSearch.getSearchedFacet(searchableFacet.getName());
                if (searchedFacet != null && searchedFacet.getIncludedValues().contains(value)) {
                    item.add(new StyleClassAppender("singleValuedFacetSelected"));
                }
            }

            SimpleSearch cloneDeleteFacet = simpleSearch.clone();
            cloneDeleteFacet.excludeSearchedFacet(searchableFacet, possibleValue);
            Link deleteFacetLink = new BookmarkablePageLink("deleteFacetLink",
                    pageFactoryPlugin.getSearchResultsPage(),
                    SearchResultsPage.getParameters(cloneDeleteFacet));
            item.add(deleteFacetLink);
            SearchedFacet facet = simpleSearch.getSearchedFacet(searchableFacet.getName());

            boolean deleteFacetLinkVisible;
            FacetDisplayPlugin facetDisplayPlugin = PluginFactory.getPlugin(FacetDisplayPlugin.class);
            if (facetDisplayPlugin == null || !facetDisplayPlugin.isDisplayAllResultsLink(searchableFacet)) {
                deleteFacetLinkVisible = facet != null && !searchableFacet.isMultiValued()
                        && facet.getIncludedValues().contains(value);
            } else {
                deleteFacetLinkVisible = false;
            }
            deleteFacetLink.setVisible(deleteFacetLinkVisible);

            RecordCollectionServices collectionServices = ConstellioSpringUtils.getRecordCollectionServices();
            String collectionName = simpleSearch.getCollectionName();
            RecordCollection collection = collectionServices.get(collectionName);
            Locale displayLocale = collection.getDisplayLocale(getLocale());

            String numFoundFormatted = NumberFormatUtils.format(numFound, displayLocale);
            Label countLabel = new Label("count",
                    possibleValue.getLabel(displayLocale) + " (" + numFoundFormatted + ")");
            addFacetLink.add(countLabel);
        }
    };

    FacetDisplayPlugin facetDisplayPlugin = PluginFactory.getPlugin(FacetDisplayPlugin.class);
    if (facetDisplayPlugin == null || facetDisplayPlugin.isPageable(searchableFacet)) {
        possibleValuesListView.setRowsPerPage(10);
    }

    int currentPage = dataProvider.getSimpleSearch().getFacetPage(searchableFacet.getName());
    possibleValuesListView.setCurrentPage(currentPage);
    pagingNavigator = new ConstellioFacetsPagingNavigator("pagingNavigator", possibleValuesListView,
            dataProvider, searchableFacet.getName());

    final SimpleSearch simpleSearch = dataProvider.getSimpleSearch();
    SimpleSearch cloneAllResultsFacet = simpleSearch.clone();
    cloneAllResultsFacet.setPage(0);
    cloneAllResultsFacet.removeSearchedFacet(searchableFacet);

    PageFactoryPlugin pageFactoryPlugin = PluginFactory.getPlugin(PageFactoryPlugin.class);
    allResultsLink = new BookmarkablePageLink("allResultsLink", pageFactoryPlugin.getSearchResultsPage(),
            SearchResultsPage.getParameters(cloneAllResultsFacet)) {
        @Override
        public boolean isVisible() {
            boolean visible = super.isVisible();
            if (visible) {
                SearchedFacet searchedFacet = simpleSearch.getSearchedFacet(searchableFacet.getName());
                if (searchedFacet != null) {
                    FacetDisplayPlugin facetDisplayPlugin = PluginFactory.getPlugin(FacetDisplayPlugin.class);
                    if (facetDisplayPlugin == null
                            || !facetDisplayPlugin.isDisplayAllResultsLink(searchableFacet)) {
                        visible = false;
                    } else {
                        visible = !searchedFacet.getExcludedValues().isEmpty()
                                || !searchedFacet.getIncludedValues().isEmpty();
                    }
                }
            }
            return visible;
        }
    };

    WebMarkupContainer multiValuedFacetOptions = new WebMarkupContainer("multiValuedFacetOptions") {
        @Override
        public boolean isVisible() {
            return searchableFacet.isMultiValued();
        }
    };

    WebMarkupContainer facetHeader = new WebMarkupContainer("facetHeader") {
        @Override
        public boolean isVisible() {
            return searchableFacet.isMultiValued() || searchableFacet.isSortable();
        }
    };

    WebMarkupContainer facetFooter = new WebMarkupContainer("facetFooter") {
        @Override
        public boolean isVisible() {
            return pagingNavigator.isVisible() || allResultsLink.isVisible();
        }
    };

    add(facetForm);
    facetForm.add(facetHeader);
    facetForm.add(selectedValuesCheckGroup);
    facetForm.add(facetFooter);
    facetHeader.add(sortField);
    facetHeader.add(multiValuedFacetOptions);
    multiValuedFacetOptions.add(refineButton);
    multiValuedFacetOptions.add(excludeButton);
    selectedValuesCheckGroup.add(listViewContainer);
    listViewContainer.add(possibleValuesListView);
    facetFooter.add(pagingNavigator);
    facetFooter.add(allResultsLink);
}

From source file:com.doculibre.constellio.wicket.panels.thesaurus.ThesaurusSuggestionPanel.java

License:Open Source License

public ThesaurusSuggestionPanel(String id, final SimpleSearch simpleSearch, final Locale displayLocale) {
    super(id);/*from   w w w  . j  a  v  a 2  s  . c  om*/

    boolean visible = false;

    RecordCollectionServices collectionServices = ConstellioSpringUtils.getRecordCollectionServices();
    SkosServices skosServices = ConstellioSpringUtils.getSkosServices();

    String collectionName = simpleSearch.getCollectionName();
    if (simpleSearch.isQueryValid()) {
        String query = simpleSearch.getQuery();
        if (StringUtils.isNotBlank(query) && !SimpleSearch.SEARCH_ALL.equals(query)) {
            RecordCollection collection = collectionServices.get(collectionName);
            if (collection != null) {
                Thesaurus thesaurus = collection.getThesaurus();
                if (thesaurus != null) {
                    Locale locale = collection.getDisplayLocale(getLocale());
                    Set<SkosConcept> prefLabelMatches = skosServices.getByPrefLabel(query, thesaurus, locale);
                    Set<SkosConcept> altLabelMatches = skosServices.searchAltLabels(query, thesaurus, locale);
                    if (prefLabelMatches.size() == 1) {
                        SkosConcept skosConcept = prefLabelMatches.iterator().next();
                        final ReloadableEntityModel<SkosConcept> skosConceptModel = new ReloadableEntityModel<SkosConcept>(
                                skosConcept);

                        prefLabelLink = new WebMarkupContainer("prefLabelLink");
                        prefLabelLink.setVisible(false);
                        prefLabelLabel = new WebMarkupContainer("prefLabelLabel");
                        prefLabelLink.setVisible(false);

                        semanticNetworkLink = new AjaxLink("semanticNetworkLink") {
                            @Override
                            public void onClick(AjaxRequestTarget target) {
                                SkosConcept skosConcept = skosConceptModel.getObject();
                                semanticNetworkModal.setContent(new SkosConceptModalPanel(
                                        semanticNetworkModal.getContentId(), skosConcept) {
                                    @Override
                                    protected AbstractLink newDetailsLink(String id, SkosConcept skosConcept) {
                                        String prefLabel = "" + skosConcept.getPrefLabel(displayLocale);
                                        prefLabel = prefLabel.toLowerCase();
                                        SimpleSearch clone = simpleSearch.clone();
                                        clone.setQuery(prefLabel);

                                        PageFactoryPlugin pageFactoryPlugin = PluginFactory
                                                .getPlugin(PageFactoryPlugin.class);
                                        return new BookmarkablePageLink(id,
                                                pageFactoryPlugin.getSearchResultsPage(),
                                                SearchResultsPage.getParameters(clone));
                                    }
                                });
                                semanticNetworkModal.show(target);
                            }

                            @Override
                            public void detachModels() {
                                skosConceptModel.detach();
                                super.detachModels();
                            }
                        };

                        String prefLabel = "" + skosConcept.getPrefLabel(displayLocale);
                        prefLabel = prefLabel.toLowerCase();
                        semanticNetworkLabel = new Label("semanticNetworkLabel", prefLabel);
                        semanticNetworkModal = new ModalWindow("semanticNetworkModal");

                        disambiguation = new WebMarkupContainer("disambiguation");
                        disambiguation.setVisible(false);

                        add(prefLabelLink);
                        prefLabelLink.add(prefLabelLabel);
                        add(semanticNetworkLink);
                        semanticNetworkLink.add(semanticNetworkLabel);
                        add(semanticNetworkModal);
                        add(disambiguation);

                        visible = true;
                    } else if (prefLabelMatches.size() > 1) {
                        prefLabelLink = new WebMarkupContainer("prefLabelLink");
                        prefLabelLink.setVisible(false);
                        prefLabelLabel = new WebMarkupContainer("prefLabelLabel");
                        prefLabelLink.setVisible(false);

                        semanticNetworkLink = new WebMarkupContainer("semanticNetworkLink");
                        semanticNetworkLink.setVisible(false);
                        semanticNetworkLabel = new WebMarkupContainer("semanticNetworkLabel");
                        semanticNetworkLabel.setVisible(false);
                        semanticNetworkModal = new ModalWindow("semanticNetworkModal");
                        semanticNetworkModal.setVisible(false);

                        List<String> disambiguationPrefLabels = new ArrayList<String>();
                        for (SkosConcept skosConcept : prefLabelMatches) {
                            String prefLabel = "" + skosConcept.getPrefLabel(displayLocale);
                            prefLabel = prefLabel.toLowerCase();
                            disambiguationPrefLabels.add(prefLabel);
                        }
                        disambiguation = new ListView("disambiguation", disambiguationPrefLabels) {
                            @Override
                            protected void populateItem(ListItem item) {
                                String prefLabel = (String) item.getModelObject();
                                SimpleSearch clone = simpleSearch.clone();
                                clone.setQuery(prefLabel);

                                PageFactoryPlugin pageFactoryPlugin = PluginFactory
                                        .getPlugin(PageFactoryPlugin.class);
                                Link prefLabelLink = new BookmarkablePageLink("prefLabelLink",
                                        pageFactoryPlugin.getSearchResultsPage(),
                                        SearchResultsPage.getParameters(clone));
                                Label prefLabelLabel = new Label("prefLabel", prefLabel);
                                item.add(prefLabelLink);
                                prefLabelLink.add(prefLabelLabel);
                            }
                        };

                        add(prefLabelLink);
                        prefLabelLink.add(prefLabelLabel);
                        add(semanticNetworkLink);
                        add(semanticNetworkModal);
                        add(disambiguation);

                        visible = true;
                    } else if (!altLabelMatches.isEmpty()) {
                        SkosConcept firstAltLabelConcept = altLabelMatches.iterator().next();
                        String prefLabel = "" + firstAltLabelConcept.getPrefLabel(displayLocale);
                        prefLabel = prefLabel.toLowerCase();
                        SimpleSearch clone = simpleSearch.clone();
                        clone.setQuery(prefLabel);

                        PageFactoryPlugin pageFactoryPlugin = PluginFactory.getPlugin(PageFactoryPlugin.class);
                        prefLabelLink = new BookmarkablePageLink("prefLabelLink",
                                pageFactoryPlugin.getSearchResultsPage(),
                                SearchResultsPage.getParameters(clone));
                        prefLabelLabel = new Label("prefLabelLabel", prefLabel);

                        semanticNetworkLink = new WebMarkupContainer("semanticNetworkLink");
                        semanticNetworkLink.setVisible(false);
                        semanticNetworkLabel = new WebMarkupContainer("semanticNetworkLabel");
                        semanticNetworkLabel.setVisible(false);
                        semanticNetworkModal = new ModalWindow("semanticNetworkModal");
                        semanticNetworkModal.setVisible(false);

                        disambiguation = new WebMarkupContainer("disambiguation");
                        disambiguation.setVisible(false);

                        add(prefLabelLink);
                        prefLabelLink.add(prefLabelLabel);
                        add(semanticNetworkLink);
                        add(semanticNetworkModal);
                        add(disambiguation);

                        visible = true;
                    }
                }
            }
        }
    }
    setVisible(visible);
}

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);//ww w  .  j a  v  a2 s  .  c  o  m

    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.TicketPage.java

License:Apache License

public TicketPage(PageParameters params) {
    super(params);

    final UserModel user = GitBlitWebSession.get().getUser() == null ? UserModel.ANONYMOUS
            : GitBlitWebSession.get().getUser();
    final RepositoryModel repository = getRepositoryModel();
    final String id = WicketUtils.getObject(params);
    long ticketId = Long.parseLong(id);
    ticket = app().tickets().getTicket(repository, ticketId);

    if (ticket == null) {
        // ticket not found
        throw new RestartResponseException(TicketsPage.class,
                WicketUtils.newRepositoryParameter(repositoryName));
    }/*from w  w  w  . j  a  v  a2  s  .  c o  m*/

    final List<Change> revisions = new ArrayList<Change>();
    List<Change> comments = new ArrayList<Change>();
    List<Change> statusChanges = new ArrayList<Change>();
    List<Change> discussion = new ArrayList<Change>();
    for (Change change : ticket.changes) {
        if (change.hasComment() || (change.isStatusChange() && (change.getStatus() != Status.New))) {
            discussion.add(change);
        }
        if (change.hasComment()) {
            comments.add(change);
        }
        if (change.hasPatchset()) {
            revisions.add(change);
        }
        if (change.isStatusChange() && !change.hasPatchset()) {
            statusChanges.add(change);
        }
    }

    final Change currentRevision = revisions.isEmpty() ? null : revisions.get(revisions.size() - 1);
    final Patchset currentPatchset = ticket.getCurrentPatchset();

    /*
     * TICKET HEADER
     */
    String href = urlFor(TicketsPage.class, params).toString();
    add(new ExternalLink("ticketNumber", href, "#" + ticket.number));
    Label headerStatus = new Label("headerStatus", ticket.status.toString());
    WicketUtils.setCssClass(headerStatus, TicketsUI.getLozengeClass(ticket.status, false));
    add(headerStatus);
    add(new Label("ticketTitle", ticket.title));
    if (currentPatchset == null) {
        add(new Label("diffstat").setVisible(false));
    } else {
        // calculate the current diffstat of the patchset
        add(new DiffStatPanel("diffstat", ticket.insertions, ticket.deletions));
    }

    /*
     * TAB TITLES
     */
    add(new Label("commentCount", "" + comments.size()).setVisible(!comments.isEmpty()));
    add(new Label("commitCount", "" + (currentPatchset == null ? 0 : currentPatchset.commits))
            .setVisible(currentPatchset != null));

    /*
     * TICKET AUTHOR and DATE (DISCUSSION TAB)
     */
    UserModel createdBy = app().users().getUserModel(ticket.createdBy);
    if (createdBy == null) {
        add(new Label("whoCreated", ticket.createdBy));
    } else {
        add(new LinkPanel("whoCreated", null, createdBy.getDisplayName(), UserPage.class,
                WicketUtils.newUsernameParameter(createdBy.username)));
    }

    if (ticket.isProposal()) {
        // clearly indicate this is a change ticket
        add(new Label("creationMessage", getString("gb.proposedThisChange")));
    } else {
        // standard ticket
        add(new Label("creationMessage", getString("gb.createdThisTicket")));
    }

    String dateFormat = app().settings().getString(Keys.web.datestampLongFormat, "EEEE, MMMM d, yyyy");
    String timestampFormat = app().settings().getString(Keys.web.datetimestampLongFormat, "EEEE, MMMM d, yyyy");
    final TimeZone timezone = getTimeZone();
    final DateFormat df = new SimpleDateFormat(dateFormat);
    df.setTimeZone(timezone);
    final DateFormat tsf = new SimpleDateFormat(timestampFormat);
    tsf.setTimeZone(timezone);
    final Calendar cal = Calendar.getInstance(timezone);

    String fuzzydate;
    TimeUtils tu = getTimeUtils();
    Date createdDate = ticket.created;
    if (TimeUtils.isToday(createdDate, timezone)) {
        fuzzydate = tu.today();
    } else if (TimeUtils.isYesterday(createdDate, timezone)) {
        fuzzydate = tu.yesterday();
    } else {
        // calculate a fuzzy time ago date
        cal.setTime(createdDate);
        cal.set(Calendar.HOUR_OF_DAY, 0);
        cal.set(Calendar.MINUTE, 0);
        cal.set(Calendar.SECOND, 0);
        cal.set(Calendar.MILLISECOND, 0);
        createdDate = cal.getTime();
        fuzzydate = getTimeUtils().timeAgo(createdDate);
    }
    Label when = new Label("whenCreated", fuzzydate + ", " + df.format(createdDate));
    WicketUtils.setHtmlTooltip(when, tsf.format(ticket.created));
    add(when);

    String exportHref = urlFor(ExportTicketPage.class, params).toString();
    add(new ExternalLink("exportJson", exportHref, "json"));

    /*
     * RESPONSIBLE (DISCUSSION TAB)
     */
    if (StringUtils.isEmpty(ticket.responsible)) {
        add(new Label("responsible"));
    } else {
        UserModel responsible = app().users().getUserModel(ticket.responsible);
        if (responsible == null) {
            add(new Label("responsible", ticket.responsible));
        } else {
            add(new LinkPanel("responsible", null, responsible.getDisplayName(), UserPage.class,
                    WicketUtils.newUsernameParameter(responsible.username)));
        }
    }

    /*
     * MILESTONE PROGRESS (DISCUSSION TAB)
     */
    if (StringUtils.isEmpty(ticket.milestone)) {
        add(new Label("milestone"));
    } else {
        // link to milestone query
        TicketMilestone tm = app().tickets().getMilestone(repository, ticket.milestone);
        if (tm == null) {
            tm = new TicketMilestone(ticket.milestone);
        }
        PageParameters milestoneParameters;
        if (tm.isOpen()) {
            milestoneParameters = WicketUtils.newOpenTicketsParameter(repositoryName);
        } else {
            milestoneParameters = WicketUtils.newRepositoryParameter(repositoryName);
        }
        milestoneParameters.add(Lucene.milestone.name(), ticket.milestone);
        int progress = 0;
        int open = 0;
        int closed = 0;
        if (tm != null) {
            progress = tm.getProgress();
            open = tm.getOpenTickets();
            closed = tm.getClosedTickets();
        }

        Fragment milestoneProgress = new Fragment("milestone", "milestoneProgressFragment", TicketPage.this);
        milestoneProgress
                .add(new LinkPanel("link", null, ticket.milestone, TicketsPage.class, milestoneParameters));
        Label label = new Label("progress");
        WicketUtils.setCssStyle(label, "width:" + progress + "%;");
        milestoneProgress.add(label);
        WicketUtils.setHtmlTooltip(milestoneProgress,
                MessageFormat.format(getString("gb.milestoneProgress"), open, closed));
        add(milestoneProgress);
    }

    /*
     * TICKET DESCRIPTION (DISCUSSION TAB)
     */
    String desc;
    if (StringUtils.isEmpty(ticket.body)) {
        desc = getString("gb.noDescriptionGiven");
    } else {
        String bugtraq = bugtraqProcessor().processText(getRepository(), repositoryName, ticket.body);
        String html = MarkdownUtils.transformGFM(app().settings(), bugtraq, ticket.repository);
        String safeHtml = app().xssFilter().relaxed(html);
        desc = safeHtml;
    }
    add(new Label("ticketDescription", desc).setEscapeModelStrings(false));

    /*
     * PARTICIPANTS (DISCUSSION TAB)
     */
    if (app().settings().getBoolean(Keys.web.allowGravatar, true)) {
        // gravatar allowed
        List<String> participants = ticket.getParticipants();
        add(new Label("participantsLabel",
                MessageFormat.format(
                        getString(participants.size() > 1 ? "gb.nParticipants" : "gb.oneParticipant"),
                        "<b>" + participants.size() + "</b>")).setEscapeModelStrings(false));
        ListDataProvider<String> participantsDp = new ListDataProvider<String>(participants);
        DataView<String> participantsView = new DataView<String>("participants", participantsDp) {
            private static final long serialVersionUID = 1L;

            @Override
            public void populateItem(final Item<String> item) {
                String username = item.getModelObject();
                UserModel user = app().users().getUserModel(username);
                if (user == null) {
                    user = new UserModel(username);
                }
                item.add(new AvatarImage("participant", user.getDisplayName(), user.emailAddress, null, 25,
                        true));
            }
        };
        add(participantsView);
    } else {
        // gravatar prohibited
        add(new Label("participantsLabel").setVisible(false));
        add(new Label("participants").setVisible(false));
    }

    /*
     * LARGE STATUS INDICATOR WITH ICON (DISCUSSION TAB->SIDE BAR)
     */
    Fragment ticketStatus = new Fragment("ticketStatus", "ticketStatusFragment", TicketPage.this);
    Label ticketIcon = TicketsUI.getStateIcon("ticketIcon", ticket);
    ticketStatus.add(ticketIcon);
    ticketStatus.add(new Label("ticketStatus", ticket.status.toString()));
    WicketUtils.setCssClass(ticketStatus, TicketsUI.getLozengeClass(ticket.status, false));
    add(ticketStatus);

    /*
     * UPDATE FORM (DISCUSSION TAB)
     */
    if (user.canEdit(ticket, repository) && app().tickets().isAcceptingTicketUpdates(repository)) {
        if (user.canAdmin(ticket, repository) && ticket.isOpen()) {
            /*
             * OPEN TICKET
             */
            Fragment controls = new Fragment("controls", "openControlsFragment", TicketPage.this);

            /*
             * STATUS
             */
            List<Status> choices = new ArrayList<Status>();
            if (ticket.isProposal()) {
                choices.addAll(Arrays.asList(TicketModel.Status.proposalWorkflow));
            } else if (ticket.isBug()) {
                choices.addAll(Arrays.asList(TicketModel.Status.bugWorkflow));
            } else {
                choices.addAll(Arrays.asList(TicketModel.Status.requestWorkflow));
            }
            choices.remove(ticket.status);

            ListDataProvider<Status> workflowDp = new ListDataProvider<Status>(choices);
            DataView<Status> statusView = new DataView<Status>("newStatus", workflowDp) {
                private static final long serialVersionUID = 1L;

                @Override
                public void populateItem(final Item<Status> item) {
                    SimpleAjaxLink<Status> link = new SimpleAjaxLink<Status>("link", item.getModel()) {

                        private static final long serialVersionUID = 1L;

                        @Override
                        public void onClick(AjaxRequestTarget target) {
                            Status status = getModel().getObject();
                            Change change = new Change(user.username);
                            change.setField(Field.status, status);
                            if (!ticket.isWatching(user.username)) {
                                change.watch(user.username);
                            }
                            TicketModel update = app().tickets().updateTicket(repository, ticket.number,
                                    change);
                            app().tickets().createNotifier().sendMailing(update);
                            redirectTo(TicketsPage.class, getPageParameters());
                        }
                    };
                    String css = TicketsUI.getStatusClass(item.getModel().getObject());
                    WicketUtils.setCssClass(link, css);
                    item.add(link);
                }
            };
            controls.add(statusView);

            /*
             * RESPONSIBLE LIST
             */
            Set<String> userlist = new TreeSet<String>(ticket.getParticipants());
            if (UserModel.ANONYMOUS.canPush(getRepositoryModel())
                    || AuthorizationControl.AUTHENTICATED == getRepositoryModel().authorizationControl) {
                //    authorization is ANONYMOUS or AUTHENTICATED (i.e. all users can be set responsible)
                userlist.addAll(app().users().getAllUsernames());
            } else {
                // authorization is by NAMED users (users with PUSH permission can be set responsible)
                for (RegistrantAccessPermission rp : app().repositories()
                        .getUserAccessPermissions(getRepositoryModel())) {
                    if (rp.permission.atLeast(AccessPermission.PUSH)) {
                        userlist.add(rp.registrant);
                    }
                }
            }
            List<TicketResponsible> responsibles = new ArrayList<TicketResponsible>();
            if (!StringUtils.isEmpty(ticket.responsible)) {
                // exclude the current responsible
                userlist.remove(ticket.responsible);
            }
            for (String username : userlist) {
                UserModel u = app().users().getUserModel(username);
                if (u != null) {
                    responsibles.add(new TicketResponsible(u));
                }
            }
            Collections.sort(responsibles);
            responsibles.add(new TicketResponsible(ESC_NIL, "", ""));
            ListDataProvider<TicketResponsible> responsibleDp = new ListDataProvider<TicketResponsible>(
                    responsibles);
            DataView<TicketResponsible> responsibleView = new DataView<TicketResponsible>("newResponsible",
                    responsibleDp) {
                private static final long serialVersionUID = 1L;

                @Override
                public void populateItem(final Item<TicketResponsible> item) {
                    SimpleAjaxLink<TicketResponsible> link = new SimpleAjaxLink<TicketResponsible>("link",
                            item.getModel()) {

                        private static final long serialVersionUID = 1L;

                        @Override
                        public void onClick(AjaxRequestTarget target) {
                            TicketResponsible responsible = getModel().getObject();
                            Change change = new Change(user.username);
                            change.setField(Field.responsible, responsible.username);
                            if (!StringUtils.isEmpty(responsible.username)) {
                                if (!ticket.isWatching(responsible.username)) {
                                    change.watch(responsible.username);
                                }
                            }
                            if (!ticket.isWatching(user.username)) {
                                change.watch(user.username);
                            }
                            TicketModel update = app().tickets().updateTicket(repository, ticket.number,
                                    change);
                            app().tickets().createNotifier().sendMailing(update);
                            redirectTo(TicketsPage.class, getPageParameters());
                        }
                    };
                    item.add(link);
                }
            };
            controls.add(responsibleView);

            /*
             * MILESTONE LIST
             */
            List<TicketMilestone> milestones = app().tickets().getMilestones(repository, Status.Open);
            if (!StringUtils.isEmpty(ticket.milestone)) {
                for (TicketMilestone milestone : milestones) {
                    if (milestone.name.equals(ticket.milestone)) {
                        milestones.remove(milestone);
                        break;
                    }
                }
            }
            milestones.add(new TicketMilestone(ESC_NIL));
            ListDataProvider<TicketMilestone> milestoneDp = new ListDataProvider<TicketMilestone>(milestones);
            DataView<TicketMilestone> milestoneView = new DataView<TicketMilestone>("newMilestone",
                    milestoneDp) {
                private static final long serialVersionUID = 1L;

                @Override
                public void populateItem(final Item<TicketMilestone> item) {
                    SimpleAjaxLink<TicketMilestone> link = new SimpleAjaxLink<TicketMilestone>("link",
                            item.getModel()) {

                        private static final long serialVersionUID = 1L;

                        @Override
                        public void onClick(AjaxRequestTarget target) {
                            TicketMilestone milestone = getModel().getObject();
                            Change change = new Change(user.username);
                            if (NIL.equals(milestone.name) || ESC_NIL.equals(milestone.name)) {
                                change.setField(Field.milestone, "");
                            } else {
                                change.setField(Field.milestone, milestone.name);
                            }
                            if (!ticket.isWatching(user.username)) {
                                change.watch(user.username);
                            }
                            TicketModel update = app().tickets().updateTicket(repository, ticket.number,
                                    change);
                            app().tickets().createNotifier().sendMailing(update);
                            redirectTo(TicketsPage.class, getPageParameters());
                        }
                    };
                    item.add(link);
                }
            };
            controls.add(milestoneView);

            String editHref = urlFor(EditTicketPage.class, params).toString();
            controls.add(new ExternalLink("editLink", editHref, getString("gb.edit")));

            add(controls);
        } else {
            /*
             * CLOSED TICKET
             */
            Fragment controls = new Fragment("controls", "closedControlsFragment", TicketPage.this);

            String editHref = urlFor(EditTicketPage.class, params).toString();
            controls.add(new ExternalLink("editLink", editHref, getString("gb.edit")));

            add(controls);
        }
    } else {
        add(new Label("controls").setVisible(false));
    }

    /*
     * TICKET METADATA
     */
    add(new Label("ticketType", ticket.type.toString()));

    add(new Label("priority", ticket.priority.toString()));
    add(new Label("severity", ticket.severity.toString()));

    if (StringUtils.isEmpty(ticket.topic)) {
        add(new Label("ticketTopic").setVisible(false));
    } else {
        // process the topic using the bugtraq config to link things
        String topic = bugtraqProcessor().processText(getRepository(), repositoryName, ticket.topic);
        String safeTopic = app().xssFilter().relaxed(topic);
        add(new Label("ticketTopic", safeTopic).setEscapeModelStrings(false));
    }

    /*
     * VOTERS
     */
    List<String> voters = ticket.getVoters();
    Label votersCount = new Label("votes", "" + voters.size());
    if (voters.size() == 0) {
        WicketUtils.setCssClass(votersCount, "badge");
    } else {
        WicketUtils.setCssClass(votersCount, "badge badge-info");
    }
    add(votersCount);
    if (user.isAuthenticated && app().tickets().isAcceptingTicketUpdates(repository)) {
        Model<String> model;
        if (ticket.isVoter(user.username)) {
            model = Model.of(getString("gb.removeVote"));
        } else {
            model = Model.of(MessageFormat.format(getString("gb.vote"), ticket.type.toString()));
        }
        SimpleAjaxLink<String> link = new SimpleAjaxLink<String>("voteLink", model) {

            private static final long serialVersionUID = 1L;

            @Override
            public void onClick(AjaxRequestTarget target) {
                Change change = new Change(user.username);
                if (ticket.isVoter(user.username)) {
                    change.unvote(user.username);
                } else {
                    change.vote(user.username);
                }
                app().tickets().updateTicket(repository, ticket.number, change);
                redirectTo(TicketsPage.class, getPageParameters());
            }
        };
        add(link);
    } else {
        add(new Label("voteLink").setVisible(false));
    }

    /*
     * WATCHERS
     */
    List<String> watchers = ticket.getWatchers();
    Label watchersCount = new Label("watchers", "" + watchers.size());
    if (watchers.size() == 0) {
        WicketUtils.setCssClass(watchersCount, "badge");
    } else {
        WicketUtils.setCssClass(watchersCount, "badge badge-info");
    }
    add(watchersCount);
    if (user.isAuthenticated && app().tickets().isAcceptingTicketUpdates(repository)) {
        Model<String> model;
        if (ticket.isWatching(user.username)) {
            model = Model.of(getString("gb.stopWatching"));
        } else {
            model = Model.of(MessageFormat.format(getString("gb.watch"), ticket.type.toString()));
        }
        SimpleAjaxLink<String> link = new SimpleAjaxLink<String>("watchLink", model) {

            private static final long serialVersionUID = 1L;

            @Override
            public void onClick(AjaxRequestTarget target) {
                Change change = new Change(user.username);
                if (ticket.isWatching(user.username)) {
                    change.unwatch(user.username);
                } else {
                    change.watch(user.username);
                }
                app().tickets().updateTicket(repository, ticket.number, change);
                redirectTo(TicketsPage.class, getPageParameters());
            }
        };
        add(link);
    } else {
        add(new Label("watchLink").setVisible(false));
    }

    /*
     * TOPIC & LABELS (DISCUSSION TAB->SIDE BAR)
     */
    ListDataProvider<String> labelsDp = new ListDataProvider<String>(ticket.getLabels());
    DataView<String> labelsView = new DataView<String>("labels", labelsDp) {
        private static final long serialVersionUID = 1L;

        @Override
        public void populateItem(final Item<String> item) {
            final String value = item.getModelObject();
            Label label = new Label("label", value);
            TicketLabel tLabel = app().tickets().getLabel(repository, value);
            String background = MessageFormat.format("background-color:{0};", tLabel.color);
            label.add(new AttributeModifier("style", background));
            item.add(label);
        }
    };

    add(labelsView);

    /*
     * COMMENTS & STATUS CHANGES (DISCUSSION TAB)
     */
    if (comments.size() == 0) {
        add(new Label("discussion").setVisible(false));
    } else {
        Fragment discussionFragment = new Fragment("discussion", "discussionFragment", TicketPage.this);
        ListDataProvider<Change> discussionDp = new ListDataProvider<Change>(discussion);
        DataView<Change> discussionView = new DataView<Change>("discussion", discussionDp) {
            private static final long serialVersionUID = 1L;

            @Override
            public void populateItem(final Item<Change> item) {
                final Change entry = item.getModelObject();
                if (entry.isMerge()) {
                    /*
                     * MERGE
                     */
                    String resolvedBy = entry.getString(Field.mergeSha);

                    // identify the merged patch, it is likely the last
                    Patchset mergedPatch = null;
                    for (Change c : revisions) {
                        if (c.patchset.tip.equals(resolvedBy)) {
                            mergedPatch = c.patchset;
                            break;
                        }
                    }

                    String commitLink;
                    if (mergedPatch == null) {
                        // shouldn't happen, but just-in-case
                        int len = app().settings().getInteger(Keys.web.shortCommitIdLength, 6);
                        commitLink = resolvedBy.substring(0, len);
                    } else {
                        // expected result
                        commitLink = mergedPatch.toString();
                    }

                    Fragment mergeFragment = new Fragment("entry", "mergeFragment", TicketPage.this);
                    mergeFragment.add(new LinkPanel("commitLink", null, commitLink, CommitPage.class,
                            WicketUtils.newObjectParameter(repositoryName, resolvedBy)));
                    mergeFragment.add(new Label("toBranch",
                            MessageFormat.format(getString("gb.toBranch"), "<b>" + ticket.mergeTo + "</b>"))
                                    .setEscapeModelStrings(false));
                    addUserAttributions(mergeFragment, entry, 0);
                    addDateAttributions(mergeFragment, entry);

                    item.add(mergeFragment);
                } else if (entry.isStatusChange()) {
                    /*
                     *  STATUS CHANGE
                     */
                    Fragment frag = new Fragment("entry", "statusFragment", TicketPage.this);
                    Label status = new Label("statusChange", entry.getStatus().toString());
                    String css = TicketsUI.getLozengeClass(entry.getStatus(), false);
                    WicketUtils.setCssClass(status, css);
                    frag.add(status);
                    addUserAttributions(frag, entry, avatarWidth);
                    addDateAttributions(frag, entry);
                    item.add(frag);
                } else {
                    /*
                     * COMMENT
                     */
                    String bugtraq = bugtraqProcessor().processText(getRepository(), repositoryName,
                            entry.comment.text);
                    String comment = MarkdownUtils.transformGFM(app().settings(), bugtraq, repositoryName);
                    String safeComment = app().xssFilter().relaxed(comment);
                    Fragment frag = new Fragment("entry", "commentFragment", TicketPage.this);
                    Label commentIcon = new Label("commentIcon");
                    if (entry.comment.src == CommentSource.Email) {
                        WicketUtils.setCssClass(commentIcon, "iconic-mail");
                    } else {
                        WicketUtils.setCssClass(commentIcon, "iconic-comment-alt2-stroke");
                    }
                    frag.add(commentIcon);
                    frag.add(new Label("comment", safeComment).setEscapeModelStrings(false));
                    addUserAttributions(frag, entry, avatarWidth);
                    addDateAttributions(frag, entry);
                    item.add(frag);
                }
            }
        };
        discussionFragment.add(discussionView);
        add(discussionFragment);
    }

    /*
     * ADD COMMENT PANEL
     */
    if (UserModel.ANONYMOUS.equals(user) || !repository.isBare || repository.isFrozen || repository.isMirror) {

        // prohibit comments for anonymous users, local working copy repos,
        // frozen repos, and mirrors
        add(new Label("newComment").setVisible(false));
    } else {
        // permit user to comment
        Fragment newComment = new Fragment("newComment", "newCommentFragment", TicketPage.this);
        AvatarImage img = new AvatarImage("newCommentAvatar", user.username, user.emailAddress,
                "gravatar-round", avatarWidth, true);
        newComment.add(img);
        CommentPanel commentPanel = new CommentPanel("commentPanel", user, ticket, null, TicketsPage.class);
        commentPanel.setRepository(repositoryName);
        newComment.add(commentPanel);
        add(newComment);
    }

    /*
     *  PATCHSET TAB
     */
    if (currentPatchset == null) {
        // no patchset available
        RepositoryUrl repoUrl = getRepositoryUrl(user, repository);
        boolean canPropose = repoUrl != null && repoUrl.hasPermission()
                && repoUrl.permission.atLeast(AccessPermission.CLONE) && !UserModel.ANONYMOUS.equals(user);
        if (ticket.isOpen() && app().tickets().isAcceptingNewPatchsets(repository) && canPropose) {
            // ticket & repo will accept a proposal patchset
            // show the instructions for proposing a patchset
            Fragment changeIdFrag = new Fragment("patchset", "proposeFragment", TicketPage.this);
            changeIdFrag.add(new Label("proposeInstructions",
                    MarkdownUtils.transformMarkdown(getString("gb.proposeInstructions")))
                            .setEscapeModelStrings(false));
            changeIdFrag
                    .add(new Label("ptWorkflow", MessageFormat.format(getString("gb.proposeWith"), "Barnum")));
            changeIdFrag.add(new Label("ptWorkflowSteps",
                    getProposeWorkflow("propose_pt.md", repoUrl.url, ticket.number))
                            .setEscapeModelStrings(false));
            changeIdFrag
                    .add(new Label("gitWorkflow", MessageFormat.format(getString("gb.proposeWith"), "Git")));
            changeIdFrag.add(new Label("gitWorkflowSteps",
                    getProposeWorkflow("propose_git.md", repoUrl.url, ticket.number))
                            .setEscapeModelStrings(false));
            add(changeIdFrag);
        } else {
            // explain why you can't propose a patchset
            Fragment fragment = new Fragment("patchset", "canNotProposeFragment", TicketPage.this);
            String reason = "";
            if (ticket.isClosed()) {
                reason = getString("gb.ticketIsClosed");
            } else if (repository.isMirror) {
                reason = getString("gb.repositoryIsMirror");
            } else if (repository.isFrozen) {
                reason = getString("gb.repositoryIsFrozen");
            } else if (!repository.acceptNewPatchsets) {
                reason = getString("gb.repositoryDoesNotAcceptPatchsets");
            } else if (!canPropose) {
                if (UserModel.ANONYMOUS.equals(user)) {
                    reason = getString("gb.anonymousCanNotPropose");
                } else {
                    reason = getString("gb.youDoNotHaveClonePermission");
                }
            } else {
                reason = getString("gb.serverDoesNotAcceptPatchsets");
            }
            fragment.add(new Label("reason", reason));
            add(fragment);
        }
    } else {
        // show current patchset
        Fragment patchsetFrag = new Fragment("patchset", "patchsetFragment", TicketPage.this);
        patchsetFrag.add(new Label("commitsInPatchset",
                MessageFormat.format(getString("gb.commitsInPatchsetN"), currentPatchset.number)));

        patchsetFrag.add(createMergePanel(user, repository));

        if (ticket.isOpen()) {
            // current revision
            MarkupContainer panel = createPatchsetPanel("panel", repository, user);
            patchsetFrag.add(panel);
            addUserAttributions(patchsetFrag, currentRevision, avatarWidth);
            addUserAttributions(panel, currentRevision, 0);
            addDateAttributions(panel, currentRevision);
        } else {
            // current revision
            patchsetFrag.add(new Label("panel").setVisible(false));
        }

        // commits
        List<RevCommit> commits = JGitUtils.getRevLog(getRepository(), currentPatchset.base,
                currentPatchset.tip);
        ListDataProvider<RevCommit> commitsDp = new ListDataProvider<RevCommit>(commits);
        DataView<RevCommit> commitsView = new DataView<RevCommit>("commit", commitsDp) {
            private static final long serialVersionUID = 1L;

            @Override
            public void populateItem(final Item<RevCommit> item) {
                RevCommit commit = item.getModelObject();
                PersonIdent author = commit.getAuthorIdent();
                item.add(new AvatarImage("authorAvatar", author.getName(), author.getEmailAddress(), null, 16,
                        false));
                item.add(new Label("author", commit.getAuthorIdent().getName()));
                item.add(new LinkPanel("commitId", null, getShortObjectId(commit.getName()), CommitPage.class,
                        WicketUtils.newObjectParameter(repositoryName, commit.getName()), true));
                item.add(new LinkPanel("diff", "link", getString("gb.diff"), CommitDiffPage.class,
                        WicketUtils.newObjectParameter(repositoryName, commit.getName()), true));
                item.add(new Label("title",
                        StringUtils.trimString(commit.getShortMessage(), Constants.LEN_SHORTLOG_REFS)));
                item.add(WicketUtils.createDateLabel("commitDate", JGitUtils.getAuthorDate(commit),
                        GitBlitWebSession.get().getTimezone(), getTimeUtils(), false));
                item.add(new DiffStatPanel("commitDiffStat", 0, 0, true));
            }
        };
        patchsetFrag.add(commitsView);
        add(patchsetFrag);
    }

    /*
     * ACTIVITY TAB
     */
    Fragment revisionHistory = new Fragment("activity", "activityFragment", TicketPage.this);
    List<Change> events = new ArrayList<Change>(ticket.changes);
    Collections.sort(events);
    Collections.reverse(events);
    ListDataProvider<Change> eventsDp = new ListDataProvider<Change>(events);
    DataView<Change> eventsView = new DataView<Change>("event", eventsDp) {
        private static final long serialVersionUID = 1L;

        @Override
        public void populateItem(final Item<Change> item) {
            Change event = item.getModelObject();

            addUserAttributions(item, event, 16);

            if (event.hasPatchset()) {
                // patchset
                Patchset patchset = event.patchset;
                String what;
                if (event.isStatusChange() && (Status.New == event.getStatus())) {
                    what = getString("gb.proposedThisChange");
                } else if (patchset.rev == 1) {
                    what = MessageFormat.format(getString("gb.uploadedPatchsetN"), patchset.number);
                } else {
                    if (patchset.added == 1) {
                        what = getString("gb.addedOneCommit");
                    } else {
                        what = MessageFormat.format(getString("gb.addedNCommits"), patchset.added);
                    }
                }
                item.add(new Label("what", what));

                LinkPanel psr = new LinkPanel("patchsetRevision", null, patchset.number + "-" + patchset.rev,
                        ComparePage.class, WicketUtils.newRangeParameter(repositoryName,
                                patchset.parent == null ? patchset.base : patchset.parent, patchset.tip),
                        true);
                WicketUtils.setHtmlTooltip(psr, patchset.toString());
                WicketUtils.setCssClass(psr, "aui-lozenge aui-lozenge-subtle");
                item.add(psr);
                String typeCss = getPatchsetTypeCss(patchset.type);
                Label typeLabel = new Label("patchsetType", patchset.type.toString());
                if (typeCss == null) {
                    typeLabel.setVisible(false);
                } else {
                    WicketUtils.setCssClass(typeLabel, typeCss);
                }
                item.add(typeLabel);

                Link<Void> deleteLink = createDeletePatchsetLink(repository, patchset);

                if (user.canDeleteRef(repository)) {
                    item.add(deleteLink.setVisible(patchset.canDelete));
                } else {
                    item.add(deleteLink.setVisible(false));
                }

                // show commit diffstat
                item.add(new DiffStatPanel("patchsetDiffStat", patchset.insertions, patchset.deletions,
                        patchset.rev > 1));
            } else if (event.hasComment()) {
                // comment
                item.add(new Label("what", getString("gb.commented")));
                item.add(new Label("patchsetRevision").setVisible(false));
                item.add(new Label("patchsetType").setVisible(false));
                item.add(new Label("deleteRevision").setVisible(false));
                item.add(new Label("patchsetDiffStat").setVisible(false));
            } else if (event.hasReference()) {
                // reference
                switch (event.reference.getSourceType()) {
                case Commit: {
                    final int shaLen = app().settings().getInteger(Keys.web.shortCommitIdLength, 6);

                    item.add(new Label("what", getString("gb.referencedByCommit")));
                    LinkPanel psr = new LinkPanel("patchsetRevision", null,
                            event.reference.toString().substring(0, shaLen), CommitPage.class,
                            WicketUtils.newObjectParameter(repositoryName, event.reference.toString()), true);
                    WicketUtils.setHtmlTooltip(psr, event.reference.toString());
                    WicketUtils.setCssClass(psr, "ticketReference-commit shortsha1");
                    item.add(psr);

                }
                    break;

                case Ticket: {
                    final String text = MessageFormat.format("ticket/{0}", event.reference.ticketId);

                    item.add(new Label("what", getString("gb.referencedByTicket")));
                    //NOTE: Ideally reference the exact comment using reference.toString,
                    //      however anchor hash is used and is escaped resulting in broken link
                    LinkPanel psr = new LinkPanel("patchsetRevision", null, text, TicketsPage.class,
                            WicketUtils.newObjectParameter(repositoryName, event.reference.ticketId.toString()),
                            true);
                    WicketUtils.setCssClass(psr, "ticketReference-comment");
                    item.add(psr);
                }
                    break;

                default: {
                    item.add(new Label("what").setVisible(false));
                    item.add(new Label("patchsetRevision").setVisible(false));
                }
                }

                item.add(new Label("patchsetType").setVisible(false));
                item.add(new Label("deleteRevision").setVisible(false));
                item.add(new Label("patchsetDiffStat").setVisible(false));
            } else if (event.hasReview()) {
                // review
                String score;
                switch (event.review.score) {
                case approved:
                    score = "<span style='color:darkGreen'>" + getScoreDescription(event.review.score)
                            + "</span>";
                    break;
                case vetoed:
                    score = "<span style='color:darkRed'>" + getScoreDescription(event.review.score)
                            + "</span>";
                    break;
                default:
                    score = getScoreDescription(event.review.score);
                }
                item.add(new Label("what", MessageFormat.format(getString("gb.reviewedPatchsetRev"),
                        event.review.patchset, event.review.rev, score)).setEscapeModelStrings(false));
                item.add(new Label("patchsetRevision").setVisible(false));
                item.add(new Label("patchsetType").setVisible(false));
                item.add(new Label("deleteRevision").setVisible(false));
                item.add(new Label("patchsetDiffStat").setVisible(false));
            } else {
                // field change
                item.add(new Label("patchsetRevision").setVisible(false));
                item.add(new Label("patchsetType").setVisible(false));
                item.add(new Label("deleteRevision").setVisible(false));
                item.add(new Label("patchsetDiffStat").setVisible(false));

                String what = "";
                if (event.isStatusChange()) {
                    switch (event.getStatus()) {
                    case New:
                        if (ticket.isProposal()) {
                            what = getString("gb.proposedThisChange");
                        } else {
                            what = getString("gb.createdThisTicket");
                        }
                        break;
                    default:
                        break;
                    }
                }
                item.add(new Label("what", what).setVisible(what.length() > 0));
            }

            addDateAttributions(item, event);

            if (event.hasFieldChanges()) {
                StringBuilder sb = new StringBuilder();
                sb.append("<table class=\"summary\"><tbody>");
                for (Map.Entry<Field, String> entry : event.fields.entrySet()) {
                    String value;
                    switch (entry.getKey()) {
                    case body:
                        String body = entry.getValue();
                        if (event.isStatusChange() && Status.New == event.getStatus()
                                && StringUtils.isEmpty(body)) {
                            // ignore initial empty description
                            continue;
                        }
                        // trim body changes
                        if (StringUtils.isEmpty(body)) {
                            value = "<i>" + ESC_NIL + "</i>";
                        } else {
                            value = StringUtils.trimString(body, Constants.LEN_SHORTLOG_REFS);
                        }
                        break;
                    case status:
                        // special handling for status
                        Status status = event.getStatus();
                        String css = TicketsUI.getLozengeClass(status, true);
                        value = String.format("<span class=\"%1$s\">%2$s</span>", css, status.toString());
                        break;
                    default:
                        value = StringUtils.isEmpty(entry.getValue()) ? ("<i>" + ESC_NIL + "</i>")
                                : StringUtils.escapeForHtml(entry.getValue(), false);
                        break;
                    }
                    sb.append("<tr><th style=\"width:70px;\">");
                    try {
                        sb.append(getString("gb." + entry.getKey().name()));
                    } catch (Exception e) {
                        sb.append(entry.getKey().name());
                    }
                    sb.append("</th><td>");
                    sb.append(value);
                    sb.append("</td></tr>");
                }
                sb.append("</tbody></table>");
                String safeHtml = app().xssFilter().relaxed(sb.toString());
                item.add(new Label("fields", safeHtml).setEscapeModelStrings(false));
            } else {
                item.add(new Label("fields").setVisible(false));
            }
        }
    };
    revisionHistory.add(eventsView);
    add(revisionHistory);
}

From source file:com.tysanclan.site.projectewok.components.BasicMemberPanel.java

License:Open Source License

private void addCreateGamePetitionLink(User user) {
    Link<?> petitionLink = new Link<Void>("creategamepetition") {
        private static final long serialVersionUID = 1L;

        /**//from w  w w.  j a  v a2s.  c  om
         * @see org.apache.wicket.markup.html.link.Link#onClick()
         */
        @Override
        public void onClick() {
            setResponsePage(new CreateGamePetitionPage());
        }
    };

    TysanRankSecured secured = CreateGamePetitionPage.class.getAnnotation(TysanRankSecured.class);
    boolean visible = false;

    if (secured != null) {
        for (Rank rank : secured.value()) {
            if (rank == user.getRank()) {
                visible = true;
            }
        }
    }

    petitionLink.setVisible(visible);

    add(petitionLink);

}

From source file:com.tysanclan.site.projectewok.components.BasicMemberPanel.java

License:Open Source License

private void addCreateRealmPetitionLink(User user) {
    Link<?> petitionLink = new Link<Void>("createrealmpetition") {
        private static final long serialVersionUID = 1L;

        /**/*  ww  w . j a v a2 s.  c  o m*/
         * @see org.apache.wicket.markup.html.link.Link#onClick()
         */
        @Override
        public void onClick() {
            setResponsePage(new CreateRealmPetitionPage());
        }
    };

    TysanRankSecured secured = CreateRealmPetitionPage.class.getAnnotation(TysanRankSecured.class);
    boolean visible = false;

    if (secured != null) {
        for (Rank rank : secured.value()) {
            if (rank == user.getRank()) {
                visible = true;
            }
        }
    }

    petitionLink.setVisible(visible);

    add(petitionLink);

}