From d65f712ea3d8941f4b9145c0630c30c20af80d13 Mon Sep 17 00:00:00 2001
From: James Moger <james.moger@gitblit.com>
Date: Fri, 11 Nov 2011 17:22:21 -0500
Subject: [PATCH] Documentation. Add javadoc and source jars to the gbapi download.

---
 src/com/gitblit/client/GitblitClient.java |  231 +++++++++++++++++++++++++++++++++------------------------
 1 files changed, 132 insertions(+), 99 deletions(-)

diff --git a/src/com/gitblit/client/GitblitClient.java b/src/com/gitblit/client/GitblitClient.java
index ccde45a..c027537 100644
--- a/src/com/gitblit/client/GitblitClient.java
+++ b/src/com/gitblit/client/GitblitClient.java
@@ -19,21 +19,24 @@
 import java.io.Serializable;
 import java.util.ArrayList;
 import java.util.Collections;
+import java.util.Date;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
+import com.gitblit.Constants;
 import com.gitblit.GitBlitException.ForbiddenException;
 import com.gitblit.GitBlitException.NotAllowedException;
 import com.gitblit.GitBlitException.UnauthorizedException;
 import com.gitblit.GitBlitException.UnknownRequestException;
 import com.gitblit.Keys;
 import com.gitblit.models.FederationModel;
+import com.gitblit.models.FeedEntryModel;
+import com.gitblit.models.FeedModel;
 import com.gitblit.models.RepositoryModel;
 import com.gitblit.models.ServerSettings;
 import com.gitblit.models.ServerStatus;
-import com.gitblit.models.SyndicatedEntryModel;
 import com.gitblit.models.UserModel;
 import com.gitblit.utils.RpcUtils;
 import com.gitblit.utils.StringUtils;
@@ -49,6 +52,8 @@
 public class GitblitClient implements Serializable {
 
 	private static final long serialVersionUID = 1L;
+
+	private static final Date NEVER = new Date(0);
 
 	protected final GitblitRegistration reg;
 
@@ -70,7 +75,11 @@
 
 	private final List<FederationModel> federationRegistrations;
 
-	private final List<SyndicatedEntryModel> syndicatedEntries;
+	private final List<FeedModel> availableFeeds;
+
+	private final List<FeedEntryModel> syndicatedEntries;
+
+	private final Set<String> subscribedRepositories;
 
 	private ServerStatus status;
 
@@ -83,24 +92,21 @@
 		this.allUsers = new ArrayList<UserModel>();
 		this.allRepositories = new ArrayList<RepositoryModel>();
 		this.federationRegistrations = new ArrayList<FederationModel>();
-		this.syndicatedEntries = new ArrayList<SyndicatedEntryModel>();
+		this.availableFeeds = new ArrayList<FeedModel>();
+		this.syndicatedEntries = new ArrayList<FeedEntryModel>();
+		this.subscribedRepositories = new HashSet<String>();
 	}
 
 	public void login() throws IOException {
+		refreshSettings();
+		refreshAvailableFeeds();
 		refreshRepositories();
+		refreshSubscribedFeeds(0);
 
-		try {
-			// RSS feeds may be disabled by server
-			refreshSubscribedFeeds();
-		} catch (IOException e) {
-			e.printStackTrace();
-		}
-		
 		try {
 			// credentials may not have administrator access
 			// or server may have disabled rpc management
 			refreshUsers();
-			refreshSettings();
 			allowManagement = true;
 		} catch (UnauthorizedException e) {
 		} catch (ForbiddenException e) {
@@ -122,7 +128,6 @@
 		} catch (IOException e) {
 			e.printStackTrace();
 		}
-
 	}
 
 	public boolean allowManagement() {
@@ -135,6 +140,33 @@
 
 	public boolean isOwner(RepositoryModel model) {
 		return account != null && account.equalsIgnoreCase(model.owner);
+	}
+
+	public String getURL(String action, String repository, String objectId) {
+		boolean mounted = settings.get(Keys.web.mountParameters).getBoolean(true);
+		StringBuilder sb = new StringBuilder();
+		sb.append(url);
+		sb.append('/');
+		sb.append(action);
+		sb.append('/');
+		if (mounted) {
+			// mounted url/action/repository/objectId
+			sb.append(StringUtils.encodeURL(repository));
+			if (!StringUtils.isEmpty(objectId)) {
+				sb.append('/');
+				sb.append(objectId);
+			}
+			return sb.toString();
+		} else {
+			// parameterized url/action/&r=repository&h=objectId
+			sb.append("?r=");
+			sb.append(repository);
+			if (!StringUtils.isEmpty(objectId)) {
+				sb.append("&h=");
+				sb.append(objectId);
+			}
+			return sb.toString();
+		}
 	}
 
 	public ServerSettings getSettings() {
@@ -155,7 +187,7 @@
 		allRepositories.clear();
 		allRepositories.addAll(repositories.values());
 		Collections.sort(allRepositories);
-		updateSubscribedStates();
+		markSubscribedFeeds();
 		return allRepositories;
 	}
 
@@ -176,108 +208,109 @@
 		return status;
 	}
 
-	public List<SyndicatedEntryModel> refreshSubscribedFeeds() throws IOException {
-		Set<SyndicatedEntryModel> allFeeds = new HashSet<SyndicatedEntryModel>();
-		if (reg.feeds != null && reg.feeds.size() > 0) {
-			for (String feed : reg.feeds) {
-				String[] values = feed.split(":");
-				String repository = values[0];
-				String branch = null;
-				if (values.length > 1) {
-					branch = values[1];
-				}
-				List<SyndicatedEntryModel> list = SyndicationUtils.readFeed(url, repository,
-						branch, -1, account, password);
-				allFeeds.addAll(list);
+	public List<String> getBranches(String repository) {
+		List<FeedModel> feeds = getAvailableFeeds(repository);
+		List<String> branches = new ArrayList<String>();
+		for (FeedModel feed : feeds) {
+			branches.add(feed.branch);
+		}
+		Collections.sort(branches);
+		return branches;
+	}
+
+	public List<FeedModel> getAvailableFeeds() {
+		return availableFeeds;
+	}
+
+	public List<FeedModel> getAvailableFeeds(RepositoryModel repository) {
+		return getAvailableFeeds(repository.name);
+	}
+
+	public List<FeedModel> getAvailableFeeds(String repository) {
+		List<FeedModel> repositoryFeeds = new ArrayList<FeedModel>();
+		if (repository == null) {
+			return repositoryFeeds;
+		}
+		for (FeedModel feed : availableFeeds) {
+			if (feed.repository.equalsIgnoreCase(repository)) {
+				repositoryFeeds.add(feed);
 			}
 		}
+		return repositoryFeeds;
+	}
+
+	public List<FeedModel> refreshAvailableFeeds() throws IOException {
+		List<FeedModel> feeds = RpcUtils.getBranchFeeds(url, account, password);
+		availableFeeds.clear();
+		availableFeeds.addAll(feeds);
+		markSubscribedFeeds();
+		return availableFeeds;
+	}
+
+	public List<FeedEntryModel> refreshSubscribedFeeds(int page) throws IOException {
+		Set<FeedEntryModel> allEntries = new HashSet<FeedEntryModel>();
+		if (reg.feeds.size() > 0) {
+			for (FeedModel feed : reg.feeds) {
+				feed.lastRefreshDate = feed.currentRefreshDate;
+				feed.currentRefreshDate = new Date();
+				List<FeedEntryModel> entries = SyndicationUtils.readFeed(url,
+						feed.repository, feed.branch, -1, page, account, password);
+				allEntries.addAll(entries);
+			}
+		}
+		reg.cacheFeeds();
 		syndicatedEntries.clear();
-		syndicatedEntries.addAll(allFeeds);
+		syndicatedEntries.addAll(allEntries);
 		Collections.sort(syndicatedEntries);
 		return syndicatedEntries;
 	}
 
-	private void updateSubscribedStates() {
-		if (reg.feeds != null) {
-			Set<String> subscribedRepositories = new HashSet<String>();
-			for (String feed : reg.feeds) {
-				if (feed.indexOf(':') > -1) {
-					// strip branch
-					subscribedRepositories.add(feed.substring(0, feed.indexOf(':')).toLowerCase());
-				} else {
-					// default branch
-					subscribedRepositories.add(feed.toLowerCase());
-				}
-			}
-			// set subscribed flag
-			for (RepositoryModel repository : allRepositories) {
-				repository.subscribed = subscribedRepositories.contains(repository.name
-						.toLowerCase());
+	public void updateSubscribedFeeds(List<FeedModel> list) {
+		reg.updateSubscribedFeeds(list);
+		markSubscribedFeeds();
+	}
+
+	private void markSubscribedFeeds() {
+		subscribedRepositories.clear();
+		for (FeedModel feed : availableFeeds) {
+			// mark feed in the available list as subscribed
+			feed.subscribed = reg.feeds.contains(feed);
+			if (feed.subscribed) {
+				subscribedRepositories.add(feed.repository.toLowerCase());
 			}
 		}
 	}
 
-	public List<SyndicatedEntryModel> getSyndicatedEntries() {
+	public Date getLastFeedRefresh(String repository, String branch) {
+		FeedModel feed = new FeedModel();
+		feed.repository = repository;
+		feed.branch = branch;
+		if (reg.feeds.contains(feed)) {
+			int idx = reg.feeds.indexOf(feed);
+			feed = reg.feeds.get(idx);
+			return feed.lastRefreshDate;
+		}
+		return NEVER;
+	}
+
+	public boolean isSubscribed(RepositoryModel repository) {
+		return subscribedRepositories.contains(repository.name.toLowerCase());
+	}
+
+	public List<FeedEntryModel> getSyndicatedEntries() {
 		return syndicatedEntries;
 	}
 
-	public boolean isSubscribed(RepositoryModel repository, String branch) {
-		if (reg.feeds != null && reg.feeds.size() > 0) {
-			for (String feed : reg.feeds) {
-				String[] values = feed.split(":");
-				String repositoryName = values[0];
-				if (repository.name.equalsIgnoreCase(repositoryName)) {
-					return true;
-				}
-				// TODO check branch subscriptions
-				String branchName = null;
-				if (values.length > 1) {
-					branchName = values[1];
-				}
-			}
-		}
-		return false;
+	public List<FeedEntryModel> log(String repository, String branch, int numberOfEntries,
+			int page) throws IOException {
+		return SyndicationUtils.readFeed(url, repository, branch, numberOfEntries, page, account,
+				password);
 	}
 
-	public boolean subscribe(RepositoryModel repository, String branch) {
-		String feed = repository.name;
-		if (!StringUtils.isEmpty(branch)) {
-			feed += ":" + branch;
-		}
-		if (reg.feeds == null) {
-			reg.feeds = new ArrayList<String>();
-		}
-		reg.feeds.add(feed);
-		updateSubscribedStates();
-		return true;
-	}
-
-	public boolean unsubscribe(RepositoryModel repository, String branch) {
-		String feed = repository.name;
-		if (!StringUtils.isEmpty(branch)) {
-			feed += ":" + branch;
-		}
-		reg.feeds.remove(feed);
-		if (syndicatedEntries.size() > 0) {
-			List<SyndicatedEntryModel> toRemove = new ArrayList<SyndicatedEntryModel>();
-			for (SyndicatedEntryModel model : syndicatedEntries) {
-				if (model.repository.equalsIgnoreCase(repository.name)) {
-					boolean emptyUnsubscribeBranch = StringUtils.isEmpty(branch);
-					boolean emptyFromBranch = StringUtils.isEmpty(model.branch);
-					if (emptyUnsubscribeBranch && emptyFromBranch) {
-						// default branch, remove
-						toRemove.add(model);
-					} else if (!emptyUnsubscribeBranch && !emptyFromBranch) {
-						if (model.branch.equals(branch)) {
-							// specific branch, remove
-							toRemove.add(model);
-						}
-					}
-				}
-			}
-		}
-		updateSubscribedStates();
-		return true;
+	public List<FeedEntryModel> search(String repository, String branch, String fragment,
+			Constants.SearchType type, int numberOfEntries, int page) throws IOException {
+		return SyndicationUtils.readSearchFeed(url, repository, branch, fragment, type,
+				numberOfEntries, page, account, password);
 	}
 
 	public List<FederationModel> refreshFederationRegistrations() throws IOException {

--
Gitblit v1.9.1