More feeds work in Manager

James Moger

2011-10-31 17820f3a1153250a325fed23dfc2da59ce6ba777

 src/com/gitblit/client/GitblitClient.java

@@ -19,18 +19,26 @@
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.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.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.SyndicationUtils;



/**

 * GitblitClient is a object that retrieves data from a Gitblit server, caches

@@ -42,6 +50,8 @@
public class GitblitClient implements Serializable {



   private static final long serialVersionUID = 1L;



   protected final GitblitRegistration reg;



   public final String url;



@@ -61,38 +71,64 @@


   private final List<FederationModel> federationRegistrations;



   private final List<FeedModel> availableFeeds;



   private final List<SyndicatedEntryModel> syndicatedEntries;



   private final Set<String> subscribedRepositories;



   private ServerStatus status;



   public GitblitClient(String url, String account, char[] password) {

      this.url = url;

      this.account = account;

      this.password = password;

   public GitblitClient(GitblitRegistration reg) {

      this.reg = reg;

      this.url = reg.url;

      this.account = reg.account;

      this.password = reg.password;



      this.allUsers = new ArrayList<UserModel>();

      this.allRepositories = new ArrayList<RepositoryModel>();

      this.federationRegistrations = new ArrayList<FederationModel>();

      this.availableFeeds = new ArrayList<FeedModel>();

      this.syndicatedEntries = new ArrayList<SyndicatedEntryModel>();

      this.subscribedRepositories = new HashSet<String>();

   }



   public void login() throws IOException {

      refreshAvailableFeeds();

      refreshRepositories();



      try {

         refreshUsers();

         allowManagement = true;

      } catch (UnauthorizedException e) {

      } catch (ForbiddenException e) {

         // RSS feeds may be disabled by server

         refreshSubscribedFeeds();

      } catch (IOException e) {

         System.err.println(e.getMessage());

         e.printStackTrace();

      }



      try {

         // credentials may not have administrator access

         // or server may have disabled rpc management

         refreshUsers();

         refreshSettings();

         status = RpcUtils.getStatus(url, account, password);

         allowManagement = true;

      } catch (UnauthorizedException e) {

      } catch (ForbiddenException e) {

      } catch (NotAllowedException e) {

      } catch (UnknownRequestException e) {

      } catch (IOException e) {

         e.printStackTrace();

      }



      try {

         // credentials may not have administrator access

         // or server may have disabled rpc administration

         refreshStatus();

         allowAdministration = true;

      } catch (UnauthorizedException e) {

      } catch (ForbiddenException e) {

      } catch (NotAllowedException e) {

      } catch (UnknownRequestException e) {

      } catch (IOException e) {

         System.err.println(e.getMessage());

         e.printStackTrace();

      }



   }

@@ -127,6 +163,7 @@
      allRepositories.clear();

      allRepositories.addAll(repositories.values());

      Collections.sort(allRepositories);

      markSubscribedFeeds();

      return allRepositories;

   }



@@ -142,6 +179,76 @@
      return settings;

   }



   public ServerStatus refreshStatus() throws IOException {

      status = RpcUtils.getStatus(url, account, password);

      return status;

   }



   public List<FeedModel> getAvailableFeeds() {

      return availableFeeds;

   }



   public List<FeedModel> getAvailableFeeds(RepositoryModel repository) {

      List<FeedModel> repositoryFeeds = new ArrayList<FeedModel>();

      if (repository == null) {

         return repositoryFeeds;

      }

      for (FeedModel feed : availableFeeds) {

         if (feed.repository.equalsIgnoreCase(repository.name)) {

            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<SyndicatedEntryModel> refreshSubscribedFeeds() throws IOException {

      Set<SyndicatedEntryModel> allEntries = new HashSet<SyndicatedEntryModel>();

      if (reg.feeds.size() > 0) {

         for (FeedModel feed : reg.feeds) {

            feed.lastRefresh = new Date();

            List<SyndicatedEntryModel> entries = SyndicationUtils.readFeed(url,

                  feed.repository, feed.branch, feed.maxRetrieval, account, password);

            allEntries.addAll(entries);

         }

      }

      syndicatedEntries.clear();

      syndicatedEntries.addAll(allEntries);

      Collections.sort(syndicatedEntries);

      return syndicatedEntries;

   }



   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 boolean isSubscribed(RepositoryModel repository) {

      return subscribedRepositories.contains(repository.name.toLowerCase());

   }



   public List<SyndicatedEntryModel> getSyndicatedEntries() {

      return syndicatedEntries;

   }



   public List<FederationModel> refreshFederationRegistrations() throws IOException {

      List<FederationModel> list = RpcUtils.getFederationRegistrations(url, account, password);

      federationRegistrations.clear();