plugins/org.argeo.slc.client.ui.dist/src/main/java/org/argeo/slc/client/ui/dist/views/DistributionsView.java

   1 /*
   2  * Copyright (C) 2007-2012 Mathieu Baudier
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *         http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package org.argeo.slc.client.ui.dist.views;
  17
  18 import java.util.ArrayList;
  19 import java.util.HashMap;
  20 import java.util.List;
  21 import java.util.Map;
  22
  23 import javax.jcr.Credentials;
  24 import javax.jcr.GuestCredentials;
  25 import javax.jcr.Repository;
  26 import javax.jcr.RepositoryException;
  27 import javax.jcr.RepositoryFactory;
  28 import javax.jcr.Session;
  29 import javax.jcr.SimpleCredentials;
  30
  31 import org.apache.commons.logging.Log;
  32 import org.apache.commons.logging.LogFactory;
  33 import org.argeo.eclipse.ui.AbstractTreeContentProvider;
  34 import org.argeo.eclipse.ui.ErrorFeedback;
  35 import org.argeo.eclipse.ui.TreeParent;
  36 import org.argeo.jcr.ArgeoJcrUtils;
  37 import org.argeo.jcr.JcrUtils;
  38 import org.argeo.slc.client.ui.dist.DistPlugin;
  39 import org.argeo.slc.client.ui.dist.commands.CopyWorkspace;
  40 import org.argeo.slc.client.ui.dist.commands.CreateWorkspace;
  41 import org.argeo.slc.client.ui.dist.commands.DeleteWorkspace;
  42 import org.argeo.slc.client.ui.dist.commands.ManageWorkspaceAuth;
  43 import org.argeo.slc.client.ui.dist.commands.NormalizeDistribution;
  44 import org.argeo.slc.client.ui.dist.editors.DistributionEditor;
  45 import org.argeo.slc.client.ui.dist.editors.DistributionEditorInput;
  46 import org.argeo.slc.client.ui.dist.utils.CommandHelpers;
  47 import org.argeo.slc.jcr.SlcNames;
  48 import org.eclipse.jface.action.IMenuListener;
  49 import org.eclipse.jface.action.IMenuManager;
  50 import org.eclipse.jface.action.MenuManager;
  51 import org.eclipse.jface.viewers.ColumnLabelProvider;
  52 import org.eclipse.jface.viewers.DoubleClickEvent;
  53 import org.eclipse.jface.viewers.IDoubleClickListener;
  54 import org.eclipse.jface.viewers.IStructuredSelection;
  55 import org.eclipse.jface.viewers.TreeViewer;
  56 import org.eclipse.jface.viewers.TreeViewerColumn;
  57 import org.eclipse.swt.SWT;
  58 import org.eclipse.swt.widgets.Composite;
  59 import org.eclipse.swt.widgets.Menu;
  60 import org.eclipse.swt.widgets.Tree;
  61 import org.eclipse.ui.IWorkbenchWindow;
  62 import org.eclipse.ui.PartInitException;
  63 import org.eclipse.ui.part.ViewPart;
  64
  65 /**
  66  * Browse and manipulate distributions (like merge, rename, etc.). Only support
  67  * one single repository currently.
  68  */
  69
  70 public class DistributionsView extends ViewPart implements SlcNames {
  71         private final static Log log = LogFactory.getLog(DistributionsView.class);
  72         public final static String ID = DistPlugin.ID + ".distributionsView";
  73
  74         private Repository repository;
  75         private RepositoryFactory repositoryFactory;
  76
  77         private TreeViewer viewer;
  78
  79         private List<RepositoryElem> repositories = new ArrayList<DistributionsView.RepositoryElem>();
  80
  81         @Override
  82         public void createPartControl(Composite parent) {
  83                 // Define the TableViewer
  84                 viewer = new TreeViewer(parent, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL
  85                                 | SWT.FULL_SELECTION | SWT.BORDER);
  86
  87                 TreeViewerColumn col = new TreeViewerColumn(viewer, SWT.NONE);
  88                 col.getColumn().setWidth(200);
  89                 col.getColumn().setText("Workspace");
  90                 col.setLabelProvider(new ColumnLabelProvider() {
  91                         @Override
  92                         public String getText(Object element) {
  93                                 return element.toString();
  94                         }
  95                 });
  96
  97                 final Tree table = viewer.getTree();
  98                 table.setHeaderVisible(true);
  99                 table.setLinesVisible(true);
 100
 101                 viewer.setContentProvider(new DistributionsContentProvider());
 102                 viewer.addDoubleClickListener(new DistributionsDCL());
 103
 104                 MenuManager menuManager = new MenuManager();
 105                 Menu menu = menuManager.createContextMenu(viewer.getTree());
 106                 menuManager.addMenuListener(new IMenuListener() {
 107                         public void menuAboutToShow(IMenuManager manager) {
 108                                 contextMenuAboutToShow(manager);
 109                         }
 110                 });
 111                 viewer.getTree().setMenu(menu);
 112                 getSite().registerContextMenu(menuManager, viewer);
 113
 114                 // Initializes repositories
 115                 // TODO make it more generic, with remote repositories etc.
 116                 repositories.add(new RepositoryElem("java", repository, null));
 117
 118                 // Remote
 119                 String uri = null;
 120                 Credentials credentials = null;
 121                 Repository remoteRepository = null;
 122
 123                 uri = "http://dev.argeo.org/org.argeo.jcr.webapp/pub/java";
 124                 credentials = new GuestCredentials();
 125                 remoteRepository = ArgeoJcrUtils.getRepositoryByUri(repositoryFactory, uri);
 126                 repositories.add(new RepositoryElem("anonymous@dev.argeo.org//java",
 127                                 remoteRepository, credentials));
 128
 129                 uri = "http://localhost:7070/org.argeo.jcr.webapp/pub/java";
 130                 credentials = new GuestCredentials();
 131                 remoteRepository = ArgeoJcrUtils.getRepositoryByUri(repositoryFactory, uri);
 132                 repositories.add(new RepositoryElem("anonymous@localhost//java",
 133                                 remoteRepository, credentials));
 134
 135                 uri = "http://localhost:7070/org.argeo.jcr.webapp/remoting/java";
 136                 credentials = new SimpleCredentials(System.getProperty("user.name"),
 137                                 "".toCharArray());
 138                 remoteRepository = ArgeoJcrUtils.getRepositoryByUri(repositoryFactory, uri);
 139                 repositories.add(new RepositoryElem("@localhost//java",
 140                                 remoteRepository, credentials));
 141
 142                 viewer.setInput(getSite());
 143
 144         }
 145
 146         @Override
 147         public void setFocus() {
 148                 viewer.getTree().setFocus();
 149         }
 150
 151         /**
 152          * Force refresh of the whole view
 153          */
 154         public void refresh() {
 155                 viewer.setContentProvider(new DistributionsContentProvider());
 156         }
 157
 158         public void setRepository(Repository repository) {
 159                 this.repository = repository;
 160         }
 161
 162         public void setRepositoryFactory(RepositoryFactory repositoryFactory) {
 163                 this.repositoryFactory = repositoryFactory;
 164         }
 165
 166         /** Programatically configure the context menu */
 167         protected void contextMenuAboutToShow(IMenuManager menuManager) {
 168                 IWorkbenchWindow window = DistPlugin.getDefault().getWorkbench()
 169                                 .getActiveWorkbenchWindow();
 170                 // Get Current selected item :
 171                 Object firstElement = ((IStructuredSelection) viewer.getSelection())
 172                                 .getFirstElement();
 173
 174                 if (firstElement instanceof TreeParent) {
 175                         TreeParent tp = (TreeParent) firstElement;
 176                         String wsName = tp.getName();
 177
 178                         // Build conditions depending on element type (repo or distribution
 179                         // for the time being)
 180                         boolean isDistribElem = false; // , isRepoElem = false;
 181
 182                         // if (tp instanceof RepositoryElem){
 183                         // isRepoElem = true;
 184                         // } else
 185                         if (tp instanceof DistributionElem) {
 186                                 isDistribElem = true;
 187                         }
 188
 189                         // create workspace
 190                         CommandHelpers.refreshCommand(menuManager, window,
 191                                         CreateWorkspace.ID, CreateWorkspace.DEFAULT_LABEL,
 192                                         CreateWorkspace.DEFAULT_ICON_PATH,
 193                                         tp instanceof RepositoryElem);
 194
 195                         // Normalize workspace
 196                         Map<String, String> params = new HashMap<String, String>();
 197                         params.put(NormalizeDistribution.PARAM_WORKSPACE, wsName);
 198                         CommandHelpers.refreshParameterizedCommand(menuManager, window,
 199                                         NormalizeDistribution.ID,
 200                                         NormalizeDistribution.DEFAULT_LABEL,
 201                                         NormalizeDistribution.DEFAULT_ICON_PATH, isDistribElem,
 202                                         params);
 203
 204                         // Copy workspace
 205                         params = new HashMap<String, String>();
 206                         params.put(CopyWorkspace.PARAM_WORKSPACE_NAME, wsName);
 207                         CommandHelpers.refreshParameterizedCommand(menuManager, window,
 208                                         CopyWorkspace.ID, CopyWorkspace.DEFAULT_LABEL,
 209                                         CopyWorkspace.DEFAULT_ICON_PATH, isDistribElem, params);
 210
 211                         // Delete Workspace
 212                         params = new HashMap<String, String>();
 213                         params.put(DeleteWorkspace.PARAM_WORKSPACE_NAME, wsName);
 214                         CommandHelpers.refreshParameterizedCommand(menuManager, window,
 215                                         DeleteWorkspace.ID, DeleteWorkspace.DEFAULT_LABEL,
 216                                         DeleteWorkspace.DEFAULT_ICON_PATH, isDistribElem, params);
 217
 218                         // Manage workspace authorizations
 219                         params = new HashMap<String, String>();
 220                         params.put(ManageWorkspaceAuth.PARAM_WORKSPACE_NAME, wsName);
 221                         CommandHelpers.refreshParameterizedCommand(menuManager, window,
 222                                         ManageWorkspaceAuth.ID, ManageWorkspaceAuth.DEFAULT_LABEL,
 223                                         ManageWorkspaceAuth.DEFAULT_ICON_PATH, isDistribElem,
 224                                         params);
 225                 }
 226         }
 227
 228         private class DistributionsContentProvider extends
 229                         AbstractTreeContentProvider {
 230
 231                 public Object[] getElements(Object arg0) {
 232                         return repositories.toArray();
 233                 }
 234
 235         }
 236
 237         /** Wraps a repository **/
 238         private static class RepositoryElem extends TreeParent {
 239                 // private final Repository repository;
 240                 private Session defaultSession;
 241
 242                 public RepositoryElem(String name, Repository repository,
 243                                 Credentials credentials) {
 244                         super(name);
 245                         try {
 246                                 defaultSession = repository.login(credentials);
 247                                 String[] workspaceNames = defaultSession.getWorkspace()
 248                                                 .getAccessibleWorkspaceNames();
 249                                 for (String workspace : workspaceNames)
 250                                         addChild(new DistributionElem(repository, workspace,
 251                                                         credentials));
 252                         } catch (RepositoryException e) {
 253                                 ErrorFeedback.show("Cannot log to repository", e);
 254                         }
 255                 }
 256
 257                 @Override
 258                 public synchronized void dispose() {
 259                         if (log.isTraceEnabled())
 260                                 log.trace("Disposing RepositoryElement");
 261                         JcrUtils.logoutQuietly(defaultSession);
 262                         super.dispose();
 263                 }
 264         }
 265
 266         private static class DistributionElem extends TreeParent {
 267                 private final String workspaceName;
 268                 private final Repository repository;
 269                 private final Credentials credentials;
 270
 271                 public DistributionElem(Repository repository, String workspaceName,
 272                                 Credentials credentials) {
 273                         super(workspaceName);
 274                         this.workspaceName = workspaceName;
 275                         this.repository = repository;
 276                         this.credentials = credentials;
 277                 }
 278
 279                 public String getWorkspaceName() {
 280                         return workspaceName;
 281                 }
 282
 283                 public Repository getRepository() {
 284                         return repository;
 285                 }
 286
 287                 public Credentials getCredentials() {
 288                         return credentials;
 289                 }
 290         }
 291
 292         @Override
 293         public void dispose() {
 294                 for (RepositoryElem re : repositories)
 295                         re.dispose();
 296                 super.dispose();
 297         }
 298
 299         private class DistributionsDCL implements IDoubleClickListener {
 300
 301                 public void doubleClick(DoubleClickEvent event) {
 302                         if (event.getSelection() == null || event.getSelection().isEmpty())
 303                                 return;
 304                         Object obj = ((IStructuredSelection) event.getSelection())
 305                                         .getFirstElement();
 306                         if (obj instanceof DistributionElem) {
 307                                 DistributionElem distributionElem = (DistributionElem) obj;
 308                                 DistributionEditorInput dei = new DistributionEditorInput(
 309                                                 distributionElem.getName(),
 310                                                 distributionElem.getRepository(),
 311                                                 distributionElem.getWorkspaceName(),
 312                                                 distributionElem.getCredentials());
 313                                 try {
 314                                         DistPlugin.getDefault().getWorkbench()
 315                                                         .getActiveWorkbenchWindow().getActivePage()
 316                                                         .openEditor(dei, DistributionEditor.ID);
 317                                 } catch (PartInitException e) {
 318                                         ErrorFeedback.show("Cannot open editor for "
 319                                                         + distributionElem.getWorkspaceName(), e);
 320                                 }
 321                         }
 322                 }
 323         }
 324 }