Example usage for org.apache.wicket.markup.repeater.data DataView DataView

Introduction

In this page you can find the example usage for org.apache.wicket.markup.repeater.data DataView DataView.

Prototype

protected DataView(String id, IDataProvider<T> dataProvider) 

Source Link

Usage

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

License:Apache License

private void setup(PageParameters params) {
    setupPage("", "");
    // check to see if we should display a login message
    boolean authenticateView = app().settings().getBoolean(Keys.web.authenticateViewPages, true);
    if (authenticateView && !GitBlitWebSession.get().isLoggedIn()) {
        add(new Label("projectsPanel"));
        return;//from  www. j  a  v  a 2 s .c o m
    }

    List<ProjectModel> projects = getProjects(params);
    Collections.sort(projects);

    ListDataProvider<ProjectModel> dp = new ListDataProvider<ProjectModel>(projects);

    DataView<ProjectModel> dataView = new DataView<ProjectModel>("project", dp) {
        private static final long serialVersionUID = 1L;
        int counter;

        @Override
        protected void onBeforeRender() {
            super.onBeforeRender();
            counter = 0;
        }

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

            PageParameters pp = WicketUtils.newProjectParameter(entry.name);
            item.add(new LinkPanel("projectTitle", "list", entry.getDisplayName(), ProjectPage.class, pp));
            item.add(new LinkPanel("projectDescription", "list", entry.description, ProjectPage.class, pp));

            item.add(new Label("repositoryCount",
                    entry.repositories.size() + " "
                            + (entry.repositories.size() == 1 ? getString("gb.repository")
                                    : getString("gb.repositories"))));

            String lastChange;
            if (entry.lastChange.getTime() == 0) {
                lastChange = "--";
            } else {
                lastChange = getTimeUtils().timeAgo(entry.lastChange);
            }
            Label lastChangeLabel = new Label("projectLastChange", lastChange);
            item.add(lastChangeLabel);
            WicketUtils.setCssClass(lastChangeLabel, getTimeUtils().timeAgoCss(entry.lastChange));
            WicketUtils.setAlternatingBackground(item, counter);
            counter++;
        }
    };
    add(dataView);
}

---

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

License:Apache License

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

    int numberCommits = app().settings().getInteger(Keys.web.summaryCommitCount, 20);
    if (numberCommits <= 0) {
        numberCommits = 20;/* w w w . jav  a  2s  .  co m*/
    }
    int numberRefs = app().settings().getInteger(Keys.web.summaryRefsCount, 5);

    Repository r = getRepository();
    final RepositoryModel model = getRepositoryModel();
    UserModel user = GitBlitWebSession.get().getUser();
    if (user == null) {
        user = UserModel.ANONYMOUS;
    }

    List<Metric> metrics = null;
    Metric metricsTotal = null;
    if (!model.skipSummaryMetrics && app().settings().getBoolean(Keys.web.generateActivityGraph, true)) {
        metrics = app().repositories().getRepositoryDefaultMetrics(model, r);
        metricsTotal = metrics.remove(0);
    }

    addSyndicationDiscoveryLink();

    // repository description
    add(new Label("repositoryDescription", getRepositoryModel().description));

    // owner links
    final List<String> owners = new ArrayList<String>(getRepositoryModel().owners);
    ListDataProvider<String> ownersDp = new ListDataProvider<String>(owners);
    DataView<String> ownersView = new DataView<String>("repositoryOwners", ownersDp) {
        private static final long serialVersionUID = 1L;
        int counter = 0;

        @Override
        public void populateItem(final Item<String> item) {
            String ownername = item.getModelObject();
            UserModel ownerModel = app().users().getUserModel(ownername);
            if (ownerModel != null) {
                item.add(new LinkPanel("owner", null, ownerModel.getDisplayName(), UserPage.class,
                        WicketUtils.newUsernameParameter(ownerModel.username)).setRenderBodyOnly(true));
            } else {
                Label owner = new Label("owner", ownername);
                WicketUtils.setCssStyle(owner, "text-decoration: line-through;");
                WicketUtils.setHtmlTooltip(owner,
                        MessageFormat.format(getString("gb.failedToFindAccount"), ownername));
                item.add(owner);
            }
            counter++;
            item.add(new Label("comma", ",").setVisible(counter < owners.size()));
            item.setRenderBodyOnly(true);
        }
    };
    ownersView.setRenderBodyOnly(true);
    add(ownersView);

    add(WicketUtils.createTimestampLabel("repositoryLastChange", JGitUtils.getLastChange(r).when, getTimeZone(),
            getTimeUtils()));
    add(new Label("repositorySize", getRepositoryModel().size));
    if (metricsTotal == null) {
        add(new Label("branchStats", ""));
    } else {
        add(new Label("branchStats", MessageFormat.format(getString("gb.branchStats"), metricsTotal.count,
                metricsTotal.tag, getTimeUtils().duration(metricsTotal.duration))));
    }
    add(new BookmarkablePageLink<Void>("metrics", MetricsPage.class,
            WicketUtils.newRepositoryParameter(repositoryName)));

    add(new RepositoryUrlPanel("repositoryUrlPanel", false, user, model));

    add(new LogPanel("commitsPanel", repositoryName, getRepositoryModel().HEAD, r, numberCommits, 0,
            getRepositoryModel().showRemoteBranches));
    add(new TagsPanel("tagsPanel", repositoryName, r, numberRefs).hideIfEmpty());
    add(new BranchesPanel("branchesPanel", getRepositoryModel(), r, numberRefs, false).hideIfEmpty());

    if (app().settings().getBoolean(Keys.web.summaryShowReadme, false)) {
        // show a readme on the summary page
        MarkupDocument markupDoc = null;
        RevCommit head = JGitUtils.getCommit(r, null);
        if (head != null) {
            MarkupProcessor processor = new MarkupProcessor(app().settings(), app().xssFilter());
            markupDoc = processor.getReadme(r, repositoryName, getBestCommitId(head));
        }
        if (markupDoc == null || markupDoc.markup == null) {
            add(new Label("readme").setVisible(false));
        } else {
            Fragment fragment = new Fragment("readme",
                    MarkupSyntax.PLAIN.equals(markupDoc.syntax) ? "plaintextPanel" : "markdownPanel",
                    SummaryPage.this);
            fragment.add(new Label("readmeFile", markupDoc.documentPath));
            // Add the html to the page
            Component content = new Label("readmeContent", markupDoc.html).setEscapeModelStrings(false);
            fragment.add(content.setVisible(!StringUtils.isEmpty(markupDoc.html)));
            add(fragment);
        }
    } else {
        // global, no readme on summary page
        add(new Label("readme").setVisible(false));
    }

    if (metrics == null || metrics.isEmpty()) {
        add(new Label("commitsChart").setVisible(false));
    } else {
        Charts charts = createCharts(metrics);
        add(charts);
    }
}

---

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 a  2 s .  c om*/

    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.gitblit.wicket.pages.TicketPage.java

License:Apache License

protected Fragment createPatchsetPanel(String wicketId, RepositoryModel repository, UserModel user) {
    final Patchset currentPatchset = ticket.getCurrentPatchset();
    List<Patchset> patchsets = new ArrayList<Patchset>(ticket.getPatchsetRevisions(currentPatchset.number));
    patchsets.remove(currentPatchset);/*from   w w  w.j a  v a2 s .com*/
    Collections.reverse(patchsets);

    Fragment panel = new Fragment(wicketId, "collapsiblePatchsetFragment", TicketPage.this);

    // patchset header
    String ps = "<b>" + currentPatchset.number + "</b>";
    if (currentPatchset.rev == 1) {
        panel.add(new Label("uploadedWhat", MessageFormat.format(getString("gb.uploadedPatchsetN"), ps))
                .setEscapeModelStrings(false));
    } else {
        String rev = "<b>" + currentPatchset.rev + "</b>";
        panel.add(new Label("uploadedWhat",
                MessageFormat.format(getString("gb.uploadedPatchsetNRevisionN"), ps, rev))
                        .setEscapeModelStrings(false));
    }
    panel.add(new LinkPanel("patchId", null, "rev " + currentPatchset.rev, CommitPage.class,
            WicketUtils.newObjectParameter(repositoryName, currentPatchset.tip), true));

    // compare menu
    panel.add(new LinkPanel("compareMergeBase", null, getString("gb.compareToMergeBase"), ComparePage.class,
            WicketUtils.newRangeParameter(repositoryName, currentPatchset.base, currentPatchset.tip), true));

    ListDataProvider<Patchset> compareMenuDp = new ListDataProvider<Patchset>(patchsets);
    DataView<Patchset> compareMenu = new DataView<Patchset>("comparePatch", compareMenuDp) {
        private static final long serialVersionUID = 1L;

        @Override
        public void populateItem(final Item<Patchset> item) {
            Patchset patchset = item.getModelObject();
            LinkPanel link = new LinkPanel("compareLink", null,
                    MessageFormat.format(getString("gb.compareToN"), patchset.number + "-" + patchset.rev),
                    ComparePage.class,
                    WicketUtils.newRangeParameter(getRepositoryModel().name, patchset.tip, currentPatchset.tip),
                    true);
            item.add(link);

        }
    };
    panel.add(compareMenu);

    // reviews
    List<Change> reviews = ticket.getReviews(currentPatchset);
    ListDataProvider<Change> reviewsDp = new ListDataProvider<Change>(reviews);
    DataView<Change> reviewsView = new DataView<Change>("reviews", reviewsDp) {
        private static final long serialVersionUID = 1L;

        @Override
        public void populateItem(final Item<Change> item) {
            Change change = item.getModelObject();
            final String username = change.author;
            UserModel user = app().users().getUserModel(username);
            if (user == null) {
                item.add(new Label("reviewer", username));
            } else {
                item.add(new LinkPanel("reviewer", null, user.getDisplayName(), UserPage.class,
                        WicketUtils.newUsernameParameter(username)));
            }

            // indicate review score
            Review review = change.review;
            Label scoreLabel = new Label("score");
            String scoreClass = getScoreClass(review.score);
            String tooltip = getScoreDescription(review.score);
            WicketUtils.setCssClass(scoreLabel, scoreClass);
            if (!StringUtils.isEmpty(tooltip)) {
                WicketUtils.setHtmlTooltip(scoreLabel, tooltip);
            }
            item.add(scoreLabel);
        }
    };
    panel.add(reviewsView);

    if (ticket.isOpen() && user.canReviewPatchset(repository)
            && app().tickets().isAcceptingTicketUpdates(repository)) {
        // can only review open tickets
        Review myReview = null;
        for (Change change : ticket.getReviews(currentPatchset)) {
            if (change.author.equals(user.username)) {
                myReview = change.review;
            }
        }

        // user can review, add review controls
        Fragment reviewControls = new Fragment("reviewControls", "reviewControlsFragment", TicketPage.this);

        // show "approve" button if no review OR not current score
        if (user.canApprovePatchset(repository) && (myReview == null || Score.approved != myReview.score)) {
            reviewControls.add(createReviewLink("approveLink", Score.approved));
        } else {
            reviewControls.add(new Label("approveLink").setVisible(false));
        }

        // show "looks good" button if no review OR not current score
        if (myReview == null || Score.looks_good != myReview.score) {
            reviewControls.add(createReviewLink("looksGoodLink", Score.looks_good));
        } else {
            reviewControls.add(new Label("looksGoodLink").setVisible(false));
        }

        // show "needs improvement" button if no review OR not current score
        if (myReview == null || Score.needs_improvement != myReview.score) {
            reviewControls.add(createReviewLink("needsImprovementLink", Score.needs_improvement));
        } else {
            reviewControls.add(new Label("needsImprovementLink").setVisible(false));
        }

        // show "veto" button if no review OR not current score
        if (user.canVetoPatchset(repository) && (myReview == null || Score.vetoed != myReview.score)) {
            reviewControls.add(createReviewLink("vetoLink", Score.vetoed));
        } else {
            reviewControls.add(new Label("vetoLink").setVisible(false));
        }
        panel.add(reviewControls);
    } else {
        // user can not review
        panel.add(new Label("reviewControls").setVisible(false));
    }

    String insertions = MessageFormat.format("<span style=\"color:darkGreen;font-weight:bold;\">+{0}</span>",
            ticket.insertions);
    String deletions = MessageFormat.format("<span style=\"color:darkRed;font-weight:bold;\">-{0}</span>",
            ticket.deletions);
    panel.add(new Label("patchsetStat", MessageFormat
            .format(StringUtils.escapeForHtml(getString("gb.diffStat"), false), insertions, deletions))
                    .setEscapeModelStrings(false));

    // changed paths list
    List<PathChangeModel> paths = JGitUtils.getFilesInRange(getRepository(), currentPatchset.base,
            currentPatchset.tip);
    ListDataProvider<PathChangeModel> pathsDp = new ListDataProvider<PathChangeModel>(paths);
    DataView<PathChangeModel> pathsView = new DataView<PathChangeModel>("changedPath", pathsDp) {
        private static final long serialVersionUID = 1L;
        int counter;

        @Override
        public void populateItem(final Item<PathChangeModel> item) {
            final PathChangeModel entry = item.getModelObject();
            Label changeType = new Label("changeType", "");
            WicketUtils.setChangeTypeCssClass(changeType, entry.changeType);
            setChangeTypeTooltip(changeType, entry.changeType);
            item.add(changeType);

            boolean hasSubmodule = false;
            String submodulePath = null;
            if (entry.isTree()) {
                // tree
                item.add(new LinkPanel("pathName", null, entry.path, TreePage.class,
                        WicketUtils.newPathParameter(repositoryName, currentPatchset.tip, entry.path), true));
                item.add(new Label("diffStat").setVisible(false));
            } else if (entry.isSubmodule()) {
                // submodule
                String submoduleId = entry.objectId;
                SubmoduleModel submodule = getSubmodule(entry.path);
                submodulePath = submodule.gitblitPath;
                hasSubmodule = submodule.hasSubmodule;

                item.add(new LinkPanel("pathName", "list", entry.path + " @ " + getShortObjectId(submoduleId),
                        TreePage.class, WicketUtils.newPathParameter(submodulePath, submoduleId, ""), true)
                                .setEnabled(hasSubmodule));
                item.add(new Label("diffStat").setVisible(false));
            } else {
                // blob
                String displayPath = entry.path;
                String path = entry.path;
                if (entry.isSymlink()) {
                    RevCommit commit = JGitUtils.getCommit(getRepository(),
                            PatchsetCommand.getTicketBranch(ticket.number));
                    path = JGitUtils.getStringContent(getRepository(), commit.getTree(), path);
                    displayPath = entry.path + " -> " + path;
                }

                if (entry.changeType.equals(ChangeType.ADD)) {
                    // add show view
                    item.add(new LinkPanel("pathName", "list", displayPath, BlobPage.class,
                            WicketUtils.newPathParameter(repositoryName, currentPatchset.tip, path), true));
                } else if (entry.changeType.equals(ChangeType.DELETE)) {
                    // delete, show label
                    item.add(new Label("pathName", displayPath));
                } else {
                    // mod, show diff
                    item.add(new LinkPanel("pathName", "list", displayPath, BlobDiffPage.class,
                            WicketUtils.newPathParameter(repositoryName, currentPatchset.tip, path), true));
                }
                item.add(new DiffStatPanel("diffStat", entry.insertions, entry.deletions, true));
            }

            // quick links
            if (entry.isSubmodule()) {
                // submodule
                item.add(setNewTarget(new BookmarkablePageLink<Void>("diff", BlobDiffPage.class,
                        WicketUtils.newPathParameter(repositoryName, entry.commitId, entry.path)))
                                .setEnabled(!entry.changeType.equals(ChangeType.ADD)));
                item.add(new BookmarkablePageLink<Void>("view", CommitPage.class,
                        WicketUtils.newObjectParameter(submodulePath, entry.objectId))
                                .setEnabled(hasSubmodule));
            } else {
                // tree or blob
                item.add(setNewTarget(new BookmarkablePageLink<Void>("diff", BlobDiffPage.class,
                        WicketUtils.newBlobDiffParameter(repositoryName, currentPatchset.base,
                                currentPatchset.tip, entry.path)))
                                        .setEnabled(!entry.changeType.equals(ChangeType.ADD)
                                                && !entry.changeType.equals(ChangeType.DELETE)));
                item.add(setNewTarget(new BookmarkablePageLink<Void>("view", BlobPage.class,
                        WicketUtils.newPathParameter(repositoryName, currentPatchset.tip, entry.path)))
                                .setEnabled(!entry.changeType.equals(ChangeType.DELETE)));
            }

            WicketUtils.setAlternatingBackground(item, counter);
            counter++;
        }
    };
    panel.add(pathsView);

    addPtCheckoutInstructions(user, repository, panel);
    addGitCheckoutInstructions(user, repository, panel);

    return panel;
}

---

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

License:Apache License

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

    if (!app().tickets().isReady()) {
        // tickets prohibited
        setResponsePage(SummaryPage.class, WicketUtils.newRepositoryParameter(repositoryName));
    } else if (!app().tickets().hasTickets(getRepositoryModel())) {
        // no tickets for this repository
        setResponsePage(NoTicketsPage.class, WicketUtils.newRepositoryParameter(repositoryName));
    } else {/*  w ww  . ja v  a  2 s.c om*/
        String id = WicketUtils.getObject(params);
        if (id != null) {
            // view the ticket with the TicketPage
            setResponsePage(TicketPage.class, params);
        }
    }

    // set stateless page preference
    setStatelessHint(true);

    any = new TicketResponsible(getString("gb.any"), "[* TO *]", null);

    UserModel user = GitBlitWebSession.get().getUser();
    boolean isAuthenticated = user != null && user.isAuthenticated;

    final String[] statiiParam = (String[]) params.getValues(Lucene.status.name()).stream()
            .map(StringValue::toString).toArray();
    final String assignedToParam = params.get(Lucene.responsible.name()).toString(null);
    final String milestoneParam = params.get(Lucene.milestone.name()).toString(null);
    final String queryParam = params.get("q").toString(null);
    final String searchParam = params.get("s").toString(null);
    final String sortBy = Lucene.fromString(params.get("sort").toString(Lucene.created.name())).name();
    final boolean desc = !"asc".equals(params.get("direction").toString("desc"));

    // add search form
    add(new TicketSearchForm("ticketSearchForm", repositoryName, searchParam, getClass(), params));

    final String activeQuery;
    if (!StringUtils.isEmpty(searchParam)) {
        activeQuery = searchParam;
    } else if (StringUtils.isEmpty(queryParam)) {
        activeQuery = "";
    } else {
        activeQuery = queryParam;
    }

    // build Lucene query from defaults and request parameters
    QueryBuilder qb = new QueryBuilder(queryParam);
    if (!qb.containsField(Lucene.rid.name())) {
        // specify the repository
        qb.and(Lucene.rid.matches(getRepositoryModel().getRID()));
    }
    if (!qb.containsField(Lucene.responsible.name())) {
        // specify the responsible
        qb.and(Lucene.responsible.matches(assignedToParam));
    }
    if (!qb.containsField(Lucene.milestone.name())) {
        // specify the milestone
        qb.and(Lucene.milestone.matches(milestoneParam));
    }
    if (!qb.containsField(Lucene.status.name()) && !ArrayUtils.isEmpty(statiiParam)) {
        // specify the states
        boolean not = false;
        QueryBuilder q = new QueryBuilder();
        for (String state : statiiParam) {
            if (state.charAt(0) == '!') {
                not = true;
                q.and(Lucene.status.doesNotMatch(state.substring(1)));
            } else {
                q.or(Lucene.status.matches(state));
            }
        }
        if (not) {
            qb.and(q.toString());
        } else {
            qb.and(q.toSubquery().toString());
        }
    }
    final String luceneQuery = qb.build();

    // open milestones
    List<TicketMilestone> milestones = app().tickets().getMilestones(getRepositoryModel(), Status.Open);
    TicketMilestone currentMilestone = null;
    if (!StringUtils.isEmpty(milestoneParam)) {
        for (TicketMilestone tm : milestones) {
            if (tm.name.equals(milestoneParam)) {
                // get the milestone (queries the index)
                currentMilestone = app().tickets().getMilestone(getRepositoryModel(), milestoneParam);
                break;
            }
        }

        if (currentMilestone == null) {
            // milestone not found, create a temporary one
            currentMilestone = new TicketMilestone(milestoneParam);
            String q = QueryBuilder.q(Lucene.rid.matches(getRepositoryModel().getRID()))
                    .and(Lucene.milestone.matches(milestoneParam)).build();
            currentMilestone.tickets = app().tickets().queryFor(q, 1, 0, Lucene.number.name(), true);
            milestones.add(currentMilestone);
        }
    }

    Fragment milestonePanel;
    if (currentMilestone == null) {
        milestonePanel = new Fragment("milestonePanel", "noMilestoneFragment", TicketsPage.this);
        add(milestonePanel);
    } else {
        milestonePanel = new Fragment("milestonePanel", "milestoneProgressFragment", TicketsPage.this);
        milestonePanel.add(new Label("currentMilestone", currentMilestone.name));
        if (currentMilestone.due == null) {
            milestonePanel.add(new Label("currentDueDate", getString("gb.notSpecified")));
        } else {
            milestonePanel.add(WicketUtils.createDateLabel("currentDueDate", currentMilestone.due,
                    GitBlitWebSession.get().getTimezone(), getTimeUtils(), false));
        }
        Label label = new Label("progress");
        WicketUtils.setCssStyle(label, "width:" + currentMilestone.getProgress() + "%;");
        milestonePanel.add(label);

        milestonePanel.add(new LinkPanel("openTickets", null,
                MessageFormat.format(getString("gb.nOpenTickets"), currentMilestone.getOpenTickets()),
                TicketsPage.class,
                queryParameters(null, currentMilestone.name, TicketsUI.openStatii, null, sortBy, desc, 1)));

        milestonePanel.add(new LinkPanel("closedTickets", null,
                MessageFormat.format(getString("gb.nClosedTickets"), currentMilestone.getClosedTickets()),
                TicketsPage.class,
                queryParameters(null, currentMilestone.name, TicketsUI.closedStatii, null, sortBy, desc, 1)));

        milestonePanel.add(new Label("totalTickets",
                MessageFormat.format(getString("gb.nTotalTickets"), currentMilestone.getTotalTickets())));
        add(milestonePanel);
    }

    Fragment milestoneDropdown = new Fragment("milestoneDropdown", "milestoneDropdownFragment",
            TicketsPage.this);
    PageParameters resetMilestone = queryParameters(queryParam, null, statiiParam, assignedToParam, sortBy,
            desc, 1);
    milestoneDropdown.add(new BookmarkablePageLink<Void>("resetMilestone", TicketsPage.class, resetMilestone));

    ListDataProvider<TicketMilestone> milestonesDp = new ListDataProvider<TicketMilestone>(milestones);
    DataView<TicketMilestone> milestonesMenu = new DataView<TicketMilestone>("milestone", milestonesDp) {
        private static final long serialVersionUID = 1L;

        @Override
        public void populateItem(final Item<TicketMilestone> item) {
            final TicketMilestone tm = item.getModelObject();
            PageParameters params = queryParameters(queryParam, tm.name, statiiParam, assignedToParam, sortBy,
                    desc, 1);
            item.add(new LinkPanel("milestoneLink", null, tm.name, TicketsPage.class, params)
                    .setRenderBodyOnly(true));
        }
    };
    milestoneDropdown.add(milestonesMenu);
    milestonePanel.add(milestoneDropdown);

    // search or query tickets
    int page = Math.max(1, WicketUtils.getPage(params));
    int pageSize = app().settings().getInteger(Keys.tickets.perPage, 25);
    List<QueryResult> results;
    if (StringUtils.isEmpty(searchParam)) {
        results = app().tickets().queryFor(luceneQuery, page, pageSize, sortBy, desc);
    } else {
        results = app().tickets().searchFor(getRepositoryModel(), searchParam, page, pageSize);
    }
    int totalResults = results.size() == 0 ? 0 : results.get(0).totalResults;

    // standard queries
    add(new BookmarkablePageLink<Void>("changesQuery", TicketsPage.class,
            queryParameters(Lucene.type.matches(TicketModel.Type.Proposal.name()), milestoneParam, statiiParam,
                    assignedToParam, sortBy, desc, 1)));

    add(new BookmarkablePageLink<Void>("bugsQuery", TicketsPage.class,
            queryParameters(Lucene.type.matches(TicketModel.Type.Bug.name()), milestoneParam, statiiParam,
                    assignedToParam, sortBy, desc, 1)));

    add(new BookmarkablePageLink<Void>("enhancementsQuery", TicketsPage.class,
            queryParameters(Lucene.type.matches(TicketModel.Type.Enhancement.name()), milestoneParam,
                    statiiParam, assignedToParam, sortBy, desc, 1)));

    add(new BookmarkablePageLink<Void>("tasksQuery", TicketsPage.class,
            queryParameters(Lucene.type.matches(TicketModel.Type.Task.name()), milestoneParam, statiiParam,
                    assignedToParam, sortBy, desc, 1)));

    add(new BookmarkablePageLink<Void>("questionsQuery", TicketsPage.class,
            queryParameters(Lucene.type.matches(TicketModel.Type.Question.name()), milestoneParam, statiiParam,
                    assignedToParam, sortBy, desc, 1)));

    add(new BookmarkablePageLink<Void>("maintenanceQuery", TicketsPage.class,
            queryParameters(Lucene.type.matches(TicketModel.Type.Maintenance.name()), milestoneParam,
                    statiiParam, assignedToParam, sortBy, desc, 1)));

    add(new BookmarkablePageLink<Void>("resetQuery", TicketsPage.class,
            queryParameters(null, milestoneParam, TicketsUI.openStatii, null, null, true, 1)));

    if (isAuthenticated) {
        add(new Label("userDivider"));
        add(new BookmarkablePageLink<Void>("createdQuery", TicketsPage.class,
                queryParameters(Lucene.createdby.matches(user.username), milestoneParam, statiiParam,
                        assignedToParam, sortBy, desc, 1)));

        add(new BookmarkablePageLink<Void>("watchedQuery", TicketsPage.class,
                queryParameters(Lucene.watchedby.matches(user.username), milestoneParam, statiiParam,
                        assignedToParam, sortBy, desc, 1)));
        add(new BookmarkablePageLink<Void>("mentionsQuery", TicketsPage.class,
                queryParameters(Lucene.mentions.matches(user.username), milestoneParam, statiiParam,
                        assignedToParam, sortBy, desc, 1)));
    } else {
        add(new Label("userDivider").setVisible(false));
        add(new Label("createdQuery").setVisible(false));
        add(new Label("watchedQuery").setVisible(false));
        add(new Label("mentionsQuery").setVisible(false));
    }

    Set<TicketQuery> dynamicQueries = new TreeSet<TicketQuery>();
    for (TicketLabel label : app().tickets().getLabels(getRepositoryModel())) {
        String q = QueryBuilder.q(Lucene.labels.matches(label.name)).build();
        dynamicQueries.add(new TicketQuery(label.name, q).color(label.color));
    }

    for (QueryResult ticket : results) {
        if (!StringUtils.isEmpty(ticket.topic)) {
            String q = QueryBuilder.q(Lucene.topic.matches(ticket.topic)).build();
            dynamicQueries.add(new TicketQuery(ticket.topic, q));
        }

        if (!ArrayUtils.isEmpty(ticket.labels)) {
            for (String label : ticket.labels) {
                String q = QueryBuilder.q(Lucene.labels.matches(label)).build();
                dynamicQueries.add(new TicketQuery(label, q));
            }
        }
    }

    if (dynamicQueries.size() == 0) {
        add(new Label("dynamicQueries").setVisible(false));
    } else {
        Fragment fragment = new Fragment("dynamicQueries", "dynamicQueriesFragment", TicketsPage.this);
        ListDataProvider<TicketQuery> dynamicQueriesDp = new ListDataProvider<TicketQuery>(
                new ArrayList<TicketQuery>(dynamicQueries));
        DataView<TicketQuery> dynamicQueriesList = new DataView<TicketQuery>("dynamicQuery", dynamicQueriesDp) {
            private static final long serialVersionUID = 1L;

            @Override
            public void populateItem(final Item<TicketQuery> item) {
                final TicketQuery tq = item.getModelObject();
                Component swatch = new Label("swatch", "&nbsp;").setEscapeModelStrings(false);
                if (StringUtils.isEmpty(tq.color)) {
                    // calculate a color
                    tq.color = StringUtils.getColor(tq.name);
                }
                String background = MessageFormat.format("background-color:{0};", tq.color);
                swatch.add(new AttributeModifier("style", background));
                item.add(swatch);
                if (activeQuery.contains(tq.query)) {
                    // selected
                    String q = QueryBuilder.q(activeQuery).remove(tq.query).build();
                    PageParameters params = queryParameters(q, milestoneParam, statiiParam, assignedToParam,
                            sortBy, desc, 1);
                    item.add(new LinkPanel("link", "active", tq.name, TicketsPage.class, params)
                            .setRenderBodyOnly(true));
                    Label checked = new Label("checked");
                    WicketUtils.setCssClass(checked, "iconic-o-x");
                    item.add(checked);
                    item.add(new AttributeModifier("style", background));
                } else {
                    // unselected
                    String q = QueryBuilder.q(queryParam).toSubquery().and(tq.query).build();
                    PageParameters params = queryParameters(q, milestoneParam, statiiParam, assignedToParam,
                            sortBy, desc, 1);
                    item.add(new LinkPanel("link", null, tq.name, TicketsPage.class, params)
                            .setRenderBodyOnly(true));
                    item.add(new Label("checked").setVisible(false));
                }
            }
        };
        fragment.add(dynamicQueriesList);
        add(fragment);
    }

    // states
    if (ArrayUtils.isEmpty(statiiParam)) {
        add(new Label("selectedStatii", getString("gb.all")));
    } else {
        add(new Label("selectedStatii", StringUtils.flattenStrings(Arrays.asList(statiiParam), ",")));
    }
    add(new BookmarkablePageLink<Void>("openTickets", TicketsPage.class, queryParameters(queryParam,
            milestoneParam, TicketsUI.openStatii, assignedToParam, sortBy, desc, 1)));
    add(new BookmarkablePageLink<Void>("closedTickets", TicketsPage.class, queryParameters(queryParam,
            milestoneParam, TicketsUI.closedStatii, assignedToParam, sortBy, desc, 1)));
    add(new BookmarkablePageLink<Void>("allTickets", TicketsPage.class,
            queryParameters(queryParam, milestoneParam, null, assignedToParam, sortBy, desc, 1)));

    // by status
    List<Status> statii = new ArrayList<Status>(Arrays.asList(Status.values()));
    statii.remove(Status.Closed);
    ListDataProvider<Status> resolutionsDp = new ListDataProvider<Status>(statii);
    DataView<Status> statiiLinks = new DataView<Status>("statii", resolutionsDp) {
        private static final long serialVersionUID = 1L;

        @Override
        public void populateItem(final Item<Status> item) {
            final Status status = item.getModelObject();
            PageParameters p = queryParameters(queryParam, milestoneParam,
                    new String[] { status.name().toLowerCase() }, assignedToParam, sortBy, desc, 1);
            String css = TicketsUI.getStatusClass(status);
            item.add(new LinkPanel("statusLink", css, status.toString(), TicketsPage.class, p)
                    .setRenderBodyOnly(true));
        }
    };
    add(statiiLinks);

    // responsible filter
    List<TicketResponsible> responsibles = new ArrayList<TicketResponsible>();
    for (RegistrantAccessPermission perm : app().repositories()
            .getUserAccessPermissions(getRepositoryModel())) {
        if (perm.permission.atLeast(AccessPermission.PUSH)) {
            UserModel u = app().users().getUserModel(perm.registrant);
            responsibles.add(new TicketResponsible(u));
        }
    }
    Collections.sort(responsibles);
    responsibles.add(0, any);

    TicketResponsible currentResponsible = null;
    for (TicketResponsible u : responsibles) {
        if (u.username.equals(assignedToParam)) {
            currentResponsible = u;
            break;
        }
    }

    add(new Label("currentResponsible", currentResponsible == null ? "" : currentResponsible.displayname));
    ListDataProvider<TicketResponsible> responsibleDp = new ListDataProvider<TicketResponsible>(responsibles);
    DataView<TicketResponsible> responsibleMenu = new DataView<TicketResponsible>("responsible",
            responsibleDp) {
        private static final long serialVersionUID = 1L;

        @Override
        public void populateItem(final Item<TicketResponsible> item) {
            final TicketResponsible u = item.getModelObject();
            PageParameters params = queryParameters(queryParam, milestoneParam, statiiParam, u.username, sortBy,
                    desc, 1);
            item.add(new LinkPanel("responsibleLink", null, u.displayname, TicketsPage.class, params)
                    .setRenderBodyOnly(true));
        }
    };
    add(responsibleMenu);
    PageParameters resetResponsibleParams = queryParameters(queryParam, milestoneParam, statiiParam, null,
            sortBy, desc, 1);
    add(new BookmarkablePageLink<Void>("resetResponsible", TicketsPage.class, resetResponsibleParams));

    List<TicketSort> sortChoices = new ArrayList<TicketSort>();
    sortChoices.add(new TicketSort(getString("gb.sortNewest"), Lucene.created.name(), true));
    sortChoices.add(new TicketSort(getString("gb.sortOldest"), Lucene.created.name(), false));
    sortChoices.add(new TicketSort(getString("gb.sortMostRecentlyUpdated"), Lucene.updated.name(), true));
    sortChoices.add(new TicketSort(getString("gb.sortLeastRecentlyUpdated"), Lucene.updated.name(), false));
    sortChoices.add(new TicketSort(getString("gb.sortMostComments"), Lucene.comments.name(), true));
    sortChoices.add(new TicketSort(getString("gb.sortLeastComments"), Lucene.comments.name(), false));
    sortChoices.add(new TicketSort(getString("gb.sortMostPatchsetRevisions"), Lucene.patchsets.name(), true));
    sortChoices.add(new TicketSort(getString("gb.sortLeastPatchsetRevisions"), Lucene.patchsets.name(), false));
    sortChoices.add(new TicketSort(getString("gb.sortMostVotes"), Lucene.votes.name(), true));
    sortChoices.add(new TicketSort(getString("gb.sortLeastVotes"), Lucene.votes.name(), false));
    sortChoices.add(new TicketSort(getString("gb.sortHighestPriority"), Lucene.priority.name(), true));
    sortChoices.add(new TicketSort(getString("gb.sortLowestPriority"), Lucene.priority.name(), false));
    sortChoices.add(new TicketSort(getString("gb.sortHighestSeverity"), Lucene.severity.name(), true));
    sortChoices.add(new TicketSort(getString("gb.sortLowestSeverity"), Lucene.severity.name(), false));

    TicketSort currentSort = sortChoices.get(0);
    for (TicketSort ts : sortChoices) {
        if (ts.sortBy.equals(sortBy) && desc == ts.desc) {
            currentSort = ts;
            break;
        }
    }
    add(new Label("currentSort", currentSort.name));

    ListDataProvider<TicketSort> sortChoicesDp = new ListDataProvider<TicketSort>(sortChoices);
    DataView<TicketSort> sortMenu = new DataView<TicketSort>("sort", sortChoicesDp) {
        private static final long serialVersionUID = 1L;

        @Override
        public void populateItem(final Item<TicketSort> item) {
            final TicketSort ts = item.getModelObject();
            PageParameters params = queryParameters(queryParam, milestoneParam, statiiParam, assignedToParam,
                    ts.sortBy, ts.desc, 1);
            item.add(new LinkPanel("sortLink", null, ts.name, TicketsPage.class, params)
                    .setRenderBodyOnly(true));
        }
    };
    add(sortMenu);

    // paging links
    buildPager(queryParam, milestoneParam, statiiParam, assignedToParam, sortBy, desc, page, pageSize,
            results.size(), totalResults);

    add(new TicketListPanel("ticketList", results, false, false));

    // new milestone link
    RepositoryModel repositoryModel = getRepositoryModel();
    final boolean acceptingUpdates = app().tickets().isAcceptingTicketUpdates(repositoryModel) && user != null
            && user.canAdmin(getRepositoryModel());
    if (acceptingUpdates) {
        add(new LinkPanel("newMilestone", null, getString("gb.newMilestone"), NewMilestonePage.class,
                WicketUtils.newRepositoryParameter(repositoryName)));
    } else {
        add(new Label("newMilestone").setVisible(false));
    }

    // milestones list
    List<TicketMilestone> openMilestones = new ArrayList<TicketMilestone>();
    List<TicketMilestone> closedMilestones = new ArrayList<TicketMilestone>();
    for (TicketMilestone milestone : app().tickets().getMilestones(repositoryModel)) {
        if (milestone.isOpen()) {
            openMilestones.add(milestone);
        } else {
            closedMilestones.add(milestone);
        }
    }
    Collections.sort(openMilestones, new Comparator<TicketMilestone>() {
        @Override
        public int compare(TicketMilestone o1, TicketMilestone o2) {
            return o2.due.compareTo(o1.due);
        }
    });

    Collections.sort(closedMilestones, new Comparator<TicketMilestone>() {
        @Override
        public int compare(TicketMilestone o1, TicketMilestone o2) {
            return o2.due.compareTo(o1.due);
        }
    });

    DataView<TicketMilestone> openMilestonesList = milestoneList("openMilestonesList", openMilestones,
            acceptingUpdates);
    add(openMilestonesList);

    DataView<TicketMilestone> closedMilestonesList = milestoneList("closedMilestonesList", closedMilestones,
            acceptingUpdates);
    add(closedMilestonesList);
}

---

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

License:Apache License

protected DataView<TicketMilestone> milestoneList(String wicketId, List<TicketMilestone> milestones,
        final boolean acceptingUpdates) {
    ListDataProvider<TicketMilestone> milestonesDp = new ListDataProvider<TicketMilestone>(milestones);
    DataView<TicketMilestone> milestonesList = new DataView<TicketMilestone>(wicketId, milestonesDp) {
        private static final long serialVersionUID = 1L;

        @Override//w  w w  . j  a v a 2  s  . co m
        public void populateItem(final Item<TicketMilestone> item) {
            Fragment entryPanel = new Fragment("entryPanel", "milestoneListFragment", TicketsPage.this);
            item.add(entryPanel);

            final TicketMilestone tm = item.getModelObject();
            String[] states;
            if (tm.isOpen()) {
                states = TicketsUI.openStatii;
            } else {
                states = TicketsUI.closedStatii;
            }
            PageParameters params = queryParameters(null, tm.name, states, null, null, true, 1);
            entryPanel.add(new LinkPanel("milestoneName", null, tm.name, TicketsPage.class, params)
                    .setRenderBodyOnly(true));

            String css;
            String status = tm.status.name();
            switch (tm.status) {
            case Open:
                if (tm.isOverdue()) {
                    css = "aui-lozenge aui-lozenge-subtle aui-lozenge-error";
                    status = "overdue";
                } else {
                    css = "aui-lozenge aui-lozenge-subtle";
                }
                break;
            default:
                css = "aui-lozenge";
                break;
            }
            Label stateLabel = new Label("milestoneState", status);
            WicketUtils.setCssClass(stateLabel, css);
            entryPanel.add(stateLabel);

            if (tm.due == null) {
                entryPanel.add(new Label("milestoneDue", getString("gb.notSpecified")));
            } else {
                entryPanel.add(WicketUtils.createDatestampLabel("milestoneDue", tm.due, getTimeZone(),
                        getTimeUtils()));
            }
            if (acceptingUpdates) {
                entryPanel.add(new LinkPanel("editMilestone", null, getString("gb.edit"),
                        EditMilestonePage.class, WicketUtils.newObjectParameter(repositoryName, tm.name)));
            } else {
                entryPanel.add(new Label("editMilestone").setVisible(false));
            }

            if (tm.isOpen()) {
                // re-load milestone with query results
                TicketMilestone m = app().tickets().getMilestone(getRepositoryModel(), tm.name);

                Fragment milestonePanel = new Fragment("milestonePanel", "openMilestoneFragment",
                        TicketsPage.this);
                Label label = new Label("progress");
                WicketUtils.setCssStyle(label, "width:" + m.getProgress() + "%;");
                milestonePanel.add(label);

                milestonePanel.add(new LinkPanel("openTickets", null,
                        MessageFormat.format(getString("gb.nOpenTickets"), m.getOpenTickets()),
                        TicketsPage.class,
                        queryParameters(null, tm.name, TicketsUI.openStatii, null, null, true, 1)));

                milestonePanel.add(new LinkPanel("closedTickets", null,
                        MessageFormat.format(getString("gb.nClosedTickets"), m.getClosedTickets()),
                        TicketsPage.class,
                        queryParameters(null, tm.name, TicketsUI.closedStatii, null, null, true, 1)));

                milestonePanel.add(new Label("totalTickets",
                        MessageFormat.format(getString("gb.nTotalTickets"), m.getTotalTickets())));
                entryPanel.add(milestonePanel);
            } else {
                entryPanel.add(new Label("milestonePanel").setVisible(false));
            }
        }
    };
    return milestonesList;
}

---

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

License:Apache License

protected void buildPager(final String query, final String milestone, final String[] states,
        final String assignedTo, final String sort, final boolean desc, final int page, int pageSize, int count,
        int total) {

    boolean showNav = total > (2 * pageSize);
    boolean allowPrev = page > 1;
    boolean allowNext = (pageSize * (page - 1) + count) < total;
    add(new BookmarkablePageLink<Void>("prevLink", TicketsPage.class,
            queryParameters(query, milestone, states, assignedTo, sort, desc, page - 1)).setEnabled(allowPrev)
                    .setVisible(showNav));
    add(new BookmarkablePageLink<Void>("nextLink", TicketsPage.class,
            queryParameters(query, milestone, states, assignedTo, sort, desc, page + 1)).setEnabled(allowNext)
                    .setVisible(showNav));

    if (total <= pageSize) {
        add(new Label("pageLink").setVisible(false));
        return;//from ww w .jav  a 2  s .  co  m
    }

    // determine page numbers to display
    int pages = count == 0 ? 0 : ((total / pageSize) + (total % pageSize == 0 ? 0 : 1));
    // preferred number of pagelinks
    int segments = 5;
    if (pages < segments) {
        // not enough data for preferred number of page links
        segments = pages;
    }
    int minpage = Math.min(Math.max(1, page - 2), pages - (segments - 1));
    int maxpage = Math.min(pages, minpage + (segments - 1));
    List<Integer> sequence = new ArrayList<Integer>();
    for (int i = minpage; i <= maxpage; i++) {
        sequence.add(i);
    }

    ListDataProvider<Integer> pagesDp = new ListDataProvider<Integer>(sequence);
    DataView<Integer> pagesView = new DataView<Integer>("pageLink", pagesDp) {
        private static final long serialVersionUID = 1L;

        @Override
        public void populateItem(final Item<Integer> item) {
            final Integer i = item.getModelObject();
            LinkPanel link = new LinkPanel("page", null, "" + i, TicketsPage.class,
                    queryParameters(query, milestone, states, assignedTo, sort, desc, i));
            link.setRenderBodyOnly(true);
            if (i == page) {
                WicketUtils.setCssClass(item, "active");
            }
            item.add(link);
        }
    };
    add(pagesView);
}

---

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

License:Apache License

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

    final String path = WicketUtils.getPath(params);

    Repository r = getRepository();//  w w  w .  j a va 2 s  .  c  om
    RevCommit commit = getCommit();
    List<PathModel> paths = JGitUtils.getFilesInPath2(r, path, commit);

    // tree page links
    add(new BookmarkablePageLink<Void>("historyLink", HistoryPage.class,
            WicketUtils.newPathParameter(repositoryName, objectId, path)));
    add(new CompressedDownloadsPanel("compressedLinks",
            GitBlitRequestUtils.getRelativePathPrefixToContextRoot(), repositoryName, objectId, path));

    add(new CommitHeaderPanel("commitHeader", repositoryName, commit));

    // breadcrumbs
    add(new PathBreadcrumbsPanel("breadcrumbs", repositoryName, path, objectId));
    if (path != null && path.trim().length() > 0) {
        // add .. parent path entry
        String parentPath = null;
        if (path.lastIndexOf('/') > -1) {
            parentPath = path.substring(0, path.lastIndexOf('/'));
        }
        PathModel model = new PathModel("..", parentPath, null, 0, FileMode.TREE.getBits(), null, objectId);
        model.isParentPath = true;
        paths.add(0, model);
    }

    final String id = getBestCommitId(commit);

    final ByteFormat byteFormat = new ByteFormat();
    final String baseUrl = WicketUtils.getGitblitURL(getRequest());

    // changed paths list
    ListDataProvider<PathModel> pathsDp = new ListDataProvider<PathModel>(paths);
    DataView<PathModel> pathsView = new DataView<PathModel>("changedPath", pathsDp) {
        private static final long serialVersionUID = 1L;
        int counter;

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

            item.add(new Label("pathPermissions", JGitUtils.getPermissionsFromMode(entry.mode)));
            item.add(WicketUtils.setHtmlTooltip(new Label("filestore", ""), getString("gb.filestore"))
                    .setVisible(entry.isFilestoreItem()));

            if (entry.isParentPath) {
                // parent .. path
                item.add(WicketUtils.newBlankImage("pathIcon"));
                item.add(new Label("pathSize", ""));
                item.add(new LinkPanel("pathName", null, entry.name, TreePage.class,
                        WicketUtils.newPathParameter(repositoryName, id, entry.path)));
                item.add(new Label("pathLinks", ""));
            } else {
                if (entry.isTree()) {
                    // folder/tree link
                    item.add(WicketUtils.newImage("pathIcon", "folder_16x16.png"));
                    item.add(new Label("pathSize", ""));
                    item.add(new LinkPanel("pathName", "list", entry.name, TreePage.class,
                            WicketUtils.newPathParameter(repositoryName, id, entry.path)));

                    // links
                    Fragment links = new Fragment("pathLinks", "treeLinks", TreePage.this);
                    links.add(new BookmarkablePageLink<Void>("tree", TreePage.class,
                            WicketUtils.newPathParameter(repositoryName, id, entry.path)));
                    links.add(new BookmarkablePageLink<Void>("history", HistoryPage.class,
                            WicketUtils.newPathParameter(repositoryName, id, entry.path)));
                    links.add(new CompressedDownloadsPanel("compressedLinks", baseUrl, repositoryName, objectId,
                            entry.path));

                    item.add(links);
                } else if (entry.isSubmodule()) {
                    // submodule
                    String submoduleId = entry.objectId;
                    String submodulePath;
                    boolean hasSubmodule = false;
                    SubmoduleModel submodule = getSubmodule(entry.path);
                    submodulePath = submodule.gitblitPath;
                    hasSubmodule = submodule.hasSubmodule;

                    item.add(WicketUtils.newImage("pathIcon", "git-orange-16x16.png"));
                    item.add(new Label("pathSize", ""));
                    item.add(new LinkPanel("pathName", "list",
                            entry.name + " @ " + getShortObjectId(submoduleId), TreePage.class,
                            WicketUtils.newPathParameter(submodulePath, submoduleId, ""))
                                    .setEnabled(hasSubmodule));

                    Fragment links = new Fragment("pathLinks", "submoduleLinks", TreePage.this);
                    links.add(new BookmarkablePageLink<Void>("view", SummaryPage.class,
                            WicketUtils.newRepositoryParameter(submodulePath)).setEnabled(hasSubmodule));
                    links.add(new BookmarkablePageLink<Void>("tree", TreePage.class,
                            WicketUtils.newPathParameter(submodulePath, submoduleId, ""))
                                    .setEnabled(hasSubmodule));
                    links.add(new BookmarkablePageLink<Void>("history", HistoryPage.class,
                            WicketUtils.newPathParameter(repositoryName, id, entry.path)));
                    links.add(new CompressedDownloadsPanel("compressedLinks", baseUrl, submodulePath,
                            submoduleId, "").setEnabled(hasSubmodule));
                    item.add(links);
                } else {
                    // blob link
                    String displayPath = entry.name;
                    String path = entry.path;
                    if (entry.isSymlink()) {
                        path = JGitUtils.getStringContent(getRepository(), getCommit().getTree(), path);
                        displayPath = entry.name + " -> " + path;
                    }
                    item.add(WicketUtils.getFileImage("pathIcon", entry.name));
                    item.add(new Label("pathSize", byteFormat.format(entry.size)));

                    // links
                    Fragment links = new Fragment("pathLinks", "blobLinks", TreePage.this);

                    if (entry.isFilestoreItem()) {
                        item.add(new LinkPanel("pathName", "list", displayPath, new Link<Object>("link", null) {

                            private static final long serialVersionUID = 1L;

                            @Override
                            public void onClick() {

                                IResourceStream resourceStream = new AbstractResourceStreamWriter() {

                                    private static final long serialVersionUID = 1L;

                                    @Override
                                    public void write(OutputStream output) {
                                        UserModel user = GitBlitWebSession.get().getUser();
                                        user = user == null ? UserModel.ANONYMOUS : user;

                                        app().filestore().downloadBlob(entry.getFilestoreOid(), user,
                                                getRepositoryModel(), output);
                                    }
                                };

                                ResourceStreamRequestHandler resourceStreamRequestHandler = new ResourceStreamRequestHandler(
                                        resourceStream, entry.path);
                                getRequestCycle()
                                        .scheduleRequestHandlerAfterCurrent(resourceStreamRequestHandler);

                            }
                        }));

                        links.add(new Link<Object>("view", null) {

                            private static final long serialVersionUID = 1L;

                            @Override
                            public void onClick() {

                                IResourceStream resourceStream = new AbstractResourceStreamWriter() {

                                    private static final long serialVersionUID = 1L;

                                    @Override
                                    public void write(OutputStream output) {
                                        UserModel user = GitBlitWebSession.get().getUser();
                                        user = user == null ? UserModel.ANONYMOUS : user;

                                        app().filestore().downloadBlob(entry.getFilestoreOid(), user,
                                                getRepositoryModel(), output);
                                    }
                                };

                                ResourceStreamRequestHandler resourceStreamRequestHandler = new ResourceStreamRequestHandler(
                                        resourceStream, entry.path);
                                getRequestCycle()
                                        .scheduleRequestHandlerAfterCurrent(resourceStreamRequestHandler);
                            }
                        });

                        links.add(new Link<Object>("raw", null) {

                            private static final long serialVersionUID = 1L;

                            @Override
                            public void onClick() {

                                IResourceStream resourceStream = new AbstractResourceStreamWriter() {

                                    private static final long serialVersionUID = 1L;

                                    @Override
                                    public void write(OutputStream output) {
                                        UserModel user = GitBlitWebSession.get().getUser();
                                        user = user == null ? UserModel.ANONYMOUS : user;

                                        app().filestore().downloadBlob(entry.getFilestoreOid(), user,
                                                getRepositoryModel(), output);
                                    }
                                };

                                ResourceStreamRequestHandler resourceStreamRequestHandler = new ResourceStreamRequestHandler(
                                        resourceStream, entry.path);
                                getRequestCycle()
                                        .scheduleRequestHandlerAfterCurrent(resourceStreamRequestHandler);
                            }
                        });

                    } else {
                        item.add(new LinkPanel("pathName", "list", displayPath, BlobPage.class,
                                WicketUtils.newPathParameter(repositoryName, id, path)));

                        links.add(new BookmarkablePageLink<Void>("view", BlobPage.class,
                                WicketUtils.newPathParameter(repositoryName, id, path)));
                        String rawUrl = RawServlet.asLink(getContextUrl(), repositoryName, id, path);
                        links.add(new ExternalLink("raw", rawUrl));
                    }

                    links.add(new BookmarkablePageLink<Void>("blame", BlamePage.class,
                            WicketUtils.newPathParameter(repositoryName, id, path)));
                    links.add(new BookmarkablePageLink<Void>("history", HistoryPage.class,
                            WicketUtils.newPathParameter(repositoryName, id, path)));
                    item.add(links);
                }
            }
            WicketUtils.setAlternatingBackground(item, counter);
            counter++;
        }
    };
    add(pathsView);
}

---

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

License:Apache License

private void setup(PageParameters params) {
    setupPage("", "");
    // check to see if we should display a login message
    boolean authenticateView = app().settings().getBoolean(Keys.web.authenticateViewPages, true);
    if (authenticateView && !GitBlitWebSession.get().isLoggedIn()) {
        authenticationError("Please login");
        return;/*from   w  w  w.  j ava2 s .co m*/
    }

    String userName = WicketUtils.getUsername(params);
    if (StringUtils.isEmpty(userName)) {
        throw new GitblitRedirectException(GitBlitWebApp.get().getHomePage());
    }

    UserModel user = app().users().getUserModel(userName);
    if (user == null) {
        // construct a temporary user model
        user = new UserModel(userName);
    }

    add(new UserTitlePanel("userTitlePanel", user, user.username));

    UserModel sessionUser = GitBlitWebSession.get().getUser();
    boolean isMyProfile = sessionUser != null && sessionUser.equals(user);

    if (isMyProfile) {
        addPreferences(user);

        if (app().services().isServingSSH()) {
            // show the SSH key management tab
            addSshKeys(user);
        } else {
            // SSH daemon is disabled, hide keys tab
            add(new Label("sshKeysLink").setVisible(false));
            add(new Label("sshKeysTab").setVisible(false));
        }
    } else {
        // visiting user
        add(new Label("preferencesLink").setVisible(false));
        add(new Label("preferencesTab").setVisible(false));

        add(new Label("sshKeysLink").setVisible(false));
        add(new Label("sshKeysTab").setVisible(false));
    }

    List<RepositoryModel> repositories = getRepositories(params);

    Collections.sort(repositories, new Comparator<RepositoryModel>() {
        @Override
        public int compare(RepositoryModel o1, RepositoryModel o2) {
            // reverse-chronological sort
            return o2.lastChange.compareTo(o1.lastChange);
        }
    });

    final ListDataProvider<RepositoryModel> dp = new ListDataProvider<RepositoryModel>(repositories);
    DataView<RepositoryModel> dataView = new DataView<RepositoryModel>("repositoryList", dp) {
        private static final long serialVersionUID = 1L;

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

            ProjectRepositoryPanel row = new ProjectRepositoryPanel("repository", getLocalizer(), this,
                    showAdmin, entry, getAccessRestrictions());
            item.add(row);
        }
    };
    add(dataView);
}

---

From source file:com.gitblit.wicket.panels.ActivityPanel.java

License:Apache License

public ActivityPanel(String wicketId, List<Activity> recentActivity) {
    super(wicketId);

    Collections.sort(recentActivity);

    final int shortHashLen = app().settings().getInteger(Keys.web.shortCommitIdLength, 6);
    DataView<Activity> activityView = new DataView<Activity>("activity",
            new ListDataProvider<Activity>(recentActivity)) {
        private static final long serialVersionUID = 1L;

        @Override//from w w w. j  a  v  a2 s . co  m
        public void populateItem(final Item<Activity> activityItem) {
            final Activity entry = activityItem.getModelObject();
            activityItem.add(
                    WicketUtils.createDatestampLabel("title", entry.startDate, getTimeZone(), getTimeUtils()));

            // display the commits in chronological order
            DataView<RepositoryCommit> commits = new DataView<RepositoryCommit>("commit",
                    new ListDataProvider<RepositoryCommit>(entry.getCommits())) {
                private static final long serialVersionUID = 1L;

                @Override
                public void populateItem(final Item<RepositoryCommit> commitItem) {
                    final RepositoryCommit commit = commitItem.getModelObject();

                    // commit time of day
                    commitItem.add(WicketUtils.createTimeLabel("time", commit.getCommitterIdent().getWhen(),
                            getTimeZone(), getTimeUtils()));

                    // avatar
                    commitItem.add(new AvatarImage("avatar", commit.getAuthorIdent(), 40));

                    // merge icon
                    if (commit.getParentCount() > 1) {
                        commitItem.add(WicketUtils.newImage("commitIcon", "commit_merge_16x16.png"));
                    } else {
                        commitItem.add(WicketUtils.newBlankImage("commitIcon").setVisible(false));
                    }

                    // author search link
                    String author = commit.getAuthorIdent().getName();
                    LinkPanel authorLink = new LinkPanel("author", "list", author, GitSearchPage.class,
                            WicketUtils.newSearchParameter(commit.repository, null, author,
                                    Constants.SearchType.AUTHOR),
                            true);
                    setPersonSearchTooltip(authorLink, author, Constants.SearchType.AUTHOR);
                    commitItem.add(authorLink);

                    // repository
                    String repoName = StringUtils.stripDotGit(commit.repository);
                    LinkPanel repositoryLink = new LinkPanel("repository", null, repoName, SummaryPage.class,
                            WicketUtils.newRepositoryParameter(commit.repository), true);
                    WicketUtils.setCssBackground(repositoryLink, repoName);
                    commitItem.add(repositoryLink);

                    // repository branch
                    LinkPanel branchLink = new LinkPanel("branch", "list",
                            Repository.shortenRefName(commit.branch), LogPage.class,
                            WicketUtils.newObjectParameter(commit.repository, commit.branch), true);
                    WicketUtils.setCssStyle(branchLink, "color: #008000;");
                    commitItem.add(branchLink);

                    LinkPanel commitid = new LinkPanel("commitid", "list subject",
                            commit.getName().substring(0, shortHashLen), CommitPage.class,
                            WicketUtils.newObjectParameter(commit.repository, commit.getName()), true);
                    commitItem.add(commitid);

                    // message/commit link
                    String shortMessage = commit.getShortMessage();
                    String trimmedMessage = shortMessage;
                    if (commit.getRefs() != null && commit.getRefs().size() > 0) {
                        trimmedMessage = StringUtils.trimString(shortMessage, Constants.LEN_SHORTLOG_REFS);
                    } else {
                        trimmedMessage = StringUtils.trimString(shortMessage, Constants.LEN_SHORTLOG);
                    }
                    LinkPanel shortlog = new LinkPanel("message", "list subject", trimmedMessage,
                            CommitPage.class,
                            WicketUtils.newObjectParameter(commit.repository, commit.getName()), true);
                    if (!shortMessage.equals(trimmedMessage)) {
                        WicketUtils.setHtmlTooltip(shortlog, shortMessage);
                    }
                    commitItem.add(shortlog);

                    // refs
                    commitItem.add(new RefsPanel("commitRefs", commit.repository, commit.getRefs()));

                    // diff, tree links
                    commitItem.add(new BookmarkablePageLink<Void>("diff", CommitDiffPage.class,
                            WicketUtils.newObjectParameter(commit.repository, commit.getName()))
                                    .setEnabled(commit.getParentCount() > 0));
                    commitItem.add(new BookmarkablePageLink<Void>("tree", TreePage.class,
                            WicketUtils.newObjectParameter(commit.repository, commit.getName())));
                }
            };
            activityItem.add(commits);
        }
    };
    add(activityView);
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• »