Examples with ProjectModel com.gitblit.models.ProjectModel used on opensource projects

Example 1 with ProjectModel

use of com.gitblit.models.ProjectModel in project gitblit by gitblit.

the class MyDashboardPage method setup.

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()) {
        String messageSource = app().settings().getString(Keys.web.loginMessage, "gitblit");
        String message = readMarkdown(messageSource, "login.mkd");
        Component repositoriesMessage = new Label("repositoriesMessage", message);
        add(repositoriesMessage.setEscapeModelStrings(false));
        add(new Label("activity").setVisible(false));
        add(new Label("repositoryTabs").setVisible(false));
        return;
    }
    // Load the markdown welcome message
    String messageSource = app().settings().getString(Keys.web.repositoriesMessage, "gitblit");
    String message = readMarkdown(messageSource, "welcome.mkd");
    Component repositoriesMessage = new Label("repositoriesMessage", message).setEscapeModelStrings(false).setVisible(message.length() > 0);
    add(repositoriesMessage);
    UserModel user = GitBlitWebSession.get().getUser();
    if (user == null) {
        user = UserModel.ANONYMOUS;
    }
    // parameters
    int daysBack = params == null ? 0 : WicketUtils.getDaysBack(params);
    int maxDaysBack = app().settings().getInteger(Keys.web.activityDurationMaximum, 30);
    if (daysBack < 1) {
        daysBack = app().settings().getInteger(Keys.web.activityDuration, 7);
    }
    if (maxDaysBack > 0 && daysBack > maxDaysBack) {
        daysBack = maxDaysBack;
    }
    Calendar c = Calendar.getInstance();
    c.add(Calendar.DATE, -1 * daysBack);
    Date minimumDate = c.getTime();
    // build repo lists
    List<RepositoryModel> starred = new ArrayList<RepositoryModel>();
    List<RepositoryModel> owned = new ArrayList<RepositoryModel>();
    List<RepositoryModel> active = new ArrayList<RepositoryModel>();
    for (RepositoryModel model : getRepositoryModels()) {
        if (model.isUsersPersonalRepository(user.username) || model.isOwner(user.username)) {
            owned.add(model);
        }
        if (user.getPreferences().isStarredRepository(model.name)) {
            starred.add(model);
        }
        if (model.isShowActivity() && model.lastChange.after(minimumDate)) {
            active.add(model);
        }
    }
    Comparator<RepositoryModel> lastUpdateSort = new Comparator<RepositoryModel>() {

        @Override
        public int compare(RepositoryModel o1, RepositoryModel o2) {
            return o2.lastChange.compareTo(o1.lastChange);
        }
    };
    Collections.sort(owned, lastUpdateSort);
    Collections.sort(starred, lastUpdateSort);
    Collections.sort(active, lastUpdateSort);
    String activityTitle;
    Set<RepositoryModel> feed = new HashSet<RepositoryModel>();
    feed.addAll(starred);
    feed.addAll(owned);
    if (feed.isEmpty()) {
        // no starred or owned, go with recent activity
        activityTitle = getString("gb.recentActivity");
        feed.addAll(active);
    } else if (starred.isEmpty()) {
        // no starred, owned repos feed
        activityTitle = getString("gb.owned");
    } else if (owned.isEmpty()) {
        // no owned, starred repos feed
        activityTitle = getString("gb.starred");
    } else {
        // starred and owned repositories
        activityTitle = getString("gb.starredAndOwned");
    }
    addActivity(user, feed, activityTitle, daysBack);
    Fragment repositoryTabs;
    if (UserModel.ANONYMOUS.equals(user)) {
        repositoryTabs = new Fragment("repositoryTabs", "anonymousTabsFragment", this);
    } else {
        repositoryTabs = new Fragment("repositoryTabs", "authenticatedTabsFragment", this);
    }
    add(repositoryTabs);
    // projects list
    List<ProjectModel> projects = app().projects().getProjectModels(getRepositoryModels(), false);
    repositoryTabs.add(new FilterableProjectList("projects", projects));
    // active repository list
    if (active.isEmpty()) {
        repositoryTabs.add(new Label("active").setVisible(false));
    } else {
        FilterableRepositoryList repoList = new FilterableRepositoryList("active", active);
        repoList.setTitle(getString("gb.activeRepositories"), "icon-time");
        repositoryTabs.add(repoList);
    }
    // starred repository list
    if (ArrayUtils.isEmpty(starred)) {
        repositoryTabs.add(new Label("starred").setVisible(false));
    } else {
        FilterableRepositoryList repoList = new FilterableRepositoryList("starred", starred);
        repoList.setTitle(getString("gb.starredRepositories"), "icon-star");
        repositoryTabs.add(repoList);
    }
    // owned repository list
    if (ArrayUtils.isEmpty(owned)) {
        repositoryTabs.add(new Label("owned").setVisible(false));
    } else {
        FilterableRepositoryList repoList = new FilterableRepositoryList("owned", owned);
        repoList.setTitle(getString("gb.myRepositories"), "icon-user");
        repoList.setAllowCreate(user.canCreate() || user.canAdmin());
        repositoryTabs.add(repoList);
    }
}

Example 2 with ProjectModel

use of com.gitblit.models.ProjectModel in project gitblit by gitblit.

the class ProjectPage method getProjectsMenu.

protected List<MenuItem> getProjectsMenu() {
    List<MenuItem> menu = new ArrayList<MenuItem>();
    List<ProjectModel> projects = new ArrayList<ProjectModel>();
    for (ProjectModel model : getProjectModels()) {
        if (!model.isUserProject()) {
            projects.add(model);
        }
    }
    int maxProjects = 15;
    boolean showAllProjects = projects.size() > maxProjects;
    if (showAllProjects) {
        // sort by last changed
        Collections.sort(projects, new Comparator<ProjectModel>() {

            @Override
            public int compare(ProjectModel o1, ProjectModel o2) {
                return o2.lastChange.compareTo(o1.lastChange);
            }
        });
        // take most recent subset
        projects = projects.subList(0, maxProjects);
        // sort those by name
        Collections.sort(projects);
    }
    for (ProjectModel project : projects) {
        menu.add(new ParameterMenuItem(project.getDisplayName(), "p", project.name));
    }
    if (showAllProjects) {
        menu.add(new MenuDivider());
        menu.add(new ParameterMenuItem("all projects"));
    }
    return menu;
}

Example 3 with ProjectModel

use of com.gitblit.models.ProjectModel in project gitblit by gitblit.

the class BasePage method getProjectModels.

protected List<ProjectModel> getProjectModels() {
    final UserModel user = GitBlitWebSession.get().getUser();
    List<ProjectModel> projects = app().projects().getProjectModels(user, true);
    return projects;
}

Example 4 with ProjectModel

use of com.gitblit.models.ProjectModel in project gitblit by gitblit.

the class SyndicationServlet method processRequest.

/**
 * Generates the feed content.
 *
 * @param request
 * @param response
 * @throws javax.servlet.ServletException
 * @throws java.io.IOException
 */
private void processRequest(javax.servlet.http.HttpServletRequest request, javax.servlet.http.HttpServletResponse response) throws javax.servlet.ServletException, java.io.IOException {
    String servletUrl = request.getContextPath() + request.getServletPath();
    String url = request.getRequestURI().substring(servletUrl.length());
    if (url.length() > 1 && url.charAt(0) == '/') {
        url = url.substring(1);
    }
    String repositoryName = url;
    String objectId = request.getParameter("h");
    String l = request.getParameter("l");
    String page = request.getParameter("pg");
    String searchString = request.getParameter("s");
    Constants.SearchType searchType = Constants.SearchType.COMMIT;
    if (!StringUtils.isEmpty(request.getParameter("st"))) {
        Constants.SearchType type = Constants.SearchType.forName(request.getParameter("st"));
        if (type != null) {
            searchType = type;
        }
    }
    Constants.FeedObjectType objectType = Constants.FeedObjectType.COMMIT;
    if (!StringUtils.isEmpty(request.getParameter("ot"))) {
        Constants.FeedObjectType type = Constants.FeedObjectType.forName(request.getParameter("ot"));
        if (type != null) {
            objectType = type;
        }
    }
    int length = settings.getInteger(Keys.web.syndicationEntries, 25);
    if (StringUtils.isEmpty(objectId)) {
        objectId = org.eclipse.jgit.lib.Constants.HEAD;
    }
    if (!StringUtils.isEmpty(l)) {
        try {
            length = Integer.parseInt(l);
        } catch (NumberFormatException x) {
        }
    }
    int offset = 0;
    if (!StringUtils.isEmpty(page)) {
        try {
            offset = length * Integer.parseInt(page);
        } catch (NumberFormatException x) {
        }
    }
    response.setContentType("application/rss+xml; charset=UTF-8");
    boolean isProjectFeed = false;
    String feedName = "Gitblit";
    String feedTitle = null;
    String feedDescription = null;
    List<String> repositories = null;
    if (repositoryName.indexOf('/') == -1 && !repositoryName.toLowerCase().endsWith(".git")) {
        // try to find a project
        UserModel user = null;
        if (request instanceof AuthenticatedRequest) {
            user = ((AuthenticatedRequest) request).getUser();
        }
        ProjectModel project = projectManager.getProjectModel(repositoryName, user);
        if (project != null) {
            isProjectFeed = true;
            repositories = new ArrayList<String>(project.repositories);
            // project feed
            feedName = project.name;
            feedTitle = project.title;
            feedDescription = project.description;
        }
    }
    if (repositories == null) {
        // could not find project, assume this is a repository
        repositories = Arrays.asList(repositoryName);
    }
    boolean mountParameters = settings.getBoolean(Keys.web.mountParameters, true);
    String gitblitUrl = settings.getString(Keys.web.canonicalUrl, null);
    if (StringUtils.isEmpty(gitblitUrl)) {
        gitblitUrl = HttpUtils.getGitblitURL(request);
    }
    char fsc = settings.getChar(Keys.web.forwardSlashCharacter, '/');
    List<FeedEntryModel> entries = new ArrayList<FeedEntryModel>();
    for (String name : repositories) {
        Repository repository = repositoryManager.getRepository(name);
        RepositoryModel model = repositoryManager.getRepositoryModel(name);
        if (repository == null) {
            if (model != null && model.isCollectingGarbage) {
                logger.warn(MessageFormat.format("Temporarily excluding {0} from feed, busy collecting garbage", name));
            }
            continue;
        }
        if (!isProjectFeed) {
            // single-repository feed
            feedName = model.name;
            feedTitle = model.name;
            feedDescription = model.description;
        }
        if (objectType == Constants.FeedObjectType.TAG) {
            String urlPattern;
            if (mountParameters) {
                // mounted parameters
                urlPattern = "{0}/tag/{1}/{2}";
            } else {
                // parameterized parameters
                urlPattern = "{0}/tag/?r={1}&h={2}";
            }
            List<RefModel> tags = JGitUtils.getTags(repository, false, length, offset);
            for (RefModel tag : tags) {
                FeedEntryModel entry = new FeedEntryModel();
                entry.title = tag.getName();
                entry.author = tag.getAuthorIdent().getName();
                entry.link = MessageFormat.format(urlPattern, gitblitUrl, StringUtils.encodeURL(model.name.replace('/', fsc)), tag.getObjectId().getName());
                entry.published = tag.getDate();
                entry.contentType = "text/html";
                entry.content = tag.getFullMessage();
                entry.repository = model.name;
                entry.branch = objectId;
                entry.tags = new ArrayList<String>();
                // add tag id and referenced commit id
                entry.tags.add("tag:" + tag.getObjectId().getName());
                entry.tags.add("commit:" + tag.getReferencedObjectId().getName());
                entries.add(entry);
            }
        } else {
            String urlPattern;
            if (mountParameters) {
                // mounted parameters
                urlPattern = "{0}/commit/{1}/{2}";
            } else {
                // parameterized parameters
                urlPattern = "{0}/commit/?r={1}&h={2}";
            }
            List<RevCommit> commits;
            if (StringUtils.isEmpty(searchString)) {
                // standard log/history lookup
                commits = JGitUtils.getRevLog(repository, objectId, offset, length);
            } else {
                // repository search
                commits = JGitUtils.searchRevlogs(repository, objectId, searchString, searchType, offset, length);
            }
            Map<ObjectId, List<RefModel>> allRefs = JGitUtils.getAllRefs(repository, model.showRemoteBranches);
            BugtraqProcessor processor = new BugtraqProcessor(settings);
            // convert RevCommit to SyndicatedEntryModel
            for (RevCommit commit : commits) {
                FeedEntryModel entry = new FeedEntryModel();
                entry.title = commit.getShortMessage();
                entry.author = commit.getAuthorIdent().getName();
                entry.link = MessageFormat.format(urlPattern, gitblitUrl, StringUtils.encodeURL(model.name.replace('/', fsc)), commit.getName());
                entry.published = commit.getCommitterIdent().getWhen();
                entry.contentType = "text/html";
                String message = processor.processCommitMessage(repository, model, commit.getFullMessage());
                entry.content = message;
                entry.repository = model.name;
                entry.branch = objectId;
                entry.tags = new ArrayList<String>();
                // add commit id and parent commit ids
                entry.tags.add("commit:" + commit.getName());
                for (RevCommit parent : commit.getParents()) {
                    entry.tags.add("parent:" + parent.getName());
                }
                // add refs to tabs list
                List<RefModel> refs = allRefs.get(commit.getId());
                if (refs != null && refs.size() > 0) {
                    for (RefModel ref : refs) {
                        entry.tags.add("ref:" + ref.getName());
                    }
                }
                entries.add(entry);
            }
        }
    }
    // sort & truncate the feed
    Collections.sort(entries);
    if (entries.size() > length) {
        // clip the list
        entries = entries.subList(0, length);
    }
    String feedLink;
    if (isProjectFeed) {
        // project feed
        if (mountParameters) {
            // mounted url
            feedLink = MessageFormat.format("{0}/project/{1}", gitblitUrl, StringUtils.encodeURL(feedName));
        } else {
            // parameterized url
            feedLink = MessageFormat.format("{0}/project/?p={1}", gitblitUrl, StringUtils.encodeURL(feedName));
        }
    } else {
        // repository feed
        if (mountParameters) {
            // mounted url
            feedLink = MessageFormat.format("{0}/summary/{1}", gitblitUrl, StringUtils.encodeURL(feedName.replace('/', fsc)));
        } else {
            // parameterized url
            feedLink = MessageFormat.format("{0}/summary/?r={1}", gitblitUrl, StringUtils.encodeURL(feedName));
        }
    }
    try {
        SyndicationUtils.toRSS(gitblitUrl, feedLink, getTitle(feedTitle, objectId), feedDescription, entries, response.getOutputStream());
    } catch (Exception e) {
        logger.error("An error occurred during feed generation", e);
    }
}

Example 5 with ProjectModel

use of com.gitblit.models.ProjectModel in project gitblit by gitblit.

the class SyndicationFilter method doFilter.

/**
 * doFilter does the actual work of preprocessing the request to ensure that
 * the user may proceed.
 *
 * @see javax.servlet.Filter#doFilter(javax.servlet.ServletRequest,
 *      javax.servlet.ServletResponse, javax.servlet.FilterChain)
 */
@Override
public void doFilter(final ServletRequest request, final ServletResponse response, final FilterChain chain) throws IOException, ServletException {
    HttpServletRequest httpRequest = (HttpServletRequest) request;
    HttpServletResponse httpResponse = (HttpServletResponse) response;
    String fullUrl = getFullUrl(httpRequest);
    String name = extractRequestedName(fullUrl);
    ProjectModel project = projectManager.getProjectModel(name);
    RepositoryModel model = null;
    if (project == null) {
        // try loading a repository model
        model = repositoryManager.getRepositoryModel(name);
        if (model == null) {
            // repository not found. send 404.
            logger.info(MessageFormat.format("ARF: {0} ({1})", fullUrl, HttpServletResponse.SC_NOT_FOUND));
            httpResponse.sendError(HttpServletResponse.SC_NOT_FOUND);
            return;
        }
    }
    // Wrap the HttpServletRequest with the AccessRestrictionRequest which
    // overrides the servlet container user principal methods.
    // JGit requires either:
    // 
    // 1. servlet container authenticated user
    // 2. http.receivepack = true in each repository's config
    // 
    // Gitblit must conditionally authenticate users per-repository so just
    // enabling http.receivepack is insufficient.
    AuthenticatedRequest authenticatedRequest = new AuthenticatedRequest(httpRequest);
    UserModel user = getUser(httpRequest);
    if (user != null) {
        authenticatedRequest.setUser(user);
    }
    // BASIC authentication challenge and response processing
    if (model != null) {
        if (model.accessRestriction.atLeast(AccessRestrictionType.VIEW)) {
            if (user == null) {
                // challenge client to provide credentials. send 401.
                if (runtimeManager.isDebugMode()) {
                    logger.info(MessageFormat.format("ARF: CHALLENGE {0}", fullUrl));
                }
                httpResponse.setHeader("WWW-Authenticate", CHALLENGE);
                httpResponse.sendError(HttpServletResponse.SC_UNAUTHORIZED);
                return;
            } else {
                // check user access for request
                if (user.canView(model)) {
                    // authenticated request permitted.
                    // pass processing to the restricted servlet.
                    newSession(authenticatedRequest, httpResponse);
                    logger.info(MessageFormat.format("ARF: {0} ({1}) authenticated", fullUrl, HttpServletResponse.SC_CONTINUE));
                    chain.doFilter(authenticatedRequest, httpResponse);
                    return;
                }
                // valid user, but not for requested access. send 403.
                if (runtimeManager.isDebugMode()) {
                    logger.info(MessageFormat.format("ARF: {0} forbidden to access {1}", user.username, fullUrl));
                }
                httpResponse.sendError(HttpServletResponse.SC_FORBIDDEN);
                return;
            }
        }
    }
    if (runtimeManager.isDebugMode()) {
        logger.info(MessageFormat.format("ARF: {0} ({1}) unauthenticated", fullUrl, HttpServletResponse.SC_CONTINUE));
    }
    // unauthenticated request permitted.
    // pass processing to the restricted servlet.
    chain.doFilter(authenticatedRequest, httpResponse);
}