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