/*
|
* 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.awt.BorderLayout;
|
import java.awt.Color;
|
import java.awt.Component;
|
import java.awt.Desktop;
|
import java.awt.Dimension;
|
import java.awt.GridLayout;
|
import java.awt.Insets;
|
import java.awt.event.ActionEvent;
|
import java.awt.event.ActionListener;
|
import java.io.IOException;
|
import java.net.URI;
|
import java.text.MessageFormat;
|
import java.util.ArrayList;
|
import java.util.Collections;
|
import java.util.Date;
|
import java.util.List;
|
import java.util.Map;
|
|
import javax.swing.JButton;
|
import javax.swing.JLabel;
|
import javax.swing.JList;
|
import javax.swing.JOptionPane;
|
import javax.swing.JPanel;
|
import javax.swing.JScrollPane;
|
import javax.swing.JTabbedPane;
|
import javax.swing.JTable;
|
import javax.swing.JTextField;
|
import javax.swing.RowFilter;
|
import javax.swing.SwingConstants;
|
import javax.swing.SwingWorker;
|
import javax.swing.event.ListSelectionEvent;
|
import javax.swing.event.ListSelectionListener;
|
import javax.swing.table.DefaultTableCellRenderer;
|
import javax.swing.table.DefaultTableColumnModel;
|
import javax.swing.table.TableCellRenderer;
|
import javax.swing.table.TableColumn;
|
import javax.swing.table.TableRowSorter;
|
|
import com.gitblit.Constants.RpcRequest;
|
import com.gitblit.GitBlitException.ForbiddenException;
|
import com.gitblit.GitBlitException.UnauthorizedException;
|
import com.gitblit.IStoredSettings;
|
import com.gitblit.Keys;
|
import com.gitblit.client.ClosableTabComponent.CloseTabListener;
|
import com.gitblit.models.FederationModel;
|
import com.gitblit.models.RepositoryModel;
|
import com.gitblit.models.UserModel;
|
import com.gitblit.utils.RpcUtils;
|
import com.gitblit.utils.StringUtils;
|
|
/**
|
* GitblitPanel performs the login, all business logic, and contains all widgets
|
* to represent the state of a repository for the given account credentials.
|
*
|
* @author James Moger
|
*
|
*/
|
public class GitblitPanel extends JPanel implements CloseTabListener {
|
|
private static final long serialVersionUID = 1L;
|
|
private final int margin = 5;
|
|
private final Insets insets = new Insets(margin, margin, margin, margin);
|
|
private final String url;
|
|
private final String account;
|
|
private final char[] password;
|
|
private volatile boolean isAdmin;
|
|
private volatile List<UserModel> allUsers;
|
|
private volatile IStoredSettings settings;
|
|
private JTabbedPane tabs;
|
|
private JTable repositoriesTable;
|
|
private RepositoriesModel repositoriesModel;
|
|
private JList usersList;
|
|
private JPanel usersPanel;
|
|
private JButton createRepository;
|
|
private JButton delRepository;
|
|
private NameRenderer nameRenderer;
|
|
private IndicatorsRenderer typeRenderer;
|
|
private DefaultTableCellRenderer ownerRenderer;
|
|
private DefaultTableCellRenderer sizeRenderer;
|
|
private TableRowSorter<RepositoriesModel> defaultSorter;
|
|
private List<RepositoryModel> allRepositories;
|
|
public GitblitPanel(GitblitRegistration reg) {
|
this(reg.url, reg.account, reg.password);
|
}
|
|
public GitblitPanel(String url, String account, char[] password) {
|
this.url = url;
|
this.account = account;
|
this.password = password;
|
|
final JButton browseRepository = new JButton(Translation.get("gb.browse"));
|
browseRepository.setEnabled(false);
|
browseRepository.addActionListener(new ActionListener() {
|
public void actionPerformed(ActionEvent e) {
|
RepositoryModel model = getSelectedRepositories().get(0);
|
String u = MessageFormat.format("{0}/summary/{1}", GitblitPanel.this.url,
|
StringUtils.encodeURL(model.name));
|
try {
|
Desktop.getDesktop().browse(new URI(u));
|
} catch (Exception x) {
|
x.printStackTrace();
|
}
|
}
|
});
|
|
JButton refreshRepositories = new JButton(Translation.get("gb.refresh"));
|
refreshRepositories.addActionListener(new ActionListener() {
|
public void actionPerformed(ActionEvent e) {
|
try {
|
refreshRepositoriesTable();
|
} catch (ForbiddenException x) {
|
explainForbidden(RpcRequest.LIST_REPOSITORIES);
|
} catch (UnauthorizedException x) {
|
explainUnauthorized(RpcRequest.LIST_REPOSITORIES);
|
} catch (Throwable t) {
|
showException(t);
|
}
|
}
|
});
|
|
createRepository = new JButton(Translation.get("gb.create"));
|
createRepository.addActionListener(new ActionListener() {
|
public void actionPerformed(ActionEvent e) {
|
createRepository();
|
}
|
});
|
|
final JButton editRepository = new JButton(Translation.get("gb.edit"));
|
editRepository.setEnabled(false);
|
editRepository.addActionListener(new ActionListener() {
|
public void actionPerformed(ActionEvent e) {
|
editRepository(getSelectedRepositories().get(0));
|
}
|
});
|
|
delRepository = new JButton(Translation.get("gb.delete"));
|
delRepository.setEnabled(false);
|
delRepository.addActionListener(new ActionListener() {
|
public void actionPerformed(ActionEvent e) {
|
deleteRepositories(getSelectedRepositories());
|
}
|
});
|
|
final JButton cloneRepository = new JButton(Translation.get("gb.clone"));
|
cloneRepository.setEnabled(false);
|
cloneRepository.addActionListener(new ActionListener() {
|
public void actionPerformed(ActionEvent e) {
|
for (RepositoryModel model : getSelectedRepositories()) {
|
System.out.println("TODO Clone " + model);
|
}
|
}
|
});
|
|
nameRenderer = new NameRenderer();
|
typeRenderer = new IndicatorsRenderer();
|
|
sizeRenderer = new DefaultTableCellRenderer();
|
sizeRenderer.setHorizontalAlignment(SwingConstants.RIGHT);
|
sizeRenderer.setForeground(new Color(0, 0x80, 0));
|
|
ownerRenderer = new DefaultTableCellRenderer();
|
ownerRenderer.setForeground(Color.gray);
|
ownerRenderer.setHorizontalAlignment(SwingConstants.CENTER);
|
|
repositoriesModel = new RepositoriesModel();
|
defaultSorter = new TableRowSorter<RepositoriesModel>(repositoriesModel);
|
repositoriesTable = new JTable(repositoriesModel);
|
repositoriesTable.setRowSorter(defaultSorter);
|
repositoriesTable.getRowSorter().toggleSortOrder(RepositoriesModel.Columns.Name.ordinal());
|
|
repositoriesTable.setCellSelectionEnabled(false);
|
repositoriesTable.setRowSelectionAllowed(true);
|
repositoriesTable.setRowHeight(nameRenderer.getFont().getSize() + 8);
|
repositoriesTable.getTableHeader().setReorderingAllowed(false);
|
repositoriesTable.setGridColor(new Color(0xd9d9d9));
|
repositoriesTable.setBackground(Color.white);
|
repositoriesTable.setDefaultRenderer(Date.class,
|
new DateCellRenderer(null, Color.orange.darker()));
|
setRenderer(RepositoriesModel.Columns.Name, nameRenderer);
|
setRenderer(RepositoriesModel.Columns.Indicators, typeRenderer);
|
setRenderer(RepositoriesModel.Columns.Owner, ownerRenderer);
|
setRenderer(RepositoriesModel.Columns.Size, sizeRenderer);
|
|
repositoriesTable.getSelectionModel().addListSelectionListener(new ListSelectionListener() {
|
@Override
|
public void valueChanged(ListSelectionEvent e) {
|
if (e.getValueIsAdjusting()) {
|
return;
|
}
|
boolean singleSelection = repositoriesTable.getSelectedRowCount() == 1;
|
boolean selected = repositoriesTable.getSelectedRow() > -1;
|
browseRepository.setEnabled(singleSelection);
|
delRepository.setEnabled(selected);
|
cloneRepository.setEnabled(selected);
|
if (selected) {
|
int viewRow = repositoriesTable.getSelectedRow();
|
int modelRow = repositoriesTable.convertRowIndexToModel(viewRow);
|
RepositoryModel model = ((RepositoriesModel) repositoriesTable.getModel()).list
|
.get(modelRow);
|
editRepository.setEnabled(singleSelection
|
&& (isAdmin || model.owner.equalsIgnoreCase(GitblitPanel.this.account)));
|
} else {
|
editRepository.setEnabled(false);
|
}
|
}
|
});
|
|
final JTextField repositoryFilter = new JTextField();
|
repositoryFilter.addActionListener(new ActionListener() {
|
public void actionPerformed(ActionEvent e) {
|
filterRepositories(repositoryFilter.getText());
|
}
|
});
|
|
JPanel filterPanel = new JPanel(new BorderLayout(margin, margin));
|
filterPanel.add(new JLabel(Translation.get("gb.filter")), BorderLayout.WEST);
|
filterPanel.add(repositoryFilter, BorderLayout.CENTER);
|
|
JPanel tablePanel = new JPanel(new BorderLayout(margin, margin));
|
tablePanel.add(filterPanel, BorderLayout.NORTH);
|
tablePanel.add(new JScrollPane(repositoriesTable), BorderLayout.CENTER);
|
|
JPanel repositoryControls = new JPanel();
|
repositoryControls.add(browseRepository);
|
repositoryControls.add(cloneRepository);
|
repositoryControls.add(createRepository);
|
repositoryControls.add(editRepository);
|
repositoryControls.add(delRepository);
|
|
JPanel repositoriesPanel = new JPanel(new BorderLayout(margin, margin));
|
repositoriesPanel.add(newHeaderLabel(Translation.get("gb.repositories")),
|
BorderLayout.NORTH);
|
repositoriesPanel.add(tablePanel, BorderLayout.CENTER);
|
repositoriesPanel.add(repositoryControls, BorderLayout.SOUTH);
|
|
JButton refreshUsers = new JButton(Translation.get("gb.refresh"));
|
refreshUsers.addActionListener(new ActionListener() {
|
public void actionPerformed(ActionEvent e) {
|
try {
|
refreshUsersTable();
|
} catch (ForbiddenException x) {
|
explainForbidden(RpcRequest.LIST_USERS);
|
} catch (UnauthorizedException x) {
|
explainUnauthorized(RpcRequest.LIST_USERS);
|
} catch (Throwable t) {
|
showException(t);
|
}
|
}
|
});
|
|
JButton createUser = new JButton(Translation.get("gb.create"));
|
createUser.addActionListener(new ActionListener() {
|
public void actionPerformed(ActionEvent e) {
|
createUser();
|
}
|
});
|
|
final JButton editUser = new JButton(Translation.get("gb.edit"));
|
editUser.setEnabled(false);
|
editUser.addActionListener(new ActionListener() {
|
public void actionPerformed(ActionEvent e) {
|
editUser(getSelectedUsers().get(0));
|
}
|
});
|
|
final JButton delUser = new JButton(Translation.get("gb.delete"));
|
delUser.setEnabled(false);
|
delUser.addActionListener(new ActionListener() {
|
public void actionPerformed(ActionEvent e) {
|
deleteUsers(getSelectedUsers());
|
}
|
});
|
|
usersList = new JList();
|
usersList.addListSelectionListener(new ListSelectionListener() {
|
|
@Override
|
public void valueChanged(ListSelectionEvent e) {
|
if (e.getValueIsAdjusting()) {
|
return;
|
}
|
boolean selected = usersList.getSelectedIndex() > -1;
|
boolean singleSelection = usersList.getSelectedIndices().length == 1;
|
editUser.setEnabled(singleSelection && selected);
|
delUser.setEnabled(selected);
|
}
|
});
|
|
JPanel userControls = new JPanel(new GridLayout(0, 2));
|
userControls.add(refreshUsers);
|
userControls.add(createUser);
|
userControls.add(editUser);
|
userControls.add(delUser);
|
|
usersPanel = new JPanel(new BorderLayout(margin, margin));
|
usersPanel.add(newHeaderLabel(Translation.get("gb.users")), BorderLayout.NORTH);
|
usersPanel.add(new JScrollPane(usersList), BorderLayout.CENTER);
|
usersPanel.add(userControls, BorderLayout.SOUTH);
|
|
/*
|
* Assemble the main panel
|
*/
|
JPanel mainPanel = new JPanel(new BorderLayout(margin, margin));
|
mainPanel.add(repositoriesPanel, BorderLayout.CENTER);
|
mainPanel.add(usersPanel, BorderLayout.EAST);
|
|
tabs = new JTabbedPane(JTabbedPane.BOTTOM);
|
tabs.addTab(Translation.get("gb.repositories"), mainPanel);
|
tabs.addTab(Translation.get("gb.federation"), new JPanel());
|
|
setLayout(new BorderLayout());
|
add(tabs, BorderLayout.CENTER);
|
}
|
|
private JLabel newHeaderLabel(String text) {
|
JLabel label = new JLabel(text);
|
label.setOpaque(true);
|
label.setForeground(Color.white);
|
label.setBackground(Color.gray);
|
label.setFont(label.getFont().deriveFont(14f));
|
return label;
|
}
|
|
public void login() throws IOException {
|
refreshRepositoriesTable();
|
|
try {
|
refreshUsersTable();
|
refreshSettings();
|
isAdmin = true;
|
refreshFederationPanel();
|
} catch (ForbiddenException e) {
|
// user does not have administrator privileges
|
// hide admin repository buttons
|
createRepository.setVisible(false);
|
delRepository.setVisible(false);
|
|
// hide users panel
|
usersPanel.setVisible(false);
|
|
// remove federation tab
|
tabs.removeTabAt(1);
|
} catch (IOException e) {
|
System.err.println(e.getMessage());
|
}
|
}
|
|
private void refreshRepositoriesTable() throws IOException {
|
Map<String, RepositoryModel> repositories = RpcUtils
|
.getRepositories(url, account, password);
|
allRepositories = new ArrayList<RepositoryModel>(repositories.values());
|
Collections.sort(allRepositories);
|
repositoriesModel.list.clear();
|
repositoriesModel.list.addAll(allRepositories);
|
repositoriesModel.fireTableDataChanged();
|
packColumns(repositoriesTable, 2);
|
}
|
|
private void setRenderer(RepositoriesModel.Columns col, TableCellRenderer renderer) {
|
String name = repositoriesTable.getColumnName(col.ordinal());
|
repositoriesTable.getColumn(name).setCellRenderer(renderer);
|
}
|
|
private void refreshUsersTable() throws IOException {
|
allUsers = RpcUtils.getUsers(url, account, password);
|
usersList.setListData(allUsers.toArray());
|
}
|
|
private void refreshSettings() throws IOException {
|
settings = RpcUtils.getSettings(url, account, password);
|
}
|
|
private void refreshFederationPanel() throws IOException {
|
List<FederationModel> registrations = RpcUtils.getFederationRegistrations(url, account,
|
password);
|
}
|
|
private void filterRepositories(final String fragment) {
|
if (StringUtils.isEmpty(fragment)) {
|
repositoriesTable.setRowSorter(defaultSorter);
|
return;
|
}
|
RowFilter<RepositoriesModel, Object> containsFilter = new RowFilter<RepositoriesModel, Object>() {
|
public boolean include(Entry<? extends RepositoriesModel, ? extends Object> entry) {
|
for (int i = entry.getValueCount() - 1; i >= 0; i--) {
|
if (entry.getStringValue(i).toLowerCase().contains(fragment.toLowerCase())) {
|
return true;
|
}
|
}
|
return false;
|
}
|
};
|
RepositoriesModel model = (RepositoriesModel) repositoriesTable.getModel();
|
TableRowSorter<RepositoriesModel> sorter = new TableRowSorter<RepositoriesModel>(model);
|
sorter.setRowFilter(containsFilter);
|
repositoriesTable.setRowSorter(sorter);
|
}
|
|
private List<RepositoryModel> getSelectedRepositories() {
|
List<RepositoryModel> repositories = new ArrayList<RepositoryModel>();
|
for (int viewRow : repositoriesTable.getSelectedRows()) {
|
int modelRow = repositoriesTable.convertRowIndexToModel(viewRow);
|
RepositoryModel model = ((RepositoriesModel) repositoriesTable.getModel()).list
|
.get(modelRow);
|
repositories.add(model);
|
}
|
return repositories;
|
}
|
|
private List<UserModel> getSelectedUsers() {
|
List<UserModel> users = new ArrayList<UserModel>();
|
for (int viewRow : usersList.getSelectedIndices()) {
|
UserModel model = (UserModel) usersList.getModel().getElementAt(viewRow);
|
users.add(model);
|
}
|
return users;
|
}
|
|
private void packColumns(JTable table, int margin) {
|
for (int c = 0; c < table.getColumnCount(); c++) {
|
packColumn(table, c, 4);
|
}
|
}
|
|
// Sets the preferred width of the visible column specified by vColIndex.
|
// The column will be just wide enough to show the column head and the
|
// widest cell in the column. margin pixels are added to the left and right
|
// (resulting in an additional width of 2*margin pixels).
|
private void packColumn(JTable table, int vColIndex, int margin) {
|
DefaultTableColumnModel colModel = (DefaultTableColumnModel) table.getColumnModel();
|
TableColumn col = colModel.getColumn(vColIndex);
|
int width = 0;
|
|
// Get width of column header
|
TableCellRenderer renderer = col.getHeaderRenderer();
|
if (renderer == null) {
|
renderer = table.getTableHeader().getDefaultRenderer();
|
}
|
Component comp = renderer.getTableCellRendererComponent(table, col.getHeaderValue(), false,
|
false, 0, 0);
|
width = comp.getPreferredSize().width;
|
|
// Get maximum width of column data
|
for (int r = 0; r < table.getRowCount(); r++) {
|
renderer = table.getCellRenderer(r, vColIndex);
|
comp = renderer.getTableCellRendererComponent(table, table.getValueAt(r, vColIndex),
|
false, false, r, vColIndex);
|
width = Math.max(width, comp.getPreferredSize().width);
|
}
|
|
// Add margin
|
width += 2 * margin;
|
|
// Set the width
|
col.setPreferredWidth(width);
|
}
|
|
@Override
|
public Insets getInsets() {
|
return insets;
|
}
|
|
@Override
|
public Dimension getPreferredSize() {
|
if (isAdmin) {
|
return new Dimension(950, 550);
|
}
|
return new Dimension(775, 450);
|
}
|
|
@Override
|
public void closeTab(Component c) {
|
}
|
|
/**
|
* Displays the create repository dialog and fires a SwingWorker to update
|
* the server, if appropriate.
|
*
|
*/
|
protected void createRepository() {
|
List<String> usernames = new ArrayList<String>();
|
for (UserModel user : this.allUsers) {
|
usernames.add(user.username);
|
}
|
Collections.sort(usernames);
|
EditRepositoryDialog dialog = new EditRepositoryDialog();
|
dialog.setUsers(null, usernames, null);
|
dialog.setRepositories(allRepositories);
|
dialog.setVisible(true);
|
final RepositoryModel newRepository = dialog.getRepository();
|
final List<String> permittedUsers = dialog.getPermittedUsers();
|
if (newRepository == null) {
|
return;
|
}
|
|
final RpcRequest request = RpcRequest.CREATE_REPOSITORY;
|
SwingWorker<Boolean, Void> worker = new SwingWorker<Boolean, Void>() {
|
|
@Override
|
protected Boolean doInBackground() throws IOException {
|
boolean success = true;
|
success &= RpcUtils.createRepository(newRepository, url, account, password);
|
if (permittedUsers.size() > 0) {
|
// if new repository has named members, set them
|
success &= RpcUtils.setRepositoryMembers(newRepository, permittedUsers, url,
|
account, password);
|
}
|
return success;
|
}
|
|
@Override
|
protected void done() {
|
try {
|
boolean success = get();
|
if (success) {
|
refreshRepositoriesTable();
|
if (permittedUsers.size() > 0) {
|
refreshUsersTable();
|
}
|
} else {
|
String msg = MessageFormat.format(
|
"Failed to execute request \"{0}\" for repository \"{1}\".",
|
request.name(), newRepository.name);
|
JOptionPane.showMessageDialog(GitblitPanel.this, msg,
|
Translation.get("gb.error"), JOptionPane.ERROR_MESSAGE);
|
}
|
} catch (ForbiddenException e) {
|
explainForbidden(request);
|
} catch (UnauthorizedException e) {
|
explainUnauthorized(request);
|
} catch (Throwable t) {
|
showException(t);
|
}
|
}
|
};
|
worker.execute();
|
}
|
|
/**
|
* Displays the edit repository dialog and fires a SwingWorker to update the
|
* server, if appropriate.
|
*
|
* @param repository
|
*/
|
protected void editRepository(final RepositoryModel repository) {
|
EditRepositoryDialog dialog = new EditRepositoryDialog(repository);
|
List<String> members = new ArrayList<String>();
|
List<String> usernames = new ArrayList<String>();
|
for (UserModel user : this.allUsers) {
|
usernames.add(user.username);
|
if (user.repositories.contains(repository.name)) {
|
members.add(user.username);
|
}
|
}
|
Collections.sort(usernames);
|
dialog.setUsers(repository.owner, usernames, members);
|
dialog.setFederationSets(settings.getStrings(Keys.federation.sets),
|
repository.federationSets);
|
dialog.setVisible(true);
|
final RepositoryModel revisedRepository = dialog.getRepository();
|
final List<String> permittedUsers = dialog.getPermittedUsers();
|
if (revisedRepository == null) {
|
return;
|
}
|
|
final RpcRequest request = RpcRequest.EDIT_REPOSITORY;
|
SwingWorker<Boolean, Void> worker = new SwingWorker<Boolean, Void>() {
|
|
@Override
|
protected Boolean doInBackground() throws IOException {
|
boolean success = true;
|
success &= RpcUtils.updateRepository(repository.name, revisedRepository, url,
|
account, password);
|
// always set the repository members
|
success &= RpcUtils.setRepositoryMembers(repository, permittedUsers, url, account,
|
password);
|
return success;
|
}
|
|
@Override
|
protected void done() {
|
try {
|
boolean success = get();
|
if (success) {
|
refreshRepositoriesTable();
|
refreshUsersTable();
|
} else {
|
String msg = MessageFormat.format(
|
"Failed to execute request \"{0}\" for repository \"{1}\".",
|
request.name(), repository.name);
|
JOptionPane.showMessageDialog(GitblitPanel.this, msg,
|
Translation.get("gb.error"), JOptionPane.ERROR_MESSAGE);
|
}
|
} catch (ForbiddenException e) {
|
explainForbidden(request);
|
} catch (UnauthorizedException e) {
|
explainUnauthorized(request);
|
} catch (Throwable t) {
|
showException(t);
|
}
|
}
|
};
|
worker.execute();
|
}
|
|
protected void deleteRepositories(final List<RepositoryModel> repositories) {
|
if (repositories == null || repositories.size() == 0) {
|
return;
|
}
|
StringBuilder message = new StringBuilder("Delete the following repositories?\n\n");
|
for (RepositoryModel repository : repositories) {
|
message.append(repository.name).append("\n");
|
}
|
int result = JOptionPane.showConfirmDialog(GitblitPanel.this, message.toString(),
|
"Delete Repositories?", JOptionPane.YES_NO_OPTION);
|
if (result == JOptionPane.YES_OPTION) {
|
final RpcRequest request = RpcRequest.DELETE_REPOSITORY;
|
SwingWorker<Boolean, Void> worker = new SwingWorker<Boolean, Void>() {
|
@Override
|
protected Boolean doInBackground() throws Exception {
|
boolean success = true;
|
for (RepositoryModel repository : repositories) {
|
success &= RpcUtils.deleteRepository(repository, url, account, password);
|
}
|
return success;
|
}
|
|
@Override
|
protected void done() {
|
try {
|
boolean success = get();
|
if (success) {
|
refreshRepositoriesTable();
|
} else {
|
String msg = "Failed to delete specified repositories!";
|
JOptionPane.showMessageDialog(GitblitPanel.this, msg,
|
Translation.get("gb.error"), JOptionPane.ERROR_MESSAGE);
|
}
|
} catch (ForbiddenException e) {
|
explainForbidden(request);
|
} catch (UnauthorizedException e) {
|
explainUnauthorized(request);
|
} catch (Throwable t) {
|
showException(t);
|
}
|
}
|
};
|
worker.execute();
|
}
|
}
|
|
/**
|
* Displays the create user dialog and fires a SwingWorker to update the
|
* server, if appropriate.
|
*
|
*/
|
protected void createUser() {
|
EditUserDialog dialog = new EditUserDialog(settings);
|
dialog.setUsers(allUsers);
|
dialog.setRepositories(allRepositories, null);
|
dialog.setVisible(true);
|
final UserModel newUser = dialog.getUser();
|
if (newUser == null) {
|
return;
|
}
|
|
final RpcRequest request = RpcRequest.CREATE_USER;
|
SwingWorker<Boolean, Void> worker = new SwingWorker<Boolean, Void>() {
|
|
@Override
|
protected Boolean doInBackground() throws IOException {
|
return RpcUtils.createUser(newUser, url, account, password);
|
}
|
|
@Override
|
protected void done() {
|
try {
|
boolean success = get();
|
if (success) {
|
refreshUsersTable();
|
} else {
|
String msg = MessageFormat.format(
|
"Failed to execute request \"{0}\" for user \"{1}\".",
|
request.name(), newUser.username);
|
JOptionPane.showMessageDialog(GitblitPanel.this, msg,
|
Translation.get("gb.error"), JOptionPane.ERROR_MESSAGE);
|
}
|
} catch (ForbiddenException e) {
|
explainForbidden(request);
|
} catch (UnauthorizedException e) {
|
explainUnauthorized(request);
|
} catch (Throwable t) {
|
showException(t);
|
}
|
}
|
};
|
worker.execute();
|
}
|
|
/**
|
* Displays the edit user dialog and fires a SwingWorker to update the
|
* server, if appropriate.
|
*
|
* @param user
|
*/
|
protected void editUser(final UserModel user) {
|
EditUserDialog dialog = new EditUserDialog(user, settings);
|
dialog.setRepositories(allRepositories, new ArrayList<String>(user.repositories));
|
dialog.setVisible(true);
|
final UserModel revisedUser = dialog.getUser();
|
if (revisedUser == null) {
|
return;
|
}
|
|
final RpcRequest request = RpcRequest.EDIT_USER;
|
SwingWorker<Boolean, Void> worker = new SwingWorker<Boolean, Void>() {
|
|
@Override
|
protected Boolean doInBackground() throws IOException {
|
return RpcUtils.updateUser(user.username, revisedUser, url, account, password);
|
}
|
|
@Override
|
protected void done() {
|
try {
|
boolean success = get();
|
if (success) {
|
refreshUsersTable();
|
} else {
|
String msg = MessageFormat.format(
|
"Failed to execute request \"{0}\" for user \"{1}\".",
|
request.name(), user.username);
|
JOptionPane.showMessageDialog(GitblitPanel.this, msg,
|
Translation.get("gb.error"), JOptionPane.ERROR_MESSAGE);
|
}
|
} catch (ForbiddenException e) {
|
explainForbidden(request);
|
} catch (UnauthorizedException e) {
|
explainUnauthorized(request);
|
} catch (Throwable t) {
|
showException(t);
|
}
|
}
|
};
|
worker.execute();
|
}
|
|
protected void deleteUsers(final List<UserModel> users) {
|
if (users == null || users.size() == 0) {
|
return;
|
}
|
StringBuilder message = new StringBuilder("Delete the following users?\n\n");
|
for (UserModel user : users) {
|
message.append(user.username).append("\n");
|
}
|
int result = JOptionPane.showConfirmDialog(GitblitPanel.this, message.toString(),
|
"Delete Users?", JOptionPane.YES_NO_OPTION);
|
if (result == JOptionPane.YES_OPTION) {
|
final RpcRequest request = RpcRequest.DELETE_USER;
|
SwingWorker<Boolean, Void> worker = new SwingWorker<Boolean, Void>() {
|
@Override
|
protected Boolean doInBackground() throws Exception {
|
boolean success = true;
|
for (UserModel user : users) {
|
success &= RpcUtils.deleteUser(user, url, account, password);
|
}
|
return success;
|
}
|
|
@Override
|
protected void done() {
|
try {
|
boolean success = get();
|
if (success) {
|
refreshUsersTable();
|
} else {
|
String msg = "Failed to delete specified users!";
|
JOptionPane.showMessageDialog(GitblitPanel.this, msg,
|
Translation.get("gb.error"), JOptionPane.ERROR_MESSAGE);
|
}
|
} catch (ForbiddenException e) {
|
explainForbidden(request);
|
} catch (UnauthorizedException e) {
|
explainUnauthorized(request);
|
} catch (Throwable t) {
|
showException(t);
|
}
|
}
|
};
|
worker.execute();
|
}
|
}
|
|
private void explainForbidden(RpcRequest request) {
|
String msg = MessageFormat.format(
|
"The request \"{0}\" has been forbidden by the Gitblit server @ {1}.",
|
request.name(), url);
|
JOptionPane.showMessageDialog(GitblitPanel.this, msg, "Forbidden",
|
JOptionPane.ERROR_MESSAGE);
|
}
|
|
private void explainUnauthorized(RpcRequest request) {
|
String msg = MessageFormat.format(
|
"The account \"{0}\" is not authorized to execute the request \"{1}\".", account,
|
request.name());
|
JOptionPane.showMessageDialog(GitblitPanel.this, msg, "Unauthorized",
|
JOptionPane.ERROR_MESSAGE);
|
}
|
|
private void showException(Throwable t) {
|
// TODO show the unexpected exception
|
}
|
}
|
