From ac7f1753d3f742e0af8dd5e142b4eac9d9d2fbba Mon Sep 17 00:00:00 2001
From: James Moger <james.moger@gitblit.com>
Date: Fri, 28 Oct 2011 21:41:31 -0400
Subject: [PATCH] Preserve feed selections when not saving passwords
---
src/com/gitblit/client/GitblitClient.java | 395 ++++++++++++++++++++++++++++++++++++++++++++++---------
1 files changed, 327 insertions(+), 68 deletions(-)
diff --git a/src/com/gitblit/client/GitblitClient.java b/src/com/gitblit/client/GitblitClient.java
index d10cede..ccde45a 100644
--- a/src/com/gitblit/client/GitblitClient.java
+++ b/src/com/gitblit/client/GitblitClient.java
@@ -15,89 +15,348 @@
*/
package com.gitblit.client;
-import java.awt.BorderLayout;
-import java.awt.EventQueue;
-import java.awt.Menu;
-import java.awt.MenuBar;
-import java.awt.MenuItem;
-import java.awt.MenuShortcut;
-import java.awt.event.ActionEvent;
-import java.awt.event.ActionListener;
-import java.awt.event.KeyEvent;
import java.io.IOException;
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
-import javax.swing.JFrame;
-import javax.swing.JOptionPane;
-import javax.swing.JPanel;
-import javax.swing.JTabbedPane;
-
-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.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;
+import com.gitblit.utils.SyndicationUtils;
-public class GitblitClient extends JFrame {
+/**
+ * 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 JTabbedPane serverTabs;
- private GitblitClient() {
- super();
+ protected final GitblitRegistration reg;
+
+ public final String url;
+
+ public final String account;
+
+ private final char[] password;
+
+ 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<FederationModel> federationRegistrations;
+
+ private final List<SyndicatedEntryModel> syndicatedEntries;
+
+ 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.allRepositories = new ArrayList<RepositoryModel>();
+ this.federationRegistrations = new ArrayList<FederationModel>();
+ this.syndicatedEntries = new ArrayList<SyndicatedEntryModel>();
}
- private void initialize() {
- setupMenu();
- setContentPane(getCenterPanel());
+ public void login() throws IOException {
+ refreshRepositories();
- setTitle("Gitblit Client v" + Constants.VERSION + " (" + Constants.VERSION_DATE + ")");
- setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
- setSize(800, 600);
- setLocationRelativeTo(null);
- }
-
- private void setupMenu() {
- MenuBar menuBar = new MenuBar();
- setMenuBar(menuBar);
- Menu serversMenu = new Menu("Servers");
- menuBar.add(serversMenu);
- MenuItem login = new MenuItem("Login...", new MenuShortcut(KeyEvent.VK_L, false));
- login.addActionListener(new ActionListener() {
- public void actionPerformed(ActionEvent event) {
- String url = JOptionPane.showInputDialog(GitblitClient.this,
- "Please enter Gitblit server URL", "https://localhost:8443");
- if (StringUtils.isEmpty(url)) {
- return;
- }
- login(url, "admin", "admin".toCharArray());
- }
- });
- serversMenu.add(login);
- }
-
- private JPanel getCenterPanel() {
- serverTabs = new JTabbedPane(JTabbedPane.TOP);
- JPanel panel = new JPanel(new BorderLayout());
- panel.add(serverTabs, BorderLayout.CENTER);
- return panel;
- }
-
- private void login(String url, String account, char[] password) {
try {
- GitblitPanel panel = new GitblitPanel(url, account, password);
- panel.login();
- serverTabs.addTab(url.substring(url.indexOf("//") + 2), panel);
- serverTabs.setSelectedIndex(serverTabs.getTabCount() - 1);
+ // RSS feeds may be disabled by server
+ refreshSubscribedFeeds();
} catch (IOException e) {
- JOptionPane.showMessageDialog(GitblitClient.this, e.getMessage(), "Error",
- JOptionPane.ERROR_MESSAGE);
+ 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) {
+ } 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 boolean allowManagement() {
+ return allowManagement;
+ }
+
+ public boolean allowAdministration() {
+ return allowAdministration;
+ }
+
+ public boolean isOwner(RepositoryModel model) {
+ return account != null && account.equalsIgnoreCase(model.owner);
+ }
+
+ 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);
+ updateSubscribedStates();
+ return allRepositories;
+ }
+
+ public List<UserModel> refreshUsers() throws IOException {
+ List<UserModel> users = RpcUtils.getUsers(url, account, password);
+ allUsers.clear();
+ allUsers.addAll(users);
+ return allUsers;
+ }
+
+ 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<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);
+ }
+ }
+ syndicatedEntries.clear();
+ syndicatedEntries.addAll(allFeeds);
+ 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 static void main(String[] args) {
- EventQueue.invokeLater(new Runnable() {
- public void run() {
- GitblitClient frame = new GitblitClient();
- frame.initialize();
- frame.setVisible(true);
+ public List<SyndicatedEntryModel> 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 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<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 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.repositories.contains(repository.name)) {
+ usernames.add(user.username);
+ }
+ }
+ return usernames;
+ }
+
+ public List<String> getFederationSets() {
+ return settings.get(Keys.federation.sets).getStrings();
+ }
+
+ public List<RepositoryModel> getRepositories() {
+ return allRepositories;
+ }
+
+ public boolean createRepository(RepositoryModel repository, List<String> permittedUsers)
+ throws IOException {
+ boolean success = true;
+ success &= RpcUtils.createRepository(repository, url, account, password);
+ if (permittedUsers.size() > 0) {
+ // if new repository has named members, set them
+ success &= RpcUtils.setRepositoryMembers(repository, permittedUsers, url, account,
+ password);
+ }
+ return success;
+ }
+
+ public boolean updateRepository(String name, RepositoryModel repository,
+ List<String> permittedUsers) 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);
+ return success;
+ }
+
+ public boolean deleteRepository(RepositoryModel repository) throws IOException {
+ return RpcUtils.deleteRepository(repository, 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 updateSettings(Map<String, String> newSettings) throws IOException {
+ return RpcUtils.updateSettings(newSettings, url, account, password);
}
}
--
Gitblit v1.9.1