Reorganized to Apache Standard Directory Layout & integrated Moxie

This is a massive commit which reorganizes the entire project structure
(although it is still monolithic), removes the Build classes, and
switches to Moxie, a smarter Ant build tookit based on the original
Gitblit Build classes.

The Ant build script will likely require additional fine-tuning, but
this is big step forward.

1 files changed, 717 insertions, 0 deletions

diff --git a/src/main/java/com/gitblit/client/GitblitClient.java b/src/main/java/com/gitblit/client/GitblitClient.java
new file mode 100644
index 00000000..cc7d58a6
--- /dev/null
+++ b/src/main/java/com/gitblit/client/GitblitClient.java
@@ -0,0 +1,717 @@
+/*

+ * Copyright 2011 gitblit.com.

+ *

+ * Licensed under the Apache License, Version 2.0 (the "License");

+ * you may not use this file except in compliance with the License.

+ * You may obtain a copy of the License at

+ *

+ *     http://www.apache.org/licenses/LICENSE-2.0

+ *

+ * Unless required by applicable law or agreed to in writing, software

+ * distributed under the License is distributed on an "AS IS" BASIS,

+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

+ * See the License for the specific language governing permissions and

+ * limitations under the License.

+ */

+package com.gitblit.client;

+

+import java.io.IOException;

+import java.io.Serializable;

+import java.util.ArrayList;

+import java.util.Collections;

+import java.util.Date;

+import java.util.HashSet;

+import java.util.LinkedHashSet;

+import java.util.List;

+import java.util.Map;

+import java.util.Set;

+import java.util.TreeSet;

+

+import com.gitblit.Constants;

+import com.gitblit.Constants.AccessPermission;

+import com.gitblit.Constants.AccessRestrictionType;

+import com.gitblit.Constants.AuthorizationControl;

+import com.gitblit.Constants.PermissionType;

+import com.gitblit.Constants.RegistrantType;

+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.RegistrantAccessPermission;

+import com.gitblit.models.RepositoryModel;

+import com.gitblit.models.ServerSettings;

+import com.gitblit.models.ServerStatus;

+import com.gitblit.models.TeamModel;

+import com.gitblit.models.UserModel;

+import com.gitblit.utils.ArrayUtils;

+import com.gitblit.utils.RpcUtils;

+import com.gitblit.utils.StringUtils;

+import com.gitblit.utils.SyndicationUtils;

+

+/**

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

+ * it for local operations, and allows updating or creating Gitblit objects.

+ * 

+ * @author James Moger

+ * 

+ */

+public class GitblitClient implements Serializable {

+

+	private static final long serialVersionUID = 1L;

+

+	private static final Date NEVER = new Date(0);

+

+	protected final GitblitRegistration reg;

+

+	public final String url;

+

+	public final String account;

+

+	private final char[] password;

+

+	private volatile int protocolVersion;

+

+	private volatile boolean allowManagement;

+

+	private volatile boolean allowAdministration;

+

+	private volatile ServerSettings settings;

+

+	private final List<RepositoryModel> allRepositories;

+

+	private final List<UserModel> allUsers;

+

+	private final List<TeamModel> allTeams;

+

+	private final List<FederationModel> federationRegistrations;

+

+	private final List<FeedModel> availableFeeds;

+

+	private final List<FeedEntryModel> syndicatedEntries;

+

+	private final Set<String> subscribedRepositories;

+

+	private ServerStatus status;

+

+	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.allTeams = new ArrayList<TeamModel>();

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

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

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

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

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

+	}

+

+	public void login() throws IOException {

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

+		refreshSettings();

+		refreshAvailableFeeds();

+		refreshRepositories();

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

+		} 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) {

+			e.printStackTrace();

+		}

+	}

+

+	public int getProtocolVersion() {

+		return protocolVersion;

+	}

+

+	public boolean allowManagement() {

+		return allowManagement;

+	}

+

+	public boolean allowAdministration() {

+		return allowAdministration;

+	}

+

+	public boolean isOwner(RepositoryModel model) {

+		return model.isOwner(account);

+	}

+

+	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 AccessRestrictionType getDefaultAccessRestriction() {

+		String restriction = null;

+		if (settings.hasKey(Keys.git.defaultAccessRestriction)) {

+			restriction = settings.get(Keys.git.defaultAccessRestriction).currentValue;

+		}

+		return AccessRestrictionType.fromName(restriction);

+	}

+

+	public AuthorizationControl getDefaultAuthorizationControl() {

+		String authorization = null;

+		if (settings.hasKey(Keys.git.defaultAuthorizationControl)) {

+			authorization = settings.get(Keys.git.defaultAuthorizationControl).currentValue;

+		}

+		return AuthorizationControl.fromName(authorization);

+	}

+

+	/**

+	 * Returns the list of pre-receive scripts the repository inherited from the

+	 * global settings and team affiliations.

+	 * 

+	 * @param repository

+	 *            if null only the globally specified scripts are returned

+	 * @return a list of scripts

+	 */

+	public List<String> getPreReceiveScriptsInherited(RepositoryModel repository) {

+		Set<String> scripts = new LinkedHashSet<String>();

+		// Globals

+		for (String script : settings.get(Keys.groovy.preReceiveScripts).getStrings()) {

+			if (script.endsWith(".groovy")) {

+				scripts.add(script.substring(0, script.lastIndexOf('.')));

+			} else {

+				scripts.add(script);

+			}

+		}

+

+		// Team Scripts

+		if (repository != null) {

+			for (String teamname : getPermittedTeamnames(repository)) {

+				TeamModel team = getTeamModel(teamname);

+				if (!ArrayUtils.isEmpty(team.preReceiveScripts)) {

+					scripts.addAll(team.preReceiveScripts);

+				}

+			}

+		}

+		return new ArrayList<String>(scripts);

+	}

+

+	/**

+	 * Returns the list of all available Groovy pre-receive push hook scripts

+	 * that are not already inherited by the repository. Script files must have

+	 * .groovy extension

+	 * 

+	 * @param repository

+	 *            optional parameter

+	 * @return list of available hook scripts

+	 */

+	public List<String> getPreReceiveScriptsUnused(RepositoryModel repository) {

+		Set<String> inherited = new TreeSet<String>(getPreReceiveScriptsInherited(repository));

+

+		// create list of available scripts by excluding inherited scripts

+		List<String> scripts = new ArrayList<String>();

+		for (String script : settings.pushScripts) {

+			if (!inherited.contains(script)) {

+				scripts.add(script);

+			}

+		}

+		return scripts;

+	}

+

+	/**

+	 * Returns the list of post-receive scripts the repository inherited from

+	 * the global settings and team affiliations.

+	 * 

+	 * @param repository

+	 *            if null only the globally specified scripts are returned

+	 * @return a list of scripts

+	 */

+	public List<String> getPostReceiveScriptsInherited(RepositoryModel repository) {

+		Set<String> scripts = new LinkedHashSet<String>();

+		// Global Scripts

+		for (String script : settings.get(Keys.groovy.postReceiveScripts).getStrings()) {

+			if (script.endsWith(".groovy")) {

+				scripts.add(script.substring(0, script.lastIndexOf('.')));

+			} else {

+				scripts.add(script);

+			}

+		}

+		// Team Scripts

+		if (repository != null) {

+			for (String teamname : getPermittedTeamnames(repository)) {

+				TeamModel team = getTeamModel(teamname);

+				if (!ArrayUtils.isEmpty(team.postReceiveScripts)) {

+					scripts.addAll(team.postReceiveScripts);

+				}

+			}

+		}

+		return new ArrayList<String>(scripts);

+	}

+

+	/**

+	 * Returns the list of unused Groovy post-receive push hook scripts that are

+	 * not already inherited by the repository. Script files must have .groovy

+	 * extension

+	 * 

+	 * @param repository

+	 *            optional parameter

+	 * @return list of available hook scripts

+	 */

+	public List<String> getPostReceiveScriptsUnused(RepositoryModel repository) {

+		Set<String> inherited = new TreeSet<String>(getPostReceiveScriptsInherited(repository));

+

+		// create list of available scripts by excluding inherited scripts

+		List<String> scripts = new ArrayList<String>();

+		if (!ArrayUtils.isEmpty(settings.pushScripts)) {			

+			for (String script : settings.pushScripts) {

+				if (!inherited.contains(script)) {

+					scripts.add(script);

+				}

+			}

+		}

+		return scripts;

+	}

+

+	public ServerSettings getSettings() {

+		return settings;

+	}

+

+	public ServerStatus getStatus() {

+		return status;

+	}

+

+	public String getSettingDescription(String key) {

+		return settings.get(key).description;

+	}

+

+	public List<RepositoryModel> refreshRepositories() throws IOException {

+		Map<String, RepositoryModel> repositories = RpcUtils

+				.getRepositories(url, account, password);

+		allRepositories.clear();

+		allRepositories.addAll(repositories.values());

+		Collections.sort(allRepositories);

+		markSubscribedFeeds();

+		return allRepositories;

+	}

+

+	public List<UserModel> refreshUsers() throws IOException {

+		List<UserModel> users = RpcUtils.getUsers(url, account, password);

+		allUsers.clear();

+		allUsers.addAll(users);

+		Collections.sort(users);

+		return allUsers;

+	}

+

+	public List<TeamModel> refreshTeams() throws IOException {

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

+		allTeams.clear();

+		allTeams.addAll(teams);

+		Collections.sort(teams);

+		return allTeams;

+	}

+

+	public ServerSettings refreshSettings() throws IOException {

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

+		return settings;

+	}

+

+	public ServerStatus refreshStatus() throws IOException {

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

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

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

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

+		federationRegistrations.clear();

+		federationRegistrations.addAll(list);

+		return federationRegistrations;

+	}

+

+	public List<UserModel> getUsers() {

+		return allUsers;

+	}

+	

+	public UserModel getUser(String username) {

+		for (UserModel user : getUsers()) {

+			if (user.username.equalsIgnoreCase(username)) {

+				return user;

+			}

+		}

+		return null;

+	}

+

+	public List<String> getUsernames() {

+		List<String> usernames = new ArrayList<String>();

+		for (UserModel user : this.allUsers) {

+			usernames.add(user.username);

+		}

+		Collections.sort(usernames);

+		return usernames;

+	}

+

+	public List<String> getPermittedUsernames(RepositoryModel repository) {

+		List<String> usernames = new ArrayList<String>();

+		for (UserModel user : this.allUsers) {

+			if (user.hasRepositoryPermission(repository.name)) {

+				usernames.add(user.username);

+			}

+		}

+		return usernames;

+	}

+	

+	/**

+	 * Returns the effective list of permissions for this user, taking into account

+	 * team memberships, ownerships.

+	 * 

+	 * @param user

+	 * @return the effective list of permissions for the user

+	 */

+	public List<RegistrantAccessPermission> getUserAccessPermissions(UserModel user) {

+		Set<RegistrantAccessPermission> set = new LinkedHashSet<RegistrantAccessPermission>();

+		set.addAll(user.getRepositoryPermissions());

+		// Flag missing repositories

+		for (RegistrantAccessPermission permission : set) {

+			if (permission.mutable && PermissionType.EXPLICIT.equals(permission.permissionType)) {

+				RepositoryModel rm = getRepository(permission.registrant);

+				if (rm == null) {

+					permission.permissionType = PermissionType.MISSING;

+					permission.mutable = false;

+					continue;

+				}

+			}

+		}

+

+		// TODO reconsider ownership as a user property

+		// manually specify personal repository ownerships

+		for (RepositoryModel rm : allRepositories) {

+			if (rm.isUsersPersonalRepository(user.username) || rm.isOwner(user.username)) {

+				RegistrantAccessPermission rp = new RegistrantAccessPermission(rm.name, AccessPermission.REWIND,

+						PermissionType.OWNER, RegistrantType.REPOSITORY, null, false);

+				// user may be owner of a repository to which they've inherited

+				// a team permission, replace any existing perm with owner perm

+				set.remove(rp);

+				set.add(rp);

+			}

+		}

+		

+		List<RegistrantAccessPermission> list = new ArrayList<RegistrantAccessPermission>(set);

+		Collections.sort(list);

+		return list;

+	}

+	

+	public List<RegistrantAccessPermission> getUserAccessPermissions(RepositoryModel repository) {

+		List<RegistrantAccessPermission> list = new ArrayList<RegistrantAccessPermission>();

+		if (AccessRestrictionType.NONE.equals(repository.accessRestriction)) {

+			// no permissions needed, REWIND for everyone!

+			return list;

+		}

+		if (AuthorizationControl.AUTHENTICATED.equals(repository.authorizationControl)) {

+			// no permissions needed, REWIND for authenticated!

+			return list;

+		}

+		// NAMED users and teams

+		for (UserModel user : allUsers) {

+			RegistrantAccessPermission ap = user.getRepositoryPermission(repository);

+			if (ap.permission.exceeds(AccessPermission.NONE)) {

+				list.add(ap);

+			}

+		}

+		return list;

+	}

+

+	public boolean setUserAccessPermissions(RepositoryModel repository, List<RegistrantAccessPermission> permissions) throws IOException {

+		return RpcUtils.setRepositoryMemberPermissions(repository, permissions, url, account, password);

+	}

+

+	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.hasRepositoryPermission(repository.name)) {

+				teamnames.add(team.name);

+			}

+		}

+		return teamnames;

+	}

+	

+	public List<RegistrantAccessPermission> getTeamAccessPermissions(RepositoryModel repository) {

+		List<RegistrantAccessPermission> list = new ArrayList<RegistrantAccessPermission>();

+		for (TeamModel team : allTeams) {

+			RegistrantAccessPermission ap = team.getRepositoryPermission(repository);

+			if (ap.permission.exceeds(AccessPermission.NONE)) {

+				list.add(ap);

+			}

+		}

+		Collections.sort(list);

+		return list;

+	}

+

+	public boolean setTeamAccessPermissions(RepositoryModel repository, List<RegistrantAccessPermission> permissions) throws IOException {

+		return RpcUtils.setRepositoryTeamPermissions(repository, permissions, url, account, password);

+	}

+

+	public TeamModel getTeamModel(String name) {

+		for (TeamModel team : allTeams) {

+			if (team.name.equalsIgnoreCase(name)) {

+				return team;

+			}

+		}

+		return null;

+	}

+

+	public List<String> getFederationSets() {

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

+	}

+

+	public List<RepositoryModel> getRepositories() {

+		return allRepositories;

+	}

+	

+	public RepositoryModel getRepository(String name) {

+		for (RepositoryModel repository : allRepositories) {

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

+				return repository;

+			}

+		}

+		return null;

+	}

+

+	public boolean createRepository(RepositoryModel repository, List<RegistrantAccessPermission> userPermissions)

+			throws IOException {

+		return createRepository(repository, userPermissions, null);

+	}

+

+	public boolean createRepository(RepositoryModel repository, List<RegistrantAccessPermission> userPermissions,

+			List<RegistrantAccessPermission> teamPermissions) throws IOException {

+		boolean success = true;

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

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

+			// if new repository has named members, set them

+			success &= RpcUtils.setRepositoryMemberPermissions(repository, userPermissions, url, account,

+					password);

+		}

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

+			// if new repository has named teams, set them

+			success &= RpcUtils.setRepositoryTeamPermissions(repository, teamPermissions, url, account,

+					password);

+		}

+		return success;

+	}

+

+	public boolean updateRepository(String name, RepositoryModel repository,

+			List<RegistrantAccessPermission> userPermissions) throws IOException {

+		return updateRepository(name, repository, userPermissions, null);

+	}

+

+	public boolean updateRepository(String name, RepositoryModel repository,

+			List<RegistrantAccessPermission> userPermissions,	List<RegistrantAccessPermission> teamPermissions) throws IOException {

+		boolean success = true;

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

+		// set the repository members

+		if (userPermissions != null) {

+			success &= RpcUtils.setRepositoryMemberPermissions(repository, userPermissions, url, account,

+					password);

+		}

+		if (teamPermissions != null) {

+			success &= RpcUtils.setRepositoryTeamPermissions(repository, teamPermissions, url, account,

+					password);

+		}

+		return success;

+	}

+

+	public boolean deleteRepository(RepositoryModel repository) throws IOException {

+		return RpcUtils.deleteRepository(repository, url, account, password);

+	}

+	

+	public boolean clearRepositoryCache() throws IOException {

+		return RpcUtils.clearRepositoryCache(url, account, password);

+	}

+

+	public boolean createUser(UserModel user) throws IOException {

+		return RpcUtils.createUser(user, url, account, password);

+	}

+

+	public boolean updateUser(String name, UserModel user) throws IOException {

+		return RpcUtils.updateUser(name, user, url, account, password);

+	}

+

+	public boolean deleteUser(UserModel user) throws IOException {

+		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);

+	}

+}