Teams JSON-RPC support

James Moger

2011-12-13 f08aab5c5e632431635e73b47b6096dc47243755

 src/com/gitblit/client/GitblitClient.java

@@ -25,17 +25,19 @@
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.TeamModel;

import com.gitblit.models.UserModel;

import com.gitblit.utils.RpcUtils;

import com.gitblit.utils.StringUtils;

@@ -62,6 +64,8 @@


   private final char[] password;



   private volatile int protocolVersion;



   private volatile boolean allowManagement;



   private volatile boolean allowAdministration;

@@ -72,11 +76,13 @@


   private final List<UserModel> allUsers;



   private final List<TeamModel> allTeams;



   private final List<FederationModel> federationRegistrations;



   private final List<FeedModel> availableFeeds;



   private final List<SyndicatedEntryModel> syndicatedEntries;

   private final List<FeedEntryModel> syndicatedEntries;



   private final Set<String> subscribedRepositories;



@@ -89,29 +95,28 @@
      this.password = reg.password;



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

      this.allTeams = new ArrayList<TeamModel>();

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

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

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

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

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

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

   }



   public void login() throws IOException {

      protocolVersion = RpcUtils.getProtocolVersion(url, account, password);

      refreshSettings();

      refreshAvailableFeeds();

      refreshRepositories();



      try {

         // RSS feeds may be disabled by server

         refreshSubscribedFeeds();

      } catch (IOException e) {

         e.printStackTrace();

      }

      refreshSubscribedFeeds(0);



      try {

         // credentials may not have administrator access

         // or server may have disabled rpc management

         refreshUsers();

         if (protocolVersion > 1) {

            refreshTeams();

         }

         allowManagement = true;

      } catch (UnauthorizedException e) {

      } catch (ForbiddenException e) {

@@ -133,6 +138,10 @@
      } catch (IOException e) {

         e.printStackTrace();

      }

   }



   public int getProtocolVersion() {

      return protocolVersion;

   }



   public boolean allowManagement() {

@@ -203,6 +212,13 @@
      return allUsers;

   }



   public List<TeamModel> refreshTeams() throws IOException {

      List<TeamModel> teams = RpcUtils.getTeams(url, account, password);

      allTeams.clear();

      allTeams.addAll(teams);

      return allTeams;

   }



   public ServerSettings refreshSettings() throws IOException {

      settings = RpcUtils.getSettings(url, account, password);

      return settings;

@@ -213,17 +229,31 @@
      return status;

   }



   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.name)) {

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

            repositoryFeeds.add(feed);

         }

      }

@@ -238,14 +268,14 @@
      return availableFeeds;

   }



   public List<SyndicatedEntryModel> refreshSubscribedFeeds() throws IOException {

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

   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<SyndicatedEntryModel> entries = SyndicationUtils.readFeed(url,

                  feed.repository, feed.branch, -1, account, password);

            List<FeedEntryModel> entries = SyndicationUtils.readFeed(url, feed.repository,

                  feed.branch, -1, page, account, password);

            allEntries.addAll(entries);

         }

      }

@@ -288,8 +318,20 @@
      return subscribedRepositories.contains(repository.name.toLowerCase());

   }



   public List<SyndicatedEntryModel> getSyndicatedEntries() {

   public List<FeedEntryModel> getSyndicatedEntries() {

      return syndicatedEntries;

   }



   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 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 {

@@ -322,6 +364,29 @@
      return usernames;

   }



   public List<TeamModel> getTeams() {

      return allTeams;

   }



   public List<String> getTeamnames() {

      List<String> teamnames = new ArrayList<String>();

      for (TeamModel team : this.allTeams) {

         teamnames.add(team.name);

      }

      Collections.sort(teamnames);

      return teamnames;

   }



   public List<String> getPermittedTeamnames(RepositoryModel repository) {

      List<String> teamnames = new ArrayList<String>();

      for (TeamModel team : this.allTeams) {

         if (team.repositories.contains(repository.name)) {

            teamnames.add(team.name);

         }

      }

      return teamnames;

   }



   public List<String> getFederationSets() {

      return settings.get(Keys.federation.sets).getStrings();

   }

@@ -332,11 +397,21 @@


   public boolean createRepository(RepositoryModel repository, List<String> permittedUsers)

         throws IOException {

      return createRepository(repository, permittedUsers, null);

   }



   public boolean createRepository(RepositoryModel repository, List<String> permittedUsers,

         List<String> permittedTeams) throws IOException {

      boolean success = true;

      success &= RpcUtils.createRepository(repository, url, account, password);

      if (permittedUsers.size() > 0) {

      if (permittedUsers != null && permittedUsers.size() > 0) {

         // if new repository has named members, set them

         success &= RpcUtils.setRepositoryMembers(repository, permittedUsers, url, account,

               password);

      }

      if (permittedTeams != null && permittedTeams.size() > 0) {

         // if new repository has named teams, set them

         success &= RpcUtils.setRepositoryTeams(repository, permittedTeams, url, account,

               password);

      }

      return success;

@@ -344,11 +419,22 @@


   public boolean updateRepository(String name, RepositoryModel repository,

         List<String> permittedUsers) throws IOException {

      return updateRepository(name, repository, permittedUsers, null);

   }



   public boolean updateRepository(String name, RepositoryModel repository,

         List<String> permittedUsers, List<String> permittedTeams) throws IOException {

      boolean success = true;

      success &= RpcUtils.updateRepository(name, repository, url, account, password);

      // always set the repository members

      success &= RpcUtils

            .setRepositoryMembers(repository, permittedUsers, url, account, password);

      // set the repository members

      if (permittedUsers != null) {

         success &= RpcUtils.setRepositoryMembers(repository, permittedUsers, url, account,

               password);

      }

      if (permittedTeams != null) {

         success &= RpcUtils.setRepositoryTeams(repository, permittedTeams, url, account,

               password);

      }

      return success;

   }



@@ -368,6 +454,18 @@
      return RpcUtils.deleteUser(user, url, account, password);

   }



   public boolean createTeam(TeamModel team) throws IOException {

      return RpcUtils.createTeam(team, url, account, password);

   }



   public boolean updateTeam(String name, TeamModel team) throws IOException {

      return RpcUtils.updateTeam(name, team, url, account, password);

   }



   public boolean deleteTeam(TeamModel team) throws IOException {

      return RpcUtils.deleteTeam(team, url, account, password);

   }



   public boolean updateSettings(Map<String, String> newSettings) throws IOException {

      return RpcUtils.updateSettings(newSettings, url, account, password);

   }