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